#include "pixblockdsp.h"
#include "dnxhdenc.h"
-// The largest value that will not lead to overflow for 10bit samples.
+// The largest value that will not lead to overflow for 10-bit samples.
#define DNX10BIT_QMAT_SHIFT 18
#define RC_VARIANCE 1 // use variance or ssd for fast rc
#define LAMBDA_FRAC_BITS 10
static const AVOption options[] = {
{ "nitris_compat", "encode with Avid Nitris compatibility",
offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
+ { "ibias", "intra quant bias",
+ offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT,
+ { .i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, VE },
{ NULL }
};
weight_matrix[j] = ctx->cid_table->luma_weight[i];
}
ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
- weight_matrix, ctx->m.intra_quant_bias, 1,
+ weight_matrix, ctx->intra_quant_bias, 1,
ctx->m.avctx->qmax, 1);
for (i = 1; i < 64; i++) {
int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
weight_matrix[j] = ctx->cid_table->chroma_weight[i];
}
ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
- weight_matrix, ctx->m.intra_quant_bias, 1,
+ weight_matrix, ctx->intra_quant_bias, 1,
ctx->m.avctx->qmax, 1);
for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
break;
default:
av_log(avctx, AV_LOG_ERROR,
- "pixel format is incompatible with DNxHD\n");
+ "Pixel format is incompatible with DNxHD, use yuv422p or yuv422p10.\n");
return AVERROR(EINVAL);
}
ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
if (!ctx->cid) {
av_log(avctx, AV_LOG_ERROR,
- "video parameters incompatible with DNxHD\n");
+ "Video parameters incompatible with DNxHD, available CIDs:\n");
+ ff_dnxhd_list_cid(avctx);
return AVERROR(EINVAL);
}
av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
ctx->m.mb_height = (avctx->height + 15) / 16;
ctx->m.mb_width = (avctx->width + 15) / 16;
- if (avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
+ if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
ctx->interlaced = 1;
ctx->m.mb_height /= 2;
}
ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
+#if FF_API_QUANT_BIAS
+FF_DISABLE_DEPRECATION_WARNINGS
if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
- ctx->m.intra_quant_bias = avctx->intra_quant_bias;
+ ctx->intra_quant_bias = avctx->intra_quant_bias;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
// XXX tune lbias/cbias
- if ((ret = dnxhd_init_qmat(ctx, ctx->m.intra_quant_bias, 0)) < 0)
+ if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0)
return ret;
/* Avid Nitris hardware decoder requires a minimum amount of padding
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,
ctx->m.mb_num * sizeof(uint8_t), fail);
- avctx->coded_frame = av_frame_alloc();
- if (!avctx->coded_frame)
- return AVERROR(ENOMEM);
-
+#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 (avctx->thread_count > MAX_THREADS) {
av_log(avctx, AV_LOG_ERROR, "too many threads\n");
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
{
DNXHDEncContext *ctx = avctx->priv_data;
- const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
+ static const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
memset(buf, 0, 640);
ctx->mb_cmp[mb].mb = mb;
}
} else { // 10-bit
- int const linesize = ctx->m.linesize >> 1;
+ const int linesize = ctx->m.linesize >> 1;
for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
((mb_y << 4) * linesize) + (mb_x << 4);
for (i = 0; i < 16; ++i) {
for (j = 0; j < 16; ++j) {
// Turn 16-bit pixels into 10-bit ones.
- int const sample = (unsigned) pix[j] >> 6;
+ const int sample = (unsigned) pix[j] >> 6;
sum += sample;
sqsum += sample * sample;
// 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
if (bits > ctx->frame_bits)
break;
}
- // av_dlog(ctx->m.avctx,
- // "lambda %d, up %u, down %u, bits %d, frame %d\n",
- // lambda, last_higher, last_lower, bits, ctx->frame_bits);
if (end) {
if (bits > ctx->frame_bits)
return AVERROR(EINVAL);
down_step = 1<<LAMBDA_FRAC_BITS;
}
}
- //av_dlog(ctx->m.avctx, "out lambda %d\n", lambda);
ctx->lambda = lambda;
return 0;
}
if (bits > ctx->frame_bits)
break;
}
- // av_dlog(ctx->m.avctx,
- // "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
- // ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits,
- // last_higher, last_lower);
if (bits < ctx->frame_bits) {
if (qscale == 1)
return 1;
return AVERROR(EINVAL);
}
}
- //av_dlog(ctx->m.avctx, "out qscale %d\n", qscale);
ctx->qscale = qscale;
return 0;
}
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;
}
DNXHDEncContext *ctx = avctx->priv_data;
int first_field = 1;
int offset, i, ret;
- uint8_t *buf;
+ uint8_t *buf, *sd;
if ((ret = ff_alloc_packet(pkt, ctx->cid_table->frame_size)) < 0) {
av_log(avctx, AV_LOG_ERROR,
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
+
+ sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR, sizeof(int));
+ if (!sd)
+ return AVERROR(ENOMEM);
+ *(int *)sd = ctx->qscale * FF_QP2LAMBDA;
pkt->flags |= AV_PKT_FLAG_KEY;
*got_packet = 1;
for (i = 1; i < avctx->thread_count; i++)
av_freep(&ctx->thread[i]);
- av_frame_free(&avctx->coded_frame);
-
return 0;
}
.init = dnxhd_encode_init,
.encode2 = dnxhd_encode_picture,
.close = dnxhd_encode_end,
- .capabilities = CODEC_CAP_SLICE_THREADS,
+ .capabilities = AV_CODEC_CAP_SLICE_THREADS,
.pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_YUV422P,
AV_PIX_FMT_YUV422P10,
projects / ffmpeg / blobdiff