lavc decoders: properly initialize AVFrame.
[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 Libav.
20  *
21  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
33  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34  */
35
36 /**
37  * @file
38  * DV codec.
39  */
40
41 #include "libavutil/internal.h"
42 #include "libavutil/pixdesc.h"
43 #include "avcodec.h"
44 #include "get_bits.h"
45 #include "internal.h"
46 #include "put_bits.h"
47 #include "simple_idct.h"
48 #include "dvdata.h"
49 #include "dv_tablegen.h"
50
51 /* XXX: also include quantization */
52 RL_VLC_ELEM ff_dv_rl_vlc[1184];
53
54 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
55                                           uint16_t *tbl)
56 {
57     static const uint8_t off[] = { 2, 6, 8, 0, 4 };
58     static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
59     static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
60     static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
61
62     static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
63     static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
64
65     static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
66                                        0, 1, 2, 2, 1, 0,
67                                        0, 1, 2, 2, 1, 0,
68                                        0, 1, 2, 2, 1, 0,
69                                        0, 1, 2};
70     static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
71                                        0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
72                                        0, 1, 2, 3, 4, 5};
73
74     static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
75                                        { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
76                                        {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
77                                        {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
78                                        {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
79                                        {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
80                                        {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
81                                        {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
82                                        {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
83                                        {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
84                                        {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
85                                        {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
86                                        {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
87
88     int i, k, m;
89     int x, y, blk;
90
91     for (m=0; m<5; m++) {
92          switch (d->width) {
93          case 1440:
94               blk = (chan*11+seq)*27+slot;
95
96               if (chan == 0 && seq == 11) {
97                   x = m*27+slot;
98                   if (x<90) {
99                       y = 0;
100                   } else {
101                       x = (x - 90)*2;
102                       y = 67;
103                   }
104               } else {
105                   i = (4*chan + blk + off[m])%11;
106                   k = (blk/11)%27;
107
108                   x = shuf1[m] + (chan&1)*9 + k%9;
109                   y = (i*3+k/9)*2 + (chan>>1) + 1;
110               }
111               tbl[m] = (x<<1)|(y<<9);
112               break;
113          case 1280:
114               blk = (chan*10+seq)*27+slot;
115
116               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
117               k = (blk/5)%27;
118
119               x = shuf1[m]+(chan&1)*9 + k%9;
120               y = (i*3+k/9)*2 + (chan>>1) + 4;
121
122               if (x >= 80) {
123                   x = remap[y][0]+((x-80)<<(y>59));
124                   y = remap[y][1];
125               }
126               tbl[m] = (x<<1)|(y<<9);
127               break;
128        case 960:
129               blk = (chan*10+seq)*27+slot;
130
131               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
132               k = (blk/5)%27 + (i&1)*3;
133
134               x = shuf2[m] + k%6 + 6*(chan&1);
135               y = l_start[i] + k/6 + 45*(chan>>1);
136               tbl[m] = (x<<1)|(y<<9);
137               break;
138         case 720:
139               switch (d->pix_fmt) {
140               case AV_PIX_FMT_YUV422P:
141                    x = shuf3[m] + slot/3;
142                    y = serpent1[slot] +
143                        ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
144                    tbl[m] = (x<<1)|(y<<8);
145                    break;
146               case AV_PIX_FMT_YUV420P:
147                    x = shuf3[m] + slot/3;
148                    y = serpent1[slot] +
149                        ((seq + off[m]) % d->difseg_size)*3;
150                    tbl[m] = (x<<1)|(y<<9);
151                    break;
152               case AV_PIX_FMT_YUV411P:
153                    i = (seq + off[m]) % d->difseg_size;
154                    k = slot + ((m==1||m==2)?3:0);
155
156                    x = l_start_shuffled[m] + k/6;
157                    y = serpent2[k] + i*6;
158                    if (x>21)
159                        y = y*2 - i*6;
160                    tbl[m] = (x<<2)|(y<<8);
161                    break;
162               }
163         default:
164               break;
165         }
166     }
167 }
168
169 /* quantization quanta by QNO for DV100 */
170 static const uint8_t dv100_qstep[16] = {
171     1, /* QNO = 0 and 1 both have no quantization */
172     1,
173     2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
174 };
175
176 static const uint8_t dv_quant_areas[4]  = { 6, 21, 43, 64 };
177
178 int ff_dv_init_dynamic_tables(const DVprofile *d)
179 {
180     int j,i,c,s,p;
181     uint32_t *factor1, *factor2;
182     const int *iweight1, *iweight2;
183
184     if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
185         p = i = 0;
186         for (c=0; c<d->n_difchan; c++) {
187             for (s=0; s<d->difseg_size; s++) {
188                 p += 6;
189                 for (j=0; j<27; j++) {
190                     p += !(j%3);
191                     if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
192                         !(DV_PROFILE_IS_720p50(d) && s > 9)) {
193                           dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
194                           d->work_chunks[i++].buf_offset = p;
195                     }
196                     p += 5;
197                 }
198             }
199         }
200     }
201
202     if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
203         factor1 = &d->idct_factor[0];
204         factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
205         if (d->height == 720) {
206             iweight1 = &ff_dv_iweight_720_y[0];
207             iweight2 = &ff_dv_iweight_720_c[0];
208         } else {
209             iweight1 = &ff_dv_iweight_1080_y[0];
210             iweight2 = &ff_dv_iweight_1080_c[0];
211         }
212         if (DV_PROFILE_IS_HD(d)) {
213             for (c = 0; c < 4; c++) {
214                 for (s = 0; s < 16; s++) {
215                     for (i = 0; i < 64; i++) {
216                         *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
217                         *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
218                     }
219                 }
220             }
221         } else {
222             iweight1 = &ff_dv_iweight_88[0];
223             for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {
224                 for (s = 0; s < 22; s++) {
225                     for (i = c = 0; c < 4; c++) {
226                         for (; i < dv_quant_areas[c]; i++) {
227                             *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
228                             *factor2++ = (*factor1++) << 1;
229                         }
230                     }
231                 }
232             }
233         }
234     }
235
236     return 0;
237 }
238
239 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
240 {
241     DVVideoContext *s = avctx->priv_data;
242     DSPContext dsp;
243     static int done = 0;
244     int i, j;
245
246     if (!done) {
247         VLC dv_vlc;
248         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
249         uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
250         uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
251         int16_t  new_dv_vlc_level[NB_DV_VLC*2];
252
253         done = 1;
254
255         /* it's faster to include sign bit in a generic VLC parsing scheme */
256         for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
257             new_dv_vlc_bits[j]  = dv_vlc_bits[i];
258             new_dv_vlc_len[j]   = dv_vlc_len[i];
259             new_dv_vlc_run[j]   = dv_vlc_run[i];
260             new_dv_vlc_level[j] = dv_vlc_level[i];
261
262             if (dv_vlc_level[i]) {
263                 new_dv_vlc_bits[j] <<= 1;
264                 new_dv_vlc_len[j]++;
265
266                 j++;
267                 new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
268                 new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
269                 new_dv_vlc_run[j]   =  dv_vlc_run[i];
270                 new_dv_vlc_level[j] = -dv_vlc_level[i];
271             }
272         }
273
274         /* NOTE: as a trick, we use the fact the no codes are unused
275            to accelerate the parsing of partial codes */
276         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
277                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
278         assert(dv_vlc.table_size == 1184);
279
280         for (i = 0; i < dv_vlc.table_size; i++){
281             int code = dv_vlc.table[i][0];
282             int len  = dv_vlc.table[i][1];
283             int level, run;
284
285             if (len < 0){ //more bits needed
286                 run   = 0;
287                 level = code;
288             } else {
289                 run   = new_dv_vlc_run  [code] + 1;
290                 level = new_dv_vlc_level[code];
291             }
292             ff_dv_rl_vlc[i].len   = len;
293             ff_dv_rl_vlc[i].level = level;
294             ff_dv_rl_vlc[i].run   = run;
295         }
296         ff_free_vlc(&dv_vlc);
297     }
298
299     /* Generic DSP setup */
300     ff_dsputil_init(&dsp, avctx);
301     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
302     s->get_pixels = dsp.get_pixels;
303     s->ildct_cmp = dsp.ildct_cmp[5];
304
305     /* 88DCT setup */
306     s->fdct[0]     = dsp.fdct;
307     s->idct_put[0] = dsp.idct_put;
308     for (i = 0; i < 64; i++)
309        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
310
311     /* 248DCT setup */
312     s->fdct[1]     = dsp.fdct248;
313     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
314     memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
315
316     avcodec_get_frame_defaults(&s->picture);
317     avctx->coded_frame = &s->picture;
318     s->avctx = avctx;
319     avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
320
321     return 0;
322 }
323
324 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
325 {
326     if (!avpriv_dv_codec_profile(avctx)) {
327         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
328                "Valid DV profiles are:\n",
329                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
330         ff_dv_print_profiles(avctx, AV_LOG_ERROR);
331         return AVERROR(EINVAL);
332     }
333
334     dv_vlc_map_tableinit();
335
336     return ff_dvvideo_init(avctx);
337 }
338
339 /* bit budget for AC only in 5 MBs */
340 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
341 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
342
343 static inline int put_bits_left(PutBitContext* s)
344 {
345     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
346 }
347
348 #if CONFIG_SMALL
349 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
350 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
351 {
352     int size;
353     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
354         *vlc = dv_vlc_map[run][level].vlc | sign;
355         size = dv_vlc_map[run][level].size;
356     }
357     else {
358         if (level < DV_VLC_MAP_LEV_SIZE) {
359             *vlc = dv_vlc_map[0][level].vlc | sign;
360             size = dv_vlc_map[0][level].size;
361         } else {
362             *vlc = 0xfe00 | (level << 1) | sign;
363             size = 16;
364         }
365         if (run) {
366             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
367                                   (0x1f80 | (run - 1))) << size;
368             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
369         }
370     }
371
372     return size;
373 }
374
375 static av_always_inline int dv_rl2vlc_size(int run, int level)
376 {
377     int size;
378
379     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
380         size = dv_vlc_map[run][level].size;
381     }
382     else {
383         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
384         if (run) {
385             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
386         }
387     }
388     return size;
389 }
390 #else
391 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
392 {
393     *vlc = dv_vlc_map[run][l].vlc | sign;
394     return dv_vlc_map[run][l].size;
395 }
396
397 static av_always_inline int dv_rl2vlc_size(int run, int l)
398 {
399     return dv_vlc_map[run][l].size;
400 }
401 #endif
402
403 typedef struct EncBlockInfo {
404     int      area_q[4];
405     int      bit_size[4];
406     int      prev[5];
407     int      cur_ac;
408     int      cno;
409     int      dct_mode;
410     int16_t  mb[64];
411     uint8_t  next[64];
412     uint8_t  sign[64];
413     uint8_t  partial_bit_count;
414     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
415 } EncBlockInfo;
416
417 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
418                                                     PutBitContext* pb_pool,
419                                                     PutBitContext* pb_end)
420 {
421     int prev, bits_left;
422     PutBitContext* pb = pb_pool;
423     int size = bi->partial_bit_count;
424     uint32_t vlc = bi->partial_bit_buffer;
425
426     bi->partial_bit_count = bi->partial_bit_buffer = 0;
427     for (;;){
428        /* Find suitable storage space */
429        for (; size > (bits_left = put_bits_left(pb)); pb++) {
430           if (bits_left) {
431               size -= bits_left;
432               put_bits(pb, bits_left, vlc >> size);
433               vlc = vlc & ((1 << size) - 1);
434           }
435           if (pb + 1 >= pb_end) {
436               bi->partial_bit_count  = size;
437               bi->partial_bit_buffer = vlc;
438               return pb;
439           }
440        }
441
442        /* Store VLC */
443        put_bits(pb, size, vlc);
444
445        if (bi->cur_ac >= 64)
446            break;
447
448        /* Construct the next VLC */
449        prev       = bi->cur_ac;
450        bi->cur_ac = bi->next[prev];
451        if (bi->cur_ac < 64){
452            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
453        } else {
454            size = 4; vlc = 6; /* End Of Block stamp */
455        }
456     }
457     return pb;
458 }
459
460 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
461     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
462         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
463         if (ps > 0) {
464             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
465                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
466             return ps > is;
467         }
468     }
469
470     return 0;
471 }
472
473 static const int dv_weight_bits = 18;
474 static const int dv_weight_88[64] = {
475  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
476  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
477  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
478  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
479  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
480  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
481  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
482  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
483 };
484 static const int dv_weight_248[64] = {
485  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
486  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
487  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
488  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
489  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
490  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
491  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
492  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
493 };
494
495 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
496 {
497     const int *weight;
498     const uint8_t* zigzag_scan;
499     LOCAL_ALIGNED_16(int16_t, blk, [64]);
500     int i, area;
501     /* We offer two different methods for class number assignment: the
502        method suggested in SMPTE 314M Table 22, and an improved
503        method. The SMPTE method is very conservative; it assigns class
504        3 (i.e. severe quantization) to any block where the largest AC
505        component is greater than 36. Libav's DV encoder tracks AC bit
506        consumption precisely, so there is no need to bias most blocks
507        towards strongly lossy compression. Instead, we assign class 2
508        to most blocks, and use class 3 only when strictly necessary
509        (for blocks whose largest AC component exceeds 255). */
510
511 #if 0 /* SMPTE spec method */
512     static const int classes[] = {12, 24, 36, 0xffff};
513 #else /* improved Libav method */
514     static const int classes[] = {-1, -1, 255, 0xffff};
515 #endif
516     int max  = classes[0];
517     int prev = 0;
518
519     assert((((int)blk) & 15) == 0);
520
521     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
522     bi->partial_bit_count = 0;
523     bi->partial_bit_buffer = 0;
524     bi->cur_ac = 0;
525     if (data) {
526         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
527         s->get_pixels(blk, data, linesize);
528         s->fdct[bi->dct_mode](blk);
529     } else {
530         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
531            which is precisely what the spec calls for in the "dummy" blocks. */
532         memset(blk, 0, 64*sizeof(*blk));
533         bi->dct_mode = 0;
534     }
535     bi->mb[0] = blk[0];
536
537     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
538     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
539
540     for (area = 0; area < 4; area++) {
541        bi->prev[area]     = prev;
542        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
543        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
544           int level = blk[zigzag_scan[i]];
545
546           if (level + 15 > 30U) {
547               bi->sign[i] = (level >> 31) & 1;
548               /* weight it and and shift down into range, adding for rounding */
549               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
550                  AND the 2x doubling of the weights */
551               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
552               bi->mb[i] = level;
553               if (level > max)
554                   max = level;
555               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
556               bi->next[prev]= i;
557               prev = i;
558           }
559        }
560     }
561     bi->next[prev]= i;
562     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
563
564     bi->cno += bias;
565
566     if (bi->cno >= 3) {
567         bi->cno = 3;
568         prev    = 0;
569         i       = bi->next[prev];
570         for (area = 0; area < 4; area++) {
571             bi->prev[area]     = prev;
572             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
573             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
574                 bi->mb[i] >>= 1;
575
576                 if (bi->mb[i]) {
577                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
578                     bi->next[prev]= i;
579                     prev = i;
580                 }
581             }
582         }
583         bi->next[prev]= i;
584     }
585
586     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
587 }
588
589 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
590 {
591     int size[5];
592     int i, j, k, a, prev, a2;
593     EncBlockInfo* b;
594
595     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
596     do {
597        b = blks;
598        for (i = 0; i < 5; i++) {
599           if (!qnos[i])
600               continue;
601
602           qnos[i]--;
603           size[i] = 0;
604           for (j = 0; j < 6; j++, b++) {
605              for (a = 0; a < 4; a++) {
606                 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
607                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
608                     b->area_q[a]++;
609                     prev = b->prev[a];
610                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
611                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
612                        b->mb[k] >>= 1;
613                        if (b->mb[k]) {
614                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
615                            prev = k;
616                        } else {
617                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
618                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
619                                     b->prev[a2] = prev;
620                                 assert(a2 < 4);
621                                 assert(b->mb[b->next[k]]);
622                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
623                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
624                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
625                                 b->prev[a2] = prev;
626                            }
627                            b->next[prev] = b->next[k];
628                        }
629                     }
630                     b->prev[a+1]= prev;
631                 }
632                 size[i] += b->bit_size[a];
633              }
634           }
635           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
636                 return;
637        }
638     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
639
640
641     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
642         b = blks;
643         size[0] = 5 * 6 * 4; //EOB
644         for (j = 0; j < 6 *5; j++, b++) {
645             prev = b->prev[0];
646             for (k = b->next[prev]; k < 64; k = b->next[k]) {
647                 if (b->mb[k] < a && b->mb[k] > -a){
648                     b->next[prev] = b->next[k];
649                 }else{
650                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
651                     prev = k;
652                 }
653             }
654         }
655     }
656 }
657
658 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
659 {
660     DVVideoContext *s = avctx->priv_data;
661     DVwork_chunk *work_chunk = arg;
662     int mb_index, i, j;
663     int mb_x, mb_y, c_offset, linesize, y_stride;
664     uint8_t*  y_ptr;
665     uint8_t*  dif;
666     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
667     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
668     PutBitContext pbs[5*DV_MAX_BPM];
669     PutBitContext* pb;
670     EncBlockInfo* enc_blk;
671     int       vs_bit_size = 0;
672     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
673     int*      qnosp = &qnos[0];
674
675     dif = &s->buf[work_chunk->buf_offset*80];
676     enc_blk = &enc_blks[0];
677     for (mb_index = 0; mb_index < 5; mb_index++) {
678         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
679
680         /* initializing luminance blocks */
681         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
682             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
683             (s->sys->height >= 720 && mb_y != 134)) {
684             y_stride = s->picture.linesize[0] << 3;
685         } else {
686             y_stride = 16;
687         }
688         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
689         linesize = s->picture.linesize[0];
690
691         if (s->sys->video_stype == 4) { /* SD 422 */
692             vs_bit_size +=
693             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
694             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
695             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
696             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
697         } else {
698             vs_bit_size +=
699             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
700             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
701             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
702             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
703         }
704         enc_blk += 4;
705
706         /* initializing chrominance blocks */
707         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
708                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
709         for (j = 2; j; j--) {
710             uint8_t *c_ptr = s->picture.data[j] + c_offset;
711             linesize = s->picture.linesize[j];
712             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
713             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
714                 uint8_t* d;
715                 uint8_t* b = scratch;
716                 for (i = 0; i < 8; i++) {
717                     d = c_ptr + (linesize << 3);
718                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
719                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
720                     c_ptr += linesize;
721                     b += 16;
722                 }
723                 c_ptr = scratch;
724                 linesize = 16;
725             }
726
727             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
728             if (s->sys->bpm == 8) {
729                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
730             }
731         }
732     }
733
734     if (vs_total_ac_bits < vs_bit_size)
735         dv_guess_qnos(&enc_blks[0], qnosp);
736
737     /* DIF encoding process */
738     for (j=0; j<5*s->sys->bpm;) {
739         int start_mb = j;
740
741         dif[3] = *qnosp++;
742         dif += 4;
743
744         /* First pass over individual cells only */
745         for (i=0; i<s->sys->bpm; i++, j++) {
746             int sz = s->sys->block_sizes[i]>>3;
747
748             init_put_bits(&pbs[j], dif, sz);
749             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
750             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
751             put_bits(&pbs[j], 2, enc_blks[j].cno);
752
753             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
754             dif += sz;
755         }
756
757         /* Second pass over each MB space */
758         pb = &pbs[start_mb];
759         for (i=0; i<s->sys->bpm; i++) {
760             if (enc_blks[start_mb+i].partial_bit_count)
761                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
762         }
763     }
764
765     /* Third and final pass over the whole video segment space */
766     pb = &pbs[0];
767     for (j=0; j<5*s->sys->bpm; j++) {
768        if (enc_blks[j].partial_bit_count)
769            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
770        if (enc_blks[j].partial_bit_count)
771             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
772     }
773
774     for (j=0; j<5*s->sys->bpm; j++) {
775        int pos;
776        int size = pbs[j].size_in_bits >> 3;
777        flush_put_bits(&pbs[j]);
778        pos = put_bits_count(&pbs[j]) >> 3;
779        if (pos > size) {
780            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
781            return -1;
782        }
783        memset(pbs[j].buf + pos, 0xff, size - pos);
784     }
785
786     return 0;
787 }
788
789 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
790                                 uint8_t* buf)
791 {
792     /*
793      * Here's what SMPTE314M says about these two:
794      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
795      *             as track application IDs (APTn = 001, AP1n =
796      *             001, AP2n = 001, AP3n = 001), if the source signal
797      *             comes from a digital VCR. If the signal source is
798      *             unknown, all bits for these data shall be set to 1.
799      *    (page 12) STYPE: STYPE defines a signal type of video signal
800      *                     00000b = 4:1:1 compression
801      *                     00100b = 4:2:2 compression
802      *                     XXXXXX = Reserved
803      * Now, I've got two problems with these statements:
804      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
805      *      It seems that for PAL as defined in IEC 61834 we have to set
806      *      APT to 000 and for SMPTE314M to 001.
807      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
808      *      compression scheme (if any).
809      */
810     int apt   = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
811
812     uint8_t aspect = 0;
813     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
814         aspect = 0x02;
815
816     buf[0] = (uint8_t)pack_id;
817     switch (pack_id) {
818     case dv_header525: /* I can't imagine why these two weren't defined as real */
819     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
820           buf[1] = 0xf8 |        /* reserved -- always 1 */
821                    (apt & 0x07); /* APT: Track application ID */
822           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
823                    (0x0f << 3) | /* reserved -- always 1 */
824                    (apt & 0x07); /* AP1: Audio application ID */
825           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
826                    (0x0f << 3) | /* reserved -- always 1 */
827                    (apt & 0x07); /* AP2: Video application ID */
828           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
829                    (0x0f << 3) | /* reserved -- always 1 */
830                    (apt & 0x07); /* AP3: Subcode application ID */
831           break;
832     case dv_video_source:
833           buf[1] = 0xff;      /* reserved -- always 1 */
834           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
835                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
836                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
837                    0xf;       /* reserved -- always 1 */
838           buf[3] = (3 << 6) | /* reserved -- always 1 */
839                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
840                    c->sys->video_stype; /* signal type video compression */
841           buf[4] = 0xff;      /* VISC: 0xff -- no information */
842           break;
843     case dv_video_control:
844           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
845                    0x3f;      /* reserved -- always 1 */
846           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
847                    aspect;
848           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
849                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
850                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
851                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
852                    0xc;       /* reserved -- always b1100 */
853           buf[4] = 0xff;      /* reserved -- always 1 */
854           break;
855     default:
856           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
857     }
858     return 5;
859 }
860
861 #if CONFIG_DVVIDEO_ENCODER
862 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
863                                   uint8_t seq_num, uint8_t dif_num,
864                                   uint8_t* buf)
865 {
866     buf[0] = (uint8_t)t;       /* Section type */
867     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
868              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
869              7;                /* reserved -- always 1 */
870     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
871     return 3;
872 }
873
874
875 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
876 {
877     if (syb_num == 0 || syb_num == 6) {
878         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
879                  (0  << 4) | /* AP3 (Subcode application ID) */
880                  0x0f;       /* reserved -- always 1 */
881     }
882     else if (syb_num == 11) {
883         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
884                  0x7f;       /* reserved -- always 1 */
885     }
886     else {
887         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
888                  (0  << 4) | /* APT (Track application ID) */
889                  0x0f;       /* reserved -- always 1 */
890     }
891     buf[1] = 0xf0 |            /* reserved -- always 1 */
892              (syb_num & 0x0f); /* SSYB number 0 - 11   */
893     buf[2] = 0xff;             /* reserved -- always 1 */
894     return 3;
895 }
896
897 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
898 {
899     int chan, i, j, k;
900
901     for (chan = 0; chan < c->sys->n_difchan; chan++) {
902         for (i = 0; i < c->sys->difseg_size; i++) {
903             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
904
905             /* DV header: 1DIF */
906             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
907             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
908             buf += 72; /* unused bytes */
909
910             /* DV subcode: 2DIFs */
911             for (j = 0; j < 2; j++) {
912                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
913                 for (k = 0; k < 6; k++)
914                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
915                 buf += 29; /* unused bytes */
916             }
917
918             /* DV VAUX: 3DIFS */
919             for (j = 0; j < 3; j++) {
920                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
921                 buf += dv_write_pack(dv_video_source,  c, buf);
922                 buf += dv_write_pack(dv_video_control, c, buf);
923                 buf += 7*5;
924                 buf += dv_write_pack(dv_video_source,  c, buf);
925                 buf += dv_write_pack(dv_video_control, c, buf);
926                 buf += 4*5 + 2; /* unused bytes */
927             }
928
929             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
930             for (j = 0; j < 135; j++) {
931                 if (j%15 == 0) {
932                     memset(buf, 0xff, 80);
933                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
934                     buf += 77; /* audio control & shuffled PCM audio */
935                 }
936                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
937                 buf += 77; /* 1 video macroblock: 1 bytes control
938                               4 * 14 bytes Y 8x8 data
939                               10 bytes Cr 8x8 data
940                               10 bytes Cb 8x8 data */
941             }
942         }
943     }
944 }
945
946
947 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
948                                 const AVFrame *frame, int *got_packet)
949 {
950     DVVideoContext *s = c->priv_data;
951     int ret;
952
953     s->sys = avpriv_dv_codec_profile(c);
954     if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
955         return -1;
956     if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
957         av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
958         return ret;
959     }
960
961     c->pix_fmt           = s->sys->pix_fmt;
962     s->picture           = *frame;
963     s->picture.key_frame = 1;
964     s->picture.pict_type = AV_PICTURE_TYPE_I;
965
966     s->buf = pkt->data;
967     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
968                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
969
970     emms_c();
971
972     dv_format_frame(s, pkt->data);
973
974     pkt->flags |= AV_PKT_FLAG_KEY;
975     *got_packet = 1;
976
977     return 0;
978 }
979
980 AVCodec ff_dvvideo_encoder = {
981     .name           = "dvvideo",
982     .type           = AVMEDIA_TYPE_VIDEO,
983     .id             = AV_CODEC_ID_DVVIDEO,
984     .priv_data_size = sizeof(DVVideoContext),
985     .init           = dvvideo_init_encoder,
986     .encode2        = dvvideo_encode_frame,
987     .capabilities   = CODEC_CAP_SLICE_THREADS,
988     .pix_fmts       = (const enum AVPixelFormat[]) {
989         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
990     },
991     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
992 };
993 #endif // CONFIG_DVVIDEO_ENCODER