#include "libavutil/attributes.h"
#include "libavutil/internal.h"
+#include "libavutil/mem_internal.h"
#include "libavutil/opt.h"
-#include "libavutil/timer.h"
#include "avcodec.h"
#include "blockdsp.h"
#include "internal.h"
#include "mpegvideo.h"
#include "pixblockdsp.h"
+#include "packet_internal.h"
#include "profiles.h"
#include "dnxhdenc.h"
int i, j, level, run;
int max_level = 1 << (ctx->bit_depth + 2);
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_codes,
- max_level, 4 * sizeof(*ctx->orig_vlc_codes), fail);
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->orig_vlc_bits,
- max_level, 4 * sizeof(*ctx->orig_vlc_bits), fail);
- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes,
- 63 * 2, fail);
- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,
- 63, fail);
-
+ if (!FF_ALLOCZ_TYPED_ARRAY(ctx->orig_vlc_codes, max_level * 4) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->orig_vlc_bits, max_level * 4) ||
+ !(ctx->run_codes = av_mallocz(63 * 2)) ||
+ !(ctx->run_bits = av_mallocz(63)))
+ return AVERROR(ENOMEM);
ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2;
ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2;
for (level = -max_level; level < max_level; level++) {
for (run = 0; run < 2; run++) {
- int index = (level << 1) | run;
+ int index = level * (1 << 1) | run;
int sign, offset = 0, alevel = level;
MASK_ABS(sign, alevel);
ctx->run_bits[run] = ctx->cid_table->run_bits[i];
}
return 0;
-fail:
- return AVERROR(ENOMEM);
}
static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
const uint8_t *luma_weight_table = ctx->cid_table->luma_weight;
const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,
- (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,
- (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16,
- (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
- fail);
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16,
- (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
- fail);
+ if (!FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l, ctx->m.avctx->qmax + 1) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c, ctx->m.avctx->qmax + 1) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l16, ctx->m.avctx->qmax + 1) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c16, ctx->m.avctx->qmax + 1))
+ return AVERROR(ENOMEM);
if (ctx->bit_depth == 8) {
for (i = 1; i < 64; i++) {
ctx->m.q_intra_matrix = ctx->qmatrix_l;
return 0;
-fail:
- return AVERROR(ENOMEM);
}
static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
{
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1),
- ctx->m.mb_num * sizeof(RCEntry), fail);
+ if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_rc, (ctx->m.avctx->qmax + 1) * ctx->m.mb_num))
+ return AVERROR(ENOMEM);
+
if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) {
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
- ctx->m.mb_num, sizeof(RCCMPEntry), fail);
- FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp_tmp,
- ctx->m.mb_num, sizeof(RCCMPEntry), fail);
+ if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp, ctx->m.mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp_tmp, ctx->m.mb_num))
+ return AVERROR(ENOMEM);
}
ctx->frame_bits = (ctx->coding_unit_size -
ctx->data_offset - 4 - ctx->min_padding) * 8;
ctx->qscale = 1;
ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
return 0;
-fail:
- return AVERROR(ENOMEM);
}
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
{
DNXHDEncContext *ctx = avctx->priv_data;
- int i, index, ret;
+ int i, ret;
switch (avctx->pix_fmt) {
case AV_PIX_FMT_YUV422P:
return AVERROR(EINVAL);
}
- index = ff_dnxhd_get_cid_table(ctx->cid);
- av_assert0(index >= 0);
-
- ctx->cid_table = &ff_dnxhd_cid_table[index];
+ ctx->cid_table = ff_dnxhd_get_cid_table(ctx->cid);
+ av_assert0(ctx->cid_table);
ctx->m.avctx = avctx;
ctx->m.mb_intra = 1;
ctx->m.mb_height /= 2;
}
+ if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Interlaced encoding is not supported for DNxHR profiles.\n");
+ return AVERROR(EINVAL);
+ }
+
ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
- ctx->frame_size = ff_dnxhd_get_hr_frame_size(ctx->cid,
+ ctx->frame_size = avpriv_dnxhd_get_hr_frame_size(ctx->cid,
avctx->width, avctx->height);
av_assert0(ctx->frame_size >= 0);
ctx->coding_unit_size = ctx->frame_size;
if ((ret = dnxhd_init_rc(ctx)) < 0)
return ret;
- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size,
- ctx->m.mb_height * sizeof(uint32_t), fail);
- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs,
- ctx->m.mb_height * sizeof(uint32_t), fail);
- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits,
- ctx->m.mb_num * sizeof(uint16_t), fail);
- FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,
- ctx->m.mb_num * sizeof(uint8_t), fail);
-
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- avctx->coded_frame->key_frame = 1;
- avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
+ if (!FF_ALLOCZ_TYPED_ARRAY(ctx->slice_size, ctx->m.mb_height) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->slice_offs, ctx->m.mb_height) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_bits, ctx->m.mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_qscale, ctx->m.mb_num))
+ return AVERROR(ENOMEM);
if (avctx->active_thread_type == FF_THREAD_SLICE) {
if (avctx->thread_count > MAX_THREADS) {
if (avctx->active_thread_type == FF_THREAD_SLICE) {
for (i = 1; i < avctx->thread_count; i++) {
ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
+ if (!ctx->thread[i])
+ return AVERROR(ENOMEM);
memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
}
}
return 0;
-fail: // for FF_ALLOCZ_OR_GOTO
- return AVERROR(ENOMEM);
}
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
slevel = block[j];
if (slevel) {
int run_level = i - last_non_zero - 1;
- int rlevel = (slevel << 1) | !!run_level;
+ int rlevel = slevel * (1 << 1) | !!run_level;
put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
if (run_level)
put_bits(&ctx->m.pb, ctx->run_bits[run_level],
level = block[j];
if (level) {
int run_level = i - last_non_zero - 1;
- bits += ctx->vlc_bits[(level << 1) |
+ bits += ctx->vlc_bits[level * (1 << 1) |
!!run_level] + ctx->run_bits[run_level];
last_non_zero = i;
}
int last_index = ctx->m.dct_quantize(&ctx->m, block,
ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
qscale, &overflow);
- // START_TIMER;
+
dnxhd_encode_block(ctx, block, last_index, n);
- // STOP_TIMER("encode_block");
}
}
if (put_bits_count(&ctx->m.pb) & 31)
ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8;
}
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- ctx->m.avctx->coded_frame->interlaced_frame = frame->interlaced_frame;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
ctx->cur_field = frame->interlaced_frame && !frame->top_field_first;
}
goto encode_coding_unit;
}
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- avctx->coded_frame->quality = ctx->qscale * FF_QP2LAMBDA;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
ff_side_data_set_encoder_stats(pkt, ctx->qscale * FF_QP2LAMBDA, NULL, 0, AV_PICTURE_TYPE_I);
pkt->flags |= AV_PKT_FLAG_KEY;
{ NULL },
};
-AVCodec ff_dnxhd_encoder = {
+const AVCodec ff_dnxhd_encoder = {
.name = "dnxhd",
.long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
.type = AVMEDIA_TYPE_VIDEO,
.init = dnxhd_encode_init,
.encode2 = dnxhd_encode_picture,
.close = dnxhd_encode_end,
- .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
+ .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
.pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_YUV422P,
projects / ffmpeg / blobdiff