Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 10249a5f

History | View | Annotate | Download (48.4 KB)

1
/*
2
 * DV decoder
3
 * Copyright (c) 2002 Fabrice Bellard
4
 * Copyright (c) 2004 Roman Shaposhnik
5
 *
6
 * DV encoder
7
 * Copyright (c) 2003 Roman Shaposhnik
8
 *
9
 * 50 Mbps (DVCPRO50) support
10
 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11
 *
12
 * 100 Mbps (DVCPRO HD) support
13
 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14
 * Final code by Roman Shaposhnik
15
 *
16
 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17
 * of DV technical info.
18
 *
19
 * This file is part of FFmpeg.
20
 *
21
 * FFmpeg is free software; you can redistribute it and/or
22
 * modify it under the terms of the GNU Lesser General Public
23
 * License as published by the Free Software Foundation; either
24
 * version 2.1 of the License, or (at your option) any later version.
25
 *
26
 * FFmpeg is distributed in the hope that it will be useful,
27
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
29
 * Lesser General Public License for more details.
30
 *
31
 * You should have received a copy of the GNU Lesser General Public
32
 * License along with FFmpeg; if not, write to the Free Software
33
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34
 */
35

    
36
/**
37
 * @file libavcodec/dv.c
38
 * DV codec.
39
 */
40
#define ALT_BITSTREAM_READER
41
#include "avcodec.h"
42
#include "dsputil.h"
43
#include "get_bits.h"
44
#include "put_bits.h"
45
#include "simple_idct.h"
46
#include "dvdata.h"
47
#include "dv_vlc_data.h"
48

    
49
//#undef NDEBUG
50
//#include <assert.h>
51

    
52
typedef struct DVVideoContext {
53
    const DVprofile *sys;
54
    AVFrame          picture;
55
    AVCodecContext  *avctx;
56
    uint8_t         *buf;
57

    
58
    uint8_t  dv_zigzag[2][64];
59

    
60
    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
61
    void (*fdct[2])(DCTELEM *block);
62
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
63
    me_cmp_func ildct_cmp;
64
} DVVideoContext;
65

    
66
#define TEX_VLC_BITS 9
67

    
68
#if CONFIG_SMALL
69
#define DV_VLC_MAP_RUN_SIZE 15
70
#define DV_VLC_MAP_LEV_SIZE 23
71
#else
72
#define DV_VLC_MAP_RUN_SIZE  64
73
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
74
#endif
75

    
76
/* XXX: also include quantization */
77
static RL_VLC_ELEM dv_rl_vlc[1184];
78
/* VLC encoding lookup table */
79
static struct dv_vlc_pair {
80
   uint32_t vlc;
81
   uint8_t  size;
82
} dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
83

    
84
static inline int dv_work_pool_size(const DVprofile *d)
85
{
86
    int size = d->n_difchan*d->difseg_size*27;
87
    if (DV_PROFILE_IS_1080i50(d))
88
        size -= 3*27;
89
    if (DV_PROFILE_IS_720p50(d))
90
        size -= 4*27;
91
    return size;
92
}
93

    
94
static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
95
                                          uint16_t *tbl)
96
{
97
    static const uint8_t off[] = { 2, 6, 8, 0, 4 };
98
    static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
99
    static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
100
    static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
101

    
102
    static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
103
    static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
104

    
105
    static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
106
                                       0, 1, 2, 2, 1, 0,
107
                                       0, 1, 2, 2, 1, 0,
108
                                       0, 1, 2, 2, 1, 0,
109
                                       0, 1, 2};
110
    static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
111
                                       0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
112
                                       0, 1, 2, 3, 4, 5};
113

    
114
    static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
