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