transitioning dv_guess_dct_mode to dsputil cmp function
[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     } else
820         return 0;
821 }
822
823 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
824 {
825     const int *weight;
826     const uint8_t* zigzag_scan;
827     DECLARE_ALIGNED_16(DCTELEM, blk[64]);
828     int i, area;
829     /* We offer two different methods for class number assignment: the
830        method suggested in SMPTE 314M Table 22, and an improved
831        method. The SMPTE method is very conservative; it assigns class
832        3 (i.e. severe quantization) to any block where the largest AC
833        component is greater than 36. FFmpeg's DV encoder tracks AC bit
834        consumption precisely, so there is no need to bias most blocks
835        towards strongly lossy compression. Instead, we assign class 2
836        to most blocks, and use class 3 only when strictly necessary
837        (for blocks whose largest AC component exceeds 255). */
838
839 #if 0 /* SMPTE spec method */
840     static const int classes[] = {12, 24, 36, 0xffff};
841 #else /* improved FFmpeg method */
842     static const int classes[] = {-1, -1, 255, 0xffff};
843 #endif
844     int max  = classes[0];
845     int prev = 0;
846
847     assert((((int)blk) & 15) == 0);
848
849     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
850     bi->partial_bit_count = 0;
851     bi->partial_bit_buffer = 0;
852     bi->cur_ac = 0;
853     if (data) {
854         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
855         s->get_pixels(blk, data, linesize);
856         s->fdct[bi->dct_mode](blk);
857     } else {
858         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
859            which is precisely what the spec calls for in the "dummy" blocks. */
860         memset(blk, 0, sizeof(blk));
861         bi->dct_mode = 0;
862     }
863     bi->mb[0] = blk[0];
864
865     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
866     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
867
868     for (area = 0; area < 4; area++) {
869        bi->prev[area]     = prev;
870        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
871        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
872           int level = blk[zigzag_scan[i]];
873
874           if (level + 15 > 30U) {
875               bi->sign[i] = (level >> 31) & 1;
876               /* weigh it and and shift down into range, adding for rounding */
877               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
878                  AND the 2x doubling of the weights */
879               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
880               bi->mb[i] = level;
881               if (level > max)
882                   max = level;
883               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
884               bi->next[prev]= i;
885               prev = i;
886           }
887        }
888     }
889     bi->next[prev]= i;
890     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
891
892     bi->cno += bias;
893
894     if (bi->cno >= 3) {
895         bi->cno = 3;
896         prev    = 0;
897         i       = bi->next[prev];
898         for (area = 0; area < 4; area++) {
899             bi->prev[area]     = prev;
900             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
901             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
902                 bi->mb[i] >>= 1;
903
904                 if (bi->mb[i]) {
905                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
906                     bi->next[prev]= i;
907                     prev = i;
908                 }
909             }
910         }
911         bi->next[prev]= i;
912     }
913
914     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
915 }
916
917 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
918 {
919     int size[5];
920     int i, j, k, a, prev, a2;
921     EncBlockInfo* b;
922
923     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
924     do {
925        b = blks;
926        for (i = 0; i < 5; i++) {
927           if (!qnos[i])
928               continue;
929
930           qnos[i]--;
931           size[i] = 0;
932           for (j = 0; j < 6; j++, b++) {
933              for (a = 0; a < 4; a++) {
934                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
935                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
936                     b->area_q[a]++;
937                     prev = b->prev[a];
938                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
939                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
940                        b->mb[k] >>= 1;
941                        if (b->mb[k]) {
942                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
943                            prev = k;
944                        } else {
945                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
946                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
947                                     b->prev[a2] = prev;
948                                 assert(a2 < 4);
949                                 assert(b->mb[b->next[k]]);
950                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
951                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
952                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
953                                 b->prev[a2] = prev;
954                            }
955                            b->next[prev] = b->next[k];
956                        }
957                     }
958                     b->prev[a+1]= prev;
959                 }
960                 size[i] += b->bit_size[a];
961              }
962           }
963           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
964                 return;
965        }
966     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
967
968
969     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
970         b = blks;
971         size[0] = 5 * 6 * 4; //EOB
972         for (j = 0; j < 6 *5; j++, b++) {
973             prev = b->prev[0];
974             for (k = b->next[prev]; k < 64; k = b->next[k]) {
975                 if (b->mb[k] < a && b->mb[k] > -a){
976                     b->next[prev] = b->next[k];
977                 }else{
978                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
979                     prev = k;
980                 }
981             }
982         }
983     }
984 }
985
986 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
987 {
988     DVVideoContext *s = avctx->priv_data;
989     DVwork_chunk *work_chunk = arg;
990     int mb_index, i, j;
991     int mb_x, mb_y, c_offset, linesize, y_stride;
992     uint8_t*  y_ptr;
993     uint8_t*  dif;
994     uint8_t   scratch[64];
995     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
996     PutBitContext pbs[5*DV_MAX_BPM];
997     PutBitContext* pb;
998     EncBlockInfo* enc_blk;
999     int       vs_bit_size = 0;
1000     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1001     int*      qnosp = &qnos[0];
1002
1003     dif = &s->buf[work_chunk->buf_offset*80];
1004     enc_blk = &enc_blks[0];
1005     for (mb_index = 0; mb_index < 5; mb_index++) {
1006         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1007
1008         /* initializing luminance blocks */
1009         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1010             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1011             (s->sys->height >= 720 && mb_y != 134)) {
1012             y_stride = s->picture.linesize[0] << 3;
1013         } else {
1014             y_stride = 16;
1015         }
1016         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1017         linesize = s->picture.linesize[0];
1018
1019         if (s->sys->video_stype == 4) { /* SD 422 */
1020             vs_bit_size +=
1021             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1022             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
1023             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
1024             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
1025         } else {
1026             vs_bit_size +=
1027             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1028             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
1029             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
1030             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1031         }
1032         enc_blk += 4;
1033
1034         /* initializing chrominance blocks */
1035         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1036                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1037         for (j = 2; j; j--) {
1038             uint8_t *c_ptr = s->picture.data[j] + c_offset;
1039             linesize = s->picture.linesize[j];
1040             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1041             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1042                 uint8_t* d;
1043                 uint8_t* b = scratch;
1044                 for (i = 0; i < 8; i++) {
1045                     d = c_ptr + (linesize << 3);
1046                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1047                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1048                     c_ptr += linesize;
1049                     b += 8;
1050                 }
1051                 c_ptr = scratch;
1052                 linesize = 8;
1053             }
1054
1055             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1056             if (s->sys->bpm == 8) {
1057                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1058             }
1059         }
1060     }
1061
1062     if (vs_total_ac_bits < vs_bit_size)
1063         dv_guess_qnos(&enc_blks[0], qnosp);
1064
1065     /* DIF encoding process */
1066     for (j=0; j<5*s->sys->bpm;) {
1067         int start_mb = j;
1068
1069         dif[3] = *qnosp++;
1070         dif += 4;
1071
1072         /* First pass over individual cells only */
1073         for (i=0; i<s->sys->bpm; i++, j++) {
1074             int sz = s->sys->block_sizes[i]>>3;
1075
1076             init_put_bits(&pbs[j], dif, sz);
1077             put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1078             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1079             put_bits(&pbs[j], 2, enc_blks[j].cno);
1080
1081             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1082             dif += sz;
1083         }
1084
1085         /* Second pass over each MB space */
1086         pb = &pbs[start_mb];
1087         for (i=0; i<s->sys->bpm; i++) {
1088             if (enc_blks[start_mb+i].partial_bit_count)
1089                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1090         }
1091     }
1092
1093     /* Third and final pass over the whole video segment space */
1094     pb = &pbs[0];
1095     for (j=0; j<5*s->sys->bpm; j++) {
1096        if (enc_blks[j].partial_bit_count)
1097            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1098        if (enc_blks[j].partial_bit_count)
1099             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1100     }
1101
1102     for (j=0; j<5*s->sys->bpm; j++)
1103        flush_put_bits(&pbs[j]);
1104
1105     return 0;
1106 }
1107
1108 #if CONFIG_DVVIDEO_DECODER
1109 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1110    144000 bytes for PAL - or twice those for 50Mbps) */
1111 static int dvvideo_decode_frame(AVCodecContext *avctx,
1112                                  void *data, int *data_size,
1113                                  const uint8_t *buf, int buf_size)
1114 {
1115     DVVideoContext *s = avctx->priv_data;
1116
1117     s->sys = dv_frame_profile(buf);
1118     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1119         return -1; /* NOTE: we only accept several full frames */
1120
1121     if (s->picture.data[0])
1122         avctx->release_buffer(avctx, &s->picture);
1123
1124     s->picture.reference = 0;
1125     s->picture.key_frame = 1;
1126     s->picture.pict_type = FF_I_TYPE;
1127     avctx->pix_fmt   = s->sys->pix_fmt;
1128     avctx->time_base = s->sys->time_base;
1129     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1130     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1131         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1132         return -1;
1133     }
1134     s->picture.interlaced_frame = 1;
1135     s->picture.top_field_first  = 0;
1136
1137     s->buf = buf;
1138     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1139                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1140
1141     emms_c();
1142
1143     /* return image */
1144     *data_size = sizeof(AVFrame);
1145     *(AVFrame*)data = s->picture;
1146
1147     return s->sys->frame_size;
1148 }
1149 #endif /* CONFIG_DVVIDEO_DECODER */
1150
1151
1152 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1153                                 uint8_t* buf)
1154 {
1155     /*
1156      * Here's what SMPTE314M says about these two:
1157      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1158      *             as track application IDs (APTn = 001, AP1n =
1159      *             001, AP2n = 001, AP3n = 001), if the source signal
1160      *             comes from a digital VCR. If the signal source is
1161      *             unknown, all bits for these data shall be set to 1.
1162      *    (page 12) STYPE: STYPE defines a signal type of video signal
1163      *                     00000b = 4:1:1 compression
1164      *                     00100b = 4:2:2 compression
1165      *                     XXXXXX = Reserved
1166      * Now, I've got two problems with these statements:
1167      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1168      *      It seems that for PAL as defined in IEC 61834 we have to set
1169      *      APT to 000 and for SMPTE314M to 001.
1170      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1171      *      compression scheme (if any).
1172      */
1173     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1174
1175     uint8_t aspect = 0;
1176     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1177         aspect = 0x02;
1178
1179     buf[0] = (uint8_t)pack_id;
1180     switch (pack_id) {
1181     case dv_header525: /* I can't imagine why these two weren't defined as real */
1182     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1183           buf[1] = 0xf8 |        /* reserved -- always 1 */
1184                    (apt & 0x07); /* APT: Track application ID */
1185           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1186                    (0x0f << 3) | /* reserved -- always 1 */
1187                    (apt & 0x07); /* AP1: Audio application ID */
1188           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1189                    (0x0f << 3) | /* reserved -- always 1 */
1190                    (apt & 0x07); /* AP2: Video application ID */
1191           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1192                    (0x0f << 3) | /* reserved -- always 1 */
1193                    (apt & 0x07); /* AP3: Subcode application ID */
1194           break;
1195     case dv_video_source:
1196           buf[1] = 0xff;      /* reserved -- always 1 */
1197           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1198                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1199                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1200                    0xf;       /* reserved -- always 1 */
1201           buf[3] = (3 << 6) | /* reserved -- always 1 */
1202                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1203                    c->sys->video_stype; /* signal type video compression */
1204           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1205           break;
1206     case dv_video_control:
1207           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1208                    0x3f;      /* reserved -- always 1 */
1209           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1210                    aspect;
1211           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1212                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1213                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1214                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1215                    0xc;       /* reserved -- always b1100 */
1216           buf[4] = 0xff;      /* reserved -- always 1 */
1217           break;
1218     default:
1219           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1220     }
1221     return 5;
1222 }
1223
1224 #if CONFIG_DVVIDEO_ENCODER
1225 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1226 {
1227     int chan, i, j, k;
1228
1229     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1230         for (i = 0; i < c->sys->difseg_size; i++) {
1231             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1232
1233             /* DV header: 1DIF */
1234             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1235             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1236             buf += 72; /* unused bytes */
1237
1238             /* DV subcode: 2DIFs */
1239             for (j = 0; j < 2; j++) {
1240                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1241                 for (k = 0; k < 6; k++)
1242                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1243                 buf += 29; /* unused bytes */
1244             }
1245
1246             /* DV VAUX: 3DIFS */
1247             for (j = 0; j < 3; j++) {
1248                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1249                 buf += dv_write_pack(dv_video_source,  c, buf);
1250                 buf += dv_write_pack(dv_video_control, c, buf);
1251                 buf += 7*5;
1252                 buf += dv_write_pack(dv_video_source,  c, buf);
1253                 buf += dv_write_pack(dv_video_control, c, buf);
1254                 buf += 4*5 + 2; /* unused bytes */
1255             }
1256
1257             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1258             for (j = 0; j < 135; j++) {
1259                 if (j%15 == 0) {
1260                     memset(buf, 0xff, 80);
1261                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1262                     buf += 77; /* audio control & shuffled PCM audio */
1263                 }
1264                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1265                 buf += 77; /* 1 video macroblock: 1 bytes control
1266                               4 * 14 bytes Y 8x8 data
1267                               10 bytes Cr 8x8 data
1268                               10 bytes Cb 8x8 data */
1269             }
1270         }
1271     }
1272 }
1273
1274
1275 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1276                                 void *data)
1277 {
1278     DVVideoContext *s = c->priv_data;
1279
1280     s->sys = dv_codec_profile(c);
1281     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1282         return -1;
1283
1284     c->pix_fmt           = s->sys->pix_fmt;
1285     s->picture           = *((AVFrame *)data);
1286     s->picture.key_frame = 1;
1287     s->picture.pict_type = FF_I_TYPE;
1288
1289     s->buf = buf;
1290     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1291                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1292
1293     emms_c();
1294
1295     dv_format_frame(s, buf);
1296
1297     return s->sys->frame_size;
1298 }
1299 #endif
1300
1301 static int dvvideo_close(AVCodecContext *c)
1302 {
1303     DVVideoContext *s = c->priv_data;
1304
1305     if (s->picture.data[0])
1306         c->release_buffer(c, &s->picture);
1307
1308     return 0;
1309 }
1310
1311
1312 #if CONFIG_DVVIDEO_ENCODER
1313 AVCodec dvvideo_encoder = {
1314     "dvvideo",
1315     CODEC_TYPE_VIDEO,
1316     CODEC_ID_DVVIDEO,
1317     sizeof(DVVideoContext),
1318     dvvideo_init,
1319     dvvideo_encode_frame,
1320     .pix_fmts  = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1321     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1322 };
1323 #endif // CONFIG_DVVIDEO_ENCODER
1324
1325 #if CONFIG_DVVIDEO_DECODER
1326 AVCodec dvvideo_decoder = {
1327     "dvvideo",
1328     CODEC_TYPE_VIDEO,
1329     CODEC_ID_DVVIDEO,
1330     sizeof(DVVideoContext),
1331     dvvideo_init,
1332     NULL,
1333     dvvideo_close,
1334     dvvideo_decode_frame,
1335     CODEC_CAP_DR1,
1336     NULL,
1337     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1338 };
1339 #endif