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