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