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"
54 typedef struct BlockInfo {
55 const uint32_t *factor_table;
56 const uint8_t *scan_table;
57 uint8_t pos; /* position in block */
58 void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
59 uint8_t partial_bit_count;
60 uint32_t partial_bit_buffer;
64 static const int dv_iweight_bits = 14;
66 static const uint16_t dv_iweight_88[64] = {
67 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
68 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
69 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
70 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
71 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
72 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
73 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
74 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
76 static const uint16_t dv_iweight_248[64] = {
77 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
78 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
79 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
80 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
81 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
82 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
83 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
84 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
88 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
90 static const uint16_t dv_iweight_1080_y[64] = {
91 128, 16, 16, 17, 17, 17, 18, 18,
92 18, 18, 18, 18, 19, 18, 18, 19,
93 19, 19, 19, 19, 19, 42, 38, 40,
94 40, 40, 38, 42, 44, 43, 41, 41,
95 41, 41, 43, 44, 45, 45, 42, 42,
96 42, 45, 45, 48, 46, 43, 43, 46,
97 48, 49, 48, 44, 48, 49, 101, 98,
98 98, 101, 104, 109, 104, 116, 116, 123,
100 static const uint16_t dv_iweight_1080_c[64] = {
101 128, 16, 16, 17, 17, 17, 25, 25,
102 25, 25, 26, 25, 26, 25, 26, 26,
103 26, 27, 27, 26, 26, 42, 38, 40,
104 40, 40, 38, 42, 44, 43, 41, 41,
105 41, 41, 43, 44, 91, 91, 84, 84,
106 84, 91, 91, 96, 93, 86, 86, 93,
107 96, 197, 191, 177, 191, 197, 203, 197,
108 197, 203, 209, 219, 209, 232, 232, 246,
110 static const uint16_t dv_iweight_720_y[64] = {
111 128, 16, 16, 17, 17, 17, 18, 18,
112 18, 18, 18, 18, 19, 18, 18, 19,
113 19, 19, 19, 19, 19, 42, 38, 40,
114 40, 40, 38, 42, 44, 43, 41, 41,
115 41, 41, 43, 44, 68, 68, 63, 63,
116 63, 68, 68, 96, 92, 86, 86, 92,
117 96, 98, 96, 88, 96, 98, 202, 196,
118 196, 202, 208, 218, 208, 232, 232, 246,
120 static const uint16_t dv_iweight_720_c[64] = {
121 128, 24, 24, 26, 26, 26, 36, 36,
122 36, 36, 36, 36, 38, 36, 36, 38,
123 38, 38, 38, 38, 38, 84, 76, 80,
124 80, 80, 76, 84, 88, 86, 82, 82,
125 82, 82, 86, 88, 182, 182, 168, 168,
126 168, 182, 182, 192, 186, 192, 172, 186,
127 192, 394, 382, 354, 382, 394, 406, 394,
128 394, 406, 418, 438, 418, 464, 464, 492,
131 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
134 uint32_t *factor1 = &ctx->idct_factor[0],
135 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
137 if (DV_PROFILE_IS_HD(d)) {
138 /* quantization quanta by QNO for DV100 */
139 static const uint8_t dv100_qstep[16] = {
140 1, /* QNO = 0 and 1 both have no quantization */
142 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
144 const uint16_t *iweight1, *iweight2;
146 if (d->height == 720) {
147 iweight1 = &dv_iweight_720_y[0];
148 iweight2 = &dv_iweight_720_c[0];
150 iweight1 = &dv_iweight_1080_y[0];
151 iweight2 = &dv_iweight_1080_c[0];
153 for (c = 0; c < 4; c++) {
154 for (s = 0; s < 16; s++) {
155 for (i = 0; i < 64; i++) {
156 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
157 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
162 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
163 const uint16_t *iweight1 = &dv_iweight_88[0];
164 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
165 for (s = 0; s < 22; s++) {
166 for (i = c = 0; c < 4; c++) {
167 for (; i < dv_quant_areas[c]; i++) {
168 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
169 *factor2++ = (*factor1++) << 1;
177 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
179 DVVideoContext *s = avctx->priv_data;
183 memset(&idsp,0, sizeof(idsp));
184 ff_idctdsp_init(&idsp, avctx);
186 for (i = 0; i < 64; i++)
187 s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
190 for (i = 0; i < 64; i++){
191 int j = ff_dv_zigzag248_direct[i];
192 s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
195 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
197 s->idct_put[0] = idsp.idct_put;
198 s->idct_put[1] = ff_simple_idct248_put;
200 return ff_dvvideo_init(avctx);
203 /* decode AC coefficients */
204 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
206 int last_index = gb->size_in_bits;
207 const uint8_t *scan_table = mb->scan_table;
208 const uint32_t *factor_table = mb->factor_table;
210 int partial_bit_count = mb->partial_bit_count;
211 int level, run, vlc_len, index;
213 OPEN_READER_NOSIZE(re, gb);
214 UPDATE_CACHE(re, gb);
216 /* if we must parse a partial VLC, we do it here */
217 if (partial_bit_count > 0) {
218 re_cache = re_cache >> partial_bit_count |
219 mb->partial_bit_buffer;
220 re_index -= partial_bit_count;
221 mb->partial_bit_count = 0;
224 /* get the AC coefficients until last_index is reached */
226 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
227 pos, SHOW_UBITS(re, gb, 16), re_index);
228 /* our own optimized GET_RL_VLC */
229 index = NEG_USR32(re_cache, TEX_VLC_BITS);
230 vlc_len = ff_dv_rl_vlc[index].len;
232 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
233 ff_dv_rl_vlc[index].level;
234 vlc_len = TEX_VLC_BITS - vlc_len;
236 level = ff_dv_rl_vlc[index].level;
237 run = ff_dv_rl_vlc[index].run;
239 /* gotta check if we're still within gb boundaries */
240 if (re_index + vlc_len > last_index) {
241 /* should be < 16 bits otherwise a codeword could have been parsed */
242 mb->partial_bit_count = last_index - re_index;
243 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
244 re_index = last_index;
249 ff_dlog(NULL, "run=%d level=%d\n", run, level);
254 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
256 block[scan_table[pos]] = level;
258 UPDATE_CACHE(re, gb);
260 CLOSE_READER(re, gb);
264 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
266 int bits_left = get_bits_left(gb);
267 while (bits_left >= MIN_CACHE_BITS) {
268 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
269 bits_left -= MIN_CACHE_BITS;
272 put_bits(pb, bits_left, get_bits(gb, bits_left));
275 /* mb_x and mb_y are in units of 8 pixels */
276 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
278 DVVideoContext *s = avctx->priv_data;
279 DVwork_chunk *work_chunk = arg;
280 int quant, dc, dct_mode, class1, j;
281 int mb_index, mb_x, mb_y, last_index;
282 int y_stride, linesize;
283 int16_t *block, *block1;
286 const uint8_t *buf_ptr;
287 PutBitContext pb, vs_pb;
289 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
290 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
291 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
293 const int log2_blocksize = 3-s->avctx->lowres;
294 int is_field_mode[5];
295 int vs_bit_buffer_damaged = 0;
296 int mb_bit_buffer_damaged[5] = {0};
300 av_assert1((((int) mb_bit_buffer) & 7) == 0);
301 av_assert1((((int) vs_bit_buffer) & 7) == 0);
305 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
307 /* pass 1: read DC and AC coefficients in blocks */
308 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
309 block1 = &sblock[0][0];
311 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
312 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
314 quant = buf_ptr[3] & 0x0f;
315 if (avctx->error_concealment) {
316 if ((buf_ptr[3] >> 4) == 0x0E)
317 vs_bit_buffer_damaged = 1;
319 sta = buf_ptr[3] >> 4;
320 } else if (sta != (buf_ptr[3] >> 4))
321 vs_bit_buffer_damaged = 1;
324 init_put_bits(&pb, mb_bit_buffer, 80);
327 is_field_mode[mb_index] = 0;
328 for (j = 0; j < s->sys->bpm; j++) {
329 last_index = s->sys->block_sizes[j];
330 init_get_bits(&gb, buf_ptr, last_index);
333 dc = get_sbits(&gb, 9);
334 dct_mode = get_bits1(&gb);
335 class1 = get_bits(&gb, 2);
336 if (DV_PROFILE_IS_HD(s->sys)) {
337 mb->idct_put = s->idct_put[0];
338 mb->scan_table = s->dv_zigzag[0];
339 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
342 is_field_mode[mb_index] |= !j && dct_mode;
344 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
345 mb->scan_table = s->dv_zigzag[dct_mode];
347 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
349 (quant + ff_dv_quant_offset[class1]) * 64];
352 /* convert to unsigned because 128 is not added in the
356 buf_ptr += last_index >> 3;
358 mb->partial_bit_count = 0;
360 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
361 dv_decode_ac(&gb, mb, block);
363 /* write the remaining bits in a new buffer only if the
364 * block is finished */
367 if (mb->pos >= 64 && mb->pos < 127)
368 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
374 if (mb_bit_buffer_damaged[mb_index] > 0)
377 /* pass 2: we can do it just after */
378 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
381 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
382 put_bits32(&pb, 0); // padding must be zeroed
384 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
385 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
386 dv_decode_ac(&gb, mb, block);
387 /* if still not finished, no need to parse other blocks */
391 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
394 /* all blocks are finished, so the extra bytes can be used at
395 * the video segment level */
396 if (j >= s->sys->bpm)
397 bit_copy(&vs_pb, &gb);
400 /* we need a pass over the whole video segment */
401 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
402 block = &sblock[0][0];
404 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
405 put_bits32(&vs_pb, 0); // padding must be zeroed
406 flush_put_bits(&vs_pb);
407 for (mb_index = 0; mb_index < 5; mb_index++) {
408 for (j = 0; j < s->sys->bpm; j++) {
409 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
410 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
411 dv_decode_ac(&gb, mb, block);
414 if (mb->pos >= 64 && mb->pos < 127) {
415 av_log(avctx, AV_LOG_ERROR,
416 "AC EOB marker is absent pos=%d\n", mb->pos);
417 vs_bit_buffer_damaged = 1;
423 if (vs_bit_buffer_damaged && !retried) {
424 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
429 /* compute idct and place blocks */
430 block = &sblock[0][0];
432 for (mb_index = 0; mb_index < 5; mb_index++) {
433 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
435 /* idct_put'ting luminance */
436 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
437 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
438 (s->sys->height >= 720 && mb_y != 134)) {
439 y_stride = (s->frame->linesize[0] <<
440 ((!is_field_mode[mb_index]) * log2_blocksize));
442 y_stride = (2 << log2_blocksize);
444 y_ptr = s->frame->data[0] +
445 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
446 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
447 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
448 if (s->sys->video_stype == 4) { /* SD 422 */
449 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
451 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
452 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
453 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
458 /* idct_put'ting chrominance */
459 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
460 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
461 for (j = 2; j; j--) {
462 uint8_t *c_ptr = s->frame->data[j] + c_offset;
463 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
464 uint64_t aligned_pixels[64 / 8];
465 uint8_t *pixels = (uint8_t *) aligned_pixels;
466 uint8_t *c_ptr1, *ptr1;
468 mb->idct_put(pixels, 8, block);
469 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
470 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
471 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
472 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
473 c_ptr[x] = pixels[x];
480 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
481 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
482 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
483 (mb++)->idct_put(c_ptr, linesize, block);
485 if (s->sys->bpm == 8) {
486 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
495 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
496 * 144000 bytes for PAL - or twice those for 50Mbps) */
497 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
498 int *got_frame, AVPacket *avpkt)
500 uint8_t *buf = avpkt->data;
501 int buf_size = avpkt->size;
502 DVVideoContext *s = avctx->priv_data;
503 ThreadFrame frame = { .f = data };
504 const uint8_t *vsc_pack;
505 int apt, is16_9, ret;
506 const AVDVProfile *sys;
508 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
509 if (!sys || buf_size < sys->frame_size) {
510 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
511 return -1; /* NOTE: we only accept several full frames */
515 ret = ff_dv_init_dynamic_tables(s, sys);
517 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
520 dv_init_weight_tables(s, sys);
525 frame.f->key_frame = 1;
526 frame.f->pict_type = AV_PICTURE_TYPE_I;
527 avctx->pix_fmt = s->sys->pix_fmt;
528 avctx->framerate = av_inv_q(s->sys->time_base);
530 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
534 /* Determine the codec's sample_aspect ratio from the packet */
535 vsc_pack = buf + 80 * 5 + 48 + 5;
536 if (*vsc_pack == dv_video_control) {
538 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
539 (!apt && (vsc_pack[2] & 0x07) == 0x07);
540 ff_set_sar(avctx, s->sys->sar[is16_9]);
543 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
545 frame.f->interlaced_frame = 1;
546 frame.f->top_field_first = 0;
548 /* Determine the codec's field order from the packet */
549 if ( *vsc_pack == dv_video_control ) {
550 frame.f->top_field_first = !(vsc_pack[3] & 0x40);
554 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
555 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
562 return s->sys->frame_size;
565 AVCodec ff_dvvideo_decoder = {
567 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
568 .type = AVMEDIA_TYPE_VIDEO,
569 .id = AV_CODEC_ID_DVVIDEO,
570 .priv_data_size = sizeof(DVVideoContext),
571 .init = dvvideo_decode_init,
572 .decode = dvvideo_decode_frame,
573 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,