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