115
                                       { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
116
                                       {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
117
                                       {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
118
                                       {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
119
                                       {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
120
                                       {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
121
                                       {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
122
                                       {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
123
                                       {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
124
                                       {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
125
                                       {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
126
                                       {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
127

    
128
    int i, k, m;
129
    int x, y, blk;
130

    
131
    for (m=0; m<5; m++) {
132
         switch (d->width) {
133
         case 1440:
134
              blk = (chan*11+seq)*27+slot;
135

    
136
              if (chan == 0 && seq == 11) {
137
                  x = m*27+slot;
138
                  if (x<90) {
139
                      y = 0;
140
                  } else {
141
                      x = (x - 90)*2;
142
                      y = 67;
143
                  }
144
              } else {
145
                  i = (4*chan + blk + off[m])%11;
146
                  k = (blk/11)%27;
147

    
148
                  x = shuf1[m] + (chan&1)*9 + k%9;
149
                  y = (i*3+k/9)*2 + (chan>>1) + 1;
150
              }
151
              tbl[m] = (x<<1)|(y<<9);
152
              break;
153
         case 1280:
154
              blk = (chan*10+seq)*27+slot;
155

    
156
              i = (4*chan + (seq/5) + 2*blk + off[m])%10;
157
              k = (blk/5)%27;
158

    
159
              x = shuf1[m]+(chan&1)*9 + k%9;
160
              y = (i*3+k/9)*2 + (chan>>1) + 4;
161

    
162
              if (x >= 80) {
163
                  x = remap[y][0]+((x-80)<<(y>59));
164
                  y = remap[y][1];
165
              }
166
              tbl[m] = (x<<1)|(y<<9);
167
              break;
168
       case 960:
169
              blk = (chan*10+seq)*27+slot;
170

    
171
              i = (4*chan + (seq/5) + 2*blk + off[m])%10;
172
              k = (blk/5)%27 + (i&1)*3;
173

    
174
              x = shuf2[m] + k%6 + 6*(chan&1);
175
              y = l_start[i] + k/6 + 45*(chan>>1);
176
              tbl[m] = (x<<1)|(y<<9);
177
              break;
178
        case 720:
179
              switch (d->pix_fmt) {
180
              case PIX_FMT_YUV422P:
181
                   x = shuf3[m] + slot/3;
182
                   y = serpent1[slot] +
183
                       ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
184
                   tbl[m] = (x<<1)|(y<<8);
185
                   break;
186
              case PIX_FMT_YUV420P:
187
                   x = shuf3[m] + slot/3;
188
                   y = serpent1[slot] +
189
                       ((seq + off[m]) % d->difseg_size)*3;
190
                   tbl[m] = (x<<1)|(y<<9);
191
                   break;
192
              case PIX_FMT_YUV411P:
193
                   i = (seq + off[m]) % d->difseg_size;
194
                   k = slot + ((m==1||m==2)?3:0);
195

    
196
                   x = l_start_shuffled[m] + k/6;
197
                   y = serpent2[k] + i*6;
198
                   if (x>21)
199
                       y = y*2 - i*6;
200
                   tbl[m] = (x<<2)|(y<<8);
201
                   break;
202
              }
203
        default:
204
              break;
205
        }
206
    }
207
}
208

    
209
static int dv_init_dynamic_tables(const DVprofile *d)
210
{
211
    int j,i,c,s,p;
212
    uint32_t *factor1, *factor2;
213
    const int *iweight1, *iweight2;
214

    
215
    if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
216
        p = i = 0;
217
        for (c=0; c<d->n_difchan; c++) {
218
            for (s=0; s<d->difseg_size; s++) {
219
                p += 6;
220
                for (j=0; j<27; j++) {
221
                    p += !(j%3);
222
                    if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
223
                        !(DV_PROFILE_IS_720p50(d) && s > 9)) {
224
                          dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
225
                          d->work_chunks[i++].buf_offset = p;
226
                    }
227
                    p += 5;
228
                }
229
            }
230
        }
231
    }
232

    
233
    if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
234
        factor1 = &d->idct_factor[0];
235
        factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
236
        if (d->height == 720) {
237
            iweight1 = &dv_iweight_720_y[0];
238
            iweight2 = &dv_iweight_720_c[0];
239
        } else {
240
            iweight1 = &dv_iweight_1080_y[0];
241
            iweight2 = &dv_iweight_1080_c[0];
242
            }
243
        if (DV_PROFILE_IS_HD(d)) {
244
            for (c = 0; c < 4; c++) {
245
                for (s = 0; s < 16; s++) {
246
                    for (i = 0; i < 64; i++) {
247
                        *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
248
                        *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
249
                    }
250
                }
251
            }
252
        } else {
253
            iweight1 = &dv_iweight_88[0];
254
            for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
255
                for (s = 0; s < 22; s++) {
256
                    for (i = c = 0; c < 4; c++) {
257
                        for (; i < dv_quant_areas[c]; i++) {
258
                            *factor1   = iweight1[i] << (dv_quant_shifts[s][c] + 1);
259
                            *factor2++ = (*factor1++) << 1;
260
        }
261
    }
262
            }
263
        }
264
    }
265
}
266

    
267
    return 0;
268
}
269

    
270
static av_cold int dvvideo_init(AVCodecContext *avctx)
271
{
272
    DVVideoContext *s = avctx->priv_data;
273
    DSPContext dsp;
274
    static int done = 0;
275
    int i, j;
276

    
277
    if (!done) {
278
        VLC dv_vlc;
279
        uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
280
        uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
281
        uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
282
        int16_t  new_dv_vlc_level[NB_DV_VLC*2];
283

    
284
        done = 1;
285

    
286
        /* it's faster to include sign bit in a generic VLC parsing scheme */
287
        for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
288
            new_dv_vlc_bits[j]  = dv_vlc_bits[i];
289
            new_dv_vlc_len[j]   = dv_vlc_len[i];
290
            new_dv_vlc_run[j]   = dv_vlc_run[i];
291
            new_dv_vlc_level[j] = dv_vlc_level[i];
292

    
293
            if (dv_vlc_level[i]) {
294
                new_dv_vlc_bits[j] <<= 1;
295
                new_dv_vlc_len[j]++;
296

    
297
                j++;
298
                new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
299
                new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
300
                new_dv_vlc_run[j]   =  dv_vlc_run[i];
301
                new_dv_vlc_level[j] = -dv_vlc_level[i];
302
            }
303
        }
304

    
305
        /* NOTE: as a trick, we use the fact the no codes are unused
306
           to accelerate the parsing of partial codes */
307
        init_vlc(&dv_vlc, TEX_VLC_BITS, j,
308
                 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
309
        assert(dv_vlc.table_size == 1184);
310

    
311
        for (i = 0; i < dv_vlc.table_size; i++){
312
            int code = dv_vlc.table[i][0];
313
            int len  = dv_vlc.table[i][1];
314
            int level, run;
315

    
316
            if (len < 0){ //more bits needed
317
                run   = 0;
318
                level = code;
319
            } else {
320
                run   = new_dv_vlc_run  [code] + 1;
321
                level = new_dv_vlc_level[code];
322
            }
323
            dv_rl_vlc[i].len   = len;
324
            dv_rl_vlc[i].level = level;
325
            dv_rl_vlc[i].run   = run;
326
        }
327
        free_vlc(&dv_vlc);
328

    
329
        for (i = 0; i < NB_DV_VLC - 1; i++) {
330
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
331
               continue;
332
#if CONFIG_SMALL
333
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
334
               continue;
335
#endif
336

    
337
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
338
               continue;
339

    
340
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc  =
341
               dv_vlc_bits[i] << (!!dv_vlc_level[i]);
342
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
343
               dv_vlc_len[i] + (!!dv_vlc_level[i]);
344
        }
345
        for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
346
#if CONFIG_SMALL
347
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
348
              if (dv_vlc_map[i][j].size == 0) {
349
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
350
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
351
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
352
                                          dv_vlc_map[0][j].size;
353
              }
354
           }
355
#else
356
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
357
              if (dv_vlc_map[i][j].size == 0) {
358
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
359
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
360
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
361
                                          dv_vlc_map[0][j].size;
362
              }
363
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
364
                                            dv_vlc_map[i][j].vlc | 1;
365
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
366
                                            dv_vlc_map[i][j].size;
367
           }
368
#endif
369
        }
370
    }
371

    
372
    /* Generic DSP setup */
373
    dsputil_init(&dsp, avctx);
374
    ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
375
    s->get_pixels = dsp.get_pixels;
376
    s->ildct_cmp = dsp.ildct_cmp[5];
377

    
378
    /* 88DCT setup */
379
    s->fdct[0]     = dsp.fdct;
380
    s->idct_put[0] = dsp.idct_put;
381
    for (i = 0; i < 64; i++)
382
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
383

    
384
    /* 248DCT setup */
385
    s->fdct[1]     = dsp.fdct248;
386
    s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
387
    if (avctx->lowres){
388
        for (i = 0; i < 64; i++){
389
            int j = ff_zigzag248_direct[i];
390
            s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
391
        }
392
    }else
393
        memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
394

    
395
    avctx->coded_frame = &s->picture;
396
    s->avctx = avctx;
397
    avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
398

    
399
    return 0;
400
}
401

    
402
static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
403
{
404
    if (!ff_dv_codec_profile(avctx)) {
405
        av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
406
               avctx->width, avctx->height, avcodec_get_pix_fmt_name(avctx->pix_fmt));
407
        return -1;
408
    }
409

    
410
    return dvvideo_init(avctx);
411
}
412

    
413
// #define VLC_DEBUG
414
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
415

    
416
typedef struct BlockInfo {
417
    const uint32_t *factor_table;
418
    const uint8_t *scan_table;
419
    uint8_t pos; /* position in block */
420
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
421
    uint8_t partial_bit_count;
422
    uint16_t partial_bit_buffer;
423
    int shift_offset;
424
} BlockInfo;
425

    
426
/* bit budget for AC only in 5 MBs */
427
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
428
/* see dv_88_areas and dv_248_areas for details */
429
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
430

    
431
static inline int put_bits_left(PutBitContext* s)
432
{
433
    return (s->buf_end - s->buf) * 8 - put_bits_count(s);
434
}
435

    
436
/* decode ac coefficients */
437
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
438
{
439
    int last_index = gb->size_in_bits;
440
    const uint8_t  *scan_table   = mb->scan_table;
441
    const uint32_t *factor_table = mb->factor_table;
442
    int pos               = mb->pos;
443
    int partial_bit_count = mb->partial_bit_count;
444
    int level, run, vlc_len, index;
445

    
446
    OPEN_READER(re, gb);
447
    UPDATE_CACHE(re, gb);
448

    
449
    /* if we must parse a partial vlc, we do it here */
450
    if (partial_bit_count > 0) {
451
        re_cache = ((unsigned)re_cache >> partial_bit_count) |
452
                   (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
453
        re_index -= partial_bit_count;
454
        mb->partial_bit_count = 0;
455
    }
456

    
457
    /* get the AC coefficients until last_index is reached */
458
    for (;;) {
459
#ifdef VLC_DEBUG
460
        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
461
#endif
462
        /* our own optimized GET_RL_VLC */
463
        index   = NEG_USR32(re_cache, TEX_VLC_BITS);
464
        vlc_len = dv_rl_vlc[index].len;
465
        if (vlc_len < 0) {
466
            index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
467
            vlc_len = TEX_VLC_BITS - vlc_len;
468
        }
469
        level = dv_rl_vlc[index].level;
470
        run   = dv_rl_vlc[index].run;
471

    
472
        /* gotta check if we're still within gb boundaries */
473
        if (re_index + vlc_len > last_index) {
474
            /* should be < 16 bits otherwise a codeword could have been parsed */
475
            mb->partial_bit_count = last_index - re_index;
476
            mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
477
            re_index = last_index;
478
            break;
479
        }
480
        re_index += vlc_len;
481

    
482
#ifdef VLC_DEBUG
483
        printf("run=%d level=%d\n", run, level);
484
#endif
485
        pos += run;
486
        if (pos >= 64)
487
            break;
488

    
489
        level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
490
        block[scan_table[pos]] = level;
491

    
492
        UPDATE_CACHE(re, gb);
493
    }
494
    CLOSE_READER(re, gb);
495
    mb->pos = pos;
496
}
497

    
498
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
499
{
500
    int bits_left = get_bits_left(gb);
501
    while (bits_left >= MIN_CACHE_BITS) {
502
        put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
503
        bits_left -= MIN_CACHE_BITS;
504
    }
505
    if (bits_left > 0) {
506
        put_bits(pb, bits_left, get_bits(gb, bits_left));
507
    }
508
}
509

    
510
static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
511
{
512
     *mb_x = work_chunk->mb_coordinates[m] & 0xff;
513
     *mb_y = work_chunk->mb_coordinates[m] >> 8;
514

    
515
     /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
516
     if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
517
         *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
518
     }
519
}
520

    
521
/* mb_x and mb_y are in units of 8 pixels */
522
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
523
{
524
    DVVideoContext *s = avctx->priv_data;
525
    DVwork_chunk *work_chunk = arg;
526
    int quant, dc, dct_mode, class1, j;
527
    int mb_index, mb_x, mb_y, last_index;
528
    int y_stride, linesize;
529
    DCTELEM *block, *block1;
530
    int c_offset;
531
    uint8_t *y_ptr;
532
    const uint8_t *buf_ptr;
533
    PutBitContext pb, vs_pb;
534
    GetBitContext gb;
535
    BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
536
    LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
537
    LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + 4]); /* allow some slack */
538
    LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5 * 80 + 4]); /* allow some slack */
