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