Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
[ffmpeg.git] / libavcodec / dv.c
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 "bitstream.h"
44 #include "simple_idct.h"
45 #include "dvdata.h"
46
47 //#undef NDEBUG
48 //#include <assert.h>
49
50 typedef struct DVVideoContext {
51     const DVprofile *sys;
52     AVFrame          picture;
53     AVCodecContext  *avctx;
54     uint8_t         *buf;
55
56     uint8_t  dv_zigzag[2][64];
57
58     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
59     void (*fdct[2])(DCTELEM *block);
60     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
61     me_cmp_func ildct_cmp;
62 } DVVideoContext;
63
64 #define TEX_VLC_BITS 9
65
66 #if CONFIG_SMALL
67 #define DV_VLC_MAP_RUN_SIZE 15
68 #define DV_VLC_MAP_LEV_SIZE 23
69 #else
70 #define DV_VLC_MAP_RUN_SIZE  64
71 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
72 #endif
73
74 /* XXX: also include quantization */
75 static RL_VLC_ELEM dv_rl_vlc[1184];
76 /* VLC encoding lookup table */
77 static struct dv_vlc_pair {
78    uint32_t vlc;
79    uint8_t  size;
80 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
81
82 static inline int dv_work_pool_size(const DVprofile *d)
83 {
84     int size = d->n_difchan*d->difseg_size*27;
85     if (DV_PROFILE_IS_1080i50(d))
86         size -= 3*27;
87     if (DV_PROFILE_IS_720p50(d))
88         size -= 4*27;
89     return size;
90 }
91
92 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
93                                           uint16_t *tbl)
94 {
95     static const uint8_t off[] = { 2, 6, 8, 0, 4 };
96     static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
97     static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
98     static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
99
100     static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
101     static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
102
103     static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
104                                        0, 1, 2, 2, 1, 0,
105                                        0, 1, 2, 2, 1, 0,
106                                        0, 1, 2, 2, 1, 0,
107                                        0, 1, 2};
108     static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
109                                        0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
110                                        0, 1, 2, 3, 4, 5};
111
112     static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
113                                        { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
114                                        {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
115                                        {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
116                                        {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
117                                        {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
118                                        {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
119                                        {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
120                                        {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
121                                        {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
122                                        {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
123                                        {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
124                                        {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
125
126     int i, k, m;
127     int x, y, blk;
128
129     for (m=0; m<5; m++) {
130          switch (d->width) {
131          case 1440:
132               blk = (chan*11+seq)*27+slot;
133
134               if (chan == 0 && seq == 11) {
135                   x = m*27+slot;
136                   if (x<90) {
137                       y = 0;
138                   } else {
139                       x = (x - 90)*2;
140                       y = 67;
141                   }
142               } else {
143                   i = (4*chan + blk + off[m])%11;
144                   k = (blk/11)%27;
145
146                   x = shuf1[m] + (chan&1)*9 + k%9;
147                   y = (i*3+k/9)*2 + (chan>>1) + 1;
148               }
149               tbl[m] = (x<<1)|(y<<9);
150               break;
151          case 1280:
152               blk = (chan*10+seq)*27+slot;
153
154               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
155               k = (blk/5)%27;
156
157               x = shuf1[m]+(chan&1)*9 + k%9;
158               y = (i*3+k/9)*2 + (chan>>1) + 4;
159
160               if (x >= 80) {
161                   x = remap[y][0]+((x-80)<<(y>59));
162                   y = remap[y][1];
163               }
164               tbl[m] = (x<<1)|(y<<9);
165               break;
166        case 960:
167               blk = (chan*10+seq)*27+slot;
168
169               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
170               k = (blk/5)%27 + (i&1)*3;
171
172               x = shuf2[m] + k%6 + 6*(chan&1);
173               y = l_start[i] + k/6 + 45*(chan>>1);
174               tbl[m] = (x<<1)|(y<<9);
175               break;
176         case 720:
177               switch (d->pix_fmt) {
178               case PIX_FMT_YUV422P:
179                    x = shuf3[m] + slot/3;
180                    y = serpent1[slot] +
181                        ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
182                    tbl[m] = (x<<1)|(y<<8);
183                    break;
184               case PIX_FMT_YUV420P:
185                    x = shuf3[m] + slot/3;
186                    y = serpent1[slot] +
187                        ((seq + off[m]) % d->difseg_size)*3;
188                    tbl[m] = (x<<1)|(y<<9);
189                    break;
190               case PIX_FMT_YUV411P:
191                    i = (seq + off[m]) % d->difseg_size;
192                    k = slot + ((m==1||m==2)?3:0);
193
194                    x = l_start_shuffled[m] + k/6;
195                    y = serpent2[k] + i*6;
196                    if (x>21)
197                        y = y*2 - i*6;
198                    tbl[m] = (x<<2)|(y<<8);
199                    break;
200               }
201         default:
202               break;
203         }
204     }
205 }
206
207 static int dv_init_dynamic_tables(const DVprofile *d)
208 {
209     int j,i,c,s,p;
210     uint32_t *factor1, *factor2;
211     const int *iweight1, *iweight2;
212
213     if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
214         p = i = 0;
215         for (c=0; c<d->n_difchan; c++) {
216             for (s=0; s<d->difseg_size; s++) {
217                 p += 6;
218                 for (j=0; j<27; j++) {
219                     p += !(j%3);
220                     if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
221                         !(DV_PROFILE_IS_720p50(d) && s > 9)) {
222                           dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
223                           d->work_chunks[i++].buf_offset = p;
224                     }
225                     p += 5;
226                 }
227             }
228         }
229     }
230
231     if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
232         factor1 = &d->idct_factor[0];
233         factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
234         if (d->height == 720) {
235             iweight1 = &dv_iweight_720_y[0];
236             iweight2 = &dv_iweight_720_c[0];
237         } else {
238             iweight1 = &dv_iweight_1080_y[0];
239             iweight2 = &dv_iweight_1080_c[0];
240             }
241         if (DV_PROFILE_IS_HD(d)) {
242             for (c = 0; c < 4; c++) {
243                 for (s = 0; s < 16; s++) {
244                     for (i = 0; i < 64; i++) {
245                         *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
246                         *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
247                     }
248                 }
249             }
250         } else {
251             iweight1 = &dv_iweight_88[0];
252             for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
253                 for (s = 0; s < 22; s++) {
254                     for (i = c = 0; c < 4; c++) {
255                         for (; i < dv_quant_areas[c]; i++) {
256                             *factor1   = iweight1[i] << (dv_quant_shifts[s][c] + 1);
257                             *factor2++ = (*factor1++) << 1;
258         }
259     }
260             }
261         }
262     }
263 }
264
265     return 0;
266 }
267
268 static av_cold int dvvideo_init(AVCodecContext *avctx)
269 {
270     DVVideoContext *s = avctx->priv_data;
271     DSPContext dsp;
272     static int done = 0;
273     int i, j;
274
275     if (!done) {
276         VLC dv_vlc;
277         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
278         uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
279         uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
280         int16_t  new_dv_vlc_level[NB_DV_VLC*2];
281
282         done = 1;
283
284         /* it's faster to include sign bit in a generic VLC parsing scheme */
285         for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
286             new_dv_vlc_bits[j]  = dv_vlc_bits[i];
287             new_dv_vlc_len[j]   = dv_vlc_len[i];
288             new_dv_vlc_run[j]   = dv_vlc_run[i];
289             new_dv_vlc_level[j] = dv_vlc_level[i];
290
291             if (dv_vlc_level[i]) {
292                 new_dv_vlc_bits[j] <<= 1;
293                 new_dv_vlc_len[j]++;
294
295                 j++;
296                 new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
297                 new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
298                 new_dv_vlc_run[j]   =  dv_vlc_run[i];
299                 new_dv_vlc_level[j] = -dv_vlc_level[i];
300             }
301         }
302
303         /* NOTE: as a trick, we use the fact the no codes are unused
304            to accelerate the parsing of partial codes */
305         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
306                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
307         assert(dv_vlc.table_size == 1184);
308
309         for (i = 0; i < dv_vlc.table_size; i++){
310             int code = dv_vlc.table[i][0];
311             int len  = dv_vlc.table[i][1];
312             int level, run;
313
314             if (len < 0){ //more bits needed
315                 run   = 0;
316                 level = code;
317             } else {
318                 run   = new_dv_vlc_run  [code] + 1;
319                 level = new_dv_vlc_level[code];
320             }
321             dv_rl_vlc[i].len   = len;
322             dv_rl_vlc[i].level = level;
323             dv_rl_vlc[i].run   = run;
324         }
325         free_vlc(&dv_vlc);
326
327         for (i = 0; i < NB_DV_VLC - 1; i++) {
328            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
329                continue;
330 #if CONFIG_SMALL
331            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
332                continue;
333 #endif
334
335            if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
336                continue;
337
338            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc  =
339                dv_vlc_bits[i] << (!!dv_vlc_level[i]);
340            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
341                dv_vlc_len[i] + (!!dv_vlc_level[i]);
342         }
343         for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
344 #if CONFIG_SMALL
345            for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
346               if (dv_vlc_map[i][j].size == 0) {
347                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
348                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
349                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
350                                           dv_vlc_map[0][j].size;
351               }
352            }
353 #else
354            for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
355               if (dv_vlc_map[i][j].size == 0) {
356                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
357                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
358                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
359                                           dv_vlc_map[0][j].size;
360               }
361               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
362                                             dv_vlc_map[i][j].vlc | 1;
363               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
364                                             dv_vlc_map[i][j].size;
365            }
366 #endif
367         }
368     }
369
370     /* Generic DSP setup */
371     dsputil_init(&dsp, avctx);
372     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
373     s->get_pixels = dsp.get_pixels;
374     s->ildct_cmp = dsp.ildct_cmp[5];
375
376     /* 88DCT setup */
377     s->fdct[0]     = dsp.fdct;
378     s->idct_put[0] = dsp.idct_put;
379     for (i = 0; i < 64; i++)
380        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
381
382     /* 248DCT setup */
383     s->fdct[1]     = dsp.fdct248;
384     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
385     if (avctx->lowres){
386         for (i = 0; i < 64; i++){
387             int j = ff_zigzag248_direct[i];
388             s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
389         }
390     }else
391         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
392
393     avctx->coded_frame = &s->picture;
394     s->avctx = avctx;
395
396     return 0;
397 }
398
399 // #define VLC_DEBUG
400 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
401
402 typedef struct BlockInfo {
403     const uint32_t *factor_table;
404     const uint8_t *scan_table;
405     uint8_t pos; /* position in block */
406     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
407     uint8_t partial_bit_count;
408     uint16_t partial_bit_buffer;
409     int shift_offset;
410 } BlockInfo;
411
412 /* bit budget for AC only in 5 MBs */
413 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
414 /* see dv_88_areas and dv_248_areas for details */
415 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
416
417 static inline int get_bits_left(GetBitContext *s)
418 {
419     return s->size_in_bits - get_bits_count(s);
420 }
421
422 static inline int put_bits_left(PutBitContext* s)
423 {
424     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
425 }
426
427 /* decode ac coefficients */
428 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
429 {
430     int last_index = gb->size_in_bits;
431     const uint8_t  *scan_table   = mb->scan_table;
432     const uint32_t *factor_table = mb->factor_table;
433     int pos               = mb->pos;
434     int partial_bit_count = mb->partial_bit_count;
435     int level, run, vlc_len, index;
436
437     OPEN_READER(re, gb);
438     UPDATE_CACHE(re, gb);
439
440     /* if we must parse a partial vlc, we do it here */
441     if (partial_bit_count > 0) {
442         re_cache = ((unsigned)re_cache >> partial_bit_count) |
443                    (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
444         re_index -= partial_bit_count;
445         mb->partial_bit_count = 0;
446     }
447
448     /* get the AC coefficients until last_index is reached */
449     for (;;) {
450 #ifdef VLC_DEBUG
451         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
452 #endif
453         /* our own optimized GET_RL_VLC */
454         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
455         vlc_len = dv_rl_vlc[index].len;
456         if (vlc_len < 0) {
457             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
458             vlc_len = TEX_VLC_BITS - vlc_len;
459         }
460         level = dv_rl_vlc[index].level;
461         run   = dv_rl_vlc[index].run;
462
463         /* gotta check if we're still within gb boundaries */
464         if (re_index + vlc_len > last_index) {
465             /* should be < 16 bits otherwise a codeword could have been parsed */
466             mb->partial_bit_count = last_index - re_index;
467             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
468             re_index = last_index;
469             break;
470         }
471         re_index += vlc_len;
472
473 #ifdef VLC_DEBUG
474         printf("run=%d level=%d\n", run, level);
475 #endif
476         pos += run;
477         if (pos >= 64)
478             break;
479
480         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
481         block[scan_table[pos]] = level;
482
483         UPDATE_CACHE(re, gb);
484     }
485     CLOSE_READER(re, gb);
486     mb->pos = pos;
487 }
488
489 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
490 {
491     int bits_left = get_bits_left(gb);
492     while (bits_left >= MIN_CACHE_BITS) {
493         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
494         bits_left -= MIN_CACHE_BITS;
495     }
496     if (bits_left > 0) {
497         put_bits(pb, bits_left, get_bits(gb, bits_left));
498     }
499 }
500
501 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
502 {
503      *mb_x = work_chunk->mb_coordinates[m] & 0xff;
504      *mb_y = work_chunk->mb_coordinates[m] >> 8;
505
506      /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
507      if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
508          *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
509      }
510 }
511
512 /* mb_x and mb_y are in units of 8 pixels */
513 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
514 {
515     DVVideoContext *s = avctx->priv_data;
516     DVwork_chunk *work_chunk = arg;
517     int quant, dc, dct_mode, class1, j;
518     int mb_index, mb_x, mb_y, last_index;
519     int y_stride, linesize;
520     DCTELEM *block, *block1;
521     int c_offset;
522     uint8_t *y_ptr;
523     const uint8_t *buf_ptr;
524     PutBitContext pb, vs_pb;
525     GetBitContext gb;
526     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
527     DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
528     DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
529     DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
530     const int log2_blocksize = 3-s->avctx->lowres;
531     int is_field_mode[5];
532
533     assert((((int)mb_bit_buffer) & 7) == 0);
534     assert((((int)vs_bit_buffer) & 7) == 0);
535
536     memset(sblock, 0, sizeof(sblock));
537
538     /* pass 1 : read DC and AC coefficients in blocks */
539     buf_ptr = &s->buf[work_chunk->buf_offset*80];
540     block1  = &sblock[0][0];
541     mb1     = mb_data;
542     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
543     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
544         /* skip header */
545         quant = buf_ptr[3] & 0x0f;
546         buf_ptr += 4;
547         init_put_bits(&pb, mb_bit_buffer, 80);
548         mb    = mb1;
549         block = block1;
550         is_field_mode[mb_index] = 0;
551         for (j = 0; j < s->sys->bpm; j++) {
552             last_index = s->sys->block_sizes[j];
553             init_get_bits(&gb, buf_ptr, last_index);
554
555             /* get the dc */
556             dc       = get_sbits(&gb, 9);
557             dct_mode = get_bits1(&gb);
558             class1   = get_bits(&gb, 2);
559             if (DV_PROFILE_IS_HD(s->sys)) {
560                 mb->idct_put     = s->idct_put[0];
561                 mb->scan_table   = s->dv_zigzag[0];
562                 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
563                 is_field_mode[mb_index] |= !j && dct_mode;
564             } else {
565                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
566                 mb->scan_table   = s->dv_zigzag[dct_mode];
567                 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
568                                                         (quant + dv_quant_offset[class1])*64];
569             }
570             dc = dc << 2;
571             /* convert to unsigned because 128 is not added in the
572                standard IDCT */
573             dc += 1024;
574             block[0] = dc;
575             buf_ptr += last_index >> 3;
576             mb->pos               = 0;
577             mb->partial_bit_count = 0;
578
579 #ifdef VLC_DEBUG
580             printf("MB block: %d, %d ", mb_index, j);
581 #endif
582             dv_decode_ac(&gb, mb, block);
583
584             /* write the remaining bits  in a new buffer only if the
585                block is finished */
586             if (mb->pos >= 64)
587                 bit_copy(&pb, &gb);
588
589             block += 64;
590             mb++;
591         }
592
593         /* pass 2 : we can do it just after */
594 #ifdef VLC_DEBUG
595         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
596 #endif
597         block = block1;
598         mb    = mb1;
599         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
600         flush_put_bits(&pb);
601         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
602             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
603                 dv_decode_ac(&gb, mb, block);
604                 /* if still not finished, no need to parse other blocks */
605                 if (mb->pos < 64)
606                     break;
607             }
608         }
609         /* all blocks are finished, so the extra bytes can be used at
610            the video segment level */
611         if (j >= s->sys->bpm)
612             bit_copy(&vs_pb, &gb);
613     }
614
615     /* we need a pass other the whole video segment */
616 #ifdef VLC_DEBUG
617     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
618 #endif
619     block = &sblock[0][0];
620     mb    = mb_data;
621     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
622     flush_put_bits(&vs_pb);
623     for (mb_index = 0; mb_index < 5; mb_index++) {
624         for (j = 0; j < s->sys->bpm; j++) {
625             if (mb->pos < 64) {
626 #ifdef VLC_DEBUG
627                 printf("start %d:%d\n", mb_index, j);
628 #endif
629                 dv_decode_ac(&gb, mb, block);
630             }
631             if (mb->pos >= 64 && mb->pos < 127)
632                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
633             block += 64;
634             mb++;
635         }
636     }
637
638     /* compute idct and place blocks */
639     block = &sblock[0][0];
640     mb    = mb_data;
641     for (mb_index = 0; mb_index < 5; mb_index++) {
642         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
643
644         /* idct_put'ting luminance */
645         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
646             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
647             (s->sys->height >= 720 && mb_y != 134)) {
648             y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
649         } else {
650             y_stride = (2 << log2_blocksize);
651         }
652         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
653         linesize = s->picture.linesize[0] << is_field_mode[mb_index];
654         mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
655         if (s->sys->video_stype == 4) { /* SD 422 */
656             mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
657         } else {
658             mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
659             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
660             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
661         }
662         mb += 4;
663         block += 4*64;
664
665         /* idct_put'ting chrominance */
666         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
667                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
668         for (j = 2; j; j--) {
669             uint8_t *c_ptr = s->picture.data[j] + c_offset;
670             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
671                   uint64_t aligned_pixels[64/8];
672                   uint8_t *pixels = (uint8_t*)aligned_pixels;
673                   uint8_t *c_ptr1, *ptr1;
674                   int x, y;
675                   mb->idct_put(pixels, 8, block);
676                   for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
677                       ptr1   = pixels + (1 << (log2_blocksize - 1));
678                       c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
679                       for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
680                           c_ptr[x]  = pixels[x];
681                           c_ptr1[x] = ptr1[x];
682                       }
683                   }
684                   block += 64; mb++;
685             } else {
686                   y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
687                                              s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
688                   linesize = s->picture.linesize[j] << is_field_mode[mb_index];
689                   (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
690                   if (s->sys->bpm == 8) {
691                       (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
692                   }
693             }
694         }
695     }
696     return 0;
697 }
698
699 #if CONFIG_SMALL
700 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
701 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
702 {
703     int size;
704     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
705         *vlc = dv_vlc_map[run][level].vlc | sign;
706         size = dv_vlc_map[run][level].size;
707     }
708     else {
709         if (level < DV_VLC_MAP_LEV_SIZE) {
710             *vlc = dv_vlc_map[0][level].vlc | sign;
711             size = dv_vlc_map[0][level].size;
712         } else {
713             *vlc = 0xfe00 | (level << 1) | sign;
714             size = 16;
715         }
716         if (run) {
717             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
718                                   (0x1f80 | (run - 1))) << size;
719             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
720         }
721     }
722
723     return size;
724 }
725
726 static av_always_inline int dv_rl2vlc_size(int run, int level)
727 {
728     int size;
729
730     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
731         size = dv_vlc_map[run][level].size;
732     }
733     else {
734         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
735         if (run) {
736             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
737         }
738     }
739     return size;
740 }
741 #else
742 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
743 {
744     *vlc = dv_vlc_map[run][l].vlc | sign;
745     return dv_vlc_map[run][l].size;
746 }
747
748 static av_always_inline int dv_rl2vlc_size(int run, int l)
749 {
750     return dv_vlc_map[run][l].size;
751 }
752 #endif
753
754 typedef struct EncBlockInfo {
755     int      area_q[4];
756     int      bit_size[4];
757     int      prev[5];
758     int      cur_ac;
759     int      cno;
760     int      dct_mode;
761     DCTELEM  mb[64];
762     uint8_t  next[64];
763     uint8_t  sign[64];
764     uint8_t  partial_bit_count;
765     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
766 } EncBlockInfo;
767
768 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
769                                                     PutBitContext* pb_pool,
770                                                     PutBitContext* pb_end)
771 {
772     int prev, bits_left;
773     PutBitContext* pb = pb_pool;
774     int size = bi->partial_bit_count;
775     uint32_t vlc = bi->partial_bit_buffer;
776
777     bi->partial_bit_count = bi->partial_bit_buffer = 0;
778     for (;;){
779        /* Find suitable storage space */
780        for (; size > (bits_left = put_bits_left(pb)); pb++) {
781           if (bits_left) {
782               size -= bits_left;
783               put_bits(pb, bits_left, vlc >> size);
784               vlc = vlc & ((1 << size) - 1);
785           }
786           if (pb + 1 >= pb_end) {
787               bi->partial_bit_count  = size;
788               bi->partial_bit_buffer = vlc;
789               return pb;
790           }
791        }
792
793        /* Store VLC */
794        put_bits(pb, size, vlc);
795
796        if (bi->cur_ac >= 64)
797            break;
798
799        /* Construct the next VLC */
800        prev       = bi->cur_ac;
801        bi->cur_ac = bi->next[prev];
802        if (bi->cur_ac < 64){
803            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
804        } else {
805            size = 4; vlc = 6; /* End Of Block stamp */
806        }
807     }
808     return pb;
809 }
810
811 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
812     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
813         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
814         if (ps > 0) {
815             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
816                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
817             return (ps > is);
818         }
819     }
820
821     return 0;
822 }
823
824 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
825 {
826     const int *weight;
827     const uint8_t* zigzag_scan;
828     DECLARE_ALIGNED_16(DCTELEM, blk[64]);
829     int i, area;
830     /* We offer two different methods for class number assignment: the
831        method suggested in SMPTE 314M Table 22, and an improved
832        method. The SMPTE method is very conservative; it assigns class
833        3 (i.e. severe quantization) to any block where the largest AC
834        component is greater than 36. FFmpeg's DV encoder tracks AC bit
835        consumption precisely, so there is no need to bias most blocks
836        towards strongly lossy compression. Instead, we assign class 2
837        to most blocks, and use class 3 only when strictly necessary
838        (for blocks whose largest AC component exceeds 255). */
839
840 #if 0 /* SMPTE spec method */
841     static const int classes[] = {12, 24, 36, 0xffff};
842 #else /* improved FFmpeg method */
843     static const int classes[] = {-1, -1, 255, 0xffff};
844 #endif
845     int max  = classes[0];
846     int prev = 0;
847
848     assert((((int)blk) & 15) == 0);
849
850     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
851     bi->partial_bit_count = 0;
852     bi->partial_bit_buffer = 0;
853     bi->cur_ac = 0;
854     if (data) {
855         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
856         s->get_pixels(blk, data, linesize);
857         s->fdct[bi->dct_mode](blk);
858     } else {
859         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
860            which is precisely what the spec calls for in the "dummy" blocks. */
861         memset(blk, 0, sizeof(blk));
862         bi->dct_mode = 0;
863     }
864     bi->mb[0] = blk[0];
865
866     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
867     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
868
869     for (area = 0; area < 4; area++) {
870        bi->prev[area]     = prev;
871        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
872        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
873           int level = blk[zigzag_scan[i]];
874
875           if (level + 15 > 30U) {
876               bi->sign[i] = (level >> 31) & 1;
877               /* weigh it and and shift down into range, adding for rounding */
878               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
879                  AND the 2x doubling of the weights */
880               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
881               bi->mb[i] = level;
882               if (level > max)
883                   max = level;
884               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
885               bi->next[prev]= i;
886               prev = i;
887           }
888        }
889     }
890     bi->next[prev]= i;
891     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
892
893     bi->cno += bias;
894
895     if (bi->cno >= 3) {
896         bi->cno = 3;
897         prev    = 0;
898         i       = bi->next[prev];
899         for (area = 0; area < 4; area++) {
900             bi->prev[area]     = prev;
901             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
902             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
903                 bi->mb[i] >>= 1;
904
905                 if (bi->mb[i]) {
906                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
907                     bi->next[prev]= i;
908                     prev = i;
909                 }
910             }
911         }
912         bi->next[prev]= i;
913     }
914
915     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
916 }
917
918 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
919 {
920     int size[5];
921     int i, j, k, a, prev, a2;
922     EncBlockInfo* b;
923
924     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
925     do {
926        b = blks;
927        for (i = 0; i < 5; i++) {
928           if (!qnos[i])
929               continue;
930
931           qnos[i]--;
932           size[i] = 0;
933           for (j = 0; j < 6; j++, b++) {
934              for (a = 0; a < 4; a++) {
935                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
936                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
937                     b->area_q[a]++;
938                     prev = b->prev[a];
939                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
940                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
941                        b->mb[k] >>= 1;
942                        if (b->mb[k]) {
943                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
944                            prev = k;
945                        } else {
946                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
947                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
948                                     b->prev[a2] = prev;
949                                 assert(a2 < 4);
950                                 assert(b->mb[b->next[k]]);
951                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
952                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
953                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
954                                 b->prev[a2] = prev;
955                            }
956                            b->next[prev] = b->next[k];
957                        }
958                     }
959                     b->prev[a+1]= prev;
960                 }
961                 size[i] += b->bit_size[a];
962              }
963           }
964           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
965                 return;
966        }
967     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
968
969
970     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
971         b = blks;
972         size[0] = 5 * 6 * 4; //EOB
973         for (j = 0; j < 6 *5; j++, b++) {
974             prev = b->prev[0];
975             for (k = b->next[prev]; k < 64; k = b->next[k]) {
976                 if (b->mb[k] < a && b->mb[k] > -a){
977                     b->next[prev] = b->next[k];
978                 }else{
979                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
980                     prev = k;
981                 }
982             }
983         }
984     }
985 }
986
987 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
988 {
989     DVVideoContext *s = avctx->priv_data;
990     DVwork_chunk *work_chunk = arg;
991     int mb_index, i, j;
992     int mb_x, mb_y, c_offset, linesize, y_stride;
993     uint8_t*  y_ptr;
994     uint8_t*  dif;
995     uint8_t   scratch[64];
996     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
997     PutBitContext pbs[5*DV_MAX_BPM];
998     PutBitContext* pb;
999     EncBlockInfo* enc_blk;
1000     int       vs_bit_size = 0;
1001     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1002     int*      qnosp = &qnos[0];
1003
1004     dif = &s->buf[work_chunk->buf_offset*80];
1005     enc_blk = &enc_blks[0];
1006     for (mb_index = 0; mb_index < 5; mb_index++) {
1007         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1008
1009         /* initializing luminance blocks */
1010         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1011             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1012             (s->sys->height >= 720 && mb_y != 134)) {
1013             y_stride = s->picture.linesize[0] << 3;
1014         } else {
1015             y_stride = 16;
1016         }
1017         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1018         linesize = s->picture.linesize[0];
1019
1020         if (s->sys->video_stype == 4) { /* SD 422 */
1021             vs_bit_size +=
1022             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1023             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
1024             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
1025             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
1026         } else {
1027             vs_bit_size +=
1028             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1029             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
1030             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
1031             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1032         }
1033         enc_blk += 4;
1034
1035         /* initializing chrominance blocks */
1036         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1037                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1038         for (j = 2; j; j--) {
1039             uint8_t *c_ptr = s->picture.data[j] + c_offset;
1040             linesize = s->picture.linesize[j];
1041             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1042             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1043                 uint8_t* d;
1044                 uint8_t* b = scratch;
1045                 for (i = 0; i < 8; i++) {
1046                     d = c_ptr + (linesize << 3);
1047                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1048                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1049                     c_ptr += linesize;
1050                     b += 8;
1051                 }
1052                 c_ptr = scratch;
1053                 linesize = 8;
1054             }
1055
1056             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1057             if (s->sys->bpm == 8) {
1058                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1059             }
1060         }
1061     }
1062
1063     if (vs_total_ac_bits < vs_bit_size)
1064         dv_guess_qnos(&enc_blks[0], qnosp);
1065
1066     /* DIF encoding process */
1067     for (j=0; j<5*s->sys->bpm;) {
1068         int start_mb = j;
1069
1070         dif[3] = *qnosp++;
1071         dif += 4;
1072
1073         /* First pass over individual cells only */
1074         for (i=0; i<s->sys->bpm; i++, j++) {
1075             int sz = s->sys->block_sizes[i]>>3;
1076
1077             init_put_bits(&pbs[j], dif, sz);
1078             put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1079             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1080             put_bits(&pbs[j], 2, enc_blks[j].cno);
1081
1082             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1083             dif += sz;
1084         }
1085
1086         /* Second pass over each MB space */
1087         pb = &pbs[start_mb];
1088         for (i=0; i<s->sys->bpm; i++) {
1089             if (enc_blks[start_mb+i].partial_bit_count)
1090                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1091         }
1092     }
1093
1094     /* Third and final pass over the whole video segment space */
1095     pb = &pbs[0];
1096     for (j=0; j<5*s->sys->bpm; j++) {
1097        if (enc_blks[j].partial_bit_count)
1098            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1099        if (enc_blks[j].partial_bit_count)
1100             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1101     }
1102
1103     for (j=0; j<5*s->sys->bpm; j++)
1104        flush_put_bits(&pbs[j]);
1105
1106     return 0;
1107 }
1108
1109 #if CONFIG_DVVIDEO_DECODER
1110 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1111    144000 bytes for PAL - or twice those for 50Mbps) */
1112 static int dvvideo_decode_frame(AVCodecContext *avctx,
1113                                  void *data, int *data_size,
1114                                  AVPacket *avpkt)
1115 {
1116     const uint8_t *buf = avpkt->data;
1117     int buf_size = avpkt->size;
1118     DVVideoContext *s = avctx->priv_data;
1119
1120     s->sys = dv_frame_profile(buf);
1121     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1122         return -1; /* NOTE: we only accept several full frames */
1123
1124     if (s->picture.data[0])
1125         avctx->release_buffer(avctx, &s->picture);
1126
1127     s->picture.reference = 0;
1128     s->picture.key_frame = 1;
1129     s->picture.pict_type = FF_I_TYPE;
1130     avctx->pix_fmt   = s->sys->pix_fmt;
1131     avctx->time_base = s->sys->time_base;
1132     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1133     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1134         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1135         return -1;
1136     }
1137     s->picture.interlaced_frame = 1;
1138     s->picture.top_field_first  = 0;
1139
1140     s->buf = buf;
1141     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1142                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1143
1144     emms_c();
1145
1146     /* return image */
1147     *data_size = sizeof(AVFrame);
1148     *(AVFrame*)data = s->picture;
1149
1150     return s->sys->frame_size;
1151 }
1152 #endif /* CONFIG_DVVIDEO_DECODER */
1153
1154
1155 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1156                                 uint8_t* buf)
1157 {
1158     /*
1159      * Here's what SMPTE314M says about these two:
1160      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1161      *             as track application IDs (APTn = 001, AP1n =
1162      *             001, AP2n = 001, AP3n = 001), if the source signal
1163      *             comes from a digital VCR. If the signal source is
1164      *             unknown, all bits for these data shall be set to 1.
1165      *    (page 12) STYPE: STYPE defines a signal type of video signal
1166      *                     00000b = 4:1:1 compression
1167      *                     00100b = 4:2:2 compression
1168      *                     XXXXXX = Reserved
1169      * Now, I've got two problems with these statements:
1170      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1171      *      It seems that for PAL as defined in IEC 61834 we have to set
1172      *      APT to 000 and for SMPTE314M to 001.
1173      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1174      *      compression scheme (if any).
1175      */
1176     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1177
1178     uint8_t aspect = 0;
1179     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1180         aspect = 0x02;
1181
1182     buf[0] = (uint8_t)pack_id;
1183     switch (pack_id) {
1184     case dv_header525: /* I can't imagine why these two weren't defined as real */
1185     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1186           buf[1] = 0xf8 |        /* reserved -- always 1 */
1187                    (apt & 0x07); /* APT: Track application ID */
1188           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1189                    (0x0f << 3) | /* reserved -- always 1 */
1190                    (apt & 0x07); /* AP1: Audio application ID */
1191           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1192                    (0x0f << 3) | /* reserved -- always 1 */
1193                    (apt & 0x07); /* AP2: Video application ID */
1194           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1195                    (0x0f << 3) | /* reserved -- always 1 */
1196                    (apt & 0x07); /* AP3: Subcode application ID */
1197           break;
1198     case dv_video_source:
1199           buf[1] = 0xff;      /* reserved -- always 1 */
1200           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1201                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1202                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1203                    0xf;       /* reserved -- always 1 */
1204           buf[3] = (3 << 6) | /* reserved -- always 1 */
1205                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1206                    c->sys->video_stype; /* signal type video compression */
1207           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1208           break;
1209     case dv_video_control:
1210           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1211                    0x3f;      /* reserved -- always 1 */
1212           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1213                    aspect;
1214           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1215                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1216                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1217                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1218                    0xc;       /* reserved -- always b1100 */
1219           buf[4] = 0xff;      /* reserved -- always 1 */
1220           break;
1221     default:
1222           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1223     }
1224     return 5;
1225 }
1226
1227 #if CONFIG_DVVIDEO_ENCODER
1228 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1229 {
1230     int chan, i, j, k;
1231
1232     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1233         for (i = 0; i < c->sys->difseg_size; i++) {
1234             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1235
1236             /* DV header: 1DIF */
1237             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1238             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1239             buf += 72; /* unused bytes */
1240
1241             /* DV subcode: 2DIFs */
1242             for (j = 0; j < 2; j++) {
1243                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1244                 for (k = 0; k < 6; k++)
1245                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1246                 buf += 29; /* unused bytes */
1247             }
1248
1249             /* DV VAUX: 3DIFS */
1250             for (j = 0; j < 3; j++) {
1251                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1252                 buf += dv_write_pack(dv_video_source,  c, buf);
1253                 buf += dv_write_pack(dv_video_control, c, buf);
1254                 buf += 7*5;
1255                 buf += dv_write_pack(dv_video_source,  c, buf);
1256                 buf += dv_write_pack(dv_video_control, c, buf);
1257                 buf += 4*5 + 2; /* unused bytes */
1258             }
1259
1260             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1261             for (j = 0; j < 135; j++) {
1262                 if (j%15 == 0) {
1263                     memset(buf, 0xff, 80);
1264                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1265                     buf += 77; /* audio control & shuffled PCM audio */
1266                 }
1267                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1268                 buf += 77; /* 1 video macroblock: 1 bytes control
1269                               4 * 14 bytes Y 8x8 data
1270                               10 bytes Cr 8x8 data
1271                               10 bytes Cb 8x8 data */
1272             }
1273         }
1274     }
1275 }
1276
1277
1278 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1279                                 void *data)
1280 {
1281     DVVideoContext *s = c->priv_data;
1282
1283     s->sys = dv_codec_profile(c);
1284     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1285         return -1;
1286
1287     c->pix_fmt           = s->sys->pix_fmt;
1288     s->picture           = *((AVFrame *)data);
1289     s->picture.key_frame = 1;
1290     s->picture.pict_type = FF_I_TYPE;
1291
1292     s->buf = buf;
1293     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1294                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1295
1296     emms_c();
1297
1298     dv_format_frame(s, buf);
1299
1300     return s->sys->frame_size;
1301 }
1302 #endif
1303
1304 static int dvvideo_close(AVCodecContext *c)
1305 {
1306     DVVideoContext *s = c->priv_data;
1307
1308     if (s->picture.data[0])
1309         c->release_buffer(c, &s->picture);
1310
1311     return 0;
1312 }
1313
1314
1315 #if CONFIG_DVVIDEO_ENCODER
1316 AVCodec dvvideo_encoder = {
1317     "dvvideo",
1318     CODEC_TYPE_VIDEO,
1319     CODEC_ID_DVVIDEO,
1320     sizeof(DVVideoContext),
1321     dvvideo_init,
1322     dvvideo_encode_frame,
1323     .pix_fmts  = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1324     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1325 };
1326 #endif // CONFIG_DVVIDEO_ENCODER
1327
1328 #if CONFIG_DVVIDEO_DECODER
1329 AVCodec dvvideo_decoder = {
1330     "dvvideo",
1331     CODEC_TYPE_VIDEO,
1332     CODEC_ID_DVVIDEO,
1333     sizeof(DVVideoContext),
1334     dvvideo_init,
1335     NULL,
1336     dvvideo_close,
1337     dvvideo_decode_frame,
1338     CODEC_CAP_DR1,
1339     NULL,
1340     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1341 };
1342 #endif