static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,

                               const uint8_t *buf, int buf_size,

                               int first_field)

{

    static const uint8_t header_prefix[]    = { 0x00, 0x00, 0x02, 0x80, 0x01 };

    static const uint8_t header_prefix444[] = { 0x00, 0x00, 0x02, 0x80, 0x02 };

    static const uint8_t header_prefixhr1[] = { 0x00, 0x00, 0x02, 0x80, 0x03 };

    static const uint8_t header_prefixhr2[] = { 0x00, 0x00, 0x03, 0x8C, 0x03 };

    int i, cid, ret;

    int old_bit_depth = ctx->bit_depth, bitdepth;

    int old_mb_height = ctx->mb_height;



    if (buf_size < 0x280) {

        av_log(ctx->avctx, AV_LOG_ERROR,

               "buffer too small (%d < 640).\n", buf_size);

        return AVERROR_INVALIDDATA;

    }



    if (memcmp(buf, header_prefix, 5) && memcmp(buf, header_prefix444, 5) &&

        memcmp(buf, header_prefixhr1, 5) && memcmp(buf, header_prefixhr2, 5)) {

        av_log(ctx->avctx, AV_LOG_ERROR,

               "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",

               buf[0], buf[1], buf[2], buf[3], buf[4]);

        return AVERROR_INVALIDDATA;

    }

    if (buf[5] & 2) { /* interlaced */

        ctx->cur_field = buf[5] & 1;

        frame->interlaced_frame = 1;

        frame->top_field_first  = first_field ^ ctx->cur_field;

        av_log(ctx->avctx, AV_LOG_DEBUG,

               "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);

    } else {

        ctx->cur_field = 0;

    }

    ctx->mbaff = (buf[0x6] >> 5) & 1;



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

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



    switch(buf[0x21] >> 5) {

    case 1: bitdepth = 8; break;

    case 2: bitdepth = 10; break;

    case 3: bitdepth = 12; break;

    default:

        av_log(ctx->avctx, AV_LOG_ERROR,

               "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);

        return AVERROR_INVALIDDATA;

    }



    cid = AV_RB32(buf + 0x28);

    if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)

        return ret;

    if (ctx->mbaff && ctx->cid_table->cid != 1260)

        av_log(ctx->avctx, AV_LOG_WARNING,

               "Adaptive MB interlace flag in an unsupported profile.\n");



    ctx->act = buf[0x2C] & 7;

    if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)

        av_log(ctx->avctx, AV_LOG_WARNING,

               "Adaptive color transform in an unsupported profile.\n");



    ctx->is_444 = (buf[0x2C] >> 6) & 1;

    if (ctx->is_444) {

        if (bitdepth == 8) {

            avpriv_request_sample(ctx->avctx, "4:4:4 8 bits\n");

            return AVERROR_INVALIDDATA;

        } else if (bitdepth == 10) {

            ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;

            ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10

                                    : AV_PIX_FMT_GBRP10;

        } else {

            ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;

            ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12

                                    : AV_PIX_FMT_GBRP12;

        }

    } else if (bitdepth == 12) {

        ctx->decode_dct_block = dnxhd_decode_dct_block_12;

        ctx->pix_fmt = AV_PIX_FMT_YUV422P12;

    } else if (bitdepth == 10) {

        ctx->decode_dct_block = dnxhd_decode_dct_block_10;

        ctx->pix_fmt = AV_PIX_FMT_YUV422P10;

    } else {

        ctx->decode_dct_block = dnxhd_decode_dct_block_8;

        ctx->pix_fmt = AV_PIX_FMT_YUV422P;

    }



    ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;

    if (ctx->bit_depth != old_bit_depth) {

        ff_blockdsp_init(&ctx->bdsp, ctx->avctx);

        ff_idctdsp_init(&ctx->idsp, ctx->avctx);

        ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable,

                          ff_zigzag_direct);

    }



    // make sure profile size constraints are respected

    // DNx100 allows 1920->1440 and 1280->960 subsampling

    if (ctx->width != ctx->cid_table->width &&

        ctx->cid_table->width != DNXHD_VARIABLE) {

        av_reduce(&ctx->avctx->sample_aspect_ratio.num,

                  &ctx->avctx->sample_aspect_ratio.den,

                  ctx->width, ctx->cid_table->width, 255);

        ctx->width = ctx->cid_table->width;

    }



    if (buf_size < ctx->cid_table->coding_unit_size) {

        av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %d).\n",

               buf_size, ctx->cid_table->coding_unit_size);

        return AVERROR_INVALIDDATA;

    }



    ctx->mb_width  = (ctx->width + 15)>> 4;

    ctx->mb_height = buf[0x16d];



    if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)

        ctx->height <<= 1;



    av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",

           ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",

           ctx->bit_depth, ctx->mbaff, ctx->act);



    // Newer format supports variable mb_scan_index sizes

    if (!memcmp(buf, header_prefixhr2, 5)) {

        ctx->data_offset = 0x170 + (ctx->mb_height << 2);

    } else {

        if (ctx->mb_height > 68 ||

            (ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {

            av_log(ctx->avctx, AV_LOG_ERROR,

                   "mb height too big: %d\n", ctx->mb_height);

            return AVERROR_INVALIDDATA;

        }

        ctx->data_offset = 0x280;

    }



    if (buf_size < ctx->data_offset) {

        av_log(ctx->avctx, AV_LOG_ERROR,

               "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);

        return AVERROR_INVALIDDATA;

    }



    if (ctx->mb_height != old_mb_height) {

        av_freep(&ctx->mb_scan_index);



        ctx->mb_scan_index = av_mallocz_array(ctx->mb_height, sizeof(uint32_t));

        if (!ctx->mb_scan_index)

            return AVERROR(ENOMEM);

    }



    for (i = 0; i < ctx->mb_height; i++) {

        ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));

        ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %u\n", i, 0x170 + (i << 2), ctx->mb_scan_index[i]);

        if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {

            av_log(ctx->avctx, AV_LOG_ERROR,

                   "invalid mb scan index (%u vs %u).\n",

                   ctx->mb_scan_index[i], buf_size - ctx->data_offset);

            return AVERROR_INVALIDDATA;

        }

    }



    return 0;

}