539
    const int log2_blocksize = 3-s->avctx->lowres;
540
    int is_field_mode[5];
541

    
542
    assert((((int)mb_bit_buffer) & 7) == 0);
543
    assert((((int)vs_bit_buffer) & 7) == 0);
544

    
545
    memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
546

    
547
    /* pass 1 : read DC and AC coefficients in blocks */
548
    buf_ptr = &s->buf[work_chunk->buf_offset*80];
549
    block1  = &sblock[0][0];
550
    mb1     = mb_data;
551
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
552
    for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
553
        /* skip header */
554
        quant = buf_ptr[3] & 0x0f;
555
        buf_ptr += 4;
556
        init_put_bits(&pb, mb_bit_buffer, 80);
557
        mb    = mb1;
558
        block = block1;
559
        is_field_mode[mb_index] = 0;
560
        for (j = 0; j < s->sys->bpm; j++) {
561
            last_index = s->sys->block_sizes[j];
562
            init_get_bits(&gb, buf_ptr, last_index);
563

    
564
            /* get the dc */
565
            dc       = get_sbits(&gb, 9);
566
            dct_mode = get_bits1(&gb);
567
            class1   = get_bits(&gb, 2);
568
            if (DV_PROFILE_IS_HD(s->sys)) {
569
                mb->idct_put     = s->idct_put[0];
570
                mb->scan_table   = s->dv_zigzag[0];
571
                mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
572
                is_field_mode[mb_index] |= !j && dct_mode;
573
            } else {
574
                mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
575
                mb->scan_table   = s->dv_zigzag[dct_mode];
576
                mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
577
                                                        (quant + dv_quant_offset[class1])*64];
578
            }
