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