static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,

                               const uint8_t *buf, int buf_size,

                               int first_field)

{

    static const uint8_t header_prefix[]    = { 0x00, 0x00, 0x02, 0x80, 0x01 };

    static const uint8_t header_prefix444[] = { 0x00, 0x00, 0x02, 0x80, 0x02 };

    static const uint8_t header_prefixhr1[] = { 0x00, 0x00, 0x02, 0x80, 0x03 };

    static const uint8_t header_prefixhr2[] = { 0x00, 0x00, 0x03, 0x8C, 0x03 };

    int i, cid, ret;

    int old_bit_depth = ctx->bit_depth, bitdepth;

    int old_mb_height = ctx->mb_height;



    if (buf_size < 0x280) {

        av_log(ctx->avctx, AV_LOG_ERROR,

               "buffer too small (%d < 640).\n", buf_size);

        return AVERROR_INVALIDDATA;

    }



    if (memcmp(buf, header_prefix, 5) && memcmp(buf, header_prefix444, 5) &&

        memcmp(buf, header_prefixhr1, 5) && memcmp(buf, header_prefixhr2, 5)) {

        av_log(ctx->avctx, AV_LOG_ERROR,

               "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",

               buf[0], buf[1], buf[2], buf[3], buf[4]);

        return AVERROR_INVALIDDATA;

    }

    if (buf[5] & 2) { 

        ctx->cur_field = buf[5] & 1;

        frame->interlaced_frame = 1;

        frame->top_field_first  = first_field ^ ctx->cur_field;

        av_log(ctx->avctx, AV_LOG_DEBUG,

               "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);

    } else {

        ctx->cur_field = 0;

    }

    ctx->mbaff = (buf[0x6] >> 5) & 1;



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

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



    switch(buf[0x21] >> 5) {

    case 1: bitdepth = 8; break;

    case 2: bitdepth = 10; break;

    case 3: bitdepth = 12; break;

    default:

        av_log(ctx->avctx, AV_LOG_ERROR,

               "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);

        return AVERROR_INVALIDDATA;

    }



    cid = AV_RB32(buf + 0x28);

    if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)

        return ret;

    if (ctx->mbaff && ctx->cid_table->cid != 1260)

        av_log(ctx->avctx, AV_LOG_WARNING,

               "Adaptive MB interlace flag in an unsupported profile.\n");



    ctx->act = buf[0x2C] & 7;

    if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)

        av_log(ctx->avctx, AV_LOG_WARNING,

               "Adaptive color transform in an unsupported profile.\n");



    ctx->is_444 = (buf[0x2C] >> 6) & 1;

    if (ctx->is_444) {

        if (bitdepth == 8) {

            avpriv_request_sample(ctx->avctx, "4:4:4 8 bits\n");

            return AVERROR_INVALIDDATA;

        } else if (bitdepth == 10) {

            ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;

            ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10

                                    : AV_PIX_FMT_GBRP10;

        } else {

            ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;

            ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12

                                    : AV_PIX_FMT_GBRP12;

        }

    } else if (bitdepth == 12) {

        ctx->decode_dct_block = dnxhd_decode_dct_block_12;

        ctx->pix_fmt = AV_PIX_FMT_YUV422P12;

    } else if (bitdepth == 10) {

        ctx->decode_dct_block = dnxhd_decode_dct_block_10;

        ctx->pix_fmt = AV_PIX_FMT_YUV422P10;

    } else {

        ctx->decode_dct_block = dnxhd_decode_dct_block_8;

        ctx->pix_fmt = AV_PIX_FMT_YUV422P;

    }



    ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;

    if (ctx->bit_depth != old_bit_depth) {

        ff_blockdsp_init(&ctx->bdsp, ctx->avctx);

        ff_idctdsp_init(&ctx->idsp, ctx->avctx);

        ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable,

                          ff_zigzag_direct);

    }



    

    

    if (ctx->width != ctx->cid_table->width &&

        ctx->cid_table->width != DNXHD_VARIABLE) {

        av_reduce(&ctx->avctx->sample_aspect_ratio.num,

                  &ctx->avctx->sample_aspect_ratio.den,

                  ctx->width, ctx->cid_table->width, 255);

        ctx->width = ctx->cid_table->width;

    }



    if (buf_size < ctx->cid_table->coding_unit_size) {

        av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %d).\n",

               buf_size, ctx->cid_table->coding_unit_size);

        return AVERROR_INVALIDDATA;

    }



    ctx->mb_width  = (ctx->width + 15)>> 4;

    ctx->mb_height = buf[0x16d];



    if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)

        ctx->height <<= 1;



    av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",

           ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",

           ctx->bit_depth, ctx->mbaff, ctx->act);



    

    if (!memcmp(buf, header_prefixhr2, 5)) {

        ctx->data_offset = 0x170 + (ctx->mb_height << 2);

    } else {

        if (ctx->mb_height > 68 ||

            (ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {

            av_log(ctx->avctx, AV_LOG_ERROR,

                   "mb height too big: %d\n", ctx->mb_height);

            return AVERROR_INVALIDDATA;

        }

        ctx->data_offset = 0x280;

    }



    if (buf_size < ctx->data_offset) {

        av_log(ctx->avctx, AV_LOG_ERROR,

               "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);

        return AVERROR_INVALIDDATA;

    }



    if (ctx->mb_height != old_mb_height) {

        av_freep(&ctx->mb_scan_index);



        ctx->mb_scan_index = av_mallocz_array(ctx->mb_height, sizeof(uint32_t));

        if (!ctx->mb_scan_index)

            return AVERROR(ENOMEM);

    }



    for (i = 0; i < ctx->mb_height; i++) {

        ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));

        ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %u\n", i, 0x170 + (i << 2), ctx->mb_scan_index[i]);

        if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {

            av_log(ctx->avctx, AV_LOG_ERROR,

                   "invalid mb scan index (%u vs %u).\n",

                   ctx->mb_scan_index[i], buf_size - ctx->data_offset);

            return AVERROR_INVALIDDATA;

        }

    }



    return 0;

}

    int old_mb_height = ctx->mb_height;     if (ctx->mb_height != old_mb_height) {         av_freep(&ctx->mb_scan_index);         ctx->mb_scan_index = av_mallocz_array(ctx->mb_height, sizeof(uint32_t));         if (!ctx->mb_scan_index)             return AVERROR(ENOMEM);
static int FUNC_0(DNXHDContext *VAR_0, AVFrame *VAR_1,

                               const uint8_t *VAR_2, int VAR_3,

                               int VAR_4)

{

    static const uint8_t VAR_5[]    = { 0x00, 0x00, 0x02, 0x80, 0x01 };

    static const uint8_t VAR_6[] = { 0x00, 0x00, 0x02, 0x80, 0x02 };

    static const uint8_t VAR_7[] = { 0x00, 0x00, 0x02, 0x80, 0x03 };

    static const uint8_t VAR_8[] = { 0x00, 0x00, 0x03, 0x8C, 0x03 };

    int VAR_9, VAR_10, VAR_11;

    int VAR_12 = VAR_0->bit_depth, VAR_13;

    int VAR_14 = VAR_0->mb_height;



    if (VAR_3 < 0x280) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "buffer too small (%d < 640).\n", VAR_3);

        return AVERROR_INVALIDDATA;

    }



    if (memcmp(VAR_2, VAR_5, 5) && memcmp(VAR_2, VAR_6, 5) &&

        memcmp(VAR_2, VAR_7, 5) && memcmp(VAR_2, VAR_8, 5)) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",

               VAR_2[0], VAR_2[1], VAR_2[2], VAR_2[3], VAR_2[4]);

        return AVERROR_INVALIDDATA;

    }

    if (VAR_2[5] & 2) { 

        VAR_0->cur_field = VAR_2[5] & 1;

        VAR_1->interlaced_frame = 1;

        VAR_1->top_field_first  = VAR_4 ^ VAR_0->cur_field;

        av_log(VAR_0->avctx, AV_LOG_DEBUG,

               "interlaced %d, cur field %d\n", VAR_2[5] & 3, VAR_0->cur_field);

    } else {

        VAR_0->cur_field = 0;

    }

    VAR_0->mbaff = (VAR_2[0x6] >> 5) & 1;



    VAR_0->height = AV_RB16(VAR_2 + 0x18);

    VAR_0->width  = AV_RB16(VAR_2 + 0x1a);



    switch(VAR_2[0x21] >> 5) {

    case 1: VAR_13 = 8; break;

    case 2: VAR_13 = 10; break;

    case 3: VAR_13 = 12; break;

    default:

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Unknown VAR_13 indicator (%d)\n", VAR_2[0x21] >> 5);

        return AVERROR_INVALIDDATA;

    }



    VAR_10 = AV_RB32(VAR_2 + 0x28);

    if ((VAR_11 = dnxhd_init_vlc(VAR_0, VAR_10, VAR_13)) < 0)

        return VAR_11;

    if (VAR_0->mbaff && VAR_0->cid_table->VAR_10 != 1260)

        av_log(VAR_0->avctx, AV_LOG_WARNING,

               "Adaptive MB interlace flag in an unsupported profile.\n");



    VAR_0->act = VAR_2[0x2C] & 7;

    if (VAR_0->act && VAR_0->cid_table->VAR_10 != 1256 && VAR_0->cid_table->VAR_10 != 1270)

        av_log(VAR_0->avctx, AV_LOG_WARNING,

               "Adaptive color transform in an unsupported profile.\n");



    VAR_0->is_444 = (VAR_2[0x2C] >> 6) & 1;

    if (VAR_0->is_444) {

        if (VAR_13 == 8) {

            avpriv_request_sample(VAR_0->avctx, "4:4:4 8 bits\n");

            return AVERROR_INVALIDDATA;

        } else if (VAR_13 == 10) {

            VAR_0->decode_dct_block = dnxhd_decode_dct_block_10_444;

            VAR_0->pix_fmt = VAR_0->act ? AV_PIX_FMT_YUV444P10

                                    : AV_PIX_FMT_GBRP10;

        } else {

            VAR_0->decode_dct_block = dnxhd_decode_dct_block_12_444;

            VAR_0->pix_fmt = VAR_0->act ? AV_PIX_FMT_YUV444P12

                                    : AV_PIX_FMT_GBRP12;

        }

    } else if (VAR_13 == 12) {

        VAR_0->decode_dct_block = dnxhd_decode_dct_block_12;

        VAR_0->pix_fmt = AV_PIX_FMT_YUV422P12;

    } else if (VAR_13 == 10) {

        VAR_0->decode_dct_block = dnxhd_decode_dct_block_10;

        VAR_0->pix_fmt = AV_PIX_FMT_YUV422P10;

    } else {

        VAR_0->decode_dct_block = dnxhd_decode_dct_block_8;

        VAR_0->pix_fmt = AV_PIX_FMT_YUV422P;

    }



    VAR_0->avctx->bits_per_raw_sample = VAR_0->bit_depth = VAR_13;

    if (VAR_0->bit_depth != VAR_12) {

        ff_blockdsp_init(&VAR_0->bdsp, VAR_0->avctx);

        ff_idctdsp_init(&VAR_0->idsp, VAR_0->avctx);

        ff_init_scantable(VAR_0->idsp.idct_permutation, &VAR_0->scantable,

                          ff_zigzag_direct);

    }



    

    

    if (VAR_0->width != VAR_0->cid_table->width &&

        VAR_0->cid_table->width != DNXHD_VARIABLE) {

        av_reduce(&VAR_0->avctx->sample_aspect_ratio.num,

                  &VAR_0->avctx->sample_aspect_ratio.den,

                  VAR_0->width, VAR_0->cid_table->width, 255);

        VAR_0->width = VAR_0->cid_table->width;

    }



    if (VAR_3 < VAR_0->cid_table->coding_unit_size) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "incorrect VAR_1 size (%d < %d).\n",

               VAR_3, VAR_0->cid_table->coding_unit_size);

        return AVERROR_INVALIDDATA;

    }



    VAR_0->mb_width  = (VAR_0->width + 15)>> 4;

    VAR_0->mb_height = VAR_2[0x16d];



    if ((VAR_0->height + 15) >> 4 == VAR_0->mb_height && VAR_1->interlaced_frame)

        VAR_0->height <<= 1;



    av_log(VAR_0->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",

           VAR_0->width, VAR_0->height, VAR_0->is_444 ? "4:4" : "2:2",

           VAR_0->bit_depth, VAR_0->mbaff, VAR_0->act);



    

    if (!memcmp(VAR_2, VAR_8, 5)) {

        VAR_0->data_offset = 0x170 + (VAR_0->mb_height << 2);

    } else {

        if (VAR_0->mb_height > 68 ||

            (VAR_0->mb_height << VAR_1->interlaced_frame) > (VAR_0->height + 15) >> 4) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "mb height too big: %d\n", VAR_0->mb_height);

            return AVERROR_INVALIDDATA;

        }

        VAR_0->data_offset = 0x280;

    }



    if (VAR_3 < VAR_0->data_offset) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "buffer too small (%d < %d).\n", VAR_3, VAR_0->data_offset);

        return AVERROR_INVALIDDATA;

    }



    if (VAR_0->mb_height != VAR_14) {

        av_freep(&VAR_0->mb_scan_index);



        VAR_0->mb_scan_index = av_mallocz_array(VAR_0->mb_height, sizeof(uint32_t));

        if (!VAR_0->mb_scan_index)

            return AVERROR(ENOMEM);

    }



    for (VAR_9 = 0; VAR_9 < VAR_0->mb_height; VAR_9++) {

        VAR_0->mb_scan_index[VAR_9] = AV_RB32(VAR_2 + 0x170 + (VAR_9 << 2));

        ff_dlog(VAR_0->avctx, "mb scan index %d, pos %d: %u\n", VAR_9, 0x170 + (VAR_9 << 2), VAR_0->mb_scan_index[VAR_9]);

        if (VAR_3 - VAR_0->data_offset < VAR_0->mb_scan_index[VAR_9]) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "invalid mb scan index (%u vs %u).\n",

                   VAR_0->mb_scan_index[VAR_9], VAR_3 - VAR_0->data_offset);

            return AVERROR_INVALIDDATA;

        }

    }



    return 0;

}

