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