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