dnxhddec.c 10.9 KB
Newer Older
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1 2
/*
 * VC3/DNxHD decoder.
3
 * Copyright (c) 2007 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
Baptiste Coudurier's avatar
Baptiste Coudurier committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

//#define TRACE
//#define DEBUG

#include "avcodec.h"
26
#include "get_bits.h"
Baptiste Coudurier's avatar
Baptiste Coudurier committed
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
#include "dnxhddata.h"
#include "dsputil.h"

typedef struct {
    AVCodecContext *avctx;
    AVFrame picture;
    GetBitContext gb;
    int cid;                            ///< compression id
    unsigned int width, height;
    unsigned int mb_width, mb_height;
    uint32_t mb_scan_index[68];         /* max for 1080p */
    int cur_field;                      ///< current interlaced field
    VLC ac_vlc, dc_vlc, run_vlc;
    int last_dc[3];
    DSPContext dsp;
    DECLARE_ALIGNED_16(DCTELEM, blocks[8][64]);
43
    ScanTable scantable;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
44 45 46 47
    const CIDEntry *cid_table;
} DNXHDContext;

#define DNXHD_VLC_BITS 9
48
#define DNXHD_DC_VLC_BITS 7
Baptiste Coudurier's avatar
Baptiste Coudurier committed
49

50
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
{
    DNXHDContext *ctx = avctx->priv_data;

    ctx->avctx = avctx;
    dsputil_init(&ctx->dsp, avctx);
    avctx->coded_frame = &ctx->picture;
    ctx->picture.type = FF_I_TYPE;
    return 0;
}

static int dnxhd_init_vlc(DNXHDContext *ctx, int cid)
{
    if (!ctx->cid_table) {
        int index;

66
        if ((index = ff_dnxhd_get_cid_table(cid)) < 0) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
67 68 69
            av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %d\n", cid);
            return -1;
        }
70
        ctx->cid_table = &ff_dnxhd_cid_table[index];
Baptiste Coudurier's avatar
Baptiste Coudurier committed
71
        init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,
72 73
                 ctx->cid_table->ac_bits, 1, 1,
                 ctx->cid_table->ac_codes, 2, 2, 0);
74
        init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, ctx->cid_table->bit_depth+4,
75 76
                 ctx->cid_table->dc_bits, 1, 1,
                 ctx->cid_table->dc_codes, 1, 1, 0);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
77
        init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62,
78 79
                 ctx->cid_table->run_bits, 1, 1,
                 ctx->cid_table->run_codes, 2, 2, 0);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
80 81 82 83 84 85

        ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, ff_zigzag_direct);
    }
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
86
static int dnxhd_decode_header(DNXHDContext *ctx, const uint8_t *buf, int buf_size, int first_field)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
87 88 89 90 91 92 93 94 95 96 97
{
    static const uint8_t header_prefix[] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
    int i;

    if (buf_size < 0x280)
        return -1;

    if (memcmp(buf, header_prefix, 5)) {
        av_log(ctx->avctx, AV_LOG_ERROR, "error in header\n");
        return -1;
    }
98 99
    if (buf[5] & 2) { /* interlaced */
        ctx->cur_field = buf[5] & 1;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
100
        ctx->picture.interlaced_frame = 1;
101
        ctx->picture.top_field_first = first_field ^ ctx->cur_field;
102
        av_log(ctx->avctx, AV_LOG_DEBUG, "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
103 104 105 106 107
    }

    ctx->height = AV_RB16(buf + 0x18);
    ctx->width  = AV_RB16(buf + 0x1a);

108
    dprintf(ctx->avctx, "width %d, heigth %d\n", ctx->width, ctx->height);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
109

110
    if (buf[0x21] & 0x40) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
111 112 113 114 115
        av_log(ctx->avctx, AV_LOG_ERROR, "10 bit per component\n");
        return -1;
    }

    ctx->cid = AV_RB32(buf + 0x28);
116
    dprintf(ctx->avctx, "compression id %d\n", ctx->cid);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
117 118 119 120

    if (dnxhd_init_vlc(ctx, ctx->cid) < 0)
        return -1;

121
    if (buf_size < ctx->cid_table->coding_unit_size) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
122 123 124 125 126 127 128 129 130 131 132 133
        av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size\n");
        return -1;
    }

    ctx->mb_width = ctx->width>>4;
    ctx->mb_height = buf[0x16d];

    if (ctx->mb_height > 68) {
        av_log(ctx->avctx, AV_LOG_ERROR, "mb height too big\n");
        return -1;
    }

134
    dprintf(ctx->avctx, "mb width %d, mb height %d\n", ctx->mb_width, ctx->mb_height);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