579
            dc = dc << 2;
580
            /* convert to unsigned because 128 is not added in the
581
               standard IDCT */
582
            dc += 1024;
583
            block[0] = dc;
584
            buf_ptr += last_index >> 3;
585
            mb->pos               = 0;
586
            mb->partial_bit_count = 0;
587

    
588
#ifdef VLC_DEBUG
589
            printf("MB block: %d, %d ", mb_index, j);
590
#endif
591
            dv_decode_ac(&gb, mb, block);
592

    
593
            /* write the remaining bits  in a new buffer only if the
594
               block is finished */
595
            if (mb->pos >= 64)
596
                bit_copy(&pb, &gb);
597

    
598
            block += 64;
599
            mb++;
600
        }
601

    
602
        /* pass 2 : we can do it just after */
603
#ifdef VLC_DEBUG
604
        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
605
#endif
606
        block = block1;
607
        mb    = mb1;
608
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
609
        flush_put_bits(&pb);
610
        for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
611
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
612
                dv_decode_ac(&gb, mb, block);
613
                /* if still not finished, no need to parse other blocks */
614
                if (mb->pos < 64)
615
                    break;
616
            }
617
        }
618
        /* all blocks are finished, so the extra bytes can be used at
619
           the video segment level */
620
        if (j >= s->sys->bpm)
621
            bit_copy(&vs_pb, &gb);
622
    }
623

    
624
    /* we need a pass other the whole video segment */
625
#ifdef VLC_DEBUG
626
    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
627
#endif
628
    block = &sblock[0][0];
629
    mb    = mb_data;
630
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
631
    flush_put_bits(&vs_pb);
632
    for (mb_index = 0; mb_index < 5; mb_index++) {
633
        for (j = 0; j < s->sys->bpm; j++) {
634
            if (mb->pos < 64) {
635
#ifdef VLC_DEBUG
636
                printf("start %d:%d\n", mb_index, j);
637
#endif
638
                dv_decode_ac(&gb, mb, block);
639
            }
640
            if (mb->pos >= 64 && mb->pos < 127)
641
                av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
642
            block += 64;
643
            mb++;
644
        }
645
    }
646

    
647
    /* compute idct and place blocks */
648
    block = &sblock[0][0];
649
    mb    = mb_data;