static int FUNC_0(DNXHDContext *VAR_0, AVFrame *VAR_1,
const uint8_t *VAR_2, int VAR_3,
int VAR_4)
{ static const uint8_t VAR_5[]    = { 0x00, 0x00, 0x02, 0x80, 0x01 }; static const uint8_t VAR_6[] = { 0x00, 0x00, 0x02, 0x80, 0x02 }; static const uint8_t VAR_7[] = { 0x00, 0x00, 0x02, 0x80, 0x03 }; static const uint8_t VAR_8[] = { 0x00, 0x00, 0x03, 0x8C, 0x03 }; int VAR_9, VAR_10, VAR_11; int VAR_12 = VAR_0->bit_depth, VAR_13; int VAR_14 = VAR_0->mb_height; if (VAR_3 < 0x280) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"buffer too small (%d < 640).\n", VAR_3); return AVERROR_INVALIDDATA; } if (memcmp(VAR_2, VAR_5, 5) && memcmp(VAR_2, VAR_6, 5) &&
memcmp(VAR_2, VAR_7, 5) && memcmp(VAR_2, VAR_8, 5)) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
VAR_2[0], VAR_2[1], VAR_2[2], VAR_2[3], VAR_2[4]); return AVERROR_INVALIDDATA; } if (VAR_2[5] & 2) { VAR_0->cur_field = VAR_2[5] & 1; VAR_1->interlaced_frame = 1; VAR_1->top_field_first  = VAR_4 ^ VAR_0->cur_field; av_log(VAR_0->avctx, AV_LOG_DEBUG,
"interlaced %d, cur field %d\n", VAR_2[5] & 3, VAR_0->cur_field); } else { VAR_0->cur_field = 0; } VAR_0->mbaff = (VAR_2[0x6] >> 5) & 1; VAR_0->height = AV_RB16(VAR_2 + 0x18); VAR_0->width  = AV_RB16(VAR_2 + 0x1a); switch(VAR_2[0x21] >> 5) { case 1: VAR_13 = 8; break; case 2: VAR_13 = 10; break; case 3: VAR_13 = 12; break; default:
av_log(VAR_0->avctx, AV_LOG_ERROR,
"Unknown VAR_13 indicator (%d)\n", VAR_2[0x21] >> 5); return AVERROR_INVALIDDATA; } VAR_10 = AV_RB32(VAR_2 + 0x28); if ((VAR_11 = dnxhd_init_vlc(VAR_0, VAR_10, VAR_13)) < 0)
return VAR_11; if (VAR_0->mbaff && VAR_0->cid_table->VAR_10 != 1260)
av_log(VAR_0->avctx, AV_LOG_WARNING,
"Adaptive MB interlace flag in an unsupported profile.\n"); VAR_0->act = VAR_2[0x2C] & 7; if (VAR_0->act && VAR_0->cid_table->VAR_10 != 1256 && VAR_0->cid_table->VAR_10 != 1270)
av_log(VAR_0->avctx, AV_LOG_WARNING,
"Adaptive color transform in an unsupported profile.\n"); VAR_0->is_444 = (VAR_2[0x2C] >> 6) & 1; if (VAR_0->is_444) { if (VAR_13 == 8) { avpriv_request_sample(VAR_0->avctx, "4:4:4 8 bits\n"); return AVERROR_INVALIDDATA; } else if (VAR_13 == 10) { VAR_0->decode_dct_block = dnxhd_decode_dct_block_10_444; VAR_0->pix_fmt = VAR_0->act ? AV_PIX_FMT_YUV444P10
: AV_PIX_FMT_GBRP10; } else { VAR_0->decode_dct_block = dnxhd_decode_dct_block_12_444; VAR_0->pix_fmt = VAR_0->act ? AV_PIX_FMT_YUV444P12
: AV_PIX_FMT_GBRP12; } } else if (VAR_13 == 12) { VAR_0->decode_dct_block = dnxhd_decode_dct_block_12; VAR_0->pix_fmt = AV_PIX_FMT_YUV422P12; } else if (VAR_13 == 10) { VAR_0->decode_dct_block = dnxhd_decode_dct_block_10; VAR_0->pix_fmt = AV_PIX_FMT_YUV422P10; } else { VAR_0->decode_dct_block = dnxhd_decode_dct_block_8; VAR_0->pix_fmt = AV_PIX_FMT_YUV422P; } VAR_0->avctx->bits_per_raw_sample = VAR_0->bit_depth = VAR_13; if (VAR_0->bit_depth != VAR_12) { ff_blockdsp_init(&VAR_0->bdsp, VAR_0->avctx); ff_idctdsp_init(&VAR_0->idsp, VAR_0->avctx); ff_init_scantable(VAR_0->idsp.idct_permutation, &VAR_0->scantable,
ff_zigzag_direct); } if (VAR_0->width != VAR_0->cid_table->width &&
VAR_0->cid_table->width != DNXHD_VARIABLE) { av_reduce(&VAR_0->avctx->sample_aspect_ratio.num,
&VAR_0->avctx->sample_aspect_ratio.den,
VAR_0->width, VAR_0->cid_table->width, 255); VAR_0->width = VAR_0->cid_table->width; } if (VAR_3 < VAR_0->cid_table->coding_unit_size) { av_log(VAR_0->avctx, AV_LOG_ERROR, "incorrect VAR_1 size (%d < %d).\n",
VAR_3, VAR_0->cid_table->coding_unit_size); return AVERROR_INVALIDDATA; } VAR_0->mb_width  = (VAR_0->width + 15)>> 4; VAR_0->mb_height = VAR_2[0x16d]; if ((VAR_0->height + 15) >> 4 == VAR_0->mb_height && VAR_1->interlaced_frame)
VAR_0->height <<= 1; av_log(VAR_0->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
VAR_0->width, VAR_0->height, VAR_0->is_444 ? "4:4" : "2:2",
VAR_0->bit_depth, VAR_0->mbaff, VAR_0->act); if (!memcmp(VAR_2, VAR_8, 5)) { VAR_0->data_offset = 0x170 + (VAR_0->mb_height << 2); } else { if (VAR_0->mb_height > 68 ||
(VAR_0->mb_height << VAR_1->interlaced_frame) > (VAR_0->height + 15) >> 4) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"mb height too big: %d\n", VAR_0->mb_height); return AVERROR_INVALIDDATA; } VAR_0->data_offset = 0x280; } if (VAR_3 < VAR_0->data_offset) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"buffer too small (%d < %d).\n", VAR_3, VAR_0->data_offset); return AVERROR_INVALIDDATA; } if (VAR_0->mb_height != VAR_14) { av_freep(&VAR_0->mb_scan_index); VAR_0->mb_scan_index = av_mallocz_array(VAR_0->mb_height, sizeof(uint32_t)); if (!VAR_0->mb_scan_index)
return AVERROR(ENOMEM); } for (VAR_9 = 0; VAR_9 < VAR_0->mb_height; VAR_9++) { VAR_0->mb_scan_index[VAR_9] = AV_RB32(VAR_2 + 0x170 + (VAR_9 << 2)); ff_dlog(VAR_0->avctx, "mb scan index %d, pos %d: %u\n", VAR_9, 0x170 + (VAR_9 << 2), VAR_0->mb_scan_index[VAR_9]); if (VAR_3 - VAR_0->data_offset < VAR_0->mb_scan_index[VAR_9]) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"invalid mb scan index (%u vs %u).\n",
VAR_0->mb_scan_index[VAR_9], VAR_3 - VAR_0->data_offset); return AVERROR_INVALIDDATA; } } return 0; }