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