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