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