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