650
    for (mb_index = 0; mb_index < 5; mb_index++) {
651
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
652

    
653
        /* idct_put'ting luminance */
654
        if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
655
            (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
656
            (s->sys->height >= 720 && mb_y != 134)) {
657
            y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
658
        } else {
659
            y_stride = (2 << log2_blocksize);
660
        }
661
        y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
662
        linesize = s->picture.linesize[0] << is_field_mode[mb_index];
663
        mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
664
        if (s->sys->video_stype == 4) { /* SD 422 */
665
            mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
666
        } else {
667
            mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
668
            mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
669
            mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
670
        }
671
        mb += 4;
672
        block += 4*64;
673

    
674
        /* idct_put'ting chrominance */
675
        c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
676
                     (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
677
        for (j = 2; j; j--) {
678
            uint8_t *c_ptr = s->picture.data[j] + c_offset;
679
            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
680
                  uint64_t aligned_pixels[64/8];
681
                  uint8_t *pixels = (uint8_t*)aligned_pixels;
682
                  uint8_t *c_ptr1, *ptr1;
683
                  int x, y;
684
                  mb->idct_put(pixels, 8, block);
685
                  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
686
                      ptr1   = pixels + (1 << (log2_blocksize - 1));
687
                      c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
688
                      for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
689
                          c_ptr[x]  = pixels[x];
690
                          c_ptr1[x] = ptr1[x];
691
                      }
692
                  }
693
                  block += 64; mb++;
694
            } else {
695
                  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
696
                                             s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
697
                  linesize = s->picture.linesize[j] << is_field_mode[mb_index];
698
                  (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
699
                  if (s->sys->bpm == 8) {
700
                      (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
701
                  }
702
            }
703
        }
704
    }
705
    return 0;
706
}
707

    
708
#if CONFIG_SMALL
709
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
710
static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
711
{
712
    int size;
713
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
714
        *vlc = dv_vlc_map[run][level].vlc | sign;
715
        size = dv_vlc_map[run][level].size;
716
    }
717
    else {
718
        if (level < DV_VLC_MAP_LEV_SIZE) {
719
            *vlc = dv_vlc_map[0][level].vlc | sign;
720
            size = dv_vlc_map[0][level].size;
721
        } else {
722
            *vlc = 0xfe00 | (level << 1) | sign;
723
            size = 16;
724
        }
725
        if (run) {
726
            *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
727
                                  (0x1f80 | (run - 1))) << size;
728
            size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
729
        }
730
    }
731

    
732
    return size;
733
}
734

    
735
static av_always_inline int dv_rl2vlc_size(int run, int level)
736
{
737
    int size;
738

    
739
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
740
        size = dv_vlc_map[run][level].size;
741
    }
742
    else {
743
        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
744
        if (run) {
745
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
746
        }
747
    }
748
    return size;
749
}
750
#else
751
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
752
{
753
    *vlc = dv_vlc_map[run][l].vlc | sign;
754
    return dv_vlc_map[run][l].size;
755
}
756

    
757
static av_always_inline int dv_rl2vlc_size(int run, int l)
758
{
759
    return dv_vlc_map[run][l].size;
760
}
761
#endif
762

    
763
typedef struct EncBlockInfo {
764
    int      area_q[4];
765
    int      bit_size[4];
766
    int      prev[5];
767
    int      cur_ac;
768
    int      cno;
769
    int      dct_mode;
770
    DCTELEM  mb[64];
771
    uint8_t  next[64];
772
    uint8_t  sign[64];
773
    uint8_t  partial_bit_count;
774
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
775
} EncBlockInfo;
776

    
777
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
778
                                                    PutBitContext* pb_pool,
779
                                                    PutBitContext* pb_end)
780
{
781
    int prev, bits_left;
782
    PutBitContext* pb = pb_pool;
783
    int size = bi->partial_bit_count;
784
    uint32_t vlc = bi->partial_bit_buffer;
785

    
786
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
787
    for (;;){
788
       /* Find suitable storage space */
789
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
790
          if (bits_left) {
791
              size -= bits_left;
792
              put_bits(pb, bits_left, vlc >> size);
793
              vlc = vlc & ((1 << size) - 1);
794
          }
795
          if (pb + 1 >= pb_end) {
796
              bi->partial_bit_count  = size;
797
              bi->partial_bit_buffer = vlc;
798
              return pb;
799
          }
800
       }
801

    
802
       /* Store VLC */
803
       put_bits(pb, size, vlc);
804

    
805
       if (bi->cur_ac >= 64)
806
           break;
807

    
808
       /* Construct the next VLC */
809
       prev       = bi->cur_ac;
810
       bi->cur_ac = bi->next[prev];
811
       if (bi->cur_ac < 64){
812
           size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
813
       } else {
814
           size = 4; vlc = 6; /* End Of Block stamp */
815
       }
816
    }
817
    return pb;
818
}
819

    
820
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
821
    if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
822
        int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
823
        if (ps > 0) {
824
            int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
825
                     s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
826
            return (ps > is);
827
        }
828
    }
829

    
830
    return 0;
