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