3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
7 * Copyright (c) 2003 Roman Shaposhnik
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
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
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
19 * This file is part of FFmpeg.
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.
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.
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
40 #define ALT_BITSTREAM_READER
41 #include "libavutil/pixdesc.h"
46 #include "simple_idct.h"
48 #include "dv_tablegen.h"
53 typedef struct DVVideoContext {
56 AVCodecContext *avctx;
59 uint8_t dv_zigzag[2][64];
61 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
62 void (*fdct[2])(DCTELEM *block);
63 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
64 me_cmp_func ildct_cmp;
67 #define TEX_VLC_BITS 9
69 /* XXX: also include quantization */
70 static RL_VLC_ELEM dv_rl_vlc[1184];
72 static inline int dv_work_pool_size(const DVprofile *d)
74 int size = d->n_difchan*d->difseg_size*27;
75 if (DV_PROFILE_IS_1080i50(d))
77 if (DV_PROFILE_IS_720p50(d))
82 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
85 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
86 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
87 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
88 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
90 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
91 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
93 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
98 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
102 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
103 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
104 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
105 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
106 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
107 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
108 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
109 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
110 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
111 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
112 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
113 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
114 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
119 for (m=0; m<5; m++) {
122 blk = (chan*11+seq)*27+slot;
124 if (chan == 0 && seq == 11) {
133 i = (4*chan + blk + off[m])%11;
136 x = shuf1[m] + (chan&1)*9 + k%9;
137 y = (i*3+k/9)*2 + (chan>>1) + 1;
139 tbl[m] = (x<<1)|(y<<9);
142 blk = (chan*10+seq)*27+slot;
144 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
147 x = shuf1[m]+(chan&1)*9 + k%9;
148 y = (i*3+k/9)*2 + (chan>>1) + 4;
151 x = remap[y][0]+((x-80)<<(y>59));
154 tbl[m] = (x<<1)|(y<<9);
157 blk = (chan*10+seq)*27+slot;
159 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
160 k = (blk/5)%27 + (i&1)*3;
162 x = shuf2[m] + k%6 + 6*(chan&1);
163 y = l_start[i] + k/6 + 45*(chan>>1);
164 tbl[m] = (x<<1)|(y<<9);
167 switch (d->pix_fmt) {
168 case PIX_FMT_YUV422P:
169 x = shuf3[m] + slot/3;
171 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
172 tbl[m] = (x<<1)|(y<<8);
174 case PIX_FMT_YUV420P:
175 x = shuf3[m] + slot/3;
177 ((seq + off[m]) % d->difseg_size)*3;
178 tbl[m] = (x<<1)|(y<<9);
180 case PIX_FMT_YUV411P:
181 i = (seq + off[m]) % d->difseg_size;
182 k = slot + ((m==1||m==2)?3:0);
184 x = l_start_shuffled[m] + k/6;
185 y = serpent2[k] + i*6;
188 tbl[m] = (x<<2)|(y<<8);
197 static int dv_init_dynamic_tables(const DVprofile *d)
200 uint32_t *factor1, *factor2;
201 const int *iweight1, *iweight2;
203 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
205 for (c=0; c<d->n_difchan; c++) {
206 for (s=0; s<d->difseg_size; s++) {
208 for (j=0; j<27; j++) {
210 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
211 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
212 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
213 d->work_chunks[i++].buf_offset = p;
221 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
222 factor1 = &d->idct_factor[0];
223 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
224 if (d->height == 720) {
225 iweight1 = &dv_iweight_720_y[0];
226 iweight2 = &dv_iweight_720_c[0];
228 iweight1 = &dv_iweight_1080_y[0];
229 iweight2 = &dv_iweight_1080_c[0];
231 if (DV_PROFILE_IS_HD(d)) {
232 for (c = 0; c < 4; c++) {
233 for (s = 0; s < 16; s++) {
234 for (i = 0; i < 64; i++) {
235 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
236 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
241 iweight1 = &dv_iweight_88[0];
242 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
243 for (s = 0; s < 22; s++) {
244 for (i = c = 0; c < 4; c++) {
245 for (; i < dv_quant_areas[c]; i++) {
246 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
247 *factor2++ = (*factor1++) << 1;
258 static av_cold int dvvideo_init(AVCodecContext *avctx)
260 DVVideoContext *s = avctx->priv_data;
267 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
268 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
269 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
270 int16_t new_dv_vlc_level[NB_DV_VLC*2];
274 /* it's faster to include sign bit in a generic VLC parsing scheme */
275 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
276 new_dv_vlc_bits[j] = dv_vlc_bits[i];
277 new_dv_vlc_len[j] = dv_vlc_len[i];
278 new_dv_vlc_run[j] = dv_vlc_run[i];
279 new_dv_vlc_level[j] = dv_vlc_level[i];
281 if (dv_vlc_level[i]) {
282 new_dv_vlc_bits[j] <<= 1;
286 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
287 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
288 new_dv_vlc_run[j] = dv_vlc_run[i];
289 new_dv_vlc_level[j] = -dv_vlc_level[i];
293 /* NOTE: as a trick, we use the fact the no codes are unused
294 to accelerate the parsing of partial codes */
295 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
296 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
297 assert(dv_vlc.table_size == 1184);
299 for (i = 0; i < dv_vlc.table_size; i++){
300 int code = dv_vlc.table[i][0];
301 int len = dv_vlc.table[i][1];
304 if (len < 0){ //more bits needed
308 run = new_dv_vlc_run [code] + 1;
309 level = new_dv_vlc_level[code];
311 dv_rl_vlc[i].len = len;
312 dv_rl_vlc[i].level = level;
313 dv_rl_vlc[i].run = run;
317 dv_vlc_map_tableinit();
320 /* Generic DSP setup */
321 dsputil_init(&dsp, avctx);
322 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
323 s->get_pixels = dsp.get_pixels;
324 s->ildct_cmp = dsp.ildct_cmp[5];
327 s->fdct[0] = dsp.fdct;
328 s->idct_put[0] = dsp.idct_put;
329 for (i = 0; i < 64; i++)
330 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
333 s->fdct[1] = dsp.fdct248;
334 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
336 for (i = 0; i < 64; i++){
337 int j = ff_zigzag248_direct[i];
338 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
341 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
343 avctx->coded_frame = &s->picture;
345 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
350 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
352 if (!ff_dv_codec_profile(avctx)) {
353 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
354 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
358 return dvvideo_init(avctx);
362 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
364 typedef struct BlockInfo {
365 const uint32_t *factor_table;
366 const uint8_t *scan_table;
367 uint8_t pos; /* position in block */
368 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
369 uint8_t partial_bit_count;
370 uint16_t partial_bit_buffer;
374 /* bit budget for AC only in 5 MBs */
375 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
376 /* see dv_88_areas and dv_248_areas for details */
377 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
379 static inline int put_bits_left(PutBitContext* s)
381 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
384 /* decode ac coefficients */
385 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
387 int last_index = gb->size_in_bits;
388 const uint8_t *scan_table = mb->scan_table;
389 const uint32_t *factor_table = mb->factor_table;
391 int partial_bit_count = mb->partial_bit_count;
392 int level, run, vlc_len, index;
395 UPDATE_CACHE(re, gb);
397 /* if we must parse a partial vlc, we do it here */
398 if (partial_bit_count > 0) {
399 re_cache = ((unsigned)re_cache >> partial_bit_count) |
400 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
401 re_index -= partial_bit_count;
402 mb->partial_bit_count = 0;
405 /* get the AC coefficients until last_index is reached */
408 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
410 /* our own optimized GET_RL_VLC */
411 index = NEG_USR32(re_cache, TEX_VLC_BITS);
412 vlc_len = dv_rl_vlc[index].len;
414 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
415 vlc_len = TEX_VLC_BITS - vlc_len;
417 level = dv_rl_vlc[index].level;
418 run = dv_rl_vlc[index].run;
420 /* gotta check if we're still within gb boundaries */
421 if (re_index + vlc_len > last_index) {
422 /* should be < 16 bits otherwise a codeword could have been parsed */
423 mb->partial_bit_count = last_index - re_index;
424 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
425 re_index = last_index;
431 printf("run=%d level=%d\n", run, level);
437 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
438 block[scan_table[pos]] = level;
440 UPDATE_CACHE(re, gb);
442 CLOSE_READER(re, gb);
446 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
448 int bits_left = get_bits_left(gb);
449 while (bits_left >= MIN_CACHE_BITS) {
450 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
451 bits_left -= MIN_CACHE_BITS;
454 put_bits(pb, bits_left, get_bits(gb, bits_left));
458 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
460 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
461 *mb_y = work_chunk->mb_coordinates[m] >> 8;
463 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
464 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
465 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
469 /* mb_x and mb_y are in units of 8 pixels */
470 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
472 DVVideoContext *s = avctx->priv_data;
473 DVwork_chunk *work_chunk = arg;
474 int quant, dc, dct_mode, class1, j;
475 int mb_index, mb_x, mb_y, last_index;
476 int y_stride, linesize;
477 DCTELEM *block, *block1;
480 const uint8_t *buf_ptr;
481 PutBitContext pb, vs_pb;
483 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
484 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
485 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + 4]); /* allow some slack */
486 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5 * 80 + 4]); /* allow some slack */
487 const int log2_blocksize = 3-s->avctx->lowres;
488 int is_field_mode[5];
490 assert((((int)mb_bit_buffer) & 7) == 0);
491 assert((((int)vs_bit_buffer) & 7) == 0);
493 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
495 /* pass 1 : read DC and AC coefficients in blocks */
496 buf_ptr = &s->buf[work_chunk->buf_offset*80];
497 block1 = &sblock[0][0];
499 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
500 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
502 quant = buf_ptr[3] & 0x0f;
504 init_put_bits(&pb, mb_bit_buffer, 80);
507 is_field_mode[mb_index] = 0;
508 for (j = 0; j < s->sys->bpm; j++) {
509 last_index = s->sys->block_sizes[j];
510 init_get_bits(&gb, buf_ptr, last_index);
513 dc = get_sbits(&gb, 9);
514 dct_mode = get_bits1(&gb);
515 class1 = get_bits(&gb, 2);
516 if (DV_PROFILE_IS_HD(s->sys)) {
517 mb->idct_put = s->idct_put[0];
518 mb->scan_table = s->dv_zigzag[0];
519 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
520 is_field_mode[mb_index] |= !j && dct_mode;
522 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
523 mb->scan_table = s->dv_zigzag[dct_mode];
524 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
525 (quant + dv_quant_offset[class1])*64];
528 /* convert to unsigned because 128 is not added in the
532 buf_ptr += last_index >> 3;
534 mb->partial_bit_count = 0;
537 printf("MB block: %d, %d ", mb_index, j);
539 dv_decode_ac(&gb, mb, block);
541 /* write the remaining bits in a new buffer only if the
550 /* pass 2 : we can do it just after */
552 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
556 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
558 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
559 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
560 dv_decode_ac(&gb, mb, block);
561 /* if still not finished, no need to parse other blocks */
566 /* all blocks are finished, so the extra bytes can be used at
567 the video segment level */
568 if (j >= s->sys->bpm)
569 bit_copy(&vs_pb, &gb);
572 /* we need a pass other the whole video segment */
574 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
576 block = &sblock[0][0];
578 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
579 flush_put_bits(&vs_pb);
580 for (mb_index = 0; mb_index < 5; mb_index++) {
581 for (j = 0; j < s->sys->bpm; j++) {
584 printf("start %d:%d\n", mb_index, j);
586 dv_decode_ac(&gb, mb, block);
588 if (mb->pos >= 64 && mb->pos < 127)
589 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
595 /* compute idct and place blocks */
596 block = &sblock[0][0];
598 for (mb_index = 0; mb_index < 5; mb_index++) {
599 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
601 /* idct_put'ting luminance */
602 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
603 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
604 (s->sys->height >= 720 && mb_y != 134)) {
605 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
607 y_stride = (2 << log2_blocksize);
609 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
610 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
611 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
612 if (s->sys->video_stype == 4) { /* SD 422 */
613 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
615 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
616 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
617 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
622 /* idct_put'ting chrominance */
623 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
624 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
625 for (j = 2; j; j--) {
626 uint8_t *c_ptr = s->picture.data[j] + c_offset;
627 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
628 uint64_t aligned_pixels[64/8];
629 uint8_t *pixels = (uint8_t*)aligned_pixels;
630 uint8_t *c_ptr1, *ptr1;
632 mb->idct_put(pixels, 8, block);
633 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
634 ptr1 = pixels + (1 << (log2_blocksize - 1));
635 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
636 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
637 c_ptr[x] = pixels[x];
643 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
644 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
645 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
646 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
647 if (s->sys->bpm == 8) {
648 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
657 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
658 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
661 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
662 *vlc = dv_vlc_map[run][level].vlc | sign;
663 size = dv_vlc_map[run][level].size;
666 if (level < DV_VLC_MAP_LEV_SIZE) {
667 *vlc = dv_vlc_map[0][level].vlc | sign;
668 size = dv_vlc_map[0][level].size;
670 *vlc = 0xfe00 | (level << 1) | sign;
674 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
675 (0x1f80 | (run - 1))) << size;
676 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
683 static av_always_inline int dv_rl2vlc_size(int run, int level)
687 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
688 size = dv_vlc_map[run][level].size;
691 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
693 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
699 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
701 *vlc = dv_vlc_map[run][l].vlc | sign;
702 return dv_vlc_map[run][l].size;
705 static av_always_inline int dv_rl2vlc_size(int run, int l)
707 return dv_vlc_map[run][l].size;
711 typedef struct EncBlockInfo {
721 uint8_t partial_bit_count;
722 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
725 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
726 PutBitContext* pb_pool,
727 PutBitContext* pb_end)
730 PutBitContext* pb = pb_pool;
731 int size = bi->partial_bit_count;
732 uint32_t vlc = bi->partial_bit_buffer;
734 bi->partial_bit_count = bi->partial_bit_buffer = 0;
736 /* Find suitable storage space */
737 for (; size > (bits_left = put_bits_left(pb)); pb++) {
740 put_bits(pb, bits_left, vlc >> size);
741 vlc = vlc & ((1 << size) - 1);
743 if (pb + 1 >= pb_end) {
744 bi->partial_bit_count = size;
745 bi->partial_bit_buffer = vlc;
751 put_bits(pb, size, vlc);
753 if (bi->cur_ac >= 64)
756 /* Construct the next VLC */
758 bi->cur_ac = bi->next[prev];
759 if (bi->cur_ac < 64){
760 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
762 size = 4; vlc = 6; /* End Of Block stamp */
768 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
769 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
770 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
772 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
773 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
781 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
784 const uint8_t* zigzag_scan;
785 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
787 /* We offer two different methods for class number assignment: the
788 method suggested in SMPTE 314M Table 22, and an improved
789 method. The SMPTE method is very conservative; it assigns class
790 3 (i.e. severe quantization) to any block where the largest AC
791 component is greater than 36. FFmpeg's DV encoder tracks AC bit
792 consumption precisely, so there is no need to bias most blocks
793 towards strongly lossy compression. Instead, we assign class 2
794 to most blocks, and use class 3 only when strictly necessary
795 (for blocks whose largest AC component exceeds 255). */
797 #if 0 /* SMPTE spec method */
798 static const int classes[] = {12, 24, 36, 0xffff};
799 #else /* improved FFmpeg method */
800 static const int classes[] = {-1, -1, 255, 0xffff};
802 int max = classes[0];
805 assert((((int)blk) & 15) == 0);
807 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
808 bi->partial_bit_count = 0;
809 bi->partial_bit_buffer = 0;
812 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
813 s->get_pixels(blk, data, linesize);
814 s->fdct[bi->dct_mode](blk);
816 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
817 which is precisely what the spec calls for in the "dummy" blocks. */
818 memset(blk, 0, 64*sizeof(*blk));
823 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
824 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
826 for (area = 0; area < 4; area++) {
827 bi->prev[area] = prev;
828 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
829 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
830 int level = blk[zigzag_scan[i]];
832 if (level + 15 > 30U) {
833 bi->sign[i] = (level >> 31) & 1;
834 /* weigh it and and shift down into range, adding for rounding */
835 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
836 AND the 2x doubling of the weights */
837 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
841 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
848 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
856 for (area = 0; area < 4; area++) {
857 bi->prev[area] = prev;
858 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
859 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
863 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
872 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
875 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
878 int i, j, k, a, prev, a2;
881 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
884 for (i = 0; i < 5; i++) {
890 for (j = 0; j < 6; j++, b++) {
891 for (a = 0; a < 4; a++) {
892 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
893 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
896 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
897 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
900 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
903 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
904 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
907 assert(b->mb[b->next[k]]);
908 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
909 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
910 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
913 b->next[prev] = b->next[k];
918 size[i] += b->bit_size[a];
921 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
924 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
927 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
929 size[0] = 5 * 6 * 4; //EOB
930 for (j = 0; j < 6 *5; j++, b++) {
932 for (k = b->next[prev]; k < 64; k = b->next[k]) {
933 if (b->mb[k] < a && b->mb[k] > -a){
934 b->next[prev] = b->next[k];
936 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
944 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
946 DVVideoContext *s = avctx->priv_data;
947 DVwork_chunk *work_chunk = arg;
949 int mb_x, mb_y, c_offset, linesize, y_stride;
952 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
953 EncBlockInfo enc_blks[5*DV_MAX_BPM];
954 PutBitContext pbs[5*DV_MAX_BPM];
956 EncBlockInfo* enc_blk;
958 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
959 int* qnosp = &qnos[0];
961 dif = &s->buf[work_chunk->buf_offset*80];
962 enc_blk = &enc_blks[0];
963 for (mb_index = 0; mb_index < 5; mb_index++) {
964 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
966 /* initializing luminance blocks */
967 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
968 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
969 (s->sys->height >= 720 && mb_y != 134)) {
970 y_stride = s->picture.linesize[0] << 3;
974 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
975 linesize = s->picture.linesize[0];
977 if (s->sys->video_stype == 4) { /* SD 422 */
979 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
980 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
981 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
982 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
985 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
986 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
987 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
988 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
992 /* initializing chrominance blocks */
993 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
994 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
995 for (j = 2; j; j--) {
996 uint8_t *c_ptr = s->picture.data[j] + c_offset;
997 linesize = s->picture.linesize[j];
998 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
999 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1001 uint8_t* b = scratch;
1002 for (i = 0; i < 8; i++) {
1003 d = c_ptr + (linesize << 3);
1004 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1005 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
1013 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1014 if (s->sys->bpm == 8) {
1015 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1020 if (vs_total_ac_bits < vs_bit_size)
1021 dv_guess_qnos(&enc_blks[0], qnosp);
1023 /* DIF encoding process */
1024 for (j=0; j<5*s->sys->bpm;) {
1030 /* First pass over individual cells only */
1031 for (i=0; i<s->sys->bpm; i++, j++) {
1032 int sz = s->sys->block_sizes[i]>>3;
1034 init_put_bits(&pbs[j], dif, sz);
1035 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1036 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1037 put_bits(&pbs[j], 2, enc_blks[j].cno);
1039 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1043 /* Second pass over each MB space */
1044 pb = &pbs[start_mb];
1045 for (i=0; i<s->sys->bpm; i++) {
1046 if (enc_blks[start_mb+i].partial_bit_count)
1047 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1051 /* Third and final pass over the whole video segment space */
1053 for (j=0; j<5*s->sys->bpm; j++) {
1054 if (enc_blks[j].partial_bit_count)
1055 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1056 if (enc_blks[j].partial_bit_count)
1057 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1060 for (j=0; j<5*s->sys->bpm; j++) {
1062 int size = pbs[j].size_in_bits >> 3;
1063 flush_put_bits(&pbs[j]);
1064 pos = put_bits_count(&pbs[j]) >> 3;
1066 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1069 memset(pbs[j].buf + pos, 0xff, size - pos);
1075 #if CONFIG_DVVIDEO_DECODER
1076 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1077 144000 bytes for PAL - or twice those for 50Mbps) */
1078 static int dvvideo_decode_frame(AVCodecContext *avctx,
1079 void *data, int *data_size,
1082 const uint8_t *buf = avpkt->data;
1083 int buf_size = avpkt->size;
1084 DVVideoContext *s = avctx->priv_data;
1085 const uint8_t* vsc_pack;
1088 s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1089 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1090 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1091 return -1; /* NOTE: we only accept several full frames */
1094 if (s->picture.data[0])
1095 avctx->release_buffer(avctx, &s->picture);
1097 avcodec_get_frame_defaults(&s->picture);
1098 s->picture.reference = 0;
1099 s->picture.key_frame = 1;
1100 s->picture.pict_type = AV_PICTURE_TYPE_I;
1101 avctx->pix_fmt = s->sys->pix_fmt;
1102 avctx->time_base = s->sys->time_base;
1103 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1104 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1105 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1108 s->picture.interlaced_frame = 1;
1109 s->picture.top_field_first = 0;
1112 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1113 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1118 *data_size = sizeof(AVFrame);
1119 *(AVFrame*)data = s->picture;
1121 /* Determine the codec's sample_aspect ratio from the packet */
1122 vsc_pack = buf + 80*5 + 48 + 5;
1123 if ( *vsc_pack == dv_video_control ) {
1124 apt = buf[4] & 0x07;
1125 is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1126 avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1129 return s->sys->frame_size;
1131 #endif /* CONFIG_DVVIDEO_DECODER */
1134 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1138 * Here's what SMPTE314M says about these two:
1139 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1140 * as track application IDs (APTn = 001, AP1n =
1141 * 001, AP2n = 001, AP3n = 001), if the source signal
1142 * comes from a digital VCR. If the signal source is
1143 * unknown, all bits for these data shall be set to 1.
1144 * (page 12) STYPE: STYPE defines a signal type of video signal
1145 * 00000b = 4:1:1 compression
1146 * 00100b = 4:2:2 compression
1148 * Now, I've got two problems with these statements:
1149 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1150 * It seems that for PAL as defined in IEC 61834 we have to set
1151 * APT to 000 and for SMPTE314M to 001.
1152 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1153 * compression scheme (if any).
1155 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1158 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1161 buf[0] = (uint8_t)pack_id;
1163 case dv_header525: /* I can't imagine why these two weren't defined as real */
1164 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1165 buf[1] = 0xf8 | /* reserved -- always 1 */
1166 (apt & 0x07); /* APT: Track application ID */
1167 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1168 (0x0f << 3) | /* reserved -- always 1 */
1169 (apt & 0x07); /* AP1: Audio application ID */
1170 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1171 (0x0f << 3) | /* reserved -- always 1 */
1172 (apt & 0x07); /* AP2: Video application ID */
1173 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1174 (0x0f << 3) | /* reserved -- always 1 */
1175 (apt & 0x07); /* AP3: Subcode application ID */
1177 case dv_video_source:
1178 buf[1] = 0xff; /* reserved -- always 1 */
1179 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1180 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1181 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1182 0xf; /* reserved -- always 1 */
1183 buf[3] = (3 << 6) | /* reserved -- always 1 */
1184 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1185 c->sys->video_stype; /* signal type video compression */
1186 buf[4] = 0xff; /* VISC: 0xff -- no information */
1188 case dv_video_control:
1189 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1190 0x3f; /* reserved -- always 1 */
1191 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1193 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1194 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1195 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1196 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1197 0xc; /* reserved -- always b1100 */
1198 buf[4] = 0xff; /* reserved -- always 1 */
1201 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1206 #if CONFIG_DVVIDEO_ENCODER
1207 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1211 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1212 for (i = 0; i < c->sys->difseg_size; i++) {
1213 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1215 /* DV header: 1DIF */
1216 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1217 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1218 buf += 72; /* unused bytes */
1220 /* DV subcode: 2DIFs */
1221 for (j = 0; j < 2; j++) {
1222 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1223 for (k = 0; k < 6; k++)
1224 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1225 buf += 29; /* unused bytes */
1228 /* DV VAUX: 3DIFS */
1229 for (j = 0; j < 3; j++) {
1230 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1231 buf += dv_write_pack(dv_video_source, c, buf);
1232 buf += dv_write_pack(dv_video_control, c, buf);
1234 buf += dv_write_pack(dv_video_source, c, buf);
1235 buf += dv_write_pack(dv_video_control, c, buf);
1236 buf += 4*5 + 2; /* unused bytes */
1239 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1240 for (j = 0; j < 135; j++) {
1242 memset(buf, 0xff, 80);
1243 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1244 buf += 77; /* audio control & shuffled PCM audio */
1246 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1247 buf += 77; /* 1 video macroblock: 1 bytes control
1248 4 * 14 bytes Y 8x8 data
1249 10 bytes Cr 8x8 data
1250 10 bytes Cb 8x8 data */
1257 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1260 DVVideoContext *s = c->priv_data;
1262 s->sys = ff_dv_codec_profile(c);
1263 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1266 c->pix_fmt = s->sys->pix_fmt;
1267 s->picture = *((AVFrame *)data);
1268 s->picture.key_frame = 1;
1269 s->picture.pict_type = AV_PICTURE_TYPE_I;
1272 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1273 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1277 dv_format_frame(s, buf);
1279 return s->sys->frame_size;
1283 static int dvvideo_close(AVCodecContext *c)
1285 DVVideoContext *s = c->priv_data;
1287 if (s->picture.data[0])
1288 c->release_buffer(c, &s->picture);
1294 #if CONFIG_DVVIDEO_ENCODER
1295 AVCodec ff_dvvideo_encoder = {
1299 sizeof(DVVideoContext),
1300 dvvideo_init_encoder,
1301 dvvideo_encode_frame,
1302 .capabilities = CODEC_CAP_SLICE_THREADS,
1303 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1304 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1306 #endif // CONFIG_DVVIDEO_ENCODER
1308 #if CONFIG_DVVIDEO_DECODER
1309 AVCodec ff_dvvideo_decoder = {
1313 sizeof(DVVideoContext),
1317 dvvideo_decode_frame,
1318 CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1321 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),