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
43 #include "bitstream.h"
44 #include "simple_idct.h"
50 typedef struct DVVideoContext {
53 AVCodecContext *avctx;
56 uint8_t dv_zigzag[2][64];
58 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
59 void (*fdct[2])(DCTELEM *block);
60 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
63 #define TEX_VLC_BITS 9
66 #define DV_VLC_MAP_RUN_SIZE 15
67 #define DV_VLC_MAP_LEV_SIZE 23
69 #define DV_VLC_MAP_RUN_SIZE 64
70 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
73 /* XXX: also include quantization */
74 static RL_VLC_ELEM dv_rl_vlc[1184];
75 /* VLC encoding lookup table */
76 static struct dv_vlc_pair {
79 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
81 static inline int dv_work_pool_size(const DVprofile *d)
83 int size = d->n_difchan*d->difseg_size*27;
84 if (DV_PROFILE_IS_1080i50(d))
86 if (DV_PROFILE_IS_720p50(d))
91 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
94 const static uint8_t off[] = { 2, 6, 8, 0, 4 };
95 const static uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
96 const static uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
97 const static uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
99 const static uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
100 const static uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
102 const static uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
107 const static uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
108 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
111 const static uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
112 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
113 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
114 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
115 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
116 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
117 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
118 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
119 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
120 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
121 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
122 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
123 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
128 for (m=0; m<5; m++) {
131 blk = (chan*11+seq)*27+slot;
133 if (chan == 0 && seq == 11) {
142 i = (4*chan + blk + off[m])%11;
145 x = shuf1[m] + (chan&1)*9 + k%9;
146 y = (i*3+k/9)*2 + (chan>>1) + 1;
148 tbl[m] = (x<<1)|(y<<9);
151 blk = (chan*10+seq)*27+slot;
153 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
156 x = shuf1[m]+(chan&1)*9 + k%9;
157 y = (i*3+k/9)*2 + (chan>>1) + 4;
160 x = remap[y][0]+((x-80)<<(y>59));
163 tbl[m] = (x<<1)|(y<<9);
166 blk = (chan*10+seq)*27+slot;
168 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
169 k = (blk/5)%27 + (i&1)*3;
171 x = shuf2[m] + k%6 + 6*(chan&1);
172 y = l_start[i] + k/6 + 45*(chan>>1);
173 tbl[m] = (x<<1)|(y<<9);
176 switch (d->pix_fmt) {
177 case PIX_FMT_YUV422P:
178 x = shuf3[m] + slot/3;
180 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
181 tbl[m] = (x<<1)|(y<<8);
183 case PIX_FMT_YUV420P:
184 x = shuf3[m] + slot/3;
186 ((seq + off[m]) % d->difseg_size)*3;
187 tbl[m] = (x<<1)|(y<<9);
189 case PIX_FMT_YUV411P:
190 i = (seq + off[m]) % d->difseg_size;
191 k = slot + ((m==1||m==2)?3:0);
193 x = l_start_shuffled[m] + k/6;
194 y = serpent2[k] + i*6;
197 tbl[m] = (x<<2)|(y<<8);
206 static int dv_init_dynamic_tables(const DVprofile *d)
209 uint32_t *factor1, *factor2;
210 const int *iweight1, *iweight2;
212 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
214 for (c=0; c<d->n_difchan; c++) {
215 for (s=0; s<d->difseg_size; s++) {
217 for (j=0; j<27; j++) {
219 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
220 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
221 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
222 d->work_chunks[i++].buf_offset = p;
230 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
231 factor1 = &d->idct_factor[0];
232 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
233 if (d->height == 720) {
234 iweight1 = &dv_iweight_720_y[0];
235 iweight2 = &dv_iweight_720_c[0];
237 iweight1 = &dv_iweight_1080_y[0];
238 iweight2 = &dv_iweight_1080_c[0];
240 if (DV_PROFILE_IS_HD(d)) {
241 for (c = 0; c < 4; c++) {
242 for (s = 0; s < 16; s++) {
243 for (i = 0; i < 64; i++) {
244 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
245 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
250 iweight1 = &dv_iweight_88[0];
251 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
252 for (s = 0; s < 22; s++) {
253 for (i = c = 0; c < 4; c++) {
254 for (; i < dv_quant_areas[c]; i++) {
255 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
256 *factor2++ = (*factor1++) << 1;
267 static av_cold int dvvideo_init(AVCodecContext *avctx)
269 DVVideoContext *s = avctx->priv_data;
276 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
277 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
278 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
279 int16_t new_dv_vlc_level[NB_DV_VLC*2];
283 /* it's faster to include sign bit in a generic VLC parsing scheme */
284 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
285 new_dv_vlc_bits[j] = dv_vlc_bits[i];
286 new_dv_vlc_len[j] = dv_vlc_len[i];
287 new_dv_vlc_run[j] = dv_vlc_run[i];
288 new_dv_vlc_level[j] = dv_vlc_level[i];
290 if (dv_vlc_level[i]) {
291 new_dv_vlc_bits[j] <<= 1;
295 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
296 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
297 new_dv_vlc_run[j] = dv_vlc_run[i];
298 new_dv_vlc_level[j] = -dv_vlc_level[i];
302 /* NOTE: as a trick, we use the fact the no codes are unused
303 to accelerate the parsing of partial codes */
304 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
305 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
306 assert(dv_vlc.table_size == 1184);
308 for (i = 0; i < dv_vlc.table_size; i++){
309 int code = dv_vlc.table[i][0];
310 int len = dv_vlc.table[i][1];
313 if (len < 0){ //more bits needed
317 run = new_dv_vlc_run [code] + 1;
318 level = new_dv_vlc_level[code];
320 dv_rl_vlc[i].len = len;
321 dv_rl_vlc[i].level = level;
322 dv_rl_vlc[i].run = run;
326 for (i = 0; i < NB_DV_VLC - 1; i++) {
327 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
330 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
334 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
337 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
338 dv_vlc_bits[i] << (!!dv_vlc_level[i]);
339 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
340 dv_vlc_len[i] + (!!dv_vlc_level[i]);
342 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
344 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
345 if (dv_vlc_map[i][j].size == 0) {
346 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
347 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
348 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
349 dv_vlc_map[0][j].size;
353 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
354 if (dv_vlc_map[i][j].size == 0) {
355 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
356 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
357 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
358 dv_vlc_map[0][j].size;
360 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
361 dv_vlc_map[i][j].vlc | 1;
362 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
363 dv_vlc_map[i][j].size;
369 /* Generic DSP setup */
370 dsputil_init(&dsp, avctx);
371 s->get_pixels = dsp.get_pixels;
374 s->fdct[0] = dsp.fdct;
375 s->idct_put[0] = dsp.idct_put;
376 for (i = 0; i < 64; i++)
377 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
380 s->fdct[1] = dsp.fdct248;
381 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
383 for (i = 0; i < 64; i++){
384 int j = ff_zigzag248_direct[i];
385 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
388 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
390 avctx->coded_frame = &s->picture;
397 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
399 typedef struct BlockInfo {
400 const uint32_t *factor_table;
401 const uint8_t *scan_table;
402 uint8_t pos; /* position in block */
403 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
404 uint8_t partial_bit_count;
405 uint16_t partial_bit_buffer;
409 /* bit budget for AC only in 5 MBs */
410 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
411 /* see dv_88_areas and dv_248_areas for details */
412 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
414 static inline int get_bits_left(GetBitContext *s)
416 return s->size_in_bits - get_bits_count(s);
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 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
526 DECLARE_ALIGNED_8(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(NULL, 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 //FIXME replace this by dsputil
809 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
810 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
816 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
818 for (i = 0; i < 7; i++) {
819 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
820 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
823 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
825 for (i = 0; i < 6; i++) {
826 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
827 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
831 return (score88 - score248 > -10);
834 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
837 const uint8_t* zigzag_scan;
838 DECLARE_ALIGNED_16(DCTELEM, blk[64]);
840 /* We offer two different methods for class number assignment: the
841 method suggested in SMPTE 314M Table 22, and an improved
842 method. The SMPTE method is very conservative; it assigns class
843 3 (i.e. severe quantization) to any block where the largest AC
844 component is greater than 36. FFmpeg's DV encoder tracks AC bit
845 consumption precisely, so there is no need to bias most blocks
846 towards strongly lossy compression. Instead, we assign class 2
847 to most blocks, and use class 3 only when strictly necessary
848 (for blocks whose largest AC component exceeds 255). */
850 #if 0 /* SMPTE spec method */
851 static const int classes[] = {12, 24, 36, 0xffff};
852 #else /* improved FFmpeg method */
853 static const int classes[] = {-1, -1, 255, 0xffff};
855 int max = classes[0];
858 assert((((int)blk) & 15) == 0);
860 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
861 bi->partial_bit_count = 0;
862 bi->partial_bit_buffer = 0;
865 s->get_pixels(blk, data, linesize);
866 bi->dct_mode = (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) &&
867 dv_guess_dct_mode(blk);
868 s->fdct[bi->dct_mode](blk);
870 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
871 which is precisely what the spec calls for in the "dummy" blocks. */
872 memset(blk, 0, sizeof(blk));
877 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
878 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
880 for (area = 0; area < 4; area++) {
881 bi->prev[area] = prev;
882 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
883 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
884 int level = blk[zigzag_scan[i]];
886 if (level + 15 > 30U) {
887 bi->sign[i] = (level >> 31) & 1;
888 /* weigh it and and shift down into range, adding for rounding */
889 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
890 AND the 2x doubling of the weights */
891 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
895 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
902 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
910 for (area = 0; area < 4; area++) {
911 bi->prev[area] = prev;
912 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
913 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
917 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
926 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
929 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
932 int i, j, k, a, prev, a2;
935 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
938 for (i = 0; i < 5; i++) {
944 for (j = 0; j < 6; j++, b++) {
945 for (a = 0; a < 4; a++) {
946 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
947 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
950 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
951 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
954 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
957 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
958 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
961 assert(b->mb[b->next[k]]);
962 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
963 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
964 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
967 b->next[prev] = b->next[k];
972 size[i] += b->bit_size[a];
975 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
978 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
981 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
983 size[0] = 5 * 6 * 4; //EOB
984 for (j = 0; j < 6 *5; j++, b++) {
986 for (k = b->next[prev]; k < 64; k = b->next[k]) {
987 if (b->mb[k] < a && b->mb[k] > -a){
988 b->next[prev] = b->next[k];
990 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
998 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
1000 DVVideoContext *s = avctx->priv_data;
1001 DVwork_chunk *work_chunk = arg;
1003 int mb_x, mb_y, c_offset, linesize, y_stride;
1006 uint8_t scratch[64];
1007 EncBlockInfo enc_blks[5*DV_MAX_BPM];
1008 PutBitContext pbs[5*DV_MAX_BPM];
1010 EncBlockInfo* enc_blk;
1011 int vs_bit_size = 0;
1012 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1013 int* qnosp = &qnos[0];
1015 dif = &s->buf[work_chunk->buf_offset*80];
1016 enc_blk = &enc_blks[0];
1017 for (mb_index = 0; mb_index < 5; mb_index++) {
1018 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1020 /* initializing luminance blocks */
1021 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1022 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1023 (s->sys->height >= 720 && mb_y != 134)) {
1024 y_stride = s->picture.linesize[0] << 3;
1028 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1029 linesize = s->picture.linesize[0];
1031 if (s->sys->video_stype == 4) { /* SD 422 */
1033 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
1034 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
1035 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
1036 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
1039 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
1040 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
1041 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
1042 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1046 /* initializing chrominance blocks */
1047 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1048 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1049 for (j = 2; j; j--) {
1050 uint8_t *c_ptr = s->picture.data[j] + c_offset;
1051 linesize = s->picture.linesize[j];
1052 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1053 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1055 uint8_t* b = scratch;
1056 for (i = 0; i < 8; i++) {
1057 d = c_ptr + (linesize << 3);
1058 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1059 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
1067 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1068 if (s->sys->bpm == 8) {
1069 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1074 if (vs_total_ac_bits < vs_bit_size)
1075 dv_guess_qnos(&enc_blks[0], qnosp);
1077 /* DIF encoding process */
1078 for (j=0; j<5*s->sys->bpm;) {
1084 /* First pass over individual cells only */
1085 for (i=0; i<s->sys->bpm; i++, j++) {
1086 int sz = s->sys->block_sizes[i]>>3;
1088 init_put_bits(&pbs[j], dif, sz);
1089 put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1090 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1091 put_bits(&pbs[j], 2, enc_blks[j].cno);
1093 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1097 /* Second pass over each MB space */
1098 pb = &pbs[start_mb];
1099 for (i=0; i<s->sys->bpm; i++) {
1100 if (enc_blks[start_mb+i].partial_bit_count)
1101 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1105 /* Third and final pass over the whole video segment space */
1107 for (j=0; j<5*s->sys->bpm; j++) {
1108 if (enc_blks[j].partial_bit_count)
1109 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1110 if (enc_blks[j].partial_bit_count)
1111 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1114 for (j=0; j<5*s->sys->bpm; j++)
1115 flush_put_bits(&pbs[j]);
1120 #if CONFIG_DVVIDEO_DECODER
1121 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1122 144000 bytes for PAL - or twice those for 50Mbps) */
1123 static int dvvideo_decode_frame(AVCodecContext *avctx,
1124 void *data, int *data_size,
1125 const uint8_t *buf, int buf_size)
1127 DVVideoContext *s = avctx->priv_data;
1129 s->sys = dv_frame_profile(buf);
1130 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1131 return -1; /* NOTE: we only accept several full frames */
1133 if (s->picture.data[0])
1134 avctx->release_buffer(avctx, &s->picture);
1136 s->picture.reference = 0;
1137 s->picture.key_frame = 1;
1138 s->picture.pict_type = FF_I_TYPE;
1139 avctx->pix_fmt = s->sys->pix_fmt;
1140 avctx->time_base = s->sys->time_base;
1141 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1142 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1143 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1146 s->picture.interlaced_frame = 1;
1147 s->picture.top_field_first = 0;
1150 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1151 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1156 *data_size = sizeof(AVFrame);
1157 *(AVFrame*)data = s->picture;
1159 return s->sys->frame_size;
1161 #endif /* CONFIG_DVVIDEO_DECODER */
1164 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1168 * Here's what SMPTE314M says about these two:
1169 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1170 * as track application IDs (APTn = 001, AP1n =
1171 * 001, AP2n = 001, AP3n = 001), if the source signal
1172 * comes from a digital VCR. If the signal source is
1173 * unknown, all bits for these data shall be set to 1.
1174 * (page 12) STYPE: STYPE defines a signal type of video signal
1175 * 00000b = 4:1:1 compression
1176 * 00100b = 4:2:2 compression
1178 * Now, I've got two problems with these statements:
1179 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1180 * It seems that for PAL as defined in IEC 61834 we have to set
1181 * APT to 000 and for SMPTE314M to 001.
1182 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1183 * compression scheme (if any).
1185 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1186 int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1189 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1192 buf[0] = (uint8_t)pack_id;
1194 case dv_header525: /* I can't imagine why these two weren't defined as real */
1195 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1196 buf[1] = 0xf8 | /* reserved -- always 1 */
1197 (apt & 0x07); /* APT: Track application ID */
1198 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1199 (0x0f << 3) | /* reserved -- always 1 */
1200 (apt & 0x07); /* AP1: Audio application ID */
1201 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1202 (0x0f << 3) | /* reserved -- always 1 */
1203 (apt & 0x07); /* AP2: Video application ID */
1204 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1205 (0x0f << 3) | /* reserved -- always 1 */
1206 (apt & 0x07); /* AP3: Subcode application ID */
1208 case dv_video_source:
1209 buf[1] = 0xff; /* reserved -- always 1 */
1210 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1211 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1212 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1213 0xf; /* reserved -- always 1 */
1214 buf[3] = (3 << 6) | /* reserved -- always 1 */
1215 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1216 stype; /* signal type video compression */
1217 buf[4] = 0xff; /* VISC: 0xff -- no information */
1219 case dv_video_control:
1220 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1221 0x3f; /* reserved -- always 1 */
1222 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1224 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1225 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1226 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1227 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1228 0xc; /* reserved -- always b1100 */
1229 buf[4] = 0xff; /* reserved -- always 1 */
1232 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1237 #if CONFIG_DVVIDEO_ENCODER
1238 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1242 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1243 for (i = 0; i < c->sys->difseg_size; i++) {
1244 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1246 /* DV header: 1DIF */
1247 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1248 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1249 buf += 72; /* unused bytes */
1251 /* DV subcode: 2DIFs */
1252 for (j = 0; j < 2; j++) {
1253 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1254 for (k = 0; k < 6; k++)
1255 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1256 buf += 29; /* unused bytes */
1259 /* DV VAUX: 3DIFS */
1260 for (j = 0; j < 3; j++) {
1261 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1262 buf += dv_write_pack(dv_video_source, c, buf);
1263 buf += dv_write_pack(dv_video_control, c, buf);
1265 buf += dv_write_pack(dv_video_source, c, buf);
1266 buf += dv_write_pack(dv_video_control, c, buf);
1267 buf += 4*5 + 2; /* unused bytes */
1270 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1271 for (j = 0; j < 135; j++) {
1273 memset(buf, 0xff, 80);
1274 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1275 buf += 77; /* audio control & shuffled PCM audio */
1277 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1278 buf += 77; /* 1 video macroblock: 1 bytes control
1279 4 * 14 bytes Y 8x8 data
1280 10 bytes Cr 8x8 data
1281 10 bytes Cb 8x8 data */
1288 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1291 DVVideoContext *s = c->priv_data;
1293 s->sys = dv_codec_profile(c);
1294 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1297 c->pix_fmt = s->sys->pix_fmt;
1298 s->picture = *((AVFrame *)data);
1299 s->picture.key_frame = 1;
1300 s->picture.pict_type = FF_I_TYPE;
1303 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1304 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1308 dv_format_frame(s, buf);
1310 return s->sys->frame_size;
1314 static int dvvideo_close(AVCodecContext *c)
1316 DVVideoContext *s = c->priv_data;
1318 if (s->picture.data[0])
1319 c->release_buffer(c, &s->picture);
1325 #if CONFIG_DVVIDEO_ENCODER
1326 AVCodec dvvideo_encoder = {
1330 sizeof(DVVideoContext),
1332 dvvideo_encode_frame,
1333 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1334 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1336 #endif // CONFIG_DVVIDEO_ENCODER
1338 #if CONFIG_DVVIDEO_DECODER
1339 AVCodec dvvideo_decoder = {
1343 sizeof(DVVideoContext),
1347 dvvideo_decode_frame,
1350 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),