1/* 2 * VC3/DNxHD decoder. 3 * Copyright (c) 2007 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com> 4 * Copyright (c) 2011 MirriAd Ltd 5 * 6 * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com> 7 * 8 * This file is part of Libav. 9 * 10 * Libav is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU Lesser General Public 12 * License as published by the Free Software Foundation; either 13 * version 2.1 of the License, or (at your option) any later version. 14 * 15 * Libav is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * Lesser General Public License for more details. 19 * 20 * You should have received a copy of the GNU Lesser General Public 21 * License along with Libav; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 */ 24 25//#define TRACE 26//#define DEBUG 27 28#include "libavutil/imgutils.h" 29#include "avcodec.h" 30#include "get_bits.h" 31#include "dnxhddata.h" 32#include "dsputil.h" 33 34typedef struct DNXHDContext { 35 AVCodecContext *avctx; 36 AVFrame picture; 37 GetBitContext gb; 38 int cid; ///< compression id 39 unsigned int width, height; 40 unsigned int mb_width, mb_height; 41 uint32_t mb_scan_index[68]; /* max for 1080p */ 42 int cur_field; ///< current interlaced field 43 VLC ac_vlc, dc_vlc, run_vlc; 44 int last_dc[3]; 45 DSPContext dsp; 46 DECLARE_ALIGNED(16, DCTELEM, blocks)[8][64]; 47 ScanTable scantable; 48 const CIDEntry *cid_table; 49 int bit_depth; // 8, 10 or 0 if not initialized at all. 50 void (*decode_dct_block)(struct DNXHDContext *ctx, DCTELEM *block, 51 int n, int qscale); 52} DNXHDContext; 53 54#define DNXHD_VLC_BITS 9 55#define DNXHD_DC_VLC_BITS 7 56 57static void dnxhd_decode_dct_block_8(DNXHDContext *ctx, DCTELEM *block, int n, int qscale); 58static void dnxhd_decode_dct_block_10(DNXHDContext *ctx, DCTELEM *block, int n, int qscale); 59 60static av_cold int dnxhd_decode_init(AVCodecContext *avctx) 61{ 62 DNXHDContext *ctx = avctx->priv_data; 63 64 ctx->avctx = avctx; 65 avctx->coded_frame = &ctx->picture; 66 ctx->picture.type = AV_PICTURE_TYPE_I; 67 ctx->picture.key_frame = 1; 68 return 0; 69} 70 71static int dnxhd_init_vlc(DNXHDContext *ctx, int cid) 72{ 73 if (cid != ctx->cid) { 74 int index; 75 76 if ((index = ff_dnxhd_get_cid_table(cid)) < 0) { 77 av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %d\n", cid); 78 return -1; 79 } 80 ctx->cid_table = &ff_dnxhd_cid_table[index]; 81 82 ff_free_vlc(&ctx->ac_vlc); 83 ff_free_vlc(&ctx->dc_vlc); 84 ff_free_vlc(&ctx->run_vlc); 85 86 init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257, 87 ctx->cid_table->ac_bits, 1, 1, 88 ctx->cid_table->ac_codes, 2, 2, 0); 89 init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, ctx->bit_depth + 4, 90 ctx->cid_table->dc_bits, 1, 1, 91 ctx->cid_table->dc_codes, 1, 1, 0); 92 init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62, 93 ctx->cid_table->run_bits, 1, 1, 94 ctx->cid_table->run_codes, 2, 2, 0); 95 96 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, ff_zigzag_direct); 97 ctx->cid = cid; 98 } 99 return 0; 100} 101 102static int dnxhd_decode_header(DNXHDContext *ctx, const uint8_t *buf, int buf_size, int first_field) 103{ 104 static const uint8_t header_prefix[] = { 0x00, 0x00, 0x02, 0x80, 0x01 }; 105 int i, cid; 106 107 if (buf_size < 0x280) 108 return -1; 109 110 if (memcmp(buf, header_prefix, 5)) { 111 av_log(ctx->avctx, AV_LOG_ERROR, "error in header\n"); 112 return -1; 113 } 114 if (buf[5] & 2) { /* interlaced */ 115 ctx->cur_field = buf[5] & 1; 116 ctx->picture.interlaced_frame = 1; 117 ctx->picture.top_field_first = first_field ^ ctx->cur_field; 118 av_log(ctx->avctx, AV_LOG_DEBUG, "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field); 119 } 120 121 ctx->height = AV_RB16(buf + 0x18); 122 ctx->width = AV_RB16(buf + 0x1a); 123 124 av_dlog(ctx->avctx, "width %d, height %d\n", ctx->width, ctx->height); 125 126 if (buf[0x21] & 0x40) { 127 ctx->avctx->pix_fmt = PIX_FMT_YUV422P10; 128 ctx->avctx->bits_per_raw_sample = 10; 129 if (ctx->bit_depth != 10) { 130 dsputil_init(&ctx->dsp, ctx->avctx); 131 ctx->bit_depth = 10; 132 ctx->decode_dct_block = dnxhd_decode_dct_block_10; 133 } 134 } else { 135 ctx->avctx->pix_fmt = PIX_FMT_YUV422P; 136 ctx->avctx->bits_per_raw_sample = 8; 137 if (ctx->bit_depth != 8) { 138 dsputil_init(&ctx->dsp, ctx->avctx); 139 ctx->bit_depth = 8; 140 ctx->decode_dct_block = dnxhd_decode_dct_block_8; 141 } 142 } 143 144 cid = AV_RB32(buf + 0x28); 145 av_dlog(ctx->avctx, "compression id %d\n", cid); 146 147 if (dnxhd_init_vlc(ctx, cid) < 0) 148 return -1; 149 150 if (buf_size < ctx->cid_table->coding_unit_size) { 151 av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size\n"); 152 return -1; 153 } 154 155 ctx->mb_width = ctx->width>>4; 156 ctx->mb_height = buf[0x16d]; 157 158 av_dlog(ctx->avctx, "mb width %d, mb height %d\n", ctx->mb_width, ctx->mb_height); 159 160 if ((ctx->height+15)>>4 == ctx->mb_height && ctx->picture.interlaced_frame) 161 ctx->height <<= 1; 162 163 if (ctx->mb_height > 68 || 164 (ctx->mb_height<<ctx->picture.interlaced_frame) > (ctx->height+15)>>4) { 165 av_log(ctx->avctx, AV_LOG_ERROR, "mb height too big: %d\n", ctx->mb_height); 166 return -1; 167 } 168 169 for (i = 0; i < ctx->mb_height; i++) { 170 ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i<<2)); 171 av_dlog(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]); 172 if (buf_size < ctx->mb_scan_index[i] + 0x280) { 173 av_log(ctx->avctx, AV_LOG_ERROR, "invalid mb scan index\n"); 174 return -1; 175 } 176 } 177 178 return 0; 179} 180 181static av_always_inline void dnxhd_decode_dct_block(DNXHDContext *ctx, 182 DCTELEM *block, int n, 183 int qscale, 184 int index_bits, 185 int level_bias, 186 int level_shift) 187{ 188 int i, j, index1, index2, len; 189 int level, component, sign; 190 const uint8_t *weight_matrix; 191 OPEN_READER(bs, &ctx->gb); 192 193 if (n&2) { 194 component = 1 + (n&1); 195 weight_matrix = ctx->cid_table->chroma_weight; 196 } else { 197 component = 0; 198 weight_matrix = ctx->cid_table->luma_weight; 199 } 200 201 UPDATE_CACHE(bs, &ctx->gb); 202 GET_VLC(len, bs, &ctx->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1); 203 if (len) { 204 level = GET_CACHE(bs, &ctx->gb); 205 LAST_SKIP_BITS(bs, &ctx->gb, len); 206 sign = ~level >> 31; 207 level = (NEG_USR32(sign ^ level, len) ^ sign) - sign; 208 ctx->last_dc[component] += level; 209 } 210 block[0] = ctx->last_dc[component]; 211 //av_log(ctx->avctx, AV_LOG_DEBUG, "dc %d\n", block[0]); 212 213 for (i = 1; ; i++) { 214 UPDATE_CACHE(bs, &ctx->gb); 215 GET_VLC(index1, bs, &ctx->gb, ctx->ac_vlc.table, 216 DNXHD_VLC_BITS, 2); 217 //av_log(ctx->avctx, AV_LOG_DEBUG, "index %d\n", index1); 218 level = ctx->cid_table->ac_level[index1]; 219 if (!level) { /* EOB */ 220 //av_log(ctx->avctx, AV_LOG_DEBUG, "EOB\n"); 221 break; 222 } 223 224 sign = SHOW_SBITS(bs, &ctx->gb, 1); 225 SKIP_BITS(bs, &ctx->gb, 1); 226 227 if (ctx->cid_table->ac_index_flag[index1]) { 228 level += SHOW_UBITS(bs, &ctx->gb, index_bits) << 6; 229 SKIP_BITS(bs, &ctx->gb, index_bits); 230 } 231 232 if (ctx->cid_table->ac_run_flag[index1]) { 233 UPDATE_CACHE(bs, &ctx->gb); 234 GET_VLC(index2, bs, &ctx->gb, ctx->run_vlc.table, 235 DNXHD_VLC_BITS, 2); 236 i += ctx->cid_table->run[index2]; 237 } 238 239 if (i > 63) { 240 av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i); 241 break; 242 } 243 244 j = ctx->scantable.permutated[i]; 245 //av_log(ctx->avctx, AV_LOG_DEBUG, "j %d\n", j); 246 //av_log(ctx->avctx, AV_LOG_DEBUG, "level %d, weight %d\n", level, weight_matrix[i]); 247 level = (2*level+1) * qscale * weight_matrix[i]; 248 if (level_bias < 32 || weight_matrix[i] != level_bias) 249 level += level_bias; 250 level >>= level_shift; 251 252 //av_log(NULL, AV_LOG_DEBUG, "i %d, j %d, end level %d\n", i, j, level); 253 block[j] = (level^sign) - sign; 254 } 255 256 CLOSE_READER(bs, &ctx->gb); 257} 258 259static void dnxhd_decode_dct_block_8(DNXHDContext *ctx, DCTELEM *block, 260 int n, int qscale) 261{ 262 dnxhd_decode_dct_block(ctx, block, n, qscale, 4, 32, 6); 263} 264 265static void dnxhd_decode_dct_block_10(DNXHDContext *ctx, DCTELEM *block, 266 int n, int qscale) 267{ 268 dnxhd_decode_dct_block(ctx, block, n, qscale, 6, 8, 4); 269} 270 271static int dnxhd_decode_macroblock(DNXHDContext *ctx, int x, int y) 272{ 273 int shift1 = ctx->bit_depth == 10; 274 int dct_linesize_luma = ctx->picture.linesize[0]; 275 int dct_linesize_chroma = ctx->picture.linesize[1]; 276 uint8_t *dest_y, *dest_u, *dest_v; 277 int dct_y_offset, dct_x_offset; 278 int qscale, i; 279 280 qscale = get_bits(&ctx->gb, 11); 281 skip_bits1(&ctx->gb); 282 //av_log(ctx->avctx, AV_LOG_DEBUG, "qscale %d\n", qscale); 283 284 for (i = 0; i < 8; i++) { 285 ctx->dsp.clear_block(ctx->blocks[i]); 286 ctx->decode_dct_block(ctx, ctx->blocks[i], i, qscale); 287 } 288 289 if (ctx->picture.interlaced_frame) { 290 dct_linesize_luma <<= 1; 291 dct_linesize_chroma <<= 1; 292 } 293 294 dest_y = ctx->picture.data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1)); 295 dest_u = ctx->picture.data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1)); 296 dest_v = ctx->picture.data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1)); 297 298 if (ctx->cur_field) { 299 dest_y += ctx->picture.linesize[0]; 300 dest_u += ctx->picture.linesize[1]; 301 dest_v += ctx->picture.linesize[2]; 302 } 303 304 dct_y_offset = dct_linesize_luma << 3; 305 dct_x_offset = 8 << shift1; 306 ctx->dsp.idct_put(dest_y, dct_linesize_luma, ctx->blocks[0]); 307 ctx->dsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, ctx->blocks[1]); 308 ctx->dsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, ctx->blocks[4]); 309 ctx->dsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, ctx->blocks[5]); 310 311 if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) { 312 dct_y_offset = dct_linesize_chroma << 3; 313 ctx->dsp.idct_put(dest_u, dct_linesize_chroma, ctx->blocks[2]); 314 ctx->dsp.idct_put(dest_v, dct_linesize_chroma, ctx->blocks[3]); 315 ctx->dsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, ctx->blocks[6]); 316 ctx->dsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, ctx->blocks[7]); 317 } 318 319 return 0; 320} 321 322static int dnxhd_decode_macroblocks(DNXHDContext *ctx, const uint8_t *buf, int buf_size) 323{ 324 int x, y; 325 for (y = 0; y < ctx->mb_height; y++) { 326 ctx->last_dc[0] = 327 ctx->last_dc[1] = 328 ctx->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1) 329 init_get_bits(&ctx->gb, buf + ctx->mb_scan_index[y], (buf_size - ctx->mb_scan_index[y]) << 3); 330 for (x = 0; x < ctx->mb_width; x++) { 331 //START_TIMER; 332 dnxhd_decode_macroblock(ctx, x, y); 333 //STOP_TIMER("decode macroblock"); 334 } 335 } 336 return 0; 337} 338 339static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *data_size, 340 AVPacket *avpkt) 341{ 342 const uint8_t *buf = avpkt->data; 343 int buf_size = avpkt->size; 344 DNXHDContext *ctx = avctx->priv_data; 345 AVFrame *picture = data; 346 int first_field = 1; 347 348 av_dlog(avctx, "frame size %d\n", buf_size); 349 350 decode_coding_unit: 351 if (dnxhd_decode_header(ctx, buf, buf_size, first_field) < 0) 352 return -1; 353 354 if ((avctx->width || avctx->height) && 355 (ctx->width != avctx->width || ctx->height != avctx->height)) { 356 av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %dx%d\n", 357 avctx->width, avctx->height, ctx->width, ctx->height); 358 first_field = 1; 359 } 360 361 if (av_image_check_size(ctx->width, ctx->height, 0, avctx)) 362 return -1; 363 avcodec_set_dimensions(avctx, ctx->width, ctx->height); 364 365 if (first_field) { 366 if (ctx->picture.data[0]) 367 avctx->release_buffer(avctx, &ctx->picture); 368 if (avctx->get_buffer(avctx, &ctx->picture) < 0) { 369 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 370 return -1; 371 } 372 } 373 374 dnxhd_decode_macroblocks(ctx, buf + 0x280, buf_size - 0x280); 375 376 if (first_field && ctx->picture.interlaced_frame) { 377 buf += ctx->cid_table->coding_unit_size; 378 buf_size -= ctx->cid_table->coding_unit_size; 379 first_field = 0; 380 goto decode_coding_unit; 381 } 382 383 *picture = ctx->picture; 384 *data_size = sizeof(AVPicture); 385 return buf_size; 386} 387 388static av_cold int dnxhd_decode_close(AVCodecContext *avctx) 389{ 390 DNXHDContext *ctx = avctx->priv_data; 391 392 if (ctx->picture.data[0]) 393 avctx->release_buffer(avctx, &ctx->picture); 394 ff_free_vlc(&ctx->ac_vlc); 395 ff_free_vlc(&ctx->dc_vlc); 396 ff_free_vlc(&ctx->run_vlc); 397 return 0; 398} 399 400AVCodec ff_dnxhd_decoder = { 401 .name = "dnxhd", 402 .type = AVMEDIA_TYPE_VIDEO, 403 .id = CODEC_ID_DNXHD, 404 .priv_data_size = sizeof(DNXHDContext), 405 .init = dnxhd_decode_init, 406 .close = dnxhd_decode_close, 407 .decode = dnxhd_decode_frame, 408 .capabilities = CODEC_CAP_DR1, 409 .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"), 410}; 411