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