135 136
    for (i = 0; i < ctx->mb_height; i++) {
        ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i<<2));
137
        dprintf(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
        if (buf_size < ctx->mb_scan_index[i] + 0x280) {
            av_log(ctx->avctx, AV_LOG_ERROR, "invalid mb scan index\n");
            return -1;
        }
    }

    return 0;
}

static int dnxhd_decode_dc(DNXHDContext *ctx)
{
    int len;

    len = get_vlc2(&ctx->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
    return len ? get_xbits(&ctx->gb, len) : 0;
}

static void dnxhd_decode_dct_block(DNXHDContext *ctx, DCTELEM *block, int n, int qscale)
{
    int i, j, index, index2;
    int level, component, sign;
    const uint8_t *weigth_matrix;

    if (n&2) {
        component = 1 + (n&1);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
163
        weigth_matrix = ctx->cid_table->chroma_weight;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
164 165
    } else {
        component = 0;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
166
        weigth_matrix = ctx->cid_table->luma_weight;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
167 168 169 170 171 172 173 174
    }

    ctx->last_dc[component] += dnxhd_decode_dc(ctx);
    block[0] = ctx->last_dc[component];
    //av_log(ctx->avctx, AV_LOG_DEBUG, "dc %d\n", block[0]);
    for (i = 1; ; i++) {
        index = get_vlc2(&ctx->gb, ctx->ac_vlc.table, DNXHD_VLC_BITS, 2);
        //av_log(ctx->avctx, AV_LOG_DEBUG, "index %d\n", index);
175
        level = ctx->cid_table->ac_level[index];
Baptiste Coudurier's avatar
Baptiste Coudurier committed
176 177 178 179 180 181
        if (!level) { /* EOB */
            //av_log(ctx->avctx, AV_LOG_DEBUG, "EOB\n");
            return;
        }
        sign = get_sbits(&ctx->gb, 1);

182 183
        if (ctx->cid_table->ac_index_flag[index]) {
            level += get_bits(&ctx->gb, ctx->cid_table->index_bits)<<6;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
184 185
        }

186
        if (ctx->cid_table->ac_run_flag[index]) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
187
            index2 = get_vlc2(&ctx->gb, ctx->run_vlc.table, DNXHD_VLC_BITS, 2);
188
            i += ctx->cid_table->run[index2];
Baptiste Coudurier's avatar
Baptiste Coudurier committed
189 190
        }

191 192 193 194 195
        if (i > 63) {
            av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
            return;
        }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
196 197 198 199
        j = ctx->scantable.permutated[i];
        //av_log(ctx->avctx, AV_LOG_DEBUG, "j %d\n", j);
        //av_log(ctx->avctx, AV_LOG_DEBUG, "level %d, weigth %d\n", level, weigth_matrix[i]);
        level = (2*level+1) * qscale * weigth_matrix[i];
200 201 202 203 204 205 206 207 208
        if (ctx->cid_table->bit_depth == 10) {
            if (weigth_matrix[i] != 8)
                level += 8;
            level >>= 4;
        } else {
            if (weigth_matrix[i] != 32)
                level += 32;
            level >>= 6;
        }
Baptiste Coudurier's avatar
Baptiste Coudurier committed
209
        //av_log(NULL, AV_LOG_DEBUG, "i %d, j %d, end level %d\n", i, j, level);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
210
        block[j] = (level^sign) - sign;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
    }
}

static int dnxhd_decode_macroblock(DNXHDContext *ctx, int x, int y)
{
    int dct_linesize_luma   = ctx->picture.linesize[0];
    int dct_linesize_chroma = ctx->picture.linesize[1];
    uint8_t *dest_y, *dest_u, *dest_v;
    int dct_offset;
    int qscale, i;

    qscale = get_bits(&ctx->gb, 11);
    skip_bits1(&ctx->gb);
    //av_log(ctx->avctx, AV_LOG_DEBUG, "qscale %d\n", qscale);

    for (i = 0; i < 8; i++) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
227
        ctx->dsp.clear_block(ctx->blocks[i]);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
228 229
        dnxhd_decode_dct_block(ctx, ctx->blocks[i], i, qscale);
    }
230 231 232 233 234 235

    if (ctx->picture.interlaced_frame) {
        dct_linesize_luma   <<= 1;
        dct_linesize_chroma <<= 1;
    }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
236 237 238 239
    dest_y = ctx->picture.data[0] + ((y * dct_linesize_luma)   << 4) + (x << 4);
    dest_u = ctx->picture.data[1] + ((y * dct_linesize_chroma) << 4) + (x << 3);
    dest_v = ctx->picture.data[2] + ((y * dct_linesize_chroma) << 4) + (x << 3);

