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