831
}
832

    
833
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
834
{
835
    const int *weight;
836
    const uint8_t* zigzag_scan;
837
    LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
838
    int i, area;
839
    /* We offer two different methods for class number assignment: the
840
       method suggested in SMPTE 314M Table 22, and an improved
841
       method. The SMPTE method is very conservative; it assigns class
842
       3 (i.e. severe quantization) to any block where the largest AC
843
       component is greater than 36. FFmpeg's DV encoder tracks AC bit
844
       consumption precisely, so there is no need to bias most blocks
845
       towards strongly lossy compression. Instead, we assign class 2
846
       to most blocks, and use class 3 only when strictly necessary
847
       (for blocks whose largest AC component exceeds 255). */
848

    
849
#if 0 /* SMPTE spec method */
850
    static const int classes[] = {12, 24, 36, 0xffff};
851
#else /* improved FFmpeg method */
852
    static const int classes[] = {-1, -1, 255, 0xffff};
853
#endif
854
    int max  = classes[0];
855
    int prev = 0;
856

    
857
    assert((((int)blk) & 15) == 0);
858

    
859
    bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
860
    bi->partial_bit_count = 0;
861
    bi->partial_bit_buffer = 0;
862
    bi->cur_ac = 0;
863
    if (data) {
864
        bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
865
        s->get_pixels(blk, data, linesize);
866
        s->fdct[bi->dct_mode](blk);
867
    } else {
868
        /* We rely on the fact that encoding all zeros leads to an immediate EOB,
869
           which is precisely what the spec calls for in the "dummy" blocks. */
870
        memset(blk, 0, 64*sizeof(*blk));
871
        bi->dct_mode = 0;
872
    }
873
    bi->mb[0] = blk[0];
874

    
875
    zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
876
    weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
877

    
878
    for (area = 0; area < 4; area++) {
879
       bi->prev[area]     = prev;
880
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
881
       for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
882
          int level = blk[zigzag_scan[i]];
883

    
884
          if (level + 15 > 30U) {
885
              bi->sign[i] = (level >> 31) & 1;
886
              /* weigh it and and shift down into range, adding for rounding */
887
              /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
888
                 AND the 2x doubling of the weights */
889
              level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
890
              bi->mb[i] = level;
891
              if (level > max)
892
                  max = level;
893
              bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
894
              bi->next[prev]= i;
895
              prev = i;
896
          }
897
       }
898
    }
899
    bi->next[prev]= i;
900
    for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
901

    
902
    bi->cno += bias;
903

    
904
    if (bi->cno >= 3) {
905
        bi->cno = 3;
906
        prev    = 0;
907
        i       = bi->next[prev];
908
        for (area = 0; area < 4; area++) {
909
            bi->prev[area]     = prev;
910
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
911
            for (; i < mb_area_start[area+1]; i = bi->next[i]) {
912
                bi->mb[i] >>= 1;
913

    
914
                if (bi->mb[i]) {
915
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
916
                    bi->next[prev]= i;
917
                    prev = i;
918
                }
919
            }
920
        }
921
        bi->next[prev]= i;
922
    }
923

    
924
    return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
925
}
926

    
927
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
928
{
929
    int size[5];
930
    int i, j, k, a, prev, a2;
931
    EncBlockInfo* b;
932

    
933
    size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
934
    do {
935
       b = blks;
936
       for (i = 0; i < 5; i++) {
937
          if (!qnos[i])
938
              continue;
939

    
940
          qnos[i]--;
941
          size[i] = 0;
942
          for (j = 0; j < 6; j++, b++) {
943
             for (a = 0; a < 4; a++) {
944
                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
945
                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
946
                    b->area_q[a]++;
947
                    prev = b->prev[a];
948
                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
949
                    for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
950
                       b->mb[k] >>= 1;
951
                       if (b->mb[k]) {
952
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
953
                           prev = k;
954
                       } else {
955
                           if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
956
                                for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
957
                                    b->prev[a2] = prev;
958
                                assert(a2 < 4);
959
                                assert(b->mb[b->next[k]]);
960
                                b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
961
                                                  -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
962
                                assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
963
                                b->prev[a2] = prev;
964
                           }
965
                           b->next[prev] = b->next[k];
966
                       }
967
                    }
968
                    b->prev[a+1]= prev;
969
                }
970
                size[i] += b->bit_size[a];
971
             }
972
          }
973
          if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
974
                return;
975
       }
976
    } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
977

    
978

    
979
    for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
980
        b = blks;
981
        size[0] = 5 * 6 * 4; //EOB
982
        for (j = 0; j < 6 *5; j++, b++) {
983
            prev = b->prev[0];
984
            for (k = b->next[prev]; k < 64; k = b->next[k]) {
985
                if (b->mb[k] < a && b->mb[k] > -a){
986
                    b->next[prev] = b->next[k];
987
                }else{
988
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
989
                    prev = k;
990
                }
991
            }
992
        }
993
    }
