Replace FFmpeg with Libav in licence headers
[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 #define ALT_BITSTREAM_READER
41 #include "avcodec.h"
42 #include "dsputil.h"
43 #include "get_bits.h"
44 #include "put_bits.h"
45 #include "simple_idct.h"
46 #include "dvdata.h"
47 #include "dv_tablegen.h"
48
49 //#undef NDEBUG
50 //#include <assert.h>
51
52 typedef struct DVVideoContext {
53     const DVprofile *sys;
54     AVFrame          picture;
55     AVCodecContext  *avctx;
56     uint8_t         *buf;
57
58     uint8_t  dv_zigzag[2][64];
59
60     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
61     void (*fdct[2])(DCTELEM *block);
62     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
63     me_cmp_func ildct_cmp;
64 } DVVideoContext;
65
66 #define TEX_VLC_BITS 9
67
68 /* XXX: also include quantization */
69 static RL_VLC_ELEM dv_rl_vlc[1184];
70
71 static inline int dv_work_pool_size(const DVprofile *d)
72 {
73     int size = d->n_difchan*d->difseg_size*27;
74     if (DV_PROFILE_IS_1080i50(d))
75         size -= 3*27;
76     if (DV_PROFILE_IS_720p50(d))
77         size -= 4*27;
78     return size;
79 }
80
81 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
82                                           uint16_t *tbl)
83 {
84     static const uint8_t off[] = { 2, 6, 8, 0, 4 };
85     static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
86     static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
87     static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
88
89     static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
90     static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
91
92     static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
93                                        0, 1, 2, 2, 1, 0,
94                                        0, 1, 2, 2, 1, 0,
95                                        0, 1, 2, 2, 1, 0,
96                                        0, 1, 2};
97     static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
98                                        0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99                                        0, 1, 2, 3, 4, 5};
100
101     static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
102                                        { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
103                                        {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
104                                        {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
105                                        {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
106                                        {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
107                                        {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
108                                        {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
109                                        {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
110                                        {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
111                                        {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
112                                        {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
113                                        {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
114
115     int i, k, m;
116     int x, y, blk;
117
118     for (m=0; m<5; m++) {
119          switch (d->width) {
120          case 1440:
121               blk = (chan*11+seq)*27+slot;
122
123               if (chan == 0 && seq == 11) {
124                   x = m*27+slot;
125                   if (x<90) {
126                       y = 0;
127                   } else {
128                       x = (x - 90)*2;
129                       y = 67;
130                   }
131               } else {
132                   i = (4*chan + blk + off[m])%11;
133                   k = (blk/11)%27;
134
135                   x = shuf1[m] + (chan&1)*9 + k%9;
136                   y = (i*3+k/9)*2 + (chan>>1) + 1;
137               }
138               tbl[m] = (x<<1)|(y<<9);
139               break;
140          case 1280:
141               blk = (chan*10+seq)*27+slot;
142
143               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
144               k = (blk/5)%27;
145
146               x = shuf1[m]+(chan&1)*9 + k%9;
147               y = (i*3+k/9)*2 + (chan>>1) + 4;
148
149               if (x >= 80) {
150                   x = remap[y][0]+((x-80)<<(y>59));
151                   y = remap[y][1];
152               }
153               tbl[m] = (x<<1)|(y<<9);
154               break;
155        case 960:
156               blk = (chan*10+seq)*27+slot;
157
158               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
159               k = (blk/5)%27 + (i&1)*3;
160
161               x = shuf2[m] + k%6 + 6*(chan&1);
162               y = l_start[i] + k/6 + 45*(chan>>1);
163               tbl[m] = (x<<1)|(y<<9);
164               break;
165         case 720:
166               switch (d->pix_fmt) {
167               case PIX_FMT_YUV422P:
168                    x = shuf3[m] + slot/3;
169                    y = serpent1[slot] +
170                        ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
171                    tbl[m] = (x<<1)|(y<<8);
172                    break;
173               case PIX_FMT_YUV420P:
174                    x = shuf3[m] + slot/3;
175                    y = serpent1[slot] +
176                        ((seq + off[m]) % d->difseg_size)*3;
177                    tbl[m] = (x<<1)|(y<<9);
178                    break;
179               case PIX_FMT_YUV411P:
180                    i = (seq + off[m]) % d->difseg_size;
181                    k = slot + ((m==1||m==2)?3:0);
182
183                    x = l_start_shuffled[m] + k/6;
184                    y = serpent2[k] + i*6;
185                    if (x>21)
186                        y = y*2 - i*6;
187                    tbl[m] = (x<<2)|(y<<8);
188                    break;
189               }
190         default:
191               break;
192         }
193     }
194 }
195
196 static int dv_init_dynamic_tables(const DVprofile *d)
197 {
198     int j,i,c,s,p;
199     uint32_t *factor1, *factor2;
200     const int *iweight1, *iweight2;
201
202     if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
203         p = i = 0;
204         for (c=0; c<d->n_difchan; c++) {
205             for (s=0; s<d->difseg_size; s++) {
206                 p += 6;
207                 for (j=0; j<27; j++) {
208                     p += !(j%3);
209                     if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
210                         !(DV_PROFILE_IS_720p50(d) && s > 9)) {
211                           dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
212                           d->work_chunks[i++].buf_offset = p;
213                     }
214                     p += 5;
215                 }
216             }
217         }
218     }
219
220     if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
221         factor1 = &d->idct_factor[0];
222         factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
223         if (d->height == 720) {
224             iweight1 = &dv_iweight_720_y[0];
225             iweight2 = &dv_iweight_720_c[0];
226         } else {
227             iweight1 = &dv_iweight_1080_y[0];
228             iweight2 = &dv_iweight_1080_c[0];
229         }
230         if (DV_PROFILE_IS_HD(d)) {
231             for (c = 0; c < 4; c++) {
232                 for (s = 0; s < 16; s++) {
233                     for (i = 0; i < 64; i++) {
234                         *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
235                         *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
236                     }
237                 }
238             }
239         } else {
240             iweight1 = &dv_iweight_88[0];
241             for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
242                 for (s = 0; s < 22; s++) {
243                     for (i = c = 0; c < 4; c++) {
244                         for (; i < dv_quant_areas[c]; i++) {
245                             *factor1   = iweight1[i] << (dv_quant_shifts[s][c] + 1);
246                             *factor2++ = (*factor1++) << 1;
247                         }
248                     }
249                 }
250             }
251         }
252     }
253
254     return 0;
255 }
256
257 static av_cold int dvvideo_init(AVCodecContext *avctx)
258 {
259     DVVideoContext *s = avctx->priv_data;
260     DSPContext dsp;
261     static int done = 0;
262     int i, j;
263
264     if (!done) {
265         VLC dv_vlc;
266         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
267         uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
268         uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
269         int16_t  new_dv_vlc_level[NB_DV_VLC*2];
270
271         done = 1;
272
273         /* it's faster to include sign bit in a generic VLC parsing scheme */
274         for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
275             new_dv_vlc_bits[j]  = dv_vlc_bits[i];
276             new_dv_vlc_len[j]   = dv_vlc_len[i];
277             new_dv_vlc_run[j]   = dv_vlc_run[i];
278             new_dv_vlc_level[j] = dv_vlc_level[i];
279
280             if (dv_vlc_level[i]) {
281                 new_dv_vlc_bits[j] <<= 1;
282                 new_dv_vlc_len[j]++;
283
284                 j++;
285                 new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
286                 new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
287                 new_dv_vlc_run[j]   =  dv_vlc_run[i];
288                 new_dv_vlc_level[j] = -dv_vlc_level[i];
289             }
290         }
291
292         /* NOTE: as a trick, we use the fact the no codes are unused
293            to accelerate the parsing of partial codes */
294         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
295                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
296         assert(dv_vlc.table_size == 1184);
297
298         for (i = 0; i < dv_vlc.table_size; i++){
299             int code = dv_vlc.table[i][0];
300             int len  = dv_vlc.table[i][1];
301             int level, run;
302
303             if (len < 0){ //more bits needed
304                 run   = 0;
305                 level = code;
306             } else {
307                 run   = new_dv_vlc_run  [code] + 1;
308                 level = new_dv_vlc_level[code];
309             }
310             dv_rl_vlc[i].len   = len;
311             dv_rl_vlc[i].level = level;
312             dv_rl_vlc[i].run   = run;
313         }
314         free_vlc(&dv_vlc);
315
316         dv_vlc_map_tableinit();
317     }
318
319     /* Generic DSP setup */
320     dsputil_init(&dsp, avctx);
321     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
322     s->get_pixels = dsp.get_pixels;
323     s->ildct_cmp = dsp.ildct_cmp[5];
324
325     /* 88DCT setup */
326     s->fdct[0]     = dsp.fdct;
327     s->idct_put[0] = dsp.idct_put;
328     for (i = 0; i < 64; i++)
329        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
330
331     /* 248DCT setup */
332     s->fdct[1]     = dsp.fdct248;
333     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
334     if (avctx->lowres){
335         for (i = 0; i < 64; i++){
336             int j = ff_zigzag248_direct[i];
337             s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
338         }
339     }else
340         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
341
342     avctx->coded_frame = &s->picture;
343     s->avctx = avctx;
344     avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
345
346     return 0;
347 }
348
349 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
350 {
351     if (!ff_dv_codec_profile(avctx)) {
352         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
353                avctx->width, avctx->height, avcodec_get_pix_fmt_name(avctx->pix_fmt));
354         return -1;
355     }
356
357     return dvvideo_init(avctx);
358 }
359
360 // #define VLC_DEBUG
361 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
362
363 typedef struct BlockInfo {
364     const uint32_t *factor_table;
365     const uint8_t *scan_table;
366     uint8_t pos; /* position in block */
367     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
368     uint8_t partial_bit_count;
369     uint16_t partial_bit_buffer;
370     int shift_offset;
371 } BlockInfo;
372
373 /* bit budget for AC only in 5 MBs */
374 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
375 /* see dv_88_areas and dv_248_areas for details */
376 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
377
378 static inline int put_bits_left(PutBitContext* s)
379 {
380     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
381 }
382
383 /* decode ac coefficients */
384 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
385 {
386     int last_index = gb->size_in_bits;
387     const uint8_t  *scan_table   = mb->scan_table;
388     const uint32_t *factor_table = mb->factor_table;
389     int pos               = mb->pos;
390     int partial_bit_count = mb->partial_bit_count;
391     int level, run, vlc_len, index;
392
393     OPEN_READER(re, gb);
394     UPDATE_CACHE(re, gb);
395
396     /* if we must parse a partial vlc, we do it here */
397     if (partial_bit_count > 0) {
398         re_cache = ((unsigned)re_cache >> partial_bit_count) |
399                    (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
400         re_index -= partial_bit_count;
401         mb->partial_bit_count = 0;
402     }
403
404     /* get the AC coefficients until last_index is reached */
405     for (;;) {
406 #ifdef VLC_DEBUG
407         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
408 #endif
409         /* our own optimized GET_RL_VLC */
410         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
411         vlc_len = dv_rl_vlc[index].len;
412         if (vlc_len < 0) {
413             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
414             vlc_len = TEX_VLC_BITS - vlc_len;
415         }
416         level = dv_rl_vlc[index].level;
417         run   = dv_rl_vlc[index].run;
418
419         /* gotta check if we're still within gb boundaries */
420         if (re_index + vlc_len > last_index) {
421             /* should be < 16 bits otherwise a codeword could have been parsed */
422             mb->partial_bit_count = last_index - re_index;
423             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
424             re_index = last_index;
425             break;
426         }
427         re_index += vlc_len;
428
429 #ifdef VLC_DEBUG
430         printf("run=%d level=%d\n", run, level);
431 #endif
432         pos += run;
433         if (pos >= 64)
434             break;
435
436         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
437         block[scan_table[pos]] = level;
438
439         UPDATE_CACHE(re, gb);
440     }
441     CLOSE_READER(re, gb);
442     mb->pos = pos;
443 }
444
445 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
446 {
447     int bits_left = get_bits_left(gb);
448     while (bits_left >= MIN_CACHE_BITS) {
449         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
450         bits_left -= MIN_CACHE_BITS;
451     }
452     if (bits_left > 0) {
453         put_bits(pb, bits_left, get_bits(gb, bits_left));
454     }
455 }
456
457 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
458 {
459      *mb_x = work_chunk->mb_coordinates[m] & 0xff;
460      *mb_y = work_chunk->mb_coordinates[m] >> 8;
461
462      /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
463      if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
464          *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
465      }
466 }
467
468 /* mb_x and mb_y are in units of 8 pixels */
469 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
470 {
471     DVVideoContext *s = avctx->priv_data;
472     DVwork_chunk *work_chunk = arg;
473     int quant, dc, dct_mode, class1, j;
474     int mb_index, mb_x, mb_y, last_index;
475     int y_stride, linesize;
476     DCTELEM *block, *block1;
477     int c_offset;
478     uint8_t *y_ptr;
479     const uint8_t *buf_ptr;
480     PutBitContext pb, vs_pb;
481     GetBitContext gb;
482     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
483     LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
484     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + 4]); /* allow some slack */
485     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5 * 80 + 4]); /* allow some slack */
486     const int log2_blocksize = 3-s->avctx->lowres;
487     int is_field_mode[5];
488
489     assert((((int)mb_bit_buffer) & 7) == 0);
490     assert((((int)vs_bit_buffer) & 7) == 0);
491
492     memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
493
494     /* pass 1 : read DC and AC coefficients in blocks */
495     buf_ptr = &s->buf[work_chunk->buf_offset*80];
496     block1  = &sblock[0][0];
497     mb1     = mb_data;
498     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
499     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
500         /* skip header */
501         quant = buf_ptr[3] & 0x0f;
502         buf_ptr += 4;
503         init_put_bits(&pb, mb_bit_buffer, 80);
504         mb    = mb1;
505         block = block1;
506         is_field_mode[mb_index] = 0;
507         for (j = 0; j < s->sys->bpm; j++) {
508             last_index = s->sys->block_sizes[j];
509             init_get_bits(&gb, buf_ptr, last_index);
510
511             /* get the dc */
512             dc       = get_sbits(&gb, 9);
513             dct_mode = get_bits1(&gb);
514             class1   = get_bits(&gb, 2);
515             if (DV_PROFILE_IS_HD(s->sys)) {
516                 mb->idct_put     = s->idct_put[0];
517                 mb->scan_table   = s->dv_zigzag[0];
518                 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
519                 is_field_mode[mb_index] |= !j && dct_mode;
520             } else {
521                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
522                 mb->scan_table   = s->dv_zigzag[dct_mode];
523                 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
524                                                         (quant + dv_quant_offset[class1])*64];
525             }
526             dc = dc << 2;
527             /* convert to unsigned because 128 is not added in the
528                standard IDCT */
529             dc += 1024;
530             block[0] = dc;
531             buf_ptr += last_index >> 3;
532             mb->pos               = 0;
533             mb->partial_bit_count = 0;
534
535 #ifdef VLC_DEBUG
536             printf("MB block: %d, %d ", mb_index, j);
537 #endif
538             dv_decode_ac(&gb, mb, block);
539
540             /* write the remaining bits  in a new buffer only if the
541                block is finished */
542             if (mb->pos >= 64)
543                 bit_copy(&pb, &gb);
544
545             block += 64;
546             mb++;
547         }
548
549         /* pass 2 : we can do it just after */
550 #ifdef VLC_DEBUG
551         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
552 #endif
553         block = block1;
554         mb    = mb1;
555         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
556         flush_put_bits(&pb);
557         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
558             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
559                 dv_decode_ac(&gb, mb, block);
560                 /* if still not finished, no need to parse other blocks */
561                 if (mb->pos < 64)
562                     break;
563             }
564         }
565         /* all blocks are finished, so the extra bytes can be used at
566            the video segment level */
567         if (j >= s->sys->bpm)
568             bit_copy(&vs_pb, &gb);
569     }
570
571     /* we need a pass other the whole video segment */
572 #ifdef VLC_DEBUG
573     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
574 #endif
575     block = &sblock[0][0];
576     mb    = mb_data;
577     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
578     flush_put_bits(&vs_pb);
579     for (mb_index = 0; mb_index < 5; mb_index++) {
580         for (j = 0; j < s->sys->bpm; j++) {
581             if (mb->pos < 64) {
582 #ifdef VLC_DEBUG
583                 printf("start %d:%d\n", mb_index, j);
584 #endif
585                 dv_decode_ac(&gb, mb, block);
586             }
587             if (mb->pos >= 64 && mb->pos < 127)
588                 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
589             block += 64;
590             mb++;
591         }
592     }
593
594     /* compute idct and place blocks */
595     block = &sblock[0][0];
596     mb    = mb_data;
597     for (mb_index = 0; mb_index < 5; mb_index++) {
598         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
599
600         /* idct_put'ting luminance */
601         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
602             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
603             (s->sys->height >= 720 && mb_y != 134)) {
604             y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
605         } else {
606             y_stride = (2 << log2_blocksize);
607         }
608         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
609         linesize = s->picture.linesize[0] << is_field_mode[mb_index];
610         mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
611         if (s->sys->video_stype == 4) { /* SD 422 */
612             mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
613         } else {
614             mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
615             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
616             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
617         }
618         mb += 4;
619         block += 4*64;
620
621         /* idct_put'ting chrominance */
622         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
623                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
624         for (j = 2; j; j--) {
625             uint8_t *c_ptr = s->picture.data[j] + c_offset;
626             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
627                   uint64_t aligned_pixels[64/8];
628                   uint8_t *pixels = (uint8_t*)aligned_pixels;
629                   uint8_t *c_ptr1, *ptr1;
630                   int x, y;
631                   mb->idct_put(pixels, 8, block);
632                   for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
633                       ptr1   = pixels + (1 << (log2_blocksize - 1));
634                       c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
635                       for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
636                           c_ptr[x]  = pixels[x];
637                           c_ptr1[x] = ptr1[x];
638                       }
639                   }
640                   block += 64; mb++;
641             } else {
642                   y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
643                                              s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
644                   linesize = s->picture.linesize[j] << is_field_mode[mb_index];
645                   (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
646                   if (s->sys->bpm == 8) {
647                       (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
648                   }
649             }
650         }
651     }
652     return 0;
653 }
654
655 #if CONFIG_SMALL
656 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
657 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
658 {
659     int size;
660     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
661         *vlc = dv_vlc_map[run][level].vlc | sign;
662         size = dv_vlc_map[run][level].size;
663     }
664     else {
665         if (level < DV_VLC_MAP_LEV_SIZE) {
666             *vlc = dv_vlc_map[0][level].vlc | sign;
667             size = dv_vlc_map[0][level].size;
668         } else {
669             *vlc = 0xfe00 | (level << 1) | sign;
670             size = 16;
671         }
672         if (run) {
673             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
674                                   (0x1f80 | (run - 1))) << size;
675             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
676         }
677     }
678
679     return size;
680 }
681
682 static av_always_inline int dv_rl2vlc_size(int run, int level)
683 {
684     int size;
685
686     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
687         size = dv_vlc_map[run][level].size;
688     }
689     else {
690         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
691         if (run) {
692             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
693         }
694     }
695     return size;
696 }
697 #else
698 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
699 {
700     *vlc = dv_vlc_map[run][l].vlc | sign;
701     return dv_vlc_map[run][l].size;
702 }
703
704 static av_always_inline int dv_rl2vlc_size(int run, int l)
705 {
706     return dv_vlc_map[run][l].size;
707 }
708 #endif
709
710 typedef struct EncBlockInfo {
711     int      area_q[4];
712     int      bit_size[4];
713     int      prev[5];
714     int      cur_ac;
715     int      cno;
716     int      dct_mode;
717     DCTELEM  mb[64];
718     uint8_t  next[64];
719     uint8_t  sign[64];
720     uint8_t  partial_bit_count;
721     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
722 } EncBlockInfo;
723
724 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
725                                                     PutBitContext* pb_pool,
726                                                     PutBitContext* pb_end)
727 {
728     int prev, bits_left;
729     PutBitContext* pb = pb_pool;
730     int size = bi->partial_bit_count;
731     uint32_t vlc = bi->partial_bit_buffer;
732
733     bi->partial_bit_count = bi->partial_bit_buffer = 0;
734     for (;;){
735        /* Find suitable storage space */
736        for (; size > (bits_left = put_bits_left(pb)); pb++) {
737           if (bits_left) {
738               size -= bits_left;
739               put_bits(pb, bits_left, vlc >> size);
740               vlc = vlc & ((1 << size) - 1);
741           }
742           if (pb + 1 >= pb_end) {
743               bi->partial_bit_count  = size;
744               bi->partial_bit_buffer = vlc;
745               return pb;
746           }
747        }
748
749        /* Store VLC */
750        put_bits(pb, size, vlc);
751
752        if (bi->cur_ac >= 64)
753            break;
754
755        /* Construct the next VLC */
756        prev       = bi->cur_ac;
757        bi->cur_ac = bi->next[prev];
758        if (bi->cur_ac < 64){
759            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
760        } else {
761            size = 4; vlc = 6; /* End Of Block stamp */
762        }
763     }
764     return pb;
765 }
766
767 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
768     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
769         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
770         if (ps > 0) {
771             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
772                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
773             return (ps > is);
774         }
775     }
776
777     return 0;
778 }
779
780 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
781 {
782     const int *weight;
783     const uint8_t* zigzag_scan;
784     LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
785     int i, area;
786     /* We offer two different methods for class number assignment: the
787        method suggested in SMPTE 314M Table 22, and an improved
788        method. The SMPTE method is very conservative; it assigns class
789        3 (i.e. severe quantization) to any block where the largest AC
790        component is greater than 36. FFmpeg's DV encoder tracks AC bit
791        consumption precisely, so there is no need to bias most blocks
792        towards strongly lossy compression. Instead, we assign class 2
793        to most blocks, and use class 3 only when strictly necessary
794        (for blocks whose largest AC component exceeds 255). */
795
796 #if 0 /* SMPTE spec method */
797     static const int classes[] = {12, 24, 36, 0xffff};
798 #else /* improved FFmpeg method */
799     static const int classes[] = {-1, -1, 255, 0xffff};
800 #endif
801     int max  = classes[0];
802     int prev = 0;
803
804     assert((((int)blk) & 15) == 0);
805
806     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
807     bi->partial_bit_count = 0;
808     bi->partial_bit_buffer = 0;
809     bi->cur_ac = 0;
810     if (data) {
811         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
812         s->get_pixels(blk, data, linesize);
813         s->fdct[bi->dct_mode](blk);
814     } else {
815         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
816            which is precisely what the spec calls for in the "dummy" blocks. */
817         memset(blk, 0, 64*sizeof(*blk));
818         bi->dct_mode = 0;
819     }
820     bi->mb[0] = blk[0];
821
822     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
823     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
824
825     for (area = 0; area < 4; area++) {
826        bi->prev[area]     = prev;
827        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
828        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
829           int level = blk[zigzag_scan[i]];
830
831           if (level + 15 > 30U) {
832               bi->sign[i] = (level >> 31) & 1;
833               /* weigh it and and shift down into range, adding for rounding */
834               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
835                  AND the 2x doubling of the weights */
836               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
837               bi->mb[i] = level;
838               if (level > max)
839                   max = level;
840               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
841               bi->next[prev]= i;
842               prev = i;
843           }
844        }
845     }
846     bi->next[prev]= i;
847     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
848
849     bi->cno += bias;
850
851     if (bi->cno >= 3) {
852         bi->cno = 3;
853         prev    = 0;
854         i       = bi->next[prev];
855         for (area = 0; area < 4; area++) {
856             bi->prev[area]     = prev;
857             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
858             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
859                 bi->mb[i] >>= 1;
860
861                 if (bi->mb[i]) {
862                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
863                     bi->next[prev]= i;
864                     prev = i;
865                 }
866             }
867         }
868         bi->next[prev]= i;
869     }
870
871     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
872 }
873
874 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
875 {
876     int size[5];
877     int i, j, k, a, prev, a2;
878     EncBlockInfo* b;
879
880     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
881     do {
882        b = blks;
883        for (i = 0; i < 5; i++) {
884           if (!qnos[i])
885               continue;
886
887           qnos[i]--;
888           size[i] = 0;
889           for (j = 0; j < 6; j++, b++) {
890              for (a = 0; a < 4; a++) {
891                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
892                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
893                     b->area_q[a]++;
894                     prev = b->prev[a];
895                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
896                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
897                        b->mb[k] >>= 1;
898                        if (b->mb[k]) {
899                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
900                            prev = k;
901                        } else {
902                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
903                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
904                                     b->prev[a2] = prev;
905                                 assert(a2 < 4);
906                                 assert(b->mb[b->next[k]]);
907                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
908                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
909                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
910                                 b->prev[a2] = prev;
911                            }
912                            b->next[prev] = b->next[k];
913                        }
914                     }
915                     b->prev[a+1]= prev;
916                 }
917                 size[i] += b->bit_size[a];
918              }
919           }
920           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
921                 return;
922        }
923     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
924
925
926     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
927         b = blks;
928         size[0] = 5 * 6 * 4; //EOB
929         for (j = 0; j < 6 *5; j++, b++) {
930             prev = b->prev[0];
931             for (k = b->next[prev]; k < 64; k = b->next[k]) {
932                 if (b->mb[k] < a && b->mb[k] > -a){
933                     b->next[prev] = b->next[k];
934                 }else{
935                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
936                     prev = k;
937                 }
938             }
939         }
940     }
941 }
942
943 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
944 {
945     DVVideoContext *s = avctx->priv_data;
946     DVwork_chunk *work_chunk = arg;
947     int mb_index, i, j;
948     int mb_x, mb_y, c_offset, linesize, y_stride;
949     uint8_t*  y_ptr;
950     uint8_t*  dif;
951     LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
952     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
953     PutBitContext pbs[5*DV_MAX_BPM];
954     PutBitContext* pb;
955     EncBlockInfo* enc_blk;
956     int       vs_bit_size = 0;
957     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
958     int*      qnosp = &qnos[0];
959
960     dif = &s->buf[work_chunk->buf_offset*80];
961     enc_blk = &enc_blks[0];
962     for (mb_index = 0; mb_index < 5; mb_index++) {
963         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
964
965         /* initializing luminance blocks */
966         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
967             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
968             (s->sys->height >= 720 && mb_y != 134)) {
969             y_stride = s->picture.linesize[0] << 3;
970         } else {
971             y_stride = 16;
972         }
973         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
974         linesize = s->picture.linesize[0];
975
976         if (s->sys->video_stype == 4) { /* SD 422 */
977             vs_bit_size +=
978             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
979             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
980             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
981             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
982         } else {
983             vs_bit_size +=
984             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
985             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
986             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
987             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
988         }
989         enc_blk += 4;
990
991         /* initializing chrominance blocks */
992         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
993                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
994         for (j = 2; j; j--) {
995             uint8_t *c_ptr = s->picture.data[j] + c_offset;
996             linesize = s->picture.linesize[j];
997             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
998             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
999                 uint8_t* d;
1000                 uint8_t* b = scratch;
1001                 for (i = 0; i < 8; i++) {
1002                     d = c_ptr + (linesize << 3);
1003                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1004                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1005                     c_ptr += linesize;
1006                     b += 8;
1007                 }
1008                 c_ptr = scratch;
1009                 linesize = 8;
1010             }
1011
1012             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1013             if (s->sys->bpm == 8) {
1014                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1015             }
1016         }
1017     }
1018
1019     if (vs_total_ac_bits < vs_bit_size)
1020         dv_guess_qnos(&enc_blks[0], qnosp);
1021
1022     /* DIF encoding process */
1023     for (j=0; j<5*s->sys->bpm;) {
1024         int start_mb = j;
1025
1026         dif[3] = *qnosp++;
1027         dif += 4;
1028
1029         /* First pass over individual cells only */
1030         for (i=0; i<s->sys->bpm; i++, j++) {
1031             int sz = s->sys->block_sizes[i]>>3;
1032
1033             init_put_bits(&pbs[j], dif, sz);
1034             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1035             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1036             put_bits(&pbs[j], 2, enc_blks[j].cno);
1037
1038             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1039             dif += sz;
1040         }
1041
1042         /* Second pass over each MB space */
1043         pb = &pbs[start_mb];
1044         for (i=0; i<s->sys->bpm; i++) {
1045             if (enc_blks[start_mb+i].partial_bit_count)
1046                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1047         }
1048     }
1049
1050     /* Third and final pass over the whole video segment space */
1051     pb = &pbs[0];
1052     for (j=0; j<5*s->sys->bpm; j++) {
1053        if (enc_blks[j].partial_bit_count)
1054            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1055        if (enc_blks[j].partial_bit_count)
1056             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1057     }
1058
1059     for (j=0; j<5*s->sys->bpm; j++) {
1060        int pos;
1061        int size = pbs[j].size_in_bits >> 3;
1062        flush_put_bits(&pbs[j]);
1063        pos = put_bits_count(&pbs[j]) >> 3;
1064        if (pos > size) {
1065            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1066            return -1;
1067        }
1068        memset(pbs[j].buf + pos, 0xff, size - pos);
1069     }
1070
1071     return 0;
1072 }
1073
1074 #if CONFIG_DVVIDEO_DECODER
1075 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1076    144000 bytes for PAL - or twice those for 50Mbps) */
1077 static int dvvideo_decode_frame(AVCodecContext *avctx,
1078                                  void *data, int *data_size,
1079                                  AVPacket *avpkt)
1080 {
1081     const uint8_t *buf = avpkt->data;
1082     int buf_size = avpkt->size;
1083     DVVideoContext *s = avctx->priv_data;
1084     const uint8_t* vsc_pack;
1085     int apt, is16_9;
1086
1087     s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1088     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1089         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1090         return -1; /* NOTE: we only accept several full frames */
1091     }
1092
1093     if (s->picture.data[0])
1094         avctx->release_buffer(avctx, &s->picture);
1095
1096     s->picture.reference = 0;
1097     s->picture.key_frame = 1;
1098     s->picture.pict_type = FF_I_TYPE;
1099     avctx->pix_fmt   = s->sys->pix_fmt;
1100     avctx->time_base = s->sys->time_base;
1101     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1102     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1103         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1104         return -1;
1105     }
1106     s->picture.interlaced_frame = 1;
1107     s->picture.top_field_first  = 0;
1108
1109     s->buf = buf;
1110     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1111                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1112
1113     emms_c();
1114
1115     /* return image */
1116     *data_size = sizeof(AVFrame);
1117     *(AVFrame*)data = s->picture;
1118
1119     /* Determine the codec's sample_aspect ratio from the packet */
1120     vsc_pack = buf + 80*5 + 48 + 5;
1121     if ( *vsc_pack == dv_video_control ) {
1122         apt = buf[4] & 0x07;
1123         is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1124         avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1125     }
1126
1127     return s->sys->frame_size;
1128 }
1129 #endif /* CONFIG_DVVIDEO_DECODER */
1130
1131
1132 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1133                                 uint8_t* buf)
1134 {
1135     /*
1136      * Here's what SMPTE314M says about these two:
1137      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1138      *             as track application IDs (APTn = 001, AP1n =
1139      *             001, AP2n = 001, AP3n = 001), if the source signal
1140      *             comes from a digital VCR. If the signal source is
1141      *             unknown, all bits for these data shall be set to 1.
1142      *    (page 12) STYPE: STYPE defines a signal type of video signal
1143      *                     00000b = 4:1:1 compression
1144      *                     00100b = 4:2:2 compression
1145      *                     XXXXXX = Reserved
1146      * Now, I've got two problems with these statements:
1147      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1148      *      It seems that for PAL as defined in IEC 61834 we have to set
1149      *      APT to 000 and for SMPTE314M to 001.
1150      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1151      *      compression scheme (if any).
1152      */
1153     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1154
1155     uint8_t aspect = 0;
1156     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1157         aspect = 0x02;
1158
1159     buf[0] = (uint8_t)pack_id;
1160     switch (pack_id) {
1161     case dv_header525: /* I can't imagine why these two weren't defined as real */
1162     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1163           buf[1] = 0xf8 |        /* reserved -- always 1 */
1164                    (apt & 0x07); /* APT: Track application ID */
1165           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1166                    (0x0f << 3) | /* reserved -- always 1 */
1167                    (apt & 0x07); /* AP1: Audio application ID */
1168           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1169                    (0x0f << 3) | /* reserved -- always 1 */
1170                    (apt & 0x07); /* AP2: Video application ID */
1171           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1172                    (0x0f << 3) | /* reserved -- always 1 */
1173                    (apt & 0x07); /* AP3: Subcode application ID */
1174           break;
1175     case dv_video_source:
1176           buf[1] = 0xff;      /* reserved -- always 1 */
1177           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1178                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1179                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1180                    0xf;       /* reserved -- always 1 */
1181           buf[3] = (3 << 6) | /* reserved -- always 1 */
1182                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1183                    c->sys->video_stype; /* signal type video compression */
1184           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1185           break;
1186     case dv_video_control:
1187           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1188                    0x3f;      /* reserved -- always 1 */
1189           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1190                    aspect;
1191           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1192                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1193                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1194                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1195                    0xc;       /* reserved -- always b1100 */
1196           buf[4] = 0xff;      /* reserved -- always 1 */
1197           break;
1198     default:
1199           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1200     }
1201     return 5;
1202 }
1203
1204 #if CONFIG_DVVIDEO_ENCODER
1205 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1206 {
1207     int chan, i, j, k;
1208
1209     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1210         for (i = 0; i < c->sys->difseg_size; i++) {
1211             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1212
1213             /* DV header: 1DIF */
1214             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1215             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1216             buf += 72; /* unused bytes */
1217
1218             /* DV subcode: 2DIFs */
1219             for (j = 0; j < 2; j++) {
1220                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1221                 for (k = 0; k < 6; k++)
1222                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1223                 buf += 29; /* unused bytes */
1224             }
1225
1226             /* DV VAUX: 3DIFS */
1227             for (j = 0; j < 3; j++) {
1228                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1229                 buf += dv_write_pack(dv_video_source,  c, buf);
1230                 buf += dv_write_pack(dv_video_control, c, buf);
1231                 buf += 7*5;
1232                 buf += dv_write_pack(dv_video_source,  c, buf);
1233                 buf += dv_write_pack(dv_video_control, c, buf);
1234                 buf += 4*5 + 2; /* unused bytes */
1235             }
1236
1237             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1238             for (j = 0; j < 135; j++) {
1239                 if (j%15 == 0) {
1240                     memset(buf, 0xff, 80);
1241                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1242                     buf += 77; /* audio control & shuffled PCM audio */
1243                 }
1244                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1245                 buf += 77; /* 1 video macroblock: 1 bytes control
1246                               4 * 14 bytes Y 8x8 data
1247                               10 bytes Cr 8x8 data
1248                               10 bytes Cb 8x8 data */
1249             }
1250         }
1251     }
1252 }
1253
1254
1255 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1256                                 void *data)
1257 {
1258     DVVideoContext *s = c->priv_data;
1259
1260     s->sys = ff_dv_codec_profile(c);
1261     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1262         return -1;
1263
1264     c->pix_fmt           = s->sys->pix_fmt;
1265     s->picture           = *((AVFrame *)data);
1266     s->picture.key_frame = 1;
1267     s->picture.pict_type = FF_I_TYPE;
1268
1269     s->buf = buf;
1270     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1271                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1272
1273     emms_c();
1274
1275     dv_format_frame(s, buf);
1276
1277     return s->sys->frame_size;
1278 }
1279 #endif
1280
1281 static int dvvideo_close(AVCodecContext *c)
1282 {
1283     DVVideoContext *s = c->priv_data;
1284
1285     if (s->picture.data[0])
1286         c->release_buffer(c, &s->picture);
1287
1288     return 0;
1289 }
1290
1291
1292 #if CONFIG_DVVIDEO_ENCODER
1293 AVCodec ff_dvvideo_encoder = {
1294     "dvvideo",
1295     AVMEDIA_TYPE_VIDEO,
1296     CODEC_ID_DVVIDEO,
1297     sizeof(DVVideoContext),
1298     dvvideo_init_encoder,
1299     dvvideo_encode_frame,
1300     .pix_fmts  = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1301     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1302 };
1303 #endif // CONFIG_DVVIDEO_ENCODER
1304
1305 #if CONFIG_DVVIDEO_DECODER
1306 AVCodec ff_dvvideo_decoder = {
1307     "dvvideo",
1308     AVMEDIA_TYPE_VIDEO,
1309     CODEC_ID_DVVIDEO,
1310     sizeof(DVVideoContext),
1311     dvvideo_init,
1312     NULL,
1313     dvvideo_close,
1314     dvvideo_decode_frame,
1315     CODEC_CAP_DR1,
1316     NULL,
1317     .max_lowres = 3,
1318     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1319 };
1320 #endif