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