994
}
995

    
996
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
997
{
998
    DVVideoContext *s = avctx->priv_data;
999
    DVwork_chunk *work_chunk = arg;
1000
    int mb_index, i, j;
1001
    int mb_x, mb_y, c_offset, linesize, y_stride;
1002
    uint8_t*  y_ptr;
1003
    uint8_t*  dif;
1004
    uint8_t   scratch[64];
1005
    EncBlockInfo  enc_blks[5*DV_MAX_BPM];
1006
    PutBitContext pbs[5*DV_MAX_BPM];
1007
    PutBitContext* pb;
1008
    EncBlockInfo* enc_blk;
1009
    int       vs_bit_size = 0;
1010
    int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1011
    int*      qnosp = &qnos[0];
1012

    
1013
    dif = &s->buf[work_chunk->buf_offset*80];
1014
    enc_blk = &enc_blks[0];
1015
    for (mb_index = 0; mb_index < 5; mb_index++) {
1016
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1017

    
1018
        /* initializing luminance blocks */
1019
        if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1020
            (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1021
            (s->sys->height >= 720 && mb_y != 134)) {
1022
            y_stride = s->picture.linesize[0] << 3;
1023
        } else {
1024
            y_stride = 16;
1025
        }
1026
        y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1027
        linesize = s->picture.linesize[0];
1028

    
1029
        if (s->sys->video_stype == 4) { /* SD 422 */
1030
            vs_bit_size +=
1031
            dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1032
            dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
1033
            dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
1034
            dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
1035
        } else {
1036
            vs_bit_size +=
1037
            dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1038
            dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
1039
            dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
1040
            dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1041
        }
1042
        enc_blk += 4;
1043

    
1044
        /* initializing chrominance blocks */
1045
        c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1046
                     (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1047
        for (j = 2; j; j--) {
1048
            uint8_t *c_ptr = s->picture.data[j] + c_offset;
1049
            linesize = s->picture.linesize[j];
1050
            y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1051
            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1052
                uint8_t* d;
1053
                uint8_t* b = scratch;
1054
                for (i = 0; i < 8; i++) {
1055
                    d = c_ptr + (linesize << 3);
1056
                    b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1057
                    b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1058
                    c_ptr += linesize;
1059
                    b += 8;
1060
                }
1061
                c_ptr = scratch;
1062
                linesize = 8;
1063
            }
1064

    
1065
            vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1066
            if (s->sys->bpm == 8) {
1067
                vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1068
            }
1069
        }
1070
    }
1071

    
1072
    if (vs_total_ac_bits < vs_bit_size)
1073
        dv_guess_qnos(&enc_blks[0], qnosp);
1074

    
1075
    /* DIF encoding process */
1076
    for (j=0; j<5*s->sys->bpm;) {
1077
        int start_mb = j;
1078

    
1079
        dif[3] = *qnosp++;
1080
        dif += 4;
1081

    
1082
        /* First pass over individual cells only */
1083
        for (i=0; i<s->sys->bpm; i++, j++) {
1084
            int sz = s->sys->block_sizes[i]>>3;
1085

    
1086
            init_put_bits(&pbs[j], dif, sz);
1087
            put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1088
            put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1089
            put_bits(&pbs[j], 2, enc_blks[j].cno);
1090

    
1091
            dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1092
            dif += sz;
1093
        }
1094

    
1095
        /* Second pass over each MB space */
1096
        pb = &pbs[start_mb];
1097
        for (i=0; i<s->sys->bpm; i++) {
1098
            if (enc_blks[start_mb+i].partial_bit_count)
1099
                pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1100
        }
1101
    }
1102

    
1103
    /* Third and final pass over the whole video segment space */
1104
    pb = &pbs[0];
1105
    for (j=0; j<5*s->sys->bpm; j++) {
1106
       if (enc_blks[j].partial_bit_count)
1107
           pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1108
       if (enc_blks[j].partial_bit_count)
1109
            av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1110
    }
1111

    
1112
    for (j=0; j<5*s->sys->bpm; j++) {
1113
       int pos;
1114
       int size = pbs[j].size_in_bits >> 3;
1115
       flush_put_bits(&pbs[j]);
1116
       pos = put_bits_count(&pbs[j]) >> 3;
1117
       if (pos > size) {
1118
           av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1119
           return -1;
1120
       }
1121
       memset(pbs[j].buf + pos, 0xff, size - pos);
1122
    }
1123

    
1124
    return 0;
1125
}
1126

    
1127
#if CONFIG_DVVIDEO_DECODER
1128
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1129
   144000 bytes for PAL - or twice those for 50Mbps) */
1130
static int dvvideo_decode_frame(AVCodecContext *avctx,
1131
                                 void *data, int *data_size,
1132
                                 AVPacket *avpkt)
1133
{
1134
    const uint8_t *buf = avpkt->data;
1135
    int buf_size = avpkt->size;
1136
    DVVideoContext *s = avctx->priv_data;
1137

    
1138
    s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1139
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1140
        av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1141
        return -1; /* NOTE: we only accept several full frames */
1142
    }
1143

    
1144
    if (s->picture.data[0])
1145
        avctx->release_buffer(avctx, &s->picture);
1146

    
1147
    s->picture.reference = 0;
1148
    s->picture.key_frame = 1;
1149
    s->picture.pict_type = FF_I_TYPE;
1150
    avctx->pix_fmt   = s->sys->pix_fmt;
1151
    avctx->time_base = s->sys->time_base;
1152
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1153
    if (avctx->get_buffer(avctx, &s->picture) < 0) {
1154
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1155
        return -1;
1156
    }
1157
    s->picture.interlaced_frame = 1;
1158
    s->picture.top_field_first  = 0;
1159

    
1160
    s->buf = buf;
1161
    avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1162
                   dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1163

    
1164
    emms_c();
1165

    
1166
    /* return image */
1167
    *data_size = sizeof(AVFrame);
1168
    *(AVFrame*)data = s->picture;
1169

    
1170
    return s->sys->frame_size;
1171
}
1172
#endif /* CONFIG_DVVIDEO_DECODER */
1173

    
1174

    
1175
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1176
                                uint8_t* buf)
