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, ptrdiff_t stride, 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 static 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 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
226 pos, SHOW_UBITS(re, gb, 16), re_index);
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 ff_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 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
291 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292 const int log2_blocksize = 3-s->avctx->lowres;
293 int is_field_mode[5];
294 int vs_bit_buffer_damaged = 0;
295 int mb_bit_buffer_damaged[5] = {0};
299 av_assert1((((int) mb_bit_buffer) & 7) == 0);
300 av_assert1((((int) vs_bit_buffer) & 7) == 0);
304 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
306 /* pass 1: read DC and AC coefficients in blocks */
307 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
308 block1 = &sblock[0][0];
310 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
311 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
313 quant = buf_ptr[3] & 0x0f;
314 if (avctx->error_concealment) {
315 if ((buf_ptr[3] >> 4) == 0x0E)
316 vs_bit_buffer_damaged = 1;
318 sta = buf_ptr[3] >> 4;
319 } else if (sta != (buf_ptr[3] >> 4))
320 vs_bit_buffer_damaged = 1;
323 init_put_bits(&pb, mb_bit_buffer, 80);
326 is_field_mode[mb_index] = 0;
327 for (j = 0; j < s->sys->bpm; j++) {
328 last_index = s->sys->block_sizes[j];
329 init_get_bits(&gb, buf_ptr, last_index);
332 dc = get_sbits(&gb, 9);
333 dct_mode = get_bits1(&gb);
334 class1 = get_bits(&gb, 2);
335 if (DV_PROFILE_IS_HD(s->sys)) {
336 mb->idct_put = s->idct_put[0];
337 mb->scan_table = s->dv_zigzag[0];
338 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
341 is_field_mode[mb_index] |= !j && dct_mode;
343 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
344 mb->scan_table = s->dv_zigzag[dct_mode];
346 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
348 (quant + ff_dv_quant_offset[class1]) * 64];
351 /* convert to unsigned because 128 is not added in the
355 buf_ptr += last_index >> 3;
357 mb->partial_bit_count = 0;
359 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
360 dv_decode_ac(&gb, mb, block);
362 /* write the remaining bits in a new buffer only if the
363 * block is finished */
366 if (mb->pos >= 64 && mb->pos < 127)
367 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
373 if (mb_bit_buffer_damaged[mb_index] > 0)
376 /* pass 2: we can do it just after */
377 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
380 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
381 put_bits32(&pb, 0); // padding must be zeroed
383 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
384 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
385 dv_decode_ac(&gb, mb, block);
386 /* if still not finished, no need to parse other blocks */
390 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
393 /* all blocks are finished, so the extra bytes can be used at
394 * the video segment level */
395 if (j >= s->sys->bpm)
396 bit_copy(&vs_pb, &gb);
399 /* we need a pass over the whole video segment */
400 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
401 block = &sblock[0][0];
403 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
404 put_bits32(&vs_pb, 0); // padding must be zeroed
405 flush_put_bits(&vs_pb);
406 for (mb_index = 0; mb_index < 5; mb_index++) {
407 for (j = 0; j < s->sys->bpm; j++) {
408 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
409 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
410 dv_decode_ac(&gb, mb, block);
413 if (mb->pos >= 64 && mb->pos < 127) {
414 av_log(avctx, AV_LOG_ERROR,
415 "AC EOB marker is absent pos=%d\n", mb->pos);
416 vs_bit_buffer_damaged = 1;
422 if (vs_bit_buffer_damaged && !retried) {
423 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
428 /* compute idct and place blocks */
429 block = &sblock[0][0];
431 for (mb_index = 0; mb_index < 5; mb_index++) {
432 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
434 /* idct_put'ting luminance */
435 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
436 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
437 (s->sys->height >= 720 && mb_y != 134)) {
438 y_stride = (s->frame->linesize[0] <<
439 ((!is_field_mode[mb_index]) * log2_blocksize));
441 y_stride = (2 << log2_blocksize);
443 y_ptr = s->frame->data[0] +
444 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
445 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
446 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
447 if (s->sys->video_stype == 4) { /* SD 422 */
448 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
450 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
451 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
452 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
457 /* idct_put'ting chrominance */
458 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
459 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
460 for (j = 2; j; j--) {
461 uint8_t *c_ptr = s->frame->data[j] + c_offset;
462 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
463 uint64_t aligned_pixels[64 / 8];
464 uint8_t *pixels = (uint8_t *) aligned_pixels;
465 uint8_t *c_ptr1, *ptr1;
467 mb->idct_put(pixels, 8, block);
468 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
469 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
470 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
471 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
472 c_ptr[x] = pixels[x];
479 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
480 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
481 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
482 (mb++)->idct_put(c_ptr, linesize, block);
484 if (s->sys->bpm == 8) {
485 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
494 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
495 * 144000 bytes for PAL - or twice those for 50Mbps) */
496 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
497 int *got_frame, AVPacket *avpkt)
499 uint8_t *buf = avpkt->data;
500 int buf_size = avpkt->size;
501 DVVideoContext *s = avctx->priv_data;
502 AVFrame *frame = data;
503 const uint8_t *vsc_pack;
504 int apt, is16_9, ret;
505 const AVDVProfile *sys;
507 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
508 if (!sys || buf_size < sys->frame_size) {
509 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
510 return -1; /* NOTE: we only accept several full frames */
514 ret = ff_dv_init_dynamic_tables(s, sys);
516 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
519 dv_init_weight_tables(s, sys);
524 frame->key_frame = 1;
525 frame->pict_type = AV_PICTURE_TYPE_I;
526 avctx->pix_fmt = s->sys->pix_fmt;
527 avctx->framerate = av_inv_q(s->sys->time_base);
529 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
533 /* Determine the codec's sample_aspect ratio from the packet */
534 vsc_pack = buf + 80 * 5 + 48 + 5;
535 if (*vsc_pack == dv_video_control) {
537 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
538 (!apt && (vsc_pack[2] & 0x07) == 0x07);
539 ff_set_sar(avctx, s->sys->sar[is16_9]);
542 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
544 frame->interlaced_frame = 1;
545 frame->top_field_first = 0;
547 /* Determine the codec's field order from the packet */
548 if ( *vsc_pack == dv_video_control ) {
549 frame->top_field_first = !(vsc_pack[3] & 0x40);
553 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
554 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
561 return s->sys->frame_size;
564 AVCodec ff_dvvideo_decoder = {
566 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
567 .type = AVMEDIA_TYPE_VIDEO,
568 .id = AV_CODEC_ID_DVVIDEO,
569 .priv_data_size = sizeof(DVVideoContext),
570 .init = dvvideo_decode_init,
571 .decode = dvvideo_decode_frame,
572 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,