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