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