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