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
37 * @file libavcodec/dv.c
40 #define ALT_BITSTREAM_READER
45 #include "simple_idct.h"
51 typedef struct DVVideoContext {
54 AVCodecContext *avctx;
57 uint8_t dv_zigzag[2][64];
59 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
60 void (*fdct[2])(DCTELEM *block);
61 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
62 me_cmp_func ildct_cmp;
65 #define TEX_VLC_BITS 9
68 #define DV_VLC_MAP_RUN_SIZE 15
69 #define DV_VLC_MAP_LEV_SIZE 23
71 #define DV_VLC_MAP_RUN_SIZE 64
72 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
75 /* XXX: also include quantization */
76 static RL_VLC_ELEM dv_rl_vlc[1184];
77 /* VLC encoding lookup table */
78 static struct dv_vlc_pair {
81 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
83 static inline int dv_work_pool_size(const DVprofile *d)
85 int size = d->n_difchan*d->difseg_size*27;
86 if (DV_PROFILE_IS_1080i50(d))
88 if (DV_PROFILE_IS_720p50(d))
93 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
96 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
97 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
98 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
99 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
101 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
102 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
104 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
109 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
110 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
113 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
114 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
115 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
116 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
117 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
118 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
119 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
120 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
121 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
122 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
123 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
124 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
125 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
130 for (m=0; m<5; m++) {
133 blk = (chan*11+seq)*27+slot;
135 if (chan == 0 && seq == 11) {
144 i = (4*chan + blk + off[m])%11;
147 x = shuf1[m] + (chan&1)*9 + k%9;
148 y = (i*3+k/9)*2 + (chan>>1) + 1;
150 tbl[m] = (x<<1)|(y<<9);
153 blk = (chan*10+seq)*27+slot;
155 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
158 x = shuf1[m]+(chan&1)*9 + k%9;
159 y = (i*3+k/9)*2 + (chan>>1) + 4;
162 x = remap[y][0]+((x-80)<<(y>59));
165 tbl[m] = (x<<1)|(y<<9);
168 blk = (chan*10+seq)*27+slot;
170 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
171 k = (blk/5)%27 + (i&1)*3;
173 x = shuf2[m] + k%6 + 6*(chan&1);
174 y = l_start[i] + k/6 + 45*(chan>>1);
175 tbl[m] = (x<<1)|(y<<9);
178 switch (d->pix_fmt) {
179 case PIX_FMT_YUV422P:
180 x = shuf3[m] + slot/3;
182 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
183 tbl[m] = (x<<1)|(y<<8);
185 case PIX_FMT_YUV420P:
186 x = shuf3[m] + slot/3;
188 ((seq + off[m]) % d->difseg_size)*3;
189 tbl[m] = (x<<1)|(y<<9);
191 case PIX_FMT_YUV411P:
192 i = (seq + off[m]) % d->difseg_size;
193 k = slot + ((m==1||m==2)?3:0);
195 x = l_start_shuffled[m] + k/6;
196 y = serpent2[k] + i*6;
199 tbl[m] = (x<<2)|(y<<8);
208 static int dv_init_dynamic_tables(const DVprofile *d)
211 uint32_t *factor1, *factor2;
212 const int *iweight1, *iweight2;
214 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
216 for (c=0; c<d->n_difchan; c++) {
217 for (s=0; s<d->difseg_size; s++) {
219 for (j=0; j<27; j++) {
221 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
222 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
223 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
224 d->work_chunks[i++].buf_offset = p;
232 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
233 factor1 = &d->idct_factor[0];
234 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
235 if (d->height == 720) {
236 iweight1 = &dv_iweight_720_y[0];
237 iweight2 = &dv_iweight_720_c[0];
239 iweight1 = &dv_iweight_1080_y[0];
240 iweight2 = &dv_iweight_1080_c[0];
242 if (DV_PROFILE_IS_HD(d)) {
243 for (c = 0; c < 4; c++) {
244 for (s = 0; s < 16; s++) {
245 for (i = 0; i < 64; i++) {
246 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
247 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
252 iweight1 = &dv_iweight_88[0];
253 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
254 for (s = 0; s < 22; s++) {
255 for (i = c = 0; c < 4; c++) {
256 for (; i < dv_quant_areas[c]; i++) {
257 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
258 *factor2++ = (*factor1++) << 1;
269 static av_cold int dvvideo_init(AVCodecContext *avctx)
271 DVVideoContext *s = avctx->priv_data;
278 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
279 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
280 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
281 int16_t new_dv_vlc_level[NB_DV_VLC*2];
285 /* it's faster to include sign bit in a generic VLC parsing scheme */
286 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
287 new_dv_vlc_bits[j] = dv_vlc_bits[i];
288 new_dv_vlc_len[j] = dv_vlc_len[i];
289 new_dv_vlc_run[j] = dv_vlc_run[i];
290 new_dv_vlc_level[j] = dv_vlc_level[i];
292 if (dv_vlc_level[i]) {
293 new_dv_vlc_bits[j] <<= 1;
297 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
298 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
299 new_dv_vlc_run[j] = dv_vlc_run[i];
300 new_dv_vlc_level[j] = -dv_vlc_level[i];
304 /* NOTE: as a trick, we use the fact the no codes are unused
305 to accelerate the parsing of partial codes */
306 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
307 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
308 assert(dv_vlc.table_size == 1184);
310 for (i = 0; i < dv_vlc.table_size; i++){
311 int code = dv_vlc.table[i][0];
312 int len = dv_vlc.table[i][1];
315 if (len < 0){ //more bits needed
319 run = new_dv_vlc_run [code] + 1;
320 level = new_dv_vlc_level[code];
322 dv_rl_vlc[i].len = len;
323 dv_rl_vlc[i].level = level;
324 dv_rl_vlc[i].run = run;
328 for (i = 0; i < NB_DV_VLC - 1; i++) {
329 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
332 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
336 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
339 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
340 dv_vlc_bits[i] << (!!dv_vlc_level[i]);
341 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
342 dv_vlc_len[i] + (!!dv_vlc_level[i]);
344 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
346 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
347 if (dv_vlc_map[i][j].size == 0) {
348 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
349 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
350 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
351 dv_vlc_map[0][j].size;
355 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
356 if (dv_vlc_map[i][j].size == 0) {
357 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
358 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
359 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
360 dv_vlc_map[0][j].size;
362 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
363 dv_vlc_map[i][j].vlc | 1;
364 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
365 dv_vlc_map[i][j].size;
371 /* Generic DSP setup */
372 dsputil_init(&dsp, avctx);
373 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
374 s->get_pixels = dsp.get_pixels;
375 s->ildct_cmp = dsp.ildct_cmp[5];
378 s->fdct[0] = dsp.fdct;
379 s->idct_put[0] = dsp.idct_put;
380 for (i = 0; i < 64; i++)
381 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
384 s->fdct[1] = dsp.fdct248;
385 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
387 for (i = 0; i < 64; i++){
388 int j = ff_zigzag248_direct[i];
389 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
392 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
394 avctx->coded_frame = &s->picture;
396 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
402 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
404 typedef struct BlockInfo {
405 const uint32_t *factor_table;
406 const uint8_t *scan_table;
407 uint8_t pos; /* position in block */
408 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
409 uint8_t partial_bit_count;
410 uint16_t partial_bit_buffer;
414 /* bit budget for AC only in 5 MBs */
415 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
416 /* see dv_88_areas and dv_248_areas for details */
417 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
419 static inline int put_bits_left(PutBitContext* s)
421 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
424 /* decode ac coefficients */
425 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
427 int last_index = gb->size_in_bits;
428 const uint8_t *scan_table = mb->scan_table;
429 const uint32_t *factor_table = mb->factor_table;
431 int partial_bit_count = mb->partial_bit_count;
432 int level, run, vlc_len, index;
435 UPDATE_CACHE(re, gb);
437 /* if we must parse a partial vlc, we do it here */
438 if (partial_bit_count > 0) {
439 re_cache = ((unsigned)re_cache >> partial_bit_count) |
440 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
441 re_index -= partial_bit_count;
442 mb->partial_bit_count = 0;
445 /* get the AC coefficients until last_index is reached */
448 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
450 /* our own optimized GET_RL_VLC */
451 index = NEG_USR32(re_cache, TEX_VLC_BITS);
452 vlc_len = dv_rl_vlc[index].len;
454 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
455 vlc_len = TEX_VLC_BITS - vlc_len;
457 level = dv_rl_vlc[index].level;
458 run = dv_rl_vlc[index].run;
460 /* gotta check if we're still within gb boundaries */
461 if (re_index + vlc_len > last_index) {
462 /* should be < 16 bits otherwise a codeword could have been parsed */
463 mb->partial_bit_count = last_index - re_index;
464 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
465 re_index = last_index;
471 printf("run=%d level=%d\n", run, level);
477 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
478 block[scan_table[pos]] = level;
480 UPDATE_CACHE(re, gb);
482 CLOSE_READER(re, gb);
486 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
488 int bits_left = get_bits_left(gb);
489 while (bits_left >= MIN_CACHE_BITS) {
490 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
491 bits_left -= MIN_CACHE_BITS;
494 put_bits(pb, bits_left, get_bits(gb, bits_left));
498 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
500 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
501 *mb_y = work_chunk->mb_coordinates[m] >> 8;
503 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
504 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
505 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
509 /* mb_x and mb_y are in units of 8 pixels */
510 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
512 DVVideoContext *s = avctx->priv_data;
513 DVwork_chunk *work_chunk = arg;
514 int quant, dc, dct_mode, class1, j;
515 int mb_index, mb_x, mb_y, last_index;
516 int y_stride, linesize;
517 DCTELEM *block, *block1;
520 const uint8_t *buf_ptr;
521 PutBitContext pb, vs_pb;
523 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
524 DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
525 uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
526 uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
527 const int log2_blocksize = 3-s->avctx->lowres;
528 int is_field_mode[5];
530 assert((((int)mb_bit_buffer) & 7) == 0);
531 assert((((int)vs_bit_buffer) & 7) == 0);
533 memset(sblock, 0, sizeof(sblock));
535 /* pass 1 : read DC and AC coefficients in blocks */
536 buf_ptr = &s->buf[work_chunk->buf_offset*80];
537 block1 = &sblock[0][0];
539 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
540 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
542 quant = buf_ptr[3] & 0x0f;
544 init_put_bits(&pb, mb_bit_buffer, 80);
547 is_field_mode[mb_index] = 0;
548 for (j = 0; j < s->sys->bpm; j++) {
549 last_index = s->sys->block_sizes[j];
550 init_get_bits(&gb, buf_ptr, last_index);
553 dc = get_sbits(&gb, 9);
554 dct_mode = get_bits1(&gb);
555 class1 = get_bits(&gb, 2);
556 if (DV_PROFILE_IS_HD(s->sys)) {
557 mb->idct_put = s->idct_put[0];
558 mb->scan_table = s->dv_zigzag[0];
559 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
560 is_field_mode[mb_index] |= !j && dct_mode;
562 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
563 mb->scan_table = s->dv_zigzag[dct_mode];
564 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
565 (quant + dv_quant_offset[class1])*64];
568 /* convert to unsigned because 128 is not added in the
572 buf_ptr += last_index >> 3;
574 mb->partial_bit_count = 0;
577 printf("MB block: %d, %d ", mb_index, j);
579 dv_decode_ac(&gb, mb, block);
581 /* write the remaining bits in a new buffer only if the
590 /* pass 2 : we can do it just after */
592 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
596 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
598 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
599 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
600 dv_decode_ac(&gb, mb, block);
601 /* if still not finished, no need to parse other blocks */
606 /* all blocks are finished, so the extra bytes can be used at
607 the video segment level */
608 if (j >= s->sys->bpm)
609 bit_copy(&vs_pb, &gb);
612 /* we need a pass other the whole video segment */
614 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
616 block = &sblock[0][0];
618 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
619 flush_put_bits(&vs_pb);
620 for (mb_index = 0; mb_index < 5; mb_index++) {
621 for (j = 0; j < s->sys->bpm; j++) {
624 printf("start %d:%d\n", mb_index, j);
626 dv_decode_ac(&gb, mb, block);
628 if (mb->pos >= 64 && mb->pos < 127)
629 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
635 /* compute idct and place blocks */
636 block = &sblock[0][0];
638 for (mb_index = 0; mb_index < 5; mb_index++) {
639 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
641 /* idct_put'ting luminance */
642 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
643 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
644 (s->sys->height >= 720 && mb_y != 134)) {
645 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
647 y_stride = (2 << log2_blocksize);
649 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
650 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
651 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
652 if (s->sys->video_stype == 4) { /* SD 422 */
653 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
655 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
656 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
657 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
662 /* idct_put'ting chrominance */
663 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
664 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
665 for (j = 2; j; j--) {
666 uint8_t *c_ptr = s->picture.data[j] + c_offset;
667 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
668 uint64_t aligned_pixels[64/8];
669 uint8_t *pixels = (uint8_t*)aligned_pixels;
670 uint8_t *c_ptr1, *ptr1;
672 mb->idct_put(pixels, 8, block);
673 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
674 ptr1 = pixels + (1 << (log2_blocksize - 1));
675 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
676 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
677 c_ptr[x] = pixels[x];
683 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
684 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
685 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
686 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
687 if (s->sys->bpm == 8) {
688 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
697 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
698 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
701 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
702 *vlc = dv_vlc_map[run][level].vlc | sign;
703 size = dv_vlc_map[run][level].size;
706 if (level < DV_VLC_MAP_LEV_SIZE) {
707 *vlc = dv_vlc_map[0][level].vlc | sign;
708 size = dv_vlc_map[0][level].size;
710 *vlc = 0xfe00 | (level << 1) | sign;
714 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
715 (0x1f80 | (run - 1))) << size;
716 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
723 static av_always_inline int dv_rl2vlc_size(int run, int level)
727 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
728 size = dv_vlc_map[run][level].size;
731 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
733 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
739 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
741 *vlc = dv_vlc_map[run][l].vlc | sign;
742 return dv_vlc_map[run][l].size;
745 static av_always_inline int dv_rl2vlc_size(int run, int l)
747 return dv_vlc_map[run][l].size;
751 typedef struct EncBlockInfo {
761 uint8_t partial_bit_count;
762 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
765 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
766 PutBitContext* pb_pool,
767 PutBitContext* pb_end)
770 PutBitContext* pb = pb_pool;
771 int size = bi->partial_bit_count;
772 uint32_t vlc = bi->partial_bit_buffer;
774 bi->partial_bit_count = bi->partial_bit_buffer = 0;
776 /* Find suitable storage space */
777 for (; size > (bits_left = put_bits_left(pb)); pb++) {
780 put_bits(pb, bits_left, vlc >> size);
781 vlc = vlc & ((1 << size) - 1);
783 if (pb + 1 >= pb_end) {
784 bi->partial_bit_count = size;
785 bi->partial_bit_buffer = vlc;
791 put_bits(pb, size, vlc);
793 if (bi->cur_ac >= 64)
796 /* Construct the next VLC */
798 bi->cur_ac = bi->next[prev];
799 if (bi->cur_ac < 64){
800 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
802 size = 4; vlc = 6; /* End Of Block stamp */
808 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
809 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
810 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
812 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
813 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
821 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
824 const uint8_t* zigzag_scan;
825 DECLARE_ALIGNED_16(DCTELEM, blk[64]);
827 /* We offer two different methods for class number assignment: the
828 method suggested in SMPTE 314M Table 22, and an improved
829 method. The SMPTE method is very conservative; it assigns class
830 3 (i.e. severe quantization) to any block where the largest AC
831 component is greater than 36. FFmpeg's DV encoder tracks AC bit
832 consumption precisely, so there is no need to bias most blocks
833 towards strongly lossy compression. Instead, we assign class 2
834 to most blocks, and use class 3 only when strictly necessary
835 (for blocks whose largest AC component exceeds 255). */
837 #if 0 /* SMPTE spec method */
838 static const int classes[] = {12, 24, 36, 0xffff};
839 #else /* improved FFmpeg method */
840 static const int classes[] = {-1, -1, 255, 0xffff};
842 int max = classes[0];
845 assert((((int)blk) & 15) == 0);
847 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
848 bi->partial_bit_count = 0;
849 bi->partial_bit_buffer = 0;
852 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
853 s->get_pixels(blk, data, linesize);
854 s->fdct[bi->dct_mode](blk);
856 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
857 which is precisely what the spec calls for in the "dummy" blocks. */
858 memset(blk, 0, sizeof(blk));
863 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
864 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
866 for (area = 0; area < 4; area++) {
867 bi->prev[area] = prev;
868 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
869 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
870 int level = blk[zigzag_scan[i]];
872 if (level + 15 > 30U) {
873 bi->sign[i] = (level >> 31) & 1;
874 /* weigh it and and shift down into range, adding for rounding */
875 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
876 AND the 2x doubling of the weights */
877 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
881 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
888 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
896 for (area = 0; area < 4; area++) {
897 bi->prev[area] = prev;
898 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
899 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
903 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
912 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
915 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
918 int i, j, k, a, prev, a2;
921 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
924 for (i = 0; i < 5; i++) {
930 for (j = 0; j < 6; j++, b++) {
931 for (a = 0; a < 4; a++) {
932 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
933 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
936 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
937 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
940 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
943 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
944 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
947 assert(b->mb[b->next[k]]);
948 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
949 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
950 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
953 b->next[prev] = b->next[k];
958 size[i] += b->bit_size[a];
961 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
964 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
967 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
969 size[0] = 5 * 6 * 4; //EOB
970 for (j = 0; j < 6 *5; j++, b++) {
972 for (k = b->next[prev]; k < 64; k = b->next[k]) {
973 if (b->mb[k] < a && b->mb[k] > -a){
974 b->next[prev] = b->next[k];
976 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
984 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
986 DVVideoContext *s = avctx->priv_data;
987 DVwork_chunk *work_chunk = arg;
989 int mb_x, mb_y, c_offset, linesize, y_stride;
993 EncBlockInfo enc_blks[5*DV_MAX_BPM];
994 PutBitContext pbs[5*DV_MAX_BPM];
996 EncBlockInfo* enc_blk;
998 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
999 int* qnosp = &qnos[0];
1001 dif = &s->buf[work_chunk->buf_offset*80];
1002 enc_blk = &enc_blks[0];
1003 for (mb_index = 0; mb_index < 5; mb_index++) {
1004 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1006 /* initializing luminance blocks */
1007 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1008 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1009 (s->sys->height >= 720 && mb_y != 134)) {
1010 y_stride = s->picture.linesize[0] << 3;
1014 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1015 linesize = s->picture.linesize[0];
1017 if (s->sys->video_stype == 4) { /* SD 422 */
1019 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
1020 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
1021 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
1022 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
1025 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
1026 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
1027 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
1028 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1032 /* initializing chrominance blocks */
1033 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1034 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1035 for (j = 2; j; j--) {
1036 uint8_t *c_ptr = s->picture.data[j] + c_offset;
1037 linesize = s->picture.linesize[j];
1038 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1039 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1041 uint8_t* b = scratch;
1042 for (i = 0; i < 8; i++) {
1043 d = c_ptr + (linesize << 3);
1044 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1045 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
1053 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1054 if (s->sys->bpm == 8) {
1055 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1060 if (vs_total_ac_bits < vs_bit_size)
1061 dv_guess_qnos(&enc_blks[0], qnosp);
1063 /* DIF encoding process */
1064 for (j=0; j<5*s->sys->bpm;) {
1070 /* First pass over individual cells only */
1071 for (i=0; i<s->sys->bpm; i++, j++) {
1072 int sz = s->sys->block_sizes[i]>>3;
1074 init_put_bits(&pbs[j], dif, sz);
1075 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1076 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1077 put_bits(&pbs[j], 2, enc_blks[j].cno);
1079 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1083 /* Second pass over each MB space */
1084 pb = &pbs[start_mb];
1085 for (i=0; i<s->sys->bpm; i++) {
1086 if (enc_blks[start_mb+i].partial_bit_count)
1087 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1091 /* Third and final pass over the whole video segment space */
1093 for (j=0; j<5*s->sys->bpm; j++) {
1094 if (enc_blks[j].partial_bit_count)
1095 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1096 if (enc_blks[j].partial_bit_count)
1097 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1100 for (j=0; j<5*s->sys->bpm; j++) {
1102 int size = pbs[j].size_in_bits >> 3;
1103 flush_put_bits(&pbs[j]);
1104 pos = put_bits_count(&pbs[j]) >> 3;
1106 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1109 memset(pbs[j].buf + pos, 0xff, size - pos);
1115 #if CONFIG_DVVIDEO_DECODER
1116 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1117 144000 bytes for PAL - or twice those for 50Mbps) */
1118 static int dvvideo_decode_frame(AVCodecContext *avctx,
1119 void *data, int *data_size,
1122 const uint8_t *buf = avpkt->data;
1123 int buf_size = avpkt->size;
1124 DVVideoContext *s = avctx->priv_data;
1126 s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1127 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1128 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1129 return -1; /* NOTE: we only accept several full frames */
1132 if (s->picture.data[0])
1133 avctx->release_buffer(avctx, &s->picture);
1135 s->picture.reference = 0;
1136 s->picture.key_frame = 1;
1137 s->picture.pict_type = FF_I_TYPE;
1138 avctx->pix_fmt = s->sys->pix_fmt;
1139 avctx->time_base = s->sys->time_base;
1140 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1141 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1142 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1145 s->picture.interlaced_frame = 1;
1146 s->picture.top_field_first = 0;
1149 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1150 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1155 *data_size = sizeof(AVFrame);
1156 *(AVFrame*)data = s->picture;
1158 return s->sys->frame_size;
1160 #endif /* CONFIG_DVVIDEO_DECODER */
1163 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1167 * Here's what SMPTE314M says about these two:
1168 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1169 * as track application IDs (APTn = 001, AP1n =
1170 * 001, AP2n = 001, AP3n = 001), if the source signal
1171 * comes from a digital VCR. If the signal source is
1172 * unknown, all bits for these data shall be set to 1.
1173 * (page 12) STYPE: STYPE defines a signal type of video signal
1174 * 00000b = 4:1:1 compression
1175 * 00100b = 4:2:2 compression
1177 * Now, I've got two problems with these statements:
1178 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1179 * It seems that for PAL as defined in IEC 61834 we have to set
1180 * APT to 000 and for SMPTE314M to 001.
1181 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1182 * compression scheme (if any).
1184 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1187 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1190 buf[0] = (uint8_t)pack_id;
1192 case dv_header525: /* I can't imagine why these two weren't defined as real */
1193 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1194 buf[1] = 0xf8 | /* reserved -- always 1 */
1195 (apt & 0x07); /* APT: Track application ID */
1196 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1197 (0x0f << 3) | /* reserved -- always 1 */
1198 (apt & 0x07); /* AP1: Audio application ID */
1199 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1200 (0x0f << 3) | /* reserved -- always 1 */
1201 (apt & 0x07); /* AP2: Video application ID */
1202 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1203 (0x0f << 3) | /* reserved -- always 1 */
1204 (apt & 0x07); /* AP3: Subcode application ID */
1206 case dv_video_source:
1207 buf[1] = 0xff; /* reserved -- always 1 */
1208 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1209 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1210 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1211 0xf; /* reserved -- always 1 */
1212 buf[3] = (3 << 6) | /* reserved -- always 1 */
1213 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1214 c->sys->video_stype; /* signal type video compression */
1215 buf[4] = 0xff; /* VISC: 0xff -- no information */
1217 case dv_video_control:
1218 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1219 0x3f; /* reserved -- always 1 */
1220 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1222 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1223 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1224 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1225 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1226 0xc; /* reserved -- always b1100 */
1227 buf[4] = 0xff; /* reserved -- always 1 */
1230 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1235 #if CONFIG_DVVIDEO_ENCODER
1236 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1240 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1241 for (i = 0; i < c->sys->difseg_size; i++) {
1242 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1244 /* DV header: 1DIF */
1245 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1246 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1247 buf += 72; /* unused bytes */
1249 /* DV subcode: 2DIFs */
1250 for (j = 0; j < 2; j++) {
1251 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1252 for (k = 0; k < 6; k++)
1253 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1254 buf += 29; /* unused bytes */
1257 /* DV VAUX: 3DIFS */
1258 for (j = 0; j < 3; j++) {
1259 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1260 buf += dv_write_pack(dv_video_source, c, buf);
1261 buf += dv_write_pack(dv_video_control, c, buf);
1263 buf += dv_write_pack(dv_video_source, c, buf);
1264 buf += dv_write_pack(dv_video_control, c, buf);
1265 buf += 4*5 + 2; /* unused bytes */
1268 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1269 for (j = 0; j < 135; j++) {
1271 memset(buf, 0xff, 80);
1272 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1273 buf += 77; /* audio control & shuffled PCM audio */
1275 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1276 buf += 77; /* 1 video macroblock: 1 bytes control
1277 4 * 14 bytes Y 8x8 data
1278 10 bytes Cr 8x8 data
1279 10 bytes Cb 8x8 data */
1286 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1289 DVVideoContext *s = c->priv_data;
1291 s->sys = ff_dv_codec_profile(c);
1292 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1295 c->pix_fmt = s->sys->pix_fmt;
1296 s->picture = *((AVFrame *)data);
1297 s->picture.key_frame = 1;
1298 s->picture.pict_type = FF_I_TYPE;
1301 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1302 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1306 dv_format_frame(s, buf);
1308 return s->sys->frame_size;
1312 static int dvvideo_close(AVCodecContext *c)
1314 DVVideoContext *s = c->priv_data;
1316 if (s->picture.data[0])
1317 c->release_buffer(c, &s->picture);
1323 #if CONFIG_DVVIDEO_ENCODER
1324 AVCodec dvvideo_encoder = {
1328 sizeof(DVVideoContext),
1330 dvvideo_encode_frame,
1331 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1332 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1334 #endif // CONFIG_DVVIDEO_ENCODER
1336 #if CONFIG_DVVIDEO_DECODER
1337 AVCodec dvvideo_decoder = {
1341 sizeof(DVVideoContext),
1345 dvvideo_decode_frame,
1348 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),