3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
6 * 50 Mbps (DVCPRO50) support
7 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
9 * 100 Mbps (DVCPRO HD) support
10 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
11 * Final code by Roman Shaposhnik
13 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
14 * of DV technical info.
16 * This file is part of FFmpeg.
18 * FFmpeg is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU Lesser General Public
20 * License as published by the Free Software Foundation; either
21 * version 2.1 of the License, or (at your option) any later version.
23 * FFmpeg is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 * Lesser General Public License for more details.
28 * You should have received a copy of the GNU Lesser General Public
29 * License along with FFmpeg; if not, write to the Free Software
30 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
38 #include "libavutil/avassert.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/pixdesc.h"
45 #include "dv_profile_internal.h"
51 #include "simple_idct.h"
53 typedef struct BlockInfo {
54 const uint32_t *factor_table;
55 const uint8_t *scan_table;
56 uint8_t pos; /* position in block */
57 void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);
58 uint8_t partial_bit_count;
59 uint32_t partial_bit_buffer;
63 static const int dv_iweight_bits = 14;
65 static const uint16_t dv_iweight_88[64] = {
66 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
67 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
68 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
69 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
70 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
71 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
72 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
73 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
75 static const uint16_t dv_iweight_248[64] = {
76 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
77 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
78 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
79 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
80 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
81 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
82 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
83 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
87 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
89 static const uint16_t dv_iweight_1080_y[64] = {
90 128, 16, 16, 17, 17, 17, 18, 18,
91 18, 18, 18, 18, 19, 18, 18, 19,
92 19, 19, 19, 19, 19, 42, 38, 40,
93 40, 40, 38, 42, 44, 43, 41, 41,
94 41, 41, 43, 44, 45, 45, 42, 42,
95 42, 45, 45, 48, 46, 43, 43, 46,
96 48, 49, 48, 44, 48, 49, 101, 98,
97 98, 101, 104, 109, 104, 116, 116, 123,
99 static const uint16_t dv_iweight_1080_c[64] = {
100 128, 16, 16, 17, 17, 17, 25, 25,
101 25, 25, 26, 25, 26, 25, 26, 26,
102 26, 27, 27, 26, 26, 42, 38, 40,
103 40, 40, 38, 42, 44, 43, 41, 41,
104 41, 41, 43, 44, 91, 91, 84, 84,
105 84, 91, 91, 96, 93, 86, 86, 93,
106 96, 197, 191, 177, 191, 197, 203, 197,
107 197, 203, 209, 219, 209, 232, 232, 246,
109 static const uint16_t dv_iweight_720_y[64] = {
110 128, 16, 16, 17, 17, 17, 18, 18,
111 18, 18, 18, 18, 19, 18, 18, 19,
112 19, 19, 19, 19, 19, 42, 38, 40,
113 40, 40, 38, 42, 44, 43, 41, 41,
114 41, 41, 43, 44, 68, 68, 63, 63,
115 63, 68, 68, 96, 92, 86, 86, 92,
116 96, 98, 96, 88, 96, 98, 202, 196,
117 196, 202, 208, 218, 208, 232, 232, 246,
119 const uint16_t dv_iweight_720_c[64] = {
120 128, 24, 24, 26, 26, 26, 36, 36,
121 36, 36, 36, 36, 38, 36, 36, 38,
122 38, 38, 38, 38, 38, 84, 76, 80,
123 80, 80, 76, 84, 88, 86, 82, 82,
124 82, 82, 86, 88, 182, 182, 168, 168,
125 168, 182, 182, 192, 186, 192, 172, 186,
126 192, 394, 382, 354, 382, 394, 406, 394,
127 394, 406, 418, 438, 418, 464, 464, 492,
130 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
133 uint32_t *factor1 = &ctx->idct_factor[0],
134 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
136 if (DV_PROFILE_IS_HD(d)) {
137 /* quantization quanta by QNO for DV100 */
138 static const uint8_t dv100_qstep[16] = {
139 1, /* QNO = 0 and 1 both have no quantization */
141 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
143 const uint16_t *iweight1, *iweight2;
145 if (d->height == 720) {
146 iweight1 = &dv_iweight_720_y[0];
147 iweight2 = &dv_iweight_720_c[0];
149 iweight1 = &dv_iweight_1080_y[0];
150 iweight2 = &dv_iweight_1080_c[0];
152 for (c = 0; c < 4; c++) {
153 for (s = 0; s < 16; s++) {
154 for (i = 0; i < 64; i++) {
155 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
156 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
161 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
162 const uint16_t *iweight1 = &dv_iweight_88[0];
163 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
164 for (s = 0; s < 22; s++) {
165 for (i = c = 0; c < 4; c++) {
166 for (; i < dv_quant_areas[c]; i++) {
167 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
168 *factor2++ = (*factor1++) << 1;
176 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
178 DVVideoContext *s = avctx->priv_data;
182 memset(&idsp,0, sizeof(idsp));
183 ff_idctdsp_init(&idsp, avctx);
185 for (i = 0; i < 64; i++)
186 s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
189 for (i = 0; i < 64; i++){
190 int j = ff_dv_zigzag248_direct[i];
191 s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
194 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
196 s->idct_put[0] = idsp.idct_put;
197 s->idct_put[1] = ff_simple_idct248_put;
199 return ff_dvvideo_init(avctx);
202 /* decode AC coefficients */
203 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
205 int last_index = gb->size_in_bits;
206 const uint8_t *scan_table = mb->scan_table;
207 const uint32_t *factor_table = mb->factor_table;
209 int partial_bit_count = mb->partial_bit_count;
210 int level, run, vlc_len, index;
212 OPEN_READER_NOSIZE(re, gb);
213 UPDATE_CACHE(re, gb);
215 /* if we must parse a partial VLC, we do it here */
216 if (partial_bit_count > 0) {
217 re_cache = re_cache >> partial_bit_count |
218 mb->partial_bit_buffer;
219 re_index -= partial_bit_count;
220 mb->partial_bit_count = 0;
223 /* get the AC coefficients until last_index is reached */
225 av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
227 /* our own optimized GET_RL_VLC */
228 index = NEG_USR32(re_cache, TEX_VLC_BITS);
229 vlc_len = ff_dv_rl_vlc[index].len;
231 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
232 ff_dv_rl_vlc[index].level;
233 vlc_len = TEX_VLC_BITS - vlc_len;
235 level = ff_dv_rl_vlc[index].level;
236 run = ff_dv_rl_vlc[index].run;
238 /* gotta check if we're still within gb boundaries */
239 if (re_index + vlc_len > last_index) {
240 /* should be < 16 bits otherwise a codeword could have been parsed */
241 mb->partial_bit_count = last_index - re_index;
242 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
243 re_index = last_index;
248 av_dlog(NULL, "run=%d level=%d\n", run, level);
253 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
255 block[scan_table[pos]] = level;
257 UPDATE_CACHE(re, gb);
259 CLOSE_READER(re, gb);
263 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
265 int bits_left = get_bits_left(gb);
266 while (bits_left >= MIN_CACHE_BITS) {
267 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
268 bits_left -= MIN_CACHE_BITS;
271 put_bits(pb, bits_left, get_bits(gb, bits_left));
274 /* mb_x and mb_y are in units of 8 pixels */
275 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
277 DVVideoContext *s = avctx->priv_data;
278 DVwork_chunk *work_chunk = arg;
279 int quant, dc, dct_mode, class1, j;
280 int mb_index, mb_x, mb_y, last_index;
281 int y_stride, linesize;
282 int16_t *block, *block1;
285 const uint8_t *buf_ptr;
286 PutBitContext pb, vs_pb;
288 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
289 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
290 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
291 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292 const int log2_blocksize = 3-s->avctx->lowres;
293 int is_field_mode[5];
295 av_assert1((((int) mb_bit_buffer) & 7) == 0);
296 av_assert1((((int) vs_bit_buffer) & 7) == 0);
298 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
300 /* pass 1: read DC and AC coefficients in blocks */
301 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
302 block1 = &sblock[0][0];
304 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
305 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
307 quant = buf_ptr[3] & 0x0f;
309 init_put_bits(&pb, mb_bit_buffer, 80);
312 is_field_mode[mb_index] = 0;
313 for (j = 0; j < s->sys->bpm; j++) {
314 last_index = s->sys->block_sizes[j];
315 init_get_bits(&gb, buf_ptr, last_index);
318 dc = get_sbits(&gb, 9);
319 dct_mode = get_bits1(&gb);
320 class1 = get_bits(&gb, 2);
321 if (DV_PROFILE_IS_HD(s->sys)) {
322 mb->idct_put = s->idct_put[0];
323 mb->scan_table = s->dv_zigzag[0];
324 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
327 is_field_mode[mb_index] |= !j && dct_mode;
329 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
330 mb->scan_table = s->dv_zigzag[dct_mode];
332 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
334 (quant + ff_dv_quant_offset[class1]) * 64];
337 /* convert to unsigned because 128 is not added in the
341 buf_ptr += last_index >> 3;
343 mb->partial_bit_count = 0;
345 av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
346 dv_decode_ac(&gb, mb, block);
348 /* write the remaining bits in a new buffer only if the
349 * block is finished */
357 /* pass 2: we can do it just after */
358 av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
361 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
362 put_bits32(&pb, 0); // padding must be zeroed
364 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
365 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
366 dv_decode_ac(&gb, mb, block);
367 /* if still not finished, no need to parse other blocks */
372 /* all blocks are finished, so the extra bytes can be used at
373 * the video segment level */
374 if (j >= s->sys->bpm)
375 bit_copy(&vs_pb, &gb);
378 /* we need a pass over the whole video segment */
379 av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
380 block = &sblock[0][0];
382 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
383 put_bits32(&vs_pb, 0); // padding must be zeroed
384 flush_put_bits(&vs_pb);
385 for (mb_index = 0; mb_index < 5; mb_index++) {
386 for (j = 0; j < s->sys->bpm; j++) {
387 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
388 av_dlog(avctx, "start %d:%d\n", mb_index, j);
389 dv_decode_ac(&gb, mb, block);
391 if (mb->pos >= 64 && mb->pos < 127)
392 av_log(avctx, AV_LOG_ERROR,
393 "AC EOB marker is absent pos=%d\n", mb->pos);
399 /* compute idct and place blocks */
400 block = &sblock[0][0];
402 for (mb_index = 0; mb_index < 5; mb_index++) {
403 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
405 /* idct_put'ting luminance */
406 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
407 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
408 (s->sys->height >= 720 && mb_y != 134)) {
409 y_stride = (s->frame->linesize[0] <<
410 ((!is_field_mode[mb_index]) * log2_blocksize));
412 y_stride = (2 << log2_blocksize);
414 y_ptr = s->frame->data[0] +
415 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
416 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
417 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
418 if (s->sys->video_stype == 4) { /* SD 422 */
419 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
421 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
422 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
423 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
428 /* idct_put'ting chrominance */
429 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
430 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
431 for (j = 2; j; j--) {
432 uint8_t *c_ptr = s->frame->data[j] + c_offset;
433 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
434 uint64_t aligned_pixels[64 / 8];
435 uint8_t *pixels = (uint8_t *) aligned_pixels;
436 uint8_t *c_ptr1, *ptr1;
438 mb->idct_put(pixels, 8, block);
439 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
440 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
441 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
442 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
443 c_ptr[x] = pixels[x];
450 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
451 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
452 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
453 (mb++)->idct_put(c_ptr, linesize, block);
455 if (s->sys->bpm == 8) {
456 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
465 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
466 * 144000 bytes for PAL - or twice those for 50Mbps) */
467 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
468 int *got_frame, AVPacket *avpkt)
470 uint8_t *buf = avpkt->data;
471 int buf_size = avpkt->size;
472 DVVideoContext *s = avctx->priv_data;
473 const uint8_t *vsc_pack;
474 int apt, is16_9, ret;
475 const AVDVProfile *sys;
477 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
478 if (!sys || buf_size < sys->frame_size) {
479 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
480 return -1; /* NOTE: we only accept several full frames */
484 ret = ff_dv_init_dynamic_tables(s, sys);
486 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
489 dv_init_weight_tables(s, sys);
494 s->frame->key_frame = 1;
495 s->frame->pict_type = AV_PICTURE_TYPE_I;
496 avctx->pix_fmt = s->sys->pix_fmt;
497 avctx->framerate = av_inv_q(s->sys->time_base);
499 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
503 /* Determine the codec's sample_aspect ratio from the packet */
504 vsc_pack = buf + 80 * 5 + 48 + 5;
505 if (*vsc_pack == dv_video_control) {
507 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
508 (!apt && (vsc_pack[2] & 0x07) == 0x07);
509 ff_set_sar(avctx, s->sys->sar[is16_9]);
512 if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
514 s->frame->interlaced_frame = 1;
515 s->frame->top_field_first = 0;
517 /* Determine the codec's field order from the packet */
518 if ( *vsc_pack == dv_video_control ) {
519 s->frame->top_field_first = !(vsc_pack[3] & 0x40);
523 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
524 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
531 return s->sys->frame_size;
534 AVCodec ff_dvvideo_decoder = {
536 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
537 .type = AVMEDIA_TYPE_VIDEO,
538 .id = AV_CODEC_ID_DVVIDEO,
539 .priv_data_size = sizeof(DVVideoContext),
540 .init = dvvideo_decode_init,
541 .decode = dvvideo_decode_frame,
542 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,