1/* 2 * DV decoder 3 * Copyright (c) 2002 Fabrice Bellard 4 * Copyright (c) 2004 Roman Shaposhnik 5 * 6 * 50 Mbps (DVCPRO50) support 7 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com> 8 * 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 12 * 13 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth 14 * of DV technical info. 15 * 16 * This file is part of FFmpeg. 17 * 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. 22 * 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. 27 * 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 31 */ 32 33/** 34 * @file 35 * DV decoder 36 */ 37 38#include "libavutil/avassert.h" 39#include "libavutil/imgutils.h" 40#include "libavutil/internal.h" 41#include "libavutil/mem_internal.h" 42#include "libavutil/pixdesc.h" 43#include "libavutil/thread.h" 44 45#include "avcodec.h" 46#include "codec_internal.h" 47#include "dv.h" 48#include "dv_profile_internal.h" 49#include "dvdata.h" 50#include "get_bits.h" 51#include "internal.h" 52#include "put_bits.h" 53#include "simple_idct.h" 54#include "thread.h" 55 56typedef struct BlockInfo { 57 const uint32_t *factor_table; 58 const uint8_t *scan_table; 59 uint8_t pos; /* position in block */ 60 void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block); 61 uint8_t partial_bit_count; 62 uint32_t partial_bit_buffer; 63 int shift_offset; 64} BlockInfo; 65 66static const int dv_iweight_bits = 14; 67 68static const uint16_t dv_iweight_88[64] = { 69 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081, 70 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266, 71 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267, 72 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806, 73 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400, 74 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786, 75 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172, 76 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521, 77}; 78static const uint16_t dv_iweight_248[64] = { 79 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734, 80 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091, 81 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705, 82 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806, 83 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853, 84 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018, 85 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465, 86 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692 87}; 88 89/** 90 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged). 91 */ 92static const uint16_t dv_iweight_1080_y[64] = { 93 128, 16, 16, 17, 17, 17, 18, 18, 94 18, 18, 18, 18, 19, 18, 18, 19, 95 19, 19, 19, 19, 19, 42, 38, 40, 96 40, 40, 38, 42, 44, 43, 41, 41, 97 41, 41, 43, 44, 45, 45, 42, 42, 98 42, 45, 45, 48, 46, 43, 43, 46, 99 48, 49, 48, 44, 48, 49, 101, 98, 100 98, 101, 104, 109, 104, 116, 116, 123, 101}; 102static const uint16_t dv_iweight_1080_c[64] = { 103 128, 16, 16, 17, 17, 17, 25, 25, 104 25, 25, 26, 25, 26, 25, 26, 26, 105 26, 27, 27, 26, 26, 42, 38, 40, 106 40, 40, 38, 42, 44, 43, 41, 41, 107 41, 41, 43, 44, 91, 91, 84, 84, 108 84, 91, 91, 96, 93, 86, 86, 93, 109 96, 197, 191, 177, 191, 197, 203, 197, 110 197, 203, 209, 219, 209, 232, 232, 246, 111}; 112static const uint16_t dv_iweight_720_y[64] = { 113 128, 16, 16, 17, 17, 17, 18, 18, 114 18, 18, 18, 18, 19, 18, 18, 19, 115 19, 19, 19, 19, 19, 42, 38, 40, 116 40, 40, 38, 42, 44, 43, 41, 41, 117 41, 41, 43, 44, 68, 68, 63, 63, 118 63, 68, 68, 96, 92, 86, 86, 92, 119 96, 98, 96, 88, 96, 98, 202, 196, 120 196, 202, 208, 218, 208, 232, 232, 246, 121}; 122static const uint16_t dv_iweight_720_c[64] = { 123 128, 24, 24, 26, 26, 26, 36, 36, 124 36, 36, 36, 36, 38, 36, 36, 38, 125 38, 38, 38, 38, 38, 84, 76, 80, 126 80, 80, 76, 84, 88, 86, 82, 82, 127 82, 82, 86, 88, 182, 182, 168, 168, 128 168, 182, 182, 192, 186, 192, 172, 186, 129 192, 394, 382, 354, 382, 394, 406, 394, 130 394, 406, 418, 438, 418, 464, 464, 492, 131}; 132 133#define TEX_VLC_BITS 10 134 135/* XXX: also include quantization */ 136static RL_VLC_ELEM dv_rl_vlc[1664]; 137 138static void dv_init_static(void) 139{ 140 VLCElem vlc_buf[FF_ARRAY_ELEMS(dv_rl_vlc)] = { 0 }; 141 VLC dv_vlc = { .table = vlc_buf, .table_allocated = FF_ARRAY_ELEMS(vlc_buf) }; 142 uint16_t new_dv_vlc_bits[NB_DV_VLC * 2]; 143 uint8_t new_dv_vlc_len[NB_DV_VLC * 2]; 144 uint8_t new_dv_vlc_run[NB_DV_VLC * 2]; 145 int16_t new_dv_vlc_level[NB_DV_VLC * 2]; 146 int i, j; 147 148 /* it's faster to include sign bit in a generic VLC parsing scheme */ 149 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) { 150 new_dv_vlc_bits[j] = ff_dv_vlc_bits[i]; 151 new_dv_vlc_len[j] = ff_dv_vlc_len[i]; 152 new_dv_vlc_run[j] = ff_dv_vlc_run[i]; 153 new_dv_vlc_level[j] = ff_dv_vlc_level[i]; 154 155 if (ff_dv_vlc_level[i]) { 156 new_dv_vlc_bits[j] <<= 1; 157 new_dv_vlc_len[j]++; 158 159 j++; 160 new_dv_vlc_bits[j] = (ff_dv_vlc_bits[i] << 1) | 1; 161 new_dv_vlc_len[j] = ff_dv_vlc_len[i] + 1; 162 new_dv_vlc_run[j] = ff_dv_vlc_run[i]; 163 new_dv_vlc_level[j] = -ff_dv_vlc_level[i]; 164 } 165 } 166 167 /* NOTE: as a trick, we use the fact the no codes are unused 168 * to accelerate the parsing of partial codes */ 169 init_vlc(&dv_vlc, TEX_VLC_BITS, j, new_dv_vlc_len, 170 1, 1, new_dv_vlc_bits, 2, 2, INIT_VLC_USE_NEW_STATIC); 171 av_assert1(dv_vlc.table_size == 1664); 172 173 for (int i = 0; i < dv_vlc.table_size; i++) { 174 int code = dv_vlc.table[i].sym; 175 int len = dv_vlc.table[i].len; 176 int level, run; 177 178 if (len < 0) { // more bits needed 179 run = 0; 180 level = code; 181 } else { 182 run = new_dv_vlc_run[code] + 1; 183 level = new_dv_vlc_level[code]; 184 } 185 dv_rl_vlc[i].len = len; 186 dv_rl_vlc[i].level = level; 187 dv_rl_vlc[i].run = run; 188 } 189} 190 191static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d) 192{ 193 int j, i, c, s; 194 uint32_t *factor1 = &ctx->idct_factor[0], 195 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816]; 196 197 if (DV_PROFILE_IS_HD(d)) { 198 /* quantization quanta by QNO for DV100 */ 199 static const uint8_t dv100_qstep[16] = { 200 1, /* QNO = 0 and 1 both have no quantization */ 201 1, 202 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52 203 }; 204 const uint16_t *iweight1, *iweight2; 205 206 if (d->height == 720) { 207 iweight1 = &dv_iweight_720_y[0]; 208 iweight2 = &dv_iweight_720_c[0]; 209 } else { 210 iweight1 = &dv_iweight_1080_y[0]; 211 iweight2 = &dv_iweight_1080_c[0]; 212 } 213 for (c = 0; c < 4; c++) { 214 for (s = 0; s < 16; s++) { 215 for (i = 0; i < 64; i++) { 216 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i]; 217 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i]; 218 } 219 } 220 } 221 } else { 222 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 }; 223 const uint16_t *iweight1 = &dv_iweight_88[0]; 224 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) { 225 for (s = 0; s < 22; s++) { 226 for (i = c = 0; c < 4; c++) { 227 for (; i < dv_quant_areas[c]; i++) { 228 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1); 229 *factor2++ = (*factor1++) << 1; 230 } 231 } 232 } 233 } 234 } 235} 236 237static av_cold int dvvideo_decode_init(AVCodecContext *avctx) 238{ 239 static AVOnce init_static_once = AV_ONCE_INIT; 240 DVVideoContext *s = avctx->priv_data; 241 int i; 242 243 ff_idctdsp_init(&s->idsp, avctx); 244 245 for (i = 0; i < 64; i++) 246 s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]]; 247 248 if (avctx->lowres){ 249 for (i = 0; i < 64; i++){ 250 int j = ff_dv_zigzag248_direct[i]; 251 s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2]; 252 } 253 }else 254 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1])); 255 256 s->idct_put[0] = s->idsp.idct_put; 257 s->idct_put[1] = ff_simple_idct248_put; 258 259 ff_thread_once(&init_static_once, dv_init_static); 260 261 return ff_dvvideo_init(avctx); 262} 263 264/* decode AC coefficients */ 265static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block) 266{ 267 int last_index = gb->size_in_bits; 268 const uint8_t *scan_table = mb->scan_table; 269 const uint32_t *factor_table = mb->factor_table; 270 int pos = mb->pos; 271 int partial_bit_count = mb->partial_bit_count; 272 int level, run, vlc_len, index; 273 274 OPEN_READER_NOSIZE(re, gb); 275 UPDATE_CACHE(re, gb); 276 277 /* if we must parse a partial VLC, we do it here */ 278 if (partial_bit_count > 0) { 279 re_cache = re_cache >> partial_bit_count | 280 mb->partial_bit_buffer; 281 re_index -= partial_bit_count; 282 mb->partial_bit_count = 0; 283 } 284 285 /* get the AC coefficients until last_index is reached */ 286 for (;;) { 287 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n", 288 pos, SHOW_UBITS(re, gb, 16), re_index); 289 /* our own optimized GET_RL_VLC */ 290 index = NEG_USR32(re_cache, TEX_VLC_BITS); 291 vlc_len = dv_rl_vlc[index].len; 292 if (vlc_len < 0) { 293 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) + 294 dv_rl_vlc[index].level; 295 vlc_len = TEX_VLC_BITS - vlc_len; 296 } 297 level = dv_rl_vlc[index].level; 298 run = dv_rl_vlc[index].run; 299 300 /* gotta check if we're still within gb boundaries */ 301 if (re_index + vlc_len > last_index) { 302 /* should be < 16 bits otherwise a codeword could have been parsed */ 303 mb->partial_bit_count = last_index - re_index; 304 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count); 305 re_index = last_index; 306 break; 307 } 308 re_index += vlc_len; 309 310 ff_dlog(NULL, "run=%d level=%d\n", run, level); 311 pos += run; 312 if (pos >= 64) 313 break; 314 315 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> 316 dv_iweight_bits; 317 block[scan_table[pos]] = level; 318 319 UPDATE_CACHE(re, gb); 320 } 321 CLOSE_READER(re, gb); 322 mb->pos = pos; 323} 324 325static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) 326{ 327 int bits_left = get_bits_left(gb); 328 while (bits_left >= MIN_CACHE_BITS) { 329 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); 330 bits_left -= MIN_CACHE_BITS; 331 } 332 if (bits_left > 0) 333 put_bits(pb, bits_left, get_bits(gb, bits_left)); 334} 335 336static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride) 337{ 338 int i, j; 339 340 for (i = 0; i < 4; i++) { 341 for (j = 0; j < 8; j++) 342 p[j] = av_clip_uint8(block[j]); 343 block += 8; 344 p += stride; 345 } 346} 347 348static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data, 349 int stride, int16_t *blocks) 350{ 351 s->idsp.idct(blocks + 0*64); 352 s->idsp.idct(blocks + 1*64); 353 354 put_block_8x4(blocks+0*64, data, stride<<1); 355 put_block_8x4(blocks+0*64 + 4*8, data + 8, stride<<1); 356 put_block_8x4(blocks+1*64, data + stride, stride<<1); 357 put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1); 358} 359 360static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data, 361 int stride, int16_t *blocks) 362{ 363 s->idsp.idct(blocks + 0*64); 364 s->idsp.idct(blocks + 1*64); 365 s->idsp.idct(blocks + 2*64); 366 s->idsp.idct(blocks + 3*64); 367 368 put_block_8x4(blocks+0*64, data, stride<<1); 369 put_block_8x4(blocks+0*64 + 4*8, data + 16, stride<<1); 370 put_block_8x4(blocks+1*64, data + 8, stride<<1); 371 put_block_8x4(blocks+1*64 + 4*8, data + 24, stride<<1); 372 put_block_8x4(blocks+2*64, data + stride, stride<<1); 373 put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1); 374 put_block_8x4(blocks+3*64, data + 8 + stride, stride<<1); 375 put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1); 376} 377 378/* mb_x and mb_y are in units of 8 pixels */ 379static int dv_decode_video_segment(AVCodecContext *avctx, void *arg) 380{ 381 DVVideoContext *s = avctx->priv_data; 382 DVwork_chunk *work_chunk = arg; 383 int quant, dc, dct_mode, class1, j; 384 int mb_index, mb_x, mb_y, last_index; 385 int y_stride, linesize; 386 int16_t *block, *block1; 387 int c_offset; 388 uint8_t *y_ptr; 389 const uint8_t *buf_ptr; 390 PutBitContext pb, vs_pb; 391 GetBitContext gb; 392 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1; 393 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]); 394 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */ 395 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */ 396 const int log2_blocksize = 3-s->avctx->lowres; 397 int is_field_mode[5]; 398 int vs_bit_buffer_damaged = 0; 399 int mb_bit_buffer_damaged[5] = {0}; 400 int retried = 0; 401 int sta; 402 403 av_assert1((((uintptr_t) mb_bit_buffer) & 7) == 0); 404 av_assert1((((uintptr_t) vs_bit_buffer) & 7) == 0); 405 406retry: 407 408 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock)); 409 410 /* pass 1: read DC and AC coefficients in blocks */ 411 buf_ptr = &s->buf[work_chunk->buf_offset * 80]; 412 block1 = &sblock[0][0]; 413 mb1 = mb_data; 414 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); 415 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) { 416 /* skip header */ 417 quant = buf_ptr[3] & 0x0f; 418 if (avctx->error_concealment) { 419 if ((buf_ptr[3] >> 4) == 0x0E) 420 vs_bit_buffer_damaged = 1; 421 if (!mb_index) { 422 sta = buf_ptr[3] >> 4; 423 } else if (sta != (buf_ptr[3] >> 4)) 424 vs_bit_buffer_damaged = 1; 425 } 426 buf_ptr += 4; 427 init_put_bits(&pb, mb_bit_buffer, 80); 428 mb = mb1; 429 block = block1; 430 is_field_mode[mb_index] = 0; 431 for (j = 0; j < s->sys->bpm; j++) { 432 last_index = s->sys->block_sizes[j]; 433 init_get_bits(&gb, buf_ptr, last_index); 434 435 /* get the DC */ 436 dc = get_sbits(&gb, 9); 437 dct_mode = get_bits1(&gb); 438 class1 = get_bits(&gb, 2); 439 if (DV_PROFILE_IS_HD(s->sys)) { 440 mb->idct_put = s->idct_put[0]; 441 mb->scan_table = s->dv_zigzag[0]; 442 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 + 443 class1 * 16 * 64 + 444 quant * 64]; 445 is_field_mode[mb_index] |= !j && dct_mode; 446 } else { 447 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3]; 448 mb->scan_table = s->dv_zigzag[dct_mode]; 449 mb->factor_table = 450 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 + 451 dct_mode * 22 * 64 + 452 (quant + ff_dv_quant_offset[class1]) * 64]; 453 } 454 dc = dc * 4; 455 /* convert to unsigned because 128 is not added in the 456 * standard IDCT */ 457 dc += 1024; 458 block[0] = dc; 459 buf_ptr += last_index >> 3; 460 mb->pos = 0; 461 mb->partial_bit_count = 0; 462 463 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j); 464 dv_decode_ac(&gb, mb, block); 465 466 /* write the remaining bits in a new buffer only if the 467 * block is finished */ 468 if (mb->pos >= 64) 469 bit_copy(&pb, &gb); 470 if (mb->pos >= 64 && mb->pos < 127) 471 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1; 472 473 block += 64; 474 mb++; 475 } 476 477 if (mb_bit_buffer_damaged[mb_index] > 0) 478 continue; 479 480 /* pass 2: we can do it just after */ 481 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); 482 block = block1; 483 mb = mb1; 484 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); 485 put_bits32(&pb, 0); // padding must be zeroed 486 flush_put_bits(&pb); 487 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) { 488 if (mb->pos < 64 && get_bits_left(&gb) > 0) { 489 dv_decode_ac(&gb, mb, block); 490 /* if still not finished, no need to parse other blocks */ 491 if (mb->pos < 64) 492 break; 493 if (mb->pos < 127) 494 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1; 495 } 496 } 497 /* all blocks are finished, so the extra bytes can be used at 498 * the video segment level */ 499 if (j >= s->sys->bpm) 500 bit_copy(&vs_pb, &gb); 501 } 502 503 /* we need a pass over the whole video segment */ 504 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb)); 505 block = &sblock[0][0]; 506 mb = mb_data; 507 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); 508 put_bits32(&vs_pb, 0); // padding must be zeroed 509 flush_put_bits(&vs_pb); 510 for (mb_index = 0; mb_index < 5; mb_index++) { 511 for (j = 0; j < s->sys->bpm; j++) { 512 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) { 513 ff_dlog(avctx, "start %d:%d\n", mb_index, j); 514 dv_decode_ac(&gb, mb, block); 515 } 516 517 if (mb->pos >= 64 && mb->pos < 127) { 518 av_log(avctx, AV_LOG_ERROR, 519 "AC EOB marker is absent pos=%d\n", mb->pos); 520 vs_bit_buffer_damaged = 1; 521 } 522 block += 64; 523 mb++; 524 } 525 } 526 if (vs_bit_buffer_damaged && !retried) { 527 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n"); 528 retried = 1; 529 goto retry; 530 } 531 532 /* compute idct and place blocks */ 533 block = &sblock[0][0]; 534 mb = mb_data; 535 for (mb_index = 0; mb_index < 5; mb_index++) { 536 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); 537 538 /* idct_put'ting luminance */ 539 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) || 540 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) || 541 (s->sys->height >= 720 && mb_y != 134)) { 542 y_stride = (s->frame->linesize[0] << 543 ((!is_field_mode[mb_index]) * log2_blocksize)); 544 } else { 545 y_stride = (2 << log2_blocksize); 546 } 547 y_ptr = s->frame->data[0] + 548 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize); 549 if (mb_y == 134 && is_field_mode[mb_index]) { 550 dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block); 551 } else { 552 linesize = s->frame->linesize[0] << is_field_mode[mb_index]; 553 mb[0].idct_put(y_ptr, linesize, block + 0 * 64); 554 if (s->sys->video_stype == 4) { /* SD 422 */ 555 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64); 556 } else { 557 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64); 558 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64); 559 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64); 560 } 561 } 562 mb += 4; 563 block += 4 * 64; 564 565 /* idct_put'ting chrominance */ 566 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] + 567 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize); 568 for (j = 2; j; j--) { 569 uint8_t *c_ptr = s->frame->data[j] + c_offset; 570 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 571 uint64_t aligned_pixels[64 / 8]; 572 uint8_t *pixels = (uint8_t *) aligned_pixels; 573 uint8_t *c_ptr1, *ptr1; 574 int x, y; 575 mb->idct_put(pixels, 8, block); 576 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) { 577 ptr1 = pixels + ((1 << (log2_blocksize))>>1); 578 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize); 579 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) { 580 c_ptr[x] = pixels[x]; 581 c_ptr1[x] = ptr1[x]; 582 } 583 } 584 block += 64; 585 mb++; 586 } else { 587 y_stride = (mb_y == 134) ? (1 << log2_blocksize) : 588 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize); 589 if (mb_y == 134 && is_field_mode[mb_index]) { 590 dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block); 591 mb += 2; 592 block += 2*64; 593 } else { 594 linesize = s->frame->linesize[j] << is_field_mode[mb_index]; 595 (mb++)->idct_put(c_ptr, linesize, block); 596 block += 64; 597 if (s->sys->bpm == 8) { 598 (mb++)->idct_put(c_ptr + y_stride, linesize, block); 599 block += 64; 600 } 601 } 602 } 603 } 604 } 605 return 0; 606} 607 608/* NOTE: exactly one frame must be given (120000 bytes for NTSC, 609 * 144000 bytes for PAL - or twice those for 50Mbps) */ 610static int dvvideo_decode_frame(AVCodecContext *avctx, AVFrame *frame, 611 int *got_frame, AVPacket *avpkt) 612{ 613 uint8_t *buf = avpkt->data; 614 int buf_size = avpkt->size; 615 DVVideoContext *s = avctx->priv_data; 616 const uint8_t *vsc_pack; 617 int apt, is16_9, ret; 618 const AVDVProfile *sys; 619 620 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size); 621 if (!sys || buf_size < sys->frame_size) { 622 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n"); 623 return -1; /* NOTE: we only accept several full frames */ 624 } 625 626 if (sys != s->sys) { 627 ret = ff_dv_init_dynamic_tables(s, sys); 628 if (ret < 0) { 629 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n"); 630 return ret; 631 } 632 dv_init_weight_tables(s, sys); 633 s->sys = sys; 634 } 635 636 s->frame = frame; 637 frame->key_frame = 1; 638 frame->pict_type = AV_PICTURE_TYPE_I; 639 avctx->pix_fmt = s->sys->pix_fmt; 640 avctx->framerate = av_inv_q(s->sys->time_base); 641 642 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height); 643 if (ret < 0) 644 return ret; 645 646 /* Determine the codec's sample_aspect ratio from the packet */ 647 vsc_pack = buf + 80 * 5 + 48 + 5; 648 if (*vsc_pack == dv_video_control) { 649 apt = buf[4] & 0x07; 650 is16_9 = (vsc_pack[2] & 0x07) == 0x02 || 651 (!apt && (vsc_pack[2] & 0x07) == 0x07); 652 ff_set_sar(avctx, s->sys->sar[is16_9]); 653 } 654 655 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0) 656 return ret; 657 658 /* Determine the codec's field order from the packet */ 659 if ( *vsc_pack == dv_video_control ) { 660 if (avctx->height == 720) { 661 frame->interlaced_frame = 0; 662 frame->top_field_first = 0; 663 } else if (avctx->height == 1080) { 664 frame->interlaced_frame = 1; 665 frame->top_field_first = (vsc_pack[3] & 0x40) == 0x40; 666 } else { 667 frame->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10; 668 frame->top_field_first = !(vsc_pack[3] & 0x40); 669 } 670 } 671 672 s->buf = buf; 673 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL, 674 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); 675 676 emms_c(); 677 678 /* return image */ 679 *got_frame = 1; 680 681 return s->sys->frame_size; 682} 683 684const FFCodec ff_dvvideo_decoder = { 685 .p.name = "dvvideo", 686 .p.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 687 .p.type = AVMEDIA_TYPE_VIDEO, 688 .p.id = AV_CODEC_ID_DVVIDEO, 689 .priv_data_size = sizeof(DVVideoContext), 690 .init = dvvideo_decode_init, 691 FF_CODEC_DECODE_CB(dvvideo_decode_frame), 692 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS, 693 .p.max_lowres = 3, 694 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 695}; 696