dv: zero dsp before init, this fixes use of uninitialized dct_bits
[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
38  * DV codec.
39  */
40
41 #include "libavutil/pixdesc.h"
42 #include "avcodec.h"
43 #include "dsputil.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     memset(&dsp,0, sizeof(dsp));
301     ff_dsputil_init(&dsp, avctx);
302     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
303     s->get_pixels = dsp.get_pixels;
304     s->ildct_cmp = dsp.ildct_cmp[5];
305
306     /* 88DCT setup */
307     s->fdct[0]     = dsp.fdct;
308     s->idct_put[0] = dsp.idct_put;
309     for (i = 0; i < 64; i++)
310        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
311
312     /* 248DCT setup */
313     s->fdct[1]     = dsp.fdct248;
314     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
315     if (avctx->lowres){
316         for (i = 0; i < 64; i++){
317             int j = ff_zigzag248_direct[i];
318             s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
319         }
320     }else
321         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
322
323     avctx->coded_frame = &s->picture;
324     s->avctx = avctx;
325     avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
326
327     return 0;
328 }
329
330 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
331 {
332     if (!avpriv_dv_codec_profile(avctx)) {
333         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
334                "Valid DV profiles are:\n",
335                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
336         ff_dv_print_profiles(avctx, AV_LOG_ERROR);
337         return AVERROR(EINVAL);
338     }
339     if (avctx->height > 576) {
340         av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
341         return AVERROR_PATCHWELCOME;
342     }
343
344     dv_vlc_map_tableinit();
345
346     return ff_dvvideo_init(avctx);
347 }
348
349 /* bit budget for AC only in 5 MBs */
350 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
351 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
352
353 static inline int put_bits_left(PutBitContext* s)
354 {
355     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
356 }
357
358 #if CONFIG_SMALL
359 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
360 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
361 {
362     int size;
363     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
364         *vlc = dv_vlc_map[run][level].vlc | sign;
365         size = dv_vlc_map[run][level].size;
366     }
367     else {
368         if (level < DV_VLC_MAP_LEV_SIZE) {
369             *vlc = dv_vlc_map[0][level].vlc | sign;
370             size = dv_vlc_map[0][level].size;
371         } else {
372             *vlc = 0xfe00 | (level << 1) | sign;
373             size = 16;
374         }
375         if (run) {
376             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
377                                   (0x1f80 | (run - 1))) << size;
378             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
379         }
380     }
381
382     return size;
383 }
384
385 static av_always_inline int dv_rl2vlc_size(int run, int level)
386 {
387     int size;
388
389     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
390         size = dv_vlc_map[run][level].size;
391     }
392     else {
393         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
394         if (run) {
395             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
396         }
397     }
398     return size;
399 }
400 #else
401 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
402 {
403     *vlc = dv_vlc_map[run][l].vlc | sign;
404     return dv_vlc_map[run][l].size;
405 }
406
407 static av_always_inline int dv_rl2vlc_size(int run, int l)
408 {
409     return dv_vlc_map[run][l].size;
410 }
411 #endif
412
413 typedef struct EncBlockInfo {
414     int      area_q[4];
415     int      bit_size[4];
416     int      prev[5];
417     int      cur_ac;
418     int      cno;
419     int      dct_mode;
420     DCTELEM  mb[64];
421     uint8_t  next[64];
422     uint8_t  sign[64];
423     uint8_t  partial_bit_count;
424     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
425 } EncBlockInfo;
426
427 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
428                                                     PutBitContext* pb_pool,
429                                                     PutBitContext* pb_end)
430 {
431     int prev, bits_left;
432     PutBitContext* pb = pb_pool;
433     int size = bi->partial_bit_count;
434     uint32_t vlc = bi->partial_bit_buffer;
435
436     bi->partial_bit_count = bi->partial_bit_buffer = 0;
437     for (;;){
438        /* Find suitable storage space */
439        for (; size > (bits_left = put_bits_left(pb)); pb++) {
440           if (bits_left) {
441               size -= bits_left;
442               put_bits(pb, bits_left, vlc >> size);
443               vlc = vlc & ((1 << size) - 1);
444           }
445           if (pb + 1 >= pb_end) {
446               bi->partial_bit_count  = size;
447               bi->partial_bit_buffer = vlc;
448               return pb;
449           }
450        }
451
452        /* Store VLC */
453        put_bits(pb, size, vlc);
454
455        if (bi->cur_ac >= 64)
456            break;
457
458        /* Construct the next VLC */
459        prev       = bi->cur_ac;
460        bi->cur_ac = bi->next[prev];
461        if (bi->cur_ac < 64){
462            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
463        } else {
464            size = 4; vlc = 6; /* End Of Block stamp */
465        }
466     }
467     return pb;
468 }
469
470 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
471     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
472         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
473         if (ps > 0) {
474             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
475                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
476             return ps > is;
477         }
478     }
479
480     return 0;
481 }
482
483 static const int dv_weight_bits = 18;
484 static const int dv_weight_88[64] = {
485  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
486  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
487  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
488  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
489  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
490  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
491  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
492  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
493 };
494 static const int dv_weight_248[64] = {
495  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
496  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
497  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
498  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
499  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
500  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
501  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
502  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
503 };
504
505 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
506 {
507     const int *weight;
508     const uint8_t* zigzag_scan;
509     LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
510     int i, area;
511     /* We offer two different methods for class number assignment: the
512        method suggested in SMPTE 314M Table 22, and an improved
513        method. The SMPTE method is very conservative; it assigns class
514        3 (i.e. severe quantization) to any block where the largest AC
515        component is greater than 36. FFmpeg's DV encoder tracks AC bit
516        consumption precisely, so there is no need to bias most blocks
517        towards strongly lossy compression. Instead, we assign class 2
518        to most blocks, and use class 3 only when strictly necessary
519        (for blocks whose largest AC component exceeds 255). */
520
521 #if 0 /* SMPTE spec method */
522     static const int classes[] = {12, 24, 36, 0xffff};
523 #else /* improved FFmpeg method */
524     static const int classes[] = {-1, -1, 255, 0xffff};
525 #endif
526     int max  = classes[0];
527     int prev = 0;
528
529     assert((((int)blk) & 15) == 0);
530
531     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
532     bi->partial_bit_count = 0;
533     bi->partial_bit_buffer = 0;
534     bi->cur_ac = 0;
535     if (data) {
536         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
537         s->get_pixels(blk, data, linesize);
538         s->fdct[bi->dct_mode](blk);
539     } else {
540         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
541            which is precisely what the spec calls for in the "dummy" blocks. */
542         memset(blk, 0, 64*sizeof(*blk));
543         bi->dct_mode = 0;
544     }
545     bi->mb[0] = blk[0];
546
547     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
548     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
549
550     for (area = 0; area < 4; area++) {
551        bi->prev[area]     = prev;
552        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
553        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
554           int level = blk[zigzag_scan[i]];
555
556           if (level + 15 > 30U) {
557               bi->sign[i] = (level >> 31) & 1;
558               /* weight it and and shift down into range, adding for rounding */
559               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
560                  AND the 2x doubling of the weights */
561               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
562               bi->mb[i] = level;
563               if (level > max)
564                   max = level;
565               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
566               bi->next[prev]= i;
567               prev = i;
568           }
569        }
570     }
571     bi->next[prev]= i;
572     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
573
574     bi->cno += bias;
575
576     if (bi->cno >= 3) {
577         bi->cno = 3;
578         prev    = 0;
579         i       = bi->next[prev];
580         for (area = 0; area < 4; area++) {
581             bi->prev[area]     = prev;
582             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
583             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
584                 bi->mb[i] >>= 1;
585
586                 if (bi->mb[i]) {
587                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
588                     bi->next[prev]= i;
589                     prev = i;
590                 }
591             }
592         }
593         bi->next[prev]= i;
594     }
595
596     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
597 }
598
599 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
600 {
601     int size[5];
602     int i, j, k, a, prev, a2;
603     EncBlockInfo* b;
604
605     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
606     do {
607        b = blks;
608        for (i = 0; i < 5; i++) {
609           if (!qnos[i])
610               continue;
611
612           qnos[i]--;
613           size[i] = 0;
614           for (j = 0; j < 6; j++, b++) {
615              for (a = 0; a < 4; a++) {
616                 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
617                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
618                     b->area_q[a]++;
619                     prev = b->prev[a];
620                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
621                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
622                        b->mb[k] >>= 1;
623                        if (b->mb[k]) {
624                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
625                            prev = k;
626                        } else {
627                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
628                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
629                                     b->prev[a2] = prev;
630                                 assert(a2 < 4);
631                                 assert(b->mb[b->next[k]]);
632                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
633                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
634                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
635                                 b->prev[a2] = prev;
636                            }
637                            b->next[prev] = b->next[k];
638                        }
639                     }
640                     b->prev[a+1]= prev;
641                 }
642                 size[i] += b->bit_size[a];
643              }
644           }
645           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
646                 return;
647        }
648     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
649
650
651     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
652         b = blks;
653         size[0] = 5 * 6 * 4; //EOB
654         for (j = 0; j < 6 *5; j++, b++) {
655             prev = b->prev[0];
656             for (k = b->next[prev]; k < 64; k = b->next[k]) {
657                 if (b->mb[k] < a && b->mb[k] > -a){
658                     b->next[prev] = b->next[k];
659                 }else{
660                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
661                     prev = k;
662                 }
663             }
664         }
665     }
666 }
667
668 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
669 {
670     DVVideoContext *s = avctx->priv_data;
671     DVwork_chunk *work_chunk = arg;
672     int mb_index, i, j;
673     int mb_x, mb_y, c_offset, linesize, y_stride;
674     uint8_t*  y_ptr;
675     uint8_t*  dif;
676     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
677     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
678     PutBitContext pbs[5*DV_MAX_BPM];
679     PutBitContext* pb;
680     EncBlockInfo* enc_blk;
681     int       vs_bit_size = 0;
682     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
683     int*      qnosp = &qnos[0];
684
685     dif = &s->buf[work_chunk->buf_offset*80];
686     enc_blk = &enc_blks[0];
687     for (mb_index = 0; mb_index < 5; mb_index++) {
688         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
689
690         /* initializing luminance blocks */
691         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
692             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
693             (s->sys->height >= 720 && mb_y != 134)) {
694             y_stride = s->picture.linesize[0] << 3;
695         } else {
696             y_stride = 16;
697         }
698         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
699         linesize = s->picture.linesize[0];
700
701         if (s->sys->video_stype == 4) { /* SD 422 */
702             vs_bit_size +=
703             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
704             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
705             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
706             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
707         } else {
708             vs_bit_size +=
709             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
710             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
711             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
712             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
713         }
714         enc_blk += 4;
715
716         /* initializing chrominance blocks */
717         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
718                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
719         for (j = 2; j; j--) {
720             uint8_t *c_ptr = s->picture.data[j] + c_offset;
721             linesize = s->picture.linesize[j];
722             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
723             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
724                 uint8_t* d;
725                 uint8_t* b = scratch;
726                 for (i = 0; i < 8; i++) {
727                     d = c_ptr + (linesize << 3);
728                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
729                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
730                     c_ptr += linesize;
731                     b += 16;
732                 }
733                 c_ptr = scratch;
734                 linesize = 16;
735             }
736
737             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
738             if (s->sys->bpm == 8) {
739                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
740             }
741         }
742     }
743
744     if (vs_total_ac_bits < vs_bit_size)
745         dv_guess_qnos(&enc_blks[0], qnosp);
746
747     /* DIF encoding process */
748     for (j=0; j<5*s->sys->bpm;) {
749         int start_mb = j;
750
751         dif[3] = *qnosp++;
752         dif += 4;
753
754         /* First pass over individual cells only */
755         for (i=0; i<s->sys->bpm; i++, j++) {
756             int sz = s->sys->block_sizes[i]>>3;
757
758             init_put_bits(&pbs[j], dif, sz);
759             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
760             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
761             put_bits(&pbs[j], 2, enc_blks[j].cno);
762
763             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
764             dif += sz;
765         }
766
767         /* Second pass over each MB space */
768         pb = &pbs[start_mb];
769         for (i=0; i<s->sys->bpm; i++) {
770             if (enc_blks[start_mb+i].partial_bit_count)
771                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
772         }
773     }
774
775     /* Third and final pass over the whole video segment space */
776     pb = &pbs[0];
777     for (j=0; j<5*s->sys->bpm; j++) {
778        if (enc_blks[j].partial_bit_count)
779            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
780        if (enc_blks[j].partial_bit_count)
781             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
782     }
783
784     for (j=0; j<5*s->sys->bpm; j++) {
785        int pos;
786        int size = pbs[j].size_in_bits >> 3;
787        flush_put_bits(&pbs[j]);
788        pos = put_bits_count(&pbs[j]) >> 3;
789        if (pos > size) {
790            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
791            return -1;
792        }
793        memset(pbs[j].buf + pos, 0xff, size - pos);
794     }
795
796     return 0;
797 }
798
799 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
800                                 uint8_t* buf)
801 {
802     /*
803      * Here's what SMPTE314M says about these two:
804      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
805      *             as track application IDs (APTn = 001, AP1n =
806      *             001, AP2n = 001, AP3n = 001), if the source signal
807      *             comes from a digital VCR. If the signal source is
808      *             unknown, all bits for these data shall be set to 1.
809      *    (page 12) STYPE: STYPE defines a signal type of video signal
810      *                     00000b = 4:1:1 compression
811      *                     00100b = 4:2:2 compression
812      *                     XXXXXX = Reserved
813      * Now, I've got two problems with these statements:
814      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
815      *      It seems that for PAL as defined in IEC 61834 we have to set
816      *      APT to 000 and for SMPTE314M to 001.
817      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
818      *      compression scheme (if any).
819      */
820     int apt   = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
821
822     uint8_t aspect = 0;
823     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
824         aspect = 0x02;
825
826     buf[0] = (uint8_t)pack_id;
827     switch (pack_id) {
828     case dv_header525: /* I can't imagine why these two weren't defined as real */
829     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
830           buf[1] = 0xf8 |        /* reserved -- always 1 */
831                    (apt & 0x07); /* APT: Track application ID */
832           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
833                    (0x0f << 3) | /* reserved -- always 1 */
834                    (apt & 0x07); /* AP1: Audio application ID */
835           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
836                    (0x0f << 3) | /* reserved -- always 1 */
837                    (apt & 0x07); /* AP2: Video application ID */
838           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
839                    (0x0f << 3) | /* reserved -- always 1 */
840                    (apt & 0x07); /* AP3: Subcode application ID */
841           break;
842     case dv_video_source:
843           buf[1] = 0xff;      /* reserved -- always 1 */
844           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
845                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
846                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
847                    0xf;       /* reserved -- always 1 */
848           buf[3] = (3 << 6) | /* reserved -- always 1 */
849                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
850                    c->sys->video_stype; /* signal type video compression */
851           buf[4] = 0xff;      /* VISC: 0xff -- no information */
852           break;
853     case dv_video_control:
854           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
855                    0x3f;      /* reserved -- always 1 */
856           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
857                    aspect;
858           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
859                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
860                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
861                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
862                    0xc;       /* reserved -- always b1100 */
863           buf[4] = 0xff;      /* reserved -- always 1 */
864           break;
865     default:
866           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
867     }
868     return 5;
869 }
870
871 #if CONFIG_DVVIDEO_ENCODER
872 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
873                                   uint8_t seq_num, uint8_t dif_num,
874                                   uint8_t* buf)
875 {
876     buf[0] = (uint8_t)t;       /* Section type */
877     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
878              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
879              7;                /* reserved -- always 1 */
880     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
881     return 3;
882 }
883
884
885 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
886 {
887     if (syb_num == 0 || syb_num == 6) {
888         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
889                  (0  << 4) | /* AP3 (Subcode application ID) */
890                  0x0f;       /* reserved -- always 1 */
891     }
892     else if (syb_num == 11) {
893         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
894                  0x7f;       /* reserved -- always 1 */
895     }
896     else {
897         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
898                  (0  << 4) | /* APT (Track application ID) */
899                  0x0f;       /* reserved -- always 1 */
900     }
901     buf[1] = 0xf0 |            /* reserved -- always 1 */
902              (syb_num & 0x0f); /* SSYB number 0 - 11   */
903     buf[2] = 0xff;             /* reserved -- always 1 */
904     return 3;
905 }
906
907 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
908 {
909     int chan, i, j, k;
910
911     for (chan = 0; chan < c->sys->n_difchan; chan++) {
912         for (i = 0; i < c->sys->difseg_size; i++) {
913             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
914
915             /* DV header: 1DIF */
916             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
917             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
918             buf += 72; /* unused bytes */
919
920             /* DV subcode: 2DIFs */
921             for (j = 0; j < 2; j++) {
922                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
923                 for (k = 0; k < 6; k++)
924                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
925                 buf += 29; /* unused bytes */
926             }
927
928             /* DV VAUX: 3DIFS */
929             for (j = 0; j < 3; j++) {
930                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
931                 buf += dv_write_pack(dv_video_source,  c, buf);
932                 buf += dv_write_pack(dv_video_control, c, buf);
933                 buf += 7*5;
934                 buf += dv_write_pack(dv_video_source,  c, buf);
935                 buf += dv_write_pack(dv_video_control, c, buf);
936                 buf += 4*5 + 2; /* unused bytes */
937             }
938
939             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
940             for (j = 0; j < 135; j++) {
941                 if (j%15 == 0) {
942                     memset(buf, 0xff, 80);
943                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
944                     buf += 77; /* audio control & shuffled PCM audio */
945                 }
946                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
947                 buf += 77; /* 1 video macroblock: 1 bytes control
948                               4 * 14 bytes Y 8x8 data
949                               10 bytes Cr 8x8 data
950                               10 bytes Cb 8x8 data */
951             }
952         }
953     }
954 }
955
956
957 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
958                                 const AVFrame *frame, int *got_packet)
959 {
960     DVVideoContext *s = c->priv_data;
961     int ret;
962
963     s->sys = avpriv_dv_codec_profile(c);
964     if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
965         return -1;
966     if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
967         return ret;
968
969     c->pix_fmt           = s->sys->pix_fmt;
970     s->picture           = *frame;
971     s->picture.key_frame = 1;
972     s->picture.pict_type = AV_PICTURE_TYPE_I;
973
974     s->buf = pkt->data;
975     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
976                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
977
978     emms_c();
979
980     dv_format_frame(s, pkt->data);
981
982     pkt->flags |= AV_PKT_FLAG_KEY;
983     *got_packet = 1;
984
985     return 0;
986 }
987
988 AVCodec ff_dvvideo_encoder = {
989     .name           = "dvvideo",
990     .type           = AVMEDIA_TYPE_VIDEO,
991     .id             = AV_CODEC_ID_DVVIDEO,
992     .priv_data_size = sizeof(DVVideoContext),
993     .init           = dvvideo_init_encoder,
994     .encode2        = dvvideo_encode_frame,
995     .capabilities   = CODEC_CAP_SLICE_THREADS,
996     .pix_fmts       = (const enum AVPixelFormat[]) {
997         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
998     },
999     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1000 };
1001 #endif // CONFIG_DVVIDEO_ENCODER