240 241 242 243 244 245
    if (ctx->cur_field) {
        dest_y += ctx->picture.linesize[0];
        dest_u += ctx->picture.linesize[1];
        dest_v += ctx->picture.linesize[2];
    }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
    dct_offset = dct_linesize_luma << 3;
    ctx->dsp.idct_put(dest_y,                  dct_linesize_luma, ctx->blocks[0]);
    ctx->dsp.idct_put(dest_y + 8,              dct_linesize_luma, ctx->blocks[1]);
    ctx->dsp.idct_put(dest_y + dct_offset,     dct_linesize_luma, ctx->blocks[4]);
    ctx->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize_luma, ctx->blocks[5]);

    if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) {
        dct_offset = dct_linesize_chroma << 3;
        ctx->dsp.idct_put(dest_u,              dct_linesize_chroma, ctx->blocks[2]);
        ctx->dsp.idct_put(dest_v,              dct_linesize_chroma, ctx->blocks[3]);
        ctx->dsp.idct_put(dest_u + dct_offset, dct_linesize_chroma, ctx->blocks[6]);
        ctx->dsp.idct_put(dest_v + dct_offset, dct_linesize_chroma, ctx->blocks[7]);
    }

    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
263
static int dnxhd_decode_macroblocks(DNXHDContext *ctx, const uint8_t *buf, int buf_size)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
264 265 266
{
    int x, y;
    for (y = 0; y < ctx->mb_height; y++) {
267 268
        ctx->last_dc[0] =
        ctx->last_dc[1] =
269
        ctx->last_dc[2] = 1<<(ctx->cid_table->bit_depth+2); // for levels +2^(bitdepth-1)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
270 271 272 273 274 275 276 277 278 279 280
        init_get_bits(&ctx->gb, buf + ctx->mb_scan_index[y], (buf_size - ctx->mb_scan_index[y]) << 3);
        for (x = 0; x < ctx->mb_width; x++) {
            //START_TIMER;
            dnxhd_decode_macroblock(ctx, x, y);
            //STOP_TIMER("decode macroblock");
        }
    }
    return 0;
}

static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
281
                              AVPacket *avpkt)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
282
{
283 284
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
285 286
    DNXHDContext *ctx = avctx->priv_data;
    AVFrame *picture = data;
287
    int first_field = 1;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
288

289
    dprintf(avctx, "frame size %d\n", buf_size);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
290

291 292
 decode_coding_unit:
    if (dnxhd_decode_header(ctx, buf, buf_size, first_field) < 0)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
293 294 295 296 297 298 299
        return -1;

    avctx->pix_fmt = PIX_FMT_YUV422P;
    if (avcodec_check_dimensions(avctx, ctx->width, ctx->height))
        return -1;
    avcodec_set_dimensions(avctx, ctx->width, ctx->height);

300
    if (first_field) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
301 302 303 304 305 306
        if (ctx->picture.data[0])
            avctx->release_buffer(avctx, &ctx->picture);
        if (avctx->get_buffer(avctx, &ctx->picture) < 0) {
            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
            return -1;
        }
307
    }
Baptiste Coudurier's avatar
Baptiste Coudurier committed
308 309 310

    dnxhd_decode_macroblocks(ctx, buf + 0x280, buf_size - 0x280);

311 312 313 314 315 316 317
    if (first_field && ctx->picture.interlaced_frame) {
        buf      += ctx->cid_table->coding_unit_size;
        buf_size -= ctx->cid_table->coding_unit_size;
        first_field = 0;
        goto decode_coding_unit;
    }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
318 319
    *picture = ctx->picture;
    *data_size = sizeof(AVPicture);
320
    return buf_size;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
321 322
}

323
static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
Baptiste Coudurier's avatar
Baptiste Coudurier committed
324 325 326
{
    DNXHDContext *ctx = avctx->priv_data;

Baptiste Coudurier's avatar
Baptiste Coudurier committed
327
    if (ctx->picture.data[0])
Baptiste Coudurier's avatar
Baptiste Coudurier committed
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
        avctx->release_buffer(avctx, &ctx->picture);
    free_vlc(&ctx->ac_vlc);
    free_vlc(&ctx->dc_vlc);
    free_vlc(&ctx->run_vlc);
    return 0;
}

AVCodec dnxhd_decoder = {
    "dnxhd",
    CODEC_TYPE_VIDEO,
    CODEC_ID_DNXHD,
    sizeof(DNXHDContext),
    dnxhd_decode_init,
    NULL,
    dnxhd_decode_close,
    dnxhd_decode_frame,
    CODEC_CAP_DR1,
345
    .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
346
};