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