dv: fix comment wording mistake
[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 Libav.
20  *
21  * Libav 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  * Libav 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 Libav; 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 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
479     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* 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         put_bits32(&pb, 0); // padding must be zeroed
547         flush_put_bits(&pb);
548         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
549             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
550                 dv_decode_ac(&gb, mb, block);
551                 /* if still not finished, no need to parse other blocks */
552                 if (mb->pos < 64)
553                     break;
554             }
555         }
556         /* all blocks are finished, so the extra bytes can be used at
557            the video segment level */
558         if (j >= s->sys->bpm)
559             bit_copy(&vs_pb, &gb);
560     }
561
562     /* we need a pass over the whole video segment */
563     av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
564     block = &sblock[0][0];
565     mb    = mb_data;
566     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
567     put_bits32(&vs_pb, 0); // padding must be zeroed
568     flush_put_bits(&vs_pb);
569     for (mb_index = 0; mb_index < 5; mb_index++) {
570         for (j = 0; j < s->sys->bpm; j++) {
571             if (mb->pos < 64) {
572                 av_dlog(avctx, "start %d:%d\n", mb_index, j);
573                 dv_decode_ac(&gb, mb, block);
574             }
575             if (mb->pos >= 64 && mb->pos < 127)
576                 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
577             block += 64;
578             mb++;
579         }
580     }
581
582     /* compute idct and place blocks */
583     block = &sblock[0][0];
584     mb    = mb_data;
585     for (mb_index = 0; mb_index < 5; mb_index++) {
586         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
587
588         /* idct_put'ting luminance */
589         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
590             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
591             (s->sys->height >= 720 && mb_y != 134)) {
592             y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
593         } else {
594             y_stride = (2 << log2_blocksize);
595         }
596         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
597         linesize = s->picture.linesize[0] << is_field_mode[mb_index];
598         mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
599         if (s->sys->video_stype == 4) { /* SD 422 */
600             mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
601         } else {
602             mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
603             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
604             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
605         }
606         mb += 4;
607         block += 4*64;
608
609         /* idct_put'ting chrominance */
610         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
611                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
612         for (j = 2; j; j--) {
613             uint8_t *c_ptr = s->picture.data[j] + c_offset;
614             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
615                   uint64_t aligned_pixels[64/8];
616                   uint8_t *pixels = (uint8_t*)aligned_pixels;
617                   uint8_t *c_ptr1, *ptr1;
618                   int x, y;
619                   mb->idct_put(pixels, 8, block);
620                   for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
621                       ptr1   = pixels + (1 << (log2_blocksize - 1));
622                       c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
623                       for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
624                           c_ptr[x]  = pixels[x];
625                           c_ptr1[x] = ptr1[x];
626                       }
627                   }
628                   block += 64; mb++;
629             } else {
630                   y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
631                                              s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
632                   linesize = s->picture.linesize[j] << is_field_mode[mb_index];
633                   (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
634                   if (s->sys->bpm == 8) {
635                       (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
636                   }
637             }
638         }
639     }
640     return 0;
641 }
642
643 #if CONFIG_SMALL
644 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
645 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
646 {
647     int size;
648     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
649         *vlc = dv_vlc_map[run][level].vlc | sign;
650         size = dv_vlc_map[run][level].size;
651     }
652     else {
653         if (level < DV_VLC_MAP_LEV_SIZE) {
654             *vlc = dv_vlc_map[0][level].vlc | sign;
655             size = dv_vlc_map[0][level].size;
656         } else {
657             *vlc = 0xfe00 | (level << 1) | sign;
658             size = 16;
659         }
660         if (run) {
661             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
662                                   (0x1f80 | (run - 1))) << size;
663             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
664         }
665     }
666
667     return size;
668 }
669
670 static av_always_inline int dv_rl2vlc_size(int run, int level)
671 {
672     int size;
673
674     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
675         size = dv_vlc_map[run][level].size;
676     }
677     else {
678         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
679         if (run) {
680             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
681         }
682     }
683     return size;
684 }
685 #else
686 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
687 {
688     *vlc = dv_vlc_map[run][l].vlc | sign;
689     return dv_vlc_map[run][l].size;
690 }
691
692 static av_always_inline int dv_rl2vlc_size(int run, int l)
693 {
694     return dv_vlc_map[run][l].size;
695 }
696 #endif
697
698 typedef struct EncBlockInfo {
699     int      area_q[4];
700     int      bit_size[4];
701     int      prev[5];
702     int      cur_ac;
703     int      cno;
704     int      dct_mode;
705     DCTELEM  mb[64];
706     uint8_t  next[64];
707     uint8_t  sign[64];
708     uint8_t  partial_bit_count;
709     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
710 } EncBlockInfo;
711
712 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
713                                                     PutBitContext* pb_pool,
714                                                     PutBitContext* pb_end)
715 {
716     int prev, bits_left;
717     PutBitContext* pb = pb_pool;
718     int size = bi->partial_bit_count;
719     uint32_t vlc = bi->partial_bit_buffer;
720
721     bi->partial_bit_count = bi->partial_bit_buffer = 0;
722     for (;;){
723        /* Find suitable storage space */
724        for (; size > (bits_left = put_bits_left(pb)); pb++) {
725           if (bits_left) {
726               size -= bits_left;
727               put_bits(pb, bits_left, vlc >> size);
728               vlc = vlc & ((1 << size) - 1);
729           }
730           if (pb + 1 >= pb_end) {
731               bi->partial_bit_count  = size;
732               bi->partial_bit_buffer = vlc;
733               return pb;
734           }
735        }
736
737        /* Store VLC */
738        put_bits(pb, size, vlc);
739
740        if (bi->cur_ac >= 64)
741            break;
742
743        /* Construct the next VLC */
744        prev       = bi->cur_ac;
745        bi->cur_ac = bi->next[prev];
746        if (bi->cur_ac < 64){
747            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
748        } else {
749            size = 4; vlc = 6; /* End Of Block stamp */
750        }
751     }
752     return pb;
753 }
754
755 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
756     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
757         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
758         if (ps > 0) {
759             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
760                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
761             return (ps > is);
762         }
763     }
764
765     return 0;
766 }
767
768 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
769 {
770     const int *weight;
771     const uint8_t* zigzag_scan;
772     LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
773     int i, area;
774     /* We offer two different methods for class number assignment: the
775        method suggested in SMPTE 314M Table 22, and an improved
776        method. The SMPTE method is very conservative; it assigns class
777        3 (i.e. severe quantization) to any block where the largest AC
778        component is greater than 36. Libav's DV encoder tracks AC bit
779        consumption precisely, so there is no need to bias most blocks
780        towards strongly lossy compression. Instead, we assign class 2
781        to most blocks, and use class 3 only when strictly necessary
782        (for blocks whose largest AC component exceeds 255). */
783
784 #if 0 /* SMPTE spec method */
785     static const int classes[] = {12, 24, 36, 0xffff};
786 #else /* improved Libav method */
787     static const int classes[] = {-1, -1, 255, 0xffff};
788 #endif
789     int max  = classes[0];
790     int prev = 0;
791
792     assert((((int)blk) & 15) == 0);
793
794     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
795     bi->partial_bit_count = 0;
796     bi->partial_bit_buffer = 0;
797     bi->cur_ac = 0;
798     if (data) {
799         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
800         s->get_pixels(blk, data, linesize);
801         s->fdct[bi->dct_mode](blk);
802     } else {
803         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
804            which is precisely what the spec calls for in the "dummy" blocks. */
805         memset(blk, 0, 64*sizeof(*blk));
806         bi->dct_mode = 0;
807     }
808     bi->mb[0] = blk[0];
809
810     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
811     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
812
813     for (area = 0; area < 4; area++) {
814        bi->prev[area]     = prev;
815        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
816        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
817           int level = blk[zigzag_scan[i]];
818
819           if (level + 15 > 30U) {
820               bi->sign[i] = (level >> 31) & 1;
821               /* weight it and and shift down into range, adding for rounding */
822               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
823                  AND the 2x doubling of the weights */
824               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
825               bi->mb[i] = level;
826               if (level > max)
827                   max = level;
828               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
829               bi->next[prev]= i;
830               prev = i;
831           }
832        }
833     }
834     bi->next[prev]= i;
835     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
836
837     bi->cno += bias;
838
839     if (bi->cno >= 3) {
840         bi->cno = 3;
841         prev    = 0;
842         i       = bi->next[prev];
843         for (area = 0; area < 4; area++) {
844             bi->prev[area]     = prev;
845             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
846             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
847                 bi->mb[i] >>= 1;
848
849                 if (bi->mb[i]) {
850                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
851                     bi->next[prev]= i;
852                     prev = i;
853                 }
854             }
855         }
856         bi->next[prev]= i;
857     }
858
859     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
860 }
861
862 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
863 {
864     int size[5];
865     int i, j, k, a, prev, a2;
866     EncBlockInfo* b;
867
868     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
869     do {
870        b = blks;
871        for (i = 0; i < 5; i++) {
872           if (!qnos[i])
873               continue;
874
875           qnos[i]--;
876           size[i] = 0;
877           for (j = 0; j < 6; j++, b++) {
878              for (a = 0; a < 4; a++) {
879                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
880                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
881                     b->area_q[a]++;
882                     prev = b->prev[a];
883                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
884                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
885                        b->mb[k] >>= 1;
886                        if (b->mb[k]) {
887                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
888                            prev = k;
889                        } else {
890                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
891                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
892                                     b->prev[a2] = prev;
893                                 assert(a2 < 4);
894                                 assert(b->mb[b->next[k]]);
895                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
896                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
897                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
898                                 b->prev[a2] = prev;
899                            }
900                            b->next[prev] = b->next[k];
901                        }
902                     }
903                     b->prev[a+1]= prev;
904                 }
905                 size[i] += b->bit_size[a];
906              }
907           }
908           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
909                 return;
910        }
911     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
912
913
914     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
915         b = blks;
916         size[0] = 5 * 6 * 4; //EOB
917         for (j = 0; j < 6 *5; j++, b++) {
918             prev = b->prev[0];
919             for (k = b->next[prev]; k < 64; k = b->next[k]) {
920                 if (b->mb[k] < a && b->mb[k] > -a){
921                     b->next[prev] = b->next[k];
922                 }else{
923                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
924                     prev = k;
925                 }
926             }
927         }
928     }
929 }
930
931 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
932 {
933     DVVideoContext *s = avctx->priv_data;
934     DVwork_chunk *work_chunk = arg;
935     int mb_index, i, j;
936     int mb_x, mb_y, c_offset, linesize, y_stride;
937     uint8_t*  y_ptr;
938     uint8_t*  dif;
939     LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
940     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
941     PutBitContext pbs[5*DV_MAX_BPM];
942     PutBitContext* pb;
943     EncBlockInfo* enc_blk;
944     int       vs_bit_size = 0;
945     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
946     int*      qnosp = &qnos[0];
947
948     dif = &s->buf[work_chunk->buf_offset*80];
949     enc_blk = &enc_blks[0];
950     for (mb_index = 0; mb_index < 5; mb_index++) {
951         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
952
953         /* initializing luminance blocks */
954         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
955             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
956             (s->sys->height >= 720 && mb_y != 134)) {
957             y_stride = s->picture.linesize[0] << 3;
958         } else {
959             y_stride = 16;
960         }
961         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
962         linesize = s->picture.linesize[0];
963
964         if (s->sys->video_stype == 4) { /* SD 422 */
965             vs_bit_size +=
966             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
967             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
968             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
969             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
970         } else {
971             vs_bit_size +=
972             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
973             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
974             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
975             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
976         }
977         enc_blk += 4;
978
979         /* initializing chrominance blocks */
980         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
981                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
982         for (j = 2; j; j--) {
983             uint8_t *c_ptr = s->picture.data[j] + c_offset;
984             linesize = s->picture.linesize[j];
985             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
986             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
987                 uint8_t* d;
988                 uint8_t* b = scratch;
989                 for (i = 0; i < 8; i++) {
990                     d = c_ptr + (linesize << 3);
991                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
992                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
993                     c_ptr += linesize;
994                     b += 8;
995                 }
996                 c_ptr = scratch;
997                 linesize = 8;
998             }
999
1000             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1001             if (s->sys->bpm == 8) {
1002                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1003             }
1004         }
1005     }
1006
1007     if (vs_total_ac_bits < vs_bit_size)
1008         dv_guess_qnos(&enc_blks[0], qnosp);
1009
1010     /* DIF encoding process */
1011     for (j=0; j<5*s->sys->bpm;) {
1012         int start_mb = j;
1013
1014         dif[3] = *qnosp++;
1015         dif += 4;
1016
1017         /* First pass over individual cells only */
1018         for (i=0; i<s->sys->bpm; i++, j++) {
1019             int sz = s->sys->block_sizes[i]>>3;
1020
1021             init_put_bits(&pbs[j], dif, sz);
1022             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1023             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1024             put_bits(&pbs[j], 2, enc_blks[j].cno);
1025
1026             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1027             dif += sz;
1028         }
1029
1030         /* Second pass over each MB space */
1031         pb = &pbs[start_mb];
1032         for (i=0; i<s->sys->bpm; i++) {
1033             if (enc_blks[start_mb+i].partial_bit_count)
1034                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1035         }
1036     }
1037
1038     /* Third and final pass over the whole video segment space */
1039     pb = &pbs[0];
1040     for (j=0; j<5*s->sys->bpm; j++) {
1041        if (enc_blks[j].partial_bit_count)
1042            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1043        if (enc_blks[j].partial_bit_count)
1044             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1045     }
1046
1047     for (j=0; j<5*s->sys->bpm; j++) {
1048        int pos;
1049        int size = pbs[j].size_in_bits >> 3;
1050        flush_put_bits(&pbs[j]);
1051        pos = put_bits_count(&pbs[j]) >> 3;
1052        if (pos > size) {
1053            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1054            return -1;
1055        }
1056        memset(pbs[j].buf + pos, 0xff, size - pos);
1057     }
1058
1059     return 0;
1060 }
1061
1062 #if CONFIG_DVVIDEO_DECODER
1063 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1064    144000 bytes for PAL - or twice those for 50Mbps) */
1065 static int dvvideo_decode_frame(AVCodecContext *avctx,
1066                                  void *data, int *data_size,
1067                                  AVPacket *avpkt)
1068 {
1069     const uint8_t *buf = avpkt->data;
1070     int buf_size = avpkt->size;
1071     DVVideoContext *s = avctx->priv_data;
1072     const uint8_t* vsc_pack;
1073     int apt, is16_9;
1074
1075     s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1076     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1077         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1078         return -1; /* NOTE: we only accept several full frames */
1079     }
1080
1081     if (s->picture.data[0])
1082         avctx->release_buffer(avctx, &s->picture);
1083
1084     s->picture.reference = 0;
1085     s->picture.key_frame = 1;
1086     s->picture.pict_type = AV_PICTURE_TYPE_I;
1087     avctx->pix_fmt   = s->sys->pix_fmt;
1088     avctx->time_base = s->sys->time_base;
1089     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1090     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1091         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1092         return -1;
1093     }
1094     s->picture.interlaced_frame = 1;
1095     s->picture.top_field_first  = 0;
1096
1097     s->buf = buf;
1098     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1099                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1100
1101     emms_c();
1102
1103     /* return image */
1104     *data_size = sizeof(AVFrame);
1105     *(AVFrame*)data = s->picture;
1106
1107     /* Determine the codec's sample_aspect ratio from the packet */
1108     vsc_pack = buf + 80*5 + 48 + 5;
1109     if ( *vsc_pack == dv_video_control ) {
1110         apt = buf[4] & 0x07;
1111         is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1112         avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1113     }
1114
1115     return s->sys->frame_size;
1116 }
1117 #endif /* CONFIG_DVVIDEO_DECODER */
1118
1119
1120 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1121                                 uint8_t* buf)
1122 {
1123     /*
1124      * Here's what SMPTE314M says about these two:
1125      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1126      *             as track application IDs (APTn = 001, AP1n =
1127      *             001, AP2n = 001, AP3n = 001), if the source signal
1128      *             comes from a digital VCR. If the signal source is
1129      *             unknown, all bits for these data shall be set to 1.
1130      *    (page 12) STYPE: STYPE defines a signal type of video signal
1131      *                     00000b = 4:1:1 compression
1132      *                     00100b = 4:2:2 compression
1133      *                     XXXXXX = Reserved
1134      * Now, I've got two problems with these statements:
1135      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1136      *      It seems that for PAL as defined in IEC 61834 we have to set
1137      *      APT to 000 and for SMPTE314M to 001.
1138      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1139      *      compression scheme (if any).
1140      */
1141     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1142
1143     uint8_t aspect = 0;
1144     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1145         aspect = 0x02;
1146
1147     buf[0] = (uint8_t)pack_id;
1148     switch (pack_id) {
1149     case dv_header525: /* I can't imagine why these two weren't defined as real */
1150     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1151           buf[1] = 0xf8 |        /* reserved -- always 1 */
1152                    (apt & 0x07); /* APT: Track application ID */
1153           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1154                    (0x0f << 3) | /* reserved -- always 1 */
1155                    (apt & 0x07); /* AP1: Audio application ID */
1156           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1157                    (0x0f << 3) | /* reserved -- always 1 */
1158                    (apt & 0x07); /* AP2: Video application ID */
1159           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1160                    (0x0f << 3) | /* reserved -- always 1 */
1161                    (apt & 0x07); /* AP3: Subcode application ID */
1162           break;
1163     case dv_video_source:
1164           buf[1] = 0xff;      /* reserved -- always 1 */
1165           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1166                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1167                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1168                    0xf;       /* reserved -- always 1 */
1169           buf[3] = (3 << 6) | /* reserved -- always 1 */
1170                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1171                    c->sys->video_stype; /* signal type video compression */
1172           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1173           break;
1174     case dv_video_control:
1175           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1176                    0x3f;      /* reserved -- always 1 */
1177           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1178                    aspect;
1179           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1180                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1181                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1182                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1183                    0xc;       /* reserved -- always b1100 */
1184           buf[4] = 0xff;      /* reserved -- always 1 */
1185           break;
1186     default:
1187           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1188     }
1189     return 5;
1190 }
1191
1192 #if CONFIG_DVVIDEO_ENCODER
1193 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1194 {
1195     int chan, i, j, k;
1196
1197     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1198         for (i = 0; i < c->sys->difseg_size; i++) {
1199             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1200
1201             /* DV header: 1DIF */
1202             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1203             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1204             buf += 72; /* unused bytes */
1205
1206             /* DV subcode: 2DIFs */
1207             for (j = 0; j < 2; j++) {
1208                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1209                 for (k = 0; k < 6; k++)
1210                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1211                 buf += 29; /* unused bytes */
1212             }
1213
1214             /* DV VAUX: 3DIFS */
1215             for (j = 0; j < 3; j++) {
1216                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1217                 buf += dv_write_pack(dv_video_source,  c, buf);
1218                 buf += dv_write_pack(dv_video_control, c, buf);
1219                 buf += 7*5;
1220                 buf += dv_write_pack(dv_video_source,  c, buf);
1221                 buf += dv_write_pack(dv_video_control, c, buf);
1222                 buf += 4*5 + 2; /* unused bytes */
1223             }
1224
1225             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1226             for (j = 0; j < 135; j++) {
1227                 if (j%15 == 0) {
1228                     memset(buf, 0xff, 80);
1229                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1230                     buf += 77; /* audio control & shuffled PCM audio */
1231                 }
1232                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1233                 buf += 77; /* 1 video macroblock: 1 bytes control
1234                               4 * 14 bytes Y 8x8 data
1235                               10 bytes Cr 8x8 data
1236                               10 bytes Cb 8x8 data */
1237             }
1238         }
1239     }
1240 }
1241
1242
1243 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1244                                 void *data)
1245 {
1246     DVVideoContext *s = c->priv_data;
1247
1248     s->sys = ff_dv_codec_profile(c);
1249     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1250         return -1;
1251
1252     c->pix_fmt           = s->sys->pix_fmt;
1253     s->picture           = *((AVFrame *)data);
1254     s->picture.key_frame = 1;
1255     s->picture.pict_type = AV_PICTURE_TYPE_I;
1256
1257     s->buf = buf;
1258     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1259                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1260
1261     emms_c();
1262
1263     dv_format_frame(s, buf);
1264
1265     return s->sys->frame_size;
1266 }
1267 #endif
1268
1269 static int dvvideo_close(AVCodecContext *c)
1270 {
1271     DVVideoContext *s = c->priv_data;
1272
1273     if (s->picture.data[0])
1274         c->release_buffer(c, &s->picture);
1275
1276     return 0;
1277 }
1278
1279
1280 #if CONFIG_DVVIDEO_ENCODER
1281 AVCodec ff_dvvideo_encoder = {
1282     "dvvideo",
1283     AVMEDIA_TYPE_VIDEO,
1284     CODEC_ID_DVVIDEO,
1285     sizeof(DVVideoContext),
1286     dvvideo_init_encoder,
1287     dvvideo_encode_frame,
1288     .capabilities = CODEC_CAP_SLICE_THREADS,
1289     .pix_fmts  = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1290     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1291 };
1292 #endif // CONFIG_DVVIDEO_ENCODER
1293
1294 #if CONFIG_DVVIDEO_DECODER
1295 AVCodec ff_dvvideo_decoder = {
1296     "dvvideo",
1297     AVMEDIA_TYPE_VIDEO,
1298     CODEC_ID_DVVIDEO,
1299     sizeof(DVVideoContext),
1300     dvvideo_init,
1301     NULL,
1302     dvvideo_close,
1303     dvvideo_decode_frame,
1304     CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1305     NULL,
1306     .max_lowres = 3,
1307     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1308 };
1309 #endif