1177
{
1178
    /*
1179
     * Here's what SMPTE314M says about these two:
1180
     *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1181
     *             as track application IDs (APTn = 001, AP1n =
1182
     *             001, AP2n = 001, AP3n = 001), if the source signal
1183
     *             comes from a digital VCR. If the signal source is
1184
     *             unknown, all bits for these data shall be set to 1.
1185
     *    (page 12) STYPE: STYPE defines a signal type of video signal
1186
     *                     00000b = 4:1:1 compression
1187
     *                     00100b = 4:2:2 compression
1188
     *                     XXXXXX = Reserved
1189
     * Now, I've got two problems with these statements:
1190
     *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1191
     *      It seems that for PAL as defined in IEC 61834 we have to set
1192
     *      APT to 000 and for SMPTE314M to 001.
1193
     *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1194
     *      compression scheme (if any).
1195
     */
1196
    int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1197

    
1198
    uint8_t aspect = 0;
1199
    if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1200
        aspect = 0x02;
1201

    
1202
    buf[0] = (uint8_t)pack_id;
1203
    switch (pack_id) {
1204
    case dv_header525: /* I can't imagine why these two weren't defined as real */
1205
    case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1206
          buf[1] = 0xf8 |        /* reserved -- always 1 */
1207
                   (apt & 0x07); /* APT: Track application ID */
1208
          buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1209
                   (0x0f << 3) | /* reserved -- always 1 */
1210
                   (apt & 0x07); /* AP1: Audio application ID */
1211
          buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1212
                   (0x0f << 3) | /* reserved -- always 1 */
1213
                   (apt & 0x07); /* AP2: Video application ID */
1214
          buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1215
                   (0x0f << 3) | /* reserved -- always 1 */
1216
                   (apt & 0x07); /* AP3: Subcode application ID */
1217
          break;
1218
    case dv_video_source:
1219
          buf[1] = 0xff;      /* reserved -- always 1 */
1220
          buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1221
                   (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1222
                   (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1223
                   0xf;       /* reserved -- always 1 */
1224
          buf[3] = (3 << 6) | /* reserved -- always 1 */
1225
                   (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1226
                   c->sys->video_stype; /* signal type video compression */
1227
          buf[4] = 0xff;      /* VISC: 0xff -- no information */
1228
          break;
1229
    case dv_video_control:
1230
          buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1231
                   0x3f;      /* reserved -- always 1 */
1232
          buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1233
                   aspect;
1234
          buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1235
                   (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1236
                   (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1237
                   (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1238
                   0xc;       /* reserved -- always b1100 */
1239
          buf[4] = 0xff;      /* reserved -- always 1 */
1240
          break;
1241
    default:
1242
          buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1243
    }
1244
    return 5;
1245
}
1246

    
1247
#if CONFIG_DVVIDEO_ENCODER
1248
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1249
{
1250
    int chan, i, j, k;
1251

    
1252
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1253
        for (i = 0; i < c->sys->difseg_size; i++) {
1254
            memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1255

    
1256
            /* DV header: 1DIF */
1257
            buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1258
            buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1259
            buf += 72; /* unused bytes */
1260

    
1261
            /* DV subcode: 2DIFs */
1262
            for (j = 0; j < 2; j++) {
1263
                buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1264
                for (k = 0; k < 6; k++)
1265
                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1266
                buf += 29; /* unused bytes */
1267
            }
1268

    
1269
            /* DV VAUX: 3DIFS */
1270
            for (j = 0; j < 3; j++) {
1271
                buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1272
                buf += dv_write_pack(dv_video_source,  c, buf);
1273
                buf += dv_write_pack(dv_video_control, c, buf);
1274
                buf += 7*5;
1275
                buf += dv_write_pack(dv_video_source,  c, buf);
1276
                buf += dv_write_pack(dv_video_control, c, buf);
1277
                buf += 4*5 + 2; /* unused bytes */
1278
            }
1279

    
1280
            /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1281
            for (j = 0; j < 135; j++) {
1282
                if (j%15 == 0) {
1283
                    memset(buf, 0xff, 80);
1284
                    buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1285
                    buf += 77; /* audio control & shuffled PCM audio */
1286
                }
1287
                buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1288
                buf += 77; /* 1 video macroblock: 1 bytes control
1289
                              4 * 14 bytes Y 8x8 data
1290
                              10 bytes Cr 8x8 data
1291
                              10 bytes Cb 8x8 data */
1292
            }
1293
        }
1294
    }
1295
}
1296

    
1297

    
1298
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1299
                                void *data)
1300
{
1301
    DVVideoContext *s = c->priv_data;
1302

    
1303
    s->sys = ff_dv_codec_profile(c);
1304
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1305
        return -1;
1306

    
1307
    c->pix_fmt           = s->sys->pix_fmt;
1308
    s->picture           = *((AVFrame *)data);
1309
    s->picture.key_frame = 1;
1310
    s->picture.pict_type = FF_I_TYPE;
1311

    
1312
    s->buf = buf;
1313
    c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1314
               dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1315

    
1316
    emms_c();
1317

    
1318
    dv_format_frame(s, buf);
1319

    
1320
    return s->sys->frame_size;
1321
}
1322
#endif
1323

    
1324
static int dvvideo_close(AVCodecContext *c)
1325
{
1326
    DVVideoContext *s = c->priv_data;
1327

    
1328
    if (s->picture.data[0])
1329
        c->release_buffer(c, &s->picture);
1330

    
1331
    return 0;
1332
}
1333

    
1334

    
1335
#if CONFIG_DVVIDEO_ENCODER
1336
AVCodec dvvideo_encoder = {
1337
    "dvvideo",
1338
    CODEC_TYPE_VIDEO,
1339
    CODEC_ID_DVVIDEO,
1340
    sizeof(DVVideoContext),
1341
    dvvideo_init_encoder,
1342
    dvvideo_encode_frame,
1343
    .pix_fmts  = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1344
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1345
};
1346
#endif // CONFIG_DVVIDEO_ENCODER
1347

    
1348
#if CONFIG_DVVIDEO_DECODER
1349
AVCodec dvvideo_decoder = {
1350
    "dvvideo",
1351
    CODEC_TYPE_VIDEO,
1352
    CODEC_ID_DVVIDEO,
1353
    sizeof(DVVideoContext),
1354
    dvvideo_init,
1355
    NULL,
1356
    dvvideo_close,
1357
    dvvideo_decode_frame,
1358
    CODEC_CAP_DR1,
1359
    NULL,
1360
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1361
};
1362
#endif