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