Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit '89ef08c992c484a46711b1a68a988303679c288e'

Browse Source 
* commit '89ef08c992c484a46711b1a68a988303679c288e':
  DNxHD: K&R formatting cosmetics

Conflicts:
	libavcodec/dnxhd_parser.c
	libavcodec/dnxhddec.c
	libavcodec/dnxhdenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/64/head
Michael Niedermayer 11 years ago
parent d9fef740bd 89ef08c992
commit bad101ab8a
4 changed files with 308 additions and 205 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 31
      libavcodec/dnxhddec.c
  2. 284
      libavcodec/dnxhdenc.c

31
libavcodec/dnxhddec.c
Unescape View File

@ -57,9 +57,12 @@ typedef struct DNXHDContext {
#define DNXHD_VLC_BITS 9 #define DNXHD_VLC_BITS 9
#define DNXHD_DC_VLC_BITS 7 #define DNXHD_DC_VLC_BITS 7
static void dnxhd_decode_dct_block_8(DNXHDContext *ctx, int16_t *block, int n, int qscale); static void dnxhd_decode_dct_block_8(DNXHDContext *ctx, int16_t *block,
static void dnxhd_decode_dct_block_10(DNXHDContext *ctx, int16_t *block, int n, int qscale); int n, int qscale);
static void dnxhd_decode_dct_block_10_444(DNXHDContext *ctx, int16_t *block, int n, int qscale); static void dnxhd_decode_dct_block_10(DNXHDContext *ctx, int16_t *block,
int n, int qscale);
static void dnxhd_decode_dct_block_10_444(DNXHDContext *ctx, int16_t *block,
int n, int qscale);
static av_cold int dnxhd_decode_init(AVCodecContext *avctx) static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
{ {
@ -99,14 +102,16 @@ static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid)
ctx->cid_table->run_bits, 1, 1, ctx->cid_table->run_bits, 1, 1,
ctx->cid_table->run_codes, 2, 2, 0); ctx->cid_table->run_codes, 2, 2, 0);
ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, ff_zigzag_direct); ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,
ff_zigzag_direct);
ctx->cid = cid; ctx->cid = cid;
} }
return 0; return 0;
} }
static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame, static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
const uint8_t *buf, int buf_size, int first_field) 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_prefix[] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
static const uint8_t header_prefix444[] = { 0x00, 0x00, 0x02, 0x80, 0x02 }; static const uint8_t header_prefix444[] = { 0x00, 0x00, 0x02, 0x80, 0x02 };
@ -123,7 +128,8 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
ctx->cur_field = buf[5] & 1; ctx->cur_field = buf[5] & 1;
frame->interlaced_frame = 1; frame->interlaced_frame = 1;
frame->top_field_first = first_field ^ ctx->cur_field; 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); av_log(ctx->avctx, AV_LOG_DEBUG,
"interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
} }
ctx->height = AV_RB16(buf + 0x18); ctx->height = AV_RB16(buf + 0x18);
@ -173,14 +179,16 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
ctx->mb_width = ctx->width >> 4; ctx->mb_width = ctx->width >> 4;
ctx->mb_height = buf[0x16d]; ctx->mb_height = buf[0x16d];
av_dlog(ctx->avctx, "mb width %d, mb height %d\n", ctx->mb_width, ctx->mb_height); av_dlog(ctx->avctx,
"mb width %d, mb height %d\n", ctx->mb_width, ctx->mb_height);
if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame) if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
ctx->height <<= 1; ctx->height <<= 1;
if (ctx->mb_height > 68 || if (ctx->mb_height > 68 ||
(ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) { (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); av_log(ctx->avctx, AV_LOG_ERROR,
"mb height too big: %d\n", ctx->mb_height);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -308,7 +316,8 @@ static void dnxhd_decode_dct_block_10_444(DNXHDContext *ctx, int16_t *block,
dnxhd_decode_dct_block(ctx, block, n, qscale, 6, 32, 6); dnxhd_decode_dct_block(ctx, block, n, qscale, 6, 32, 6);
} }
static int dnxhd_decode_macroblock(DNXHDContext *ctx, AVFrame *frame, int x, int y) static int dnxhd_decode_macroblock(DNXHDContext *ctx, AVFrame *frame,
int x, int y)
{ {
int shift1 = ctx->bit_depth == 10; int shift1 = ctx->bit_depth == 10;
int dct_linesize_luma = frame->linesize[0]; int dct_linesize_luma = frame->linesize[0];
@ -409,8 +418,8 @@ static int dnxhd_decode_macroblocks(DNXHDContext *ctx, AVFrame *frame,
return 0; return 0;
} }
static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, static int dnxhd_decode_frame(AVCodecContext *avctx, void *data,
AVPacket *avpkt) int *got_frame, AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;

284
libavcodec/dnxhdenc.c
Unescape View File

@ -23,23 +23,27 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#define RC_VARIANCE 1 // use variance or ssd for fast rc
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "libavutil/internal.h" #include "libavutil/internal.h"
#include "libavutil/opt.h" #include "libavutil/opt.h"
#include "libavutil/timer.h" #include "libavutil/timer.h"
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "internal.h" #include "internal.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "dnxhdenc.h" #include "dnxhdenc.h"
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
#define DNX10BIT_QMAT_SHIFT 18 // The largest value that will not lead to overflow for 10bit samples.
// The largest value that will not lead to overflow for 10bit samples.
#define DNX10BIT_QMAT_SHIFT 18
#define RC_VARIANCE 1 // use variance or ssd for fast rc
#define LAMBDA_FRAC_BITS 10
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = { static const AVOption options[] = {
{"nitris_compat", "encode with Avid Nitris compatibility", offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, VE}, { "nitris_compat", "encode with Avid Nitris compatibility",
offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
{ NULL } { NULL }
}; };
@ -50,16 +54,20 @@ static const AVClass dnxhd_class = {
.version = LIBAVUTIL_VERSION_INT, .version = LIBAVUTIL_VERSION_INT,
}; };
#define LAMBDA_FRAC_BITS 10 static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block,
const uint8_t *pixels,
static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size) ptrdiff_t line_size)
{ {
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
block[0] = pixels[0]; block[1] = pixels[1]; block[0] = pixels[0];
block[2] = pixels[2]; block[3] = pixels[3]; block[1] = pixels[1];
block[4] = pixels[4]; block[5] = pixels[5]; block[2] = pixels[2];
block[6] = pixels[6]; block[7] = pixels[7]; block[3] = pixels[3];
block[4] = pixels[4];
block[5] = pixels[5];
block[6] = pixels[6];
block[7] = pixels[7];
pixels += line_size; pixels += line_size;
block += 8; block += 8;
} }
@ -69,7 +77,10 @@ static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint
memcpy(block + 24, block - 32, sizeof(*block) * 8); memcpy(block + 24, block - 32, sizeof(*block) * 8);
} }
static av_always_inline void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size) static av_always_inline
void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
const uint8_t *pixels,
ptrdiff_t line_size)
{ {
int i; int i;
const uint16_t* pixels16 = (const uint16_t*)pixels; const uint16_t* pixels16 = (const uint16_t*)pixels;
@ -120,10 +131,14 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
int i, j, level, run; int i, j, level, run;
int max_level = 1 << (ctx->cid_table->bit_depth + 2); int max_level = 1 << (ctx->cid_table->bit_depth + 2);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes, max_level*4*sizeof(*ctx->vlc_codes), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes,
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits, max_level*4*sizeof(*ctx->vlc_bits) , fail); max_level * 4 * sizeof(*ctx->vlc_codes), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, 63*2, fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits,
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits, 63, fail); max_level * 4 * sizeof(*ctx->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);
ctx->vlc_codes += max_level * 2; ctx->vlc_codes += max_level * 2;
ctx->vlc_bits += max_level * 2; ctx->vlc_bits += max_level * 2;
@ -143,7 +158,8 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
(!run || (ctx->cid_table->ac_flags[j] & 2) && run)) { (!run || (ctx->cid_table->ac_flags[j] & 2) && run)) {
av_assert1(!ctx->vlc_codes[index]); av_assert1(!ctx->vlc_codes[index]);
if (alevel) { if (alevel) {
ctx->vlc_codes[index] = (ctx->cid_table->ac_codes[j]<<1)|(sign&1); ctx->vlc_codes[index] =
(ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1; ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
} else { } else {
ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j]; ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
@ -154,7 +170,8 @@ static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
} }
av_assert0(!alevel || j < 257); av_assert0(!alevel || j < 257);
if (offset) { if (offset) {
ctx->vlc_codes[index] = (ctx->vlc_codes[index]<<ctx->cid_table->index_bits)|offset; ctx->vlc_codes[index] =
(ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
ctx->vlc_bits[index] += ctx->cid_table->index_bits; ctx->vlc_bits[index] += ctx->cid_table->index_bits;
} }
} }
@ -178,30 +195,41 @@ 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 *luma_weight_table = ctx->cid_table->luma_weight;
const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight; const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l, (ctx->m.avctx->qmax+1) * 64 * sizeof(int), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c, (ctx->m.avctx->qmax+1) * 64 * sizeof(int), fail); (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail); (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16,
(ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16,
(ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
fail);
if (ctx->cid_table->bit_depth == 8) { if (ctx->cid_table->bit_depth == 8) {
for (i = 1; i < 64; i++) { for (i = 1; i < 64; i++) {
int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]]; int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
weight_matrix[j] = ctx->cid_table->luma_weight[i]; weight_matrix[j] = ctx->cid_table->luma_weight[i];
} }
ff_convert_matrix(&ctx->m.dsp, ctx->qmatrix_l, ctx->qmatrix_l16, weight_matrix, ff_convert_matrix(&ctx->m.dsp, ctx->qmatrix_l, ctx->qmatrix_l16,
ctx->m.intra_quant_bias, 1, ctx->m.avctx->qmax, 1); weight_matrix, ctx->m.intra_quant_bias, 1,
ctx->m.avctx->qmax, 1);
for (i = 1; i < 64; i++) { for (i = 1; i < 64; i++) {
int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]]; int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
weight_matrix[j] = ctx->cid_table->chroma_weight[i]; weight_matrix[j] = ctx->cid_table->chroma_weight[i];
} }
ff_convert_matrix(&ctx->m.dsp, ctx->qmatrix_c, ctx->qmatrix_c16, weight_matrix, ff_convert_matrix(&ctx->m.dsp, ctx->qmatrix_c, ctx->qmatrix_c16,
ctx->m.intra_quant_bias, 1, ctx->m.avctx->qmax, 1); weight_matrix, ctx->m.intra_quant_bias, 1,
ctx->m.avctx->qmax, 1);
for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) { for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
for (i = 0; i < 64; i++) { for (i = 0; i < 64; i++) {
ctx->qmatrix_l [qscale] [i] <<= 2; ctx->qmatrix_c [qscale] [i] <<= 2; ctx->qmatrix_l[qscale][i] <<= 2;
ctx->qmatrix_l16[qscale][0][i] <<= 2; ctx->qmatrix_l16[qscale][1][i] <<= 2; ctx->qmatrix_c[qscale][i] <<= 2;
ctx->qmatrix_c16[qscale][0][i] <<= 2; ctx->qmatrix_c16[qscale][1][i] <<= 2; ctx->qmatrix_l16[qscale][0][i] <<= 2;
ctx->qmatrix_l16[qscale][1][i] <<= 2;
ctx->qmatrix_c16[qscale][0][i] <<= 2;
ctx->qmatrix_c16[qscale][1][i] <<= 2;
} }
} }
} else { } else {
@ -210,16 +238,21 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
for (i = 1; i < 64; i++) { for (i = 1; i < 64; i++) {
int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]]; int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
// The quantization formula from the VC-3 standard is: /* The quantization formula from the VC-3 standard is:
// quantized = sign(block[i]) * floor(abs(block[i]/s) * p / (qscale * weight_table[i])) * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
// Where p is 32 for 8-bit samples and 8 for 10-bit ones. * (qscale * weight_table[i]))
// The s factor compensates scaling of DCT coefficients done by the DCT routines, * Where p is 32 for 8-bit samples and 8 for 10-bit ones.
// and therefore is not present in standard. It's 8 for 8-bit samples and 4 for 10-bit ones. * The s factor compensates scaling of DCT coefficients done by
// We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be: * the DCT routines, and therefore is not present in standard.
// ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) / (qscale * weight_table[i]) * It's 8 for 8-bit samples and 4 for 10-bit ones.
// For 10-bit samples, p / s == 2 * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) / (qscale * luma_weight_table[i]); * ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) /
ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) / (qscale * chroma_weight_table[i]); * (qscale * weight_table[i])
* For 10-bit samples, p / s == 2 */
ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
(qscale * luma_weight_table[i]);
ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
(qscale * chroma_weight_table[i]);
} }
} }
} }
@ -238,9 +271,11 @@ static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
{ {
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc, 8160 * (ctx->m.avctx->qmax + 1) * sizeof(RCEntry), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc, 8160 * (ctx->m.avctx->qmax + 1) * sizeof(RCEntry), fail);
if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD)
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp, ctx->m.mb_num*sizeof(RCCMPEntry), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
ctx->m.mb_num * sizeof(RCCMPEntry), fail);
ctx->frame_bits = (ctx->cid_table->coding_unit_size - 640 - 4 - ctx->min_padding) * 8; ctx->frame_bits = (ctx->cid_table->coding_unit_size -
640 - 4 - ctx->min_padding) * 8;
ctx->qscale = 1; ctx->qscale = 1;
ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2 ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
return 0; return 0;
@ -261,13 +296,15 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
bit_depth = 10; bit_depth = 10;
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "pixel format is incompatible with DNxHD\n"); av_log(avctx, AV_LOG_ERROR,
"pixel format is incompatible with DNxHD\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth); ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
if (!ctx->cid) { if (!ctx->cid) {
av_log(avctx, AV_LOG_ERROR, "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n"); av_log(avctx, AV_LOG_ERROR,
"video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
ff_dnxhd_print_profiles(avctx, AV_LOG_ERROR); ff_dnxhd_print_profiles(avctx, AV_LOG_ERROR);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -313,10 +350,12 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
ctx->m.intra_quant_bias = avctx->intra_quant_bias; ctx->m.intra_quant_bias = avctx->intra_quant_bias;
if ((ret = dnxhd_init_qmat(ctx, ctx->m.intra_quant_bias, 0)) < 0) // XXX tune lbias/cbias // XXX tune lbias/cbias
if ((ret = dnxhd_init_qmat(ctx, ctx->m.intra_quant_bias, 0)) < 0)
return ret; return ret;
// Avid Nitris hardware decoder requires a minimum amount of padding in the coding unit payload /* Avid Nitris hardware decoder requires a minimum amount of padding
* in the coding unit payload */
if (ctx->nitris_compat) if (ctx->nitris_compat)
ctx->min_padding = 1600; ctx->min_padding = 1600;
@ -325,10 +364,14 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
if ((ret = dnxhd_init_rc(ctx)) < 0) if ((ret = dnxhd_init_rc(ctx)) < 0)
return ret; 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_size,
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, ctx->m.mb_height*sizeof(uint32_t), fail); 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->slice_offs,
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale, ctx->m.mb_num *sizeof(uint8_t), fail); 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);
avctx->coded_frame = av_frame_alloc(); avctx->coded_frame = av_frame_alloc();
if (!avctx->coded_frame) if (!avctx->coded_frame)
@ -399,10 +442,13 @@ static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
nbits = av_log2_16bit(2 * diff); nbits = av_log2_16bit(2 * diff);
} }
put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits, put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
(ctx->cid_table->dc_codes[nbits]<<nbits) + (diff & ((1 << nbits) - 1))); (ctx->cid_table->dc_codes[nbits] << nbits) +
(diff & ((1 << nbits) - 1)));
} }
static av_always_inline void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block, int last_index, int n) static av_always_inline
void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block,
int last_index, int n)
{ {
int last_non_zero = 0; int last_non_zero = 0;
int slevel, i, j; int slevel, i, j;
@ -418,20 +464,24 @@ static av_always_inline void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *b
int rlevel = (slevel << 1) | !!run_level; int rlevel = (slevel << 1) | !!run_level;
put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]); put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
if (run_level) if (run_level)
put_bits(&ctx->m.pb, ctx->run_bits[run_level], ctx->run_codes[run_level]); put_bits(&ctx->m.pb, ctx->run_bits[run_level],
ctx->run_codes[run_level]);
last_non_zero = i; last_non_zero = i;
} }
} }
put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
} }
static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n, int qscale, int last_index) static av_always_inline
void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
int qscale, int last_index)
{ {
const uint8_t *weight_matrix; const uint8_t *weight_matrix;
int level; int level;
int i; int i;
weight_matrix = (n&2) ? ctx->cid_table->chroma_weight : ctx->cid_table->luma_weight; weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
: ctx->cid_table->luma_weight;
for (i = 1; i <= last_index; i++) { for (i = 1; i <= last_index; i++) {
int j = ctx->m.intra_scantable.permutated[i]; int j = ctx->m.intra_scantable.permutated[i];
@ -475,7 +525,8 @@ static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
return score; return score;
} }
static av_always_inline int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index) static av_always_inline
int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
{ {
int last_non_zero = 0; int last_non_zero = 0;
int bits = 0; int bits = 0;
@ -485,20 +536,25 @@ static av_always_inline int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *bl
level = block[j]; level = block[j];
if (level) { if (level) {
int run_level = i - last_non_zero - 1; int run_level = i - last_non_zero - 1;
bits += ctx->vlc_bits[(level<<1)|!!run_level]+ctx->run_bits[run_level]; bits += ctx->vlc_bits[(level << 1) |
!!run_level] + ctx->run_bits[run_level];
last_non_zero = i; last_non_zero = i;
} }
} }
return bits; return bits;
} }
static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y) static av_always_inline
void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
{ {
const int bs = ctx->block_width_l2; const int bs = ctx->block_width_l2;
const int bw = 1 << bs; const int bw = 1 << bs;
const uint8_t *ptr_y = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs+1); const uint8_t *ptr_y = ctx->thread[0]->src[0] +
const uint8_t *ptr_u = ctx->thread[0]->src[1] + ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs); ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
const uint8_t *ptr_v = ctx->thread[0]->src[2] + ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs); const uint8_t *ptr_u = ctx->thread[0]->src[1] +
((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
const uint8_t *ptr_v = ctx->thread[0]->src[2] +
((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
DSPContext *dsp = &ctx->m.dsp; DSPContext *dsp = &ctx->m.dsp;
dsp->get_pixels(ctx->blocks[0], ptr_y, ctx->m.linesize); dsp->get_pixels(ctx->blocks[0], ptr_y, ctx->m.linesize);
@ -508,10 +564,18 @@ static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, in
if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) { if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
if (ctx->interlaced) { if (ctx->interlaced) {
ctx->get_pixels_8x4_sym(ctx->blocks[4], ptr_y + ctx->dct_y_offset, ctx->m.linesize); ctx->get_pixels_8x4_sym(ctx->blocks[4],
ctx->get_pixels_8x4_sym(ctx->blocks[5], ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize); ptr_y + ctx->dct_y_offset,
ctx->get_pixels_8x4_sym(ctx->blocks[6], ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize); ctx->m.linesize);
ctx->get_pixels_8x4_sym(ctx->blocks[7], ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize); ctx->get_pixels_8x4_sym(ctx->blocks[5],
ptr_y + ctx->dct_y_offset + bw,
ctx->m.linesize);
ctx->get_pixels_8x4_sym(ctx->blocks[6],
ptr_u + ctx->dct_uv_offset,
ctx->m.uvlinesize);
ctx->get_pixels_8x4_sym(ctx->blocks[7],
ptr_v + ctx->dct_uv_offset,
ctx->m.uvlinesize);
} else { } else {
dsp->clear_block(ctx->blocks[4]); dsp->clear_block(ctx->blocks[4]);
dsp->clear_block(ctx->blocks[5]); dsp->clear_block(ctx->blocks[5]);
@ -519,20 +583,26 @@ static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, in
dsp->clear_block(ctx->blocks[7]); dsp->clear_block(ctx->blocks[7]);
} }
} else { } else {
dsp->get_pixels(ctx->blocks[4], ptr_y + ctx->dct_y_offset, ctx->m.linesize); dsp->get_pixels(ctx->blocks[4],
dsp->get_pixels(ctx->blocks[5], ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize); ptr_y + ctx->dct_y_offset, ctx->m.linesize);
dsp->get_pixels(ctx->blocks[6], ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize); dsp->get_pixels(ctx->blocks[5],
dsp->get_pixels(ctx->blocks[7], ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize); ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize);
dsp->get_pixels(ctx->blocks[6],
ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize);
dsp->get_pixels(ctx->blocks[7],
ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize);
} }
} }
static av_always_inline int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i) static av_always_inline
int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
{ {
const static uint8_t component[8]={0,0,1,2,0,0,1,2}; const static uint8_t component[8]={0,0,1,2,0,0,1,2};
return component[i]; return component[i];
} }
static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr) static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
int jobnr, int threadnr)
{ {
DNXHDEncContext *ctx = avctx->priv_data; DNXHDEncContext *ctx = avctx->priv_data;
int mb_y = jobnr, mb_x; int mb_y = jobnr, mb_x;
@ -559,12 +629,15 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, i
int n = dnxhd_switch_matrix(ctx, i); int n = dnxhd_switch_matrix(ctx, i);
memcpy(block, src_block, 64 * sizeof(*block)); memcpy(block, src_block, 64 * sizeof(*block));
last_index = ctx->m.dct_quantize(&ctx->m, block, 4&(2*i), qscale, &overflow); last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
qscale, &overflow);
ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index); ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
diff = block[0] - ctx->m.last_dc[n]; diff = block[0] - ctx->m.last_dc[n];
if (diff < 0) nbits = av_log2_16bit(-2*diff); if (diff < 0)
else nbits = av_log2_16bit( 2*diff); nbits = av_log2_16bit(-2 * diff);
else
nbits = av_log2_16bit(2 * diff);
av_assert1(nbits < ctx->cid_table->bit_depth + 4); av_assert1(nbits < ctx->cid_table->bit_depth + 4);
dc_bits += ctx->cid_table->dc_bits[nbits] + nbits; dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
@ -578,17 +651,20 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, i
} }
} }
ctx->mb_rc[qscale][mb].ssd = ssd; ctx->mb_rc[qscale][mb].ssd = ssd;
ctx->mb_rc[qscale][mb].bits = ac_bits+dc_bits+12+8*ctx->vlc_bits[0]; ctx->mb_rc[qscale][mb].bits = ac_bits + dc_bits + 12 +
8 * ctx->vlc_bits[0];
} }
return 0; return 0;
} }
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr) static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg,
int jobnr, int threadnr)
{ {
DNXHDEncContext *ctx = avctx->priv_data; DNXHDEncContext *ctx = avctx->priv_data;
int mb_y = jobnr, mb_x; int mb_y = jobnr, mb_x;
ctx = ctx->thread[threadnr]; ctx = ctx->thread[threadnr];
init_put_bits(&ctx->m.pb, (uint8_t *)arg + 640 + ctx->slice_offs[jobnr], ctx->slice_size[jobnr]); init_put_bits(&ctx->m.pb, (uint8_t *)arg + 640 + ctx->slice_offs[jobnr],
ctx->slice_size[jobnr]);
ctx->m.last_dc[0] = ctx->m.last_dc[0] =
ctx->m.last_dc[1] = ctx->m.last_dc[1] =
@ -605,7 +681,8 @@ static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
int16_t *block = ctx->blocks[i]; int16_t *block = ctx->blocks[i];
int overflow, n = dnxhd_switch_matrix(ctx, i); int overflow, n = dnxhd_switch_matrix(ctx, i);
int last_index = ctx->m.dct_quantize(&ctx->m, block, 4&(2*i), qscale, &overflow); int last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
qscale, &overflow);
// START_TIMER; // START_TIMER;
dnxhd_encode_block(ctx, block, last_index, n); dnxhd_encode_block(ctx, block, last_index, n);
// STOP_TIMER("encode_block"); // STOP_TIMER("encode_block");
@ -636,7 +713,8 @@ static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
} }
} }
static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr) static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
int jobnr, int threadnr)
{ {
DNXHDEncContext *ctx = avctx->priv_data; DNXHDEncContext *ctx = avctx->priv_data;
int mb_y = jobnr, mb_x, x, y; int mb_y = jobnr, mb_x, x, y;
@ -674,7 +752,8 @@ static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int
} else { // 10-bit } else { // 10-bit
int const linesize = ctx->m.linesize >> 1; int const linesize = ctx->m.linesize >> 1;
for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) { 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); uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
((mb_y << 4) * linesize) + (mb_x << 4);
unsigned mb = mb_y * ctx->m.mb_width + mb_x; unsigned mb = mb_y * ctx->m.mb_width + mb_x;
int sum = 0; int sum = 0;
int sqsum = 0; int sqsum = 0;
@ -708,7 +787,8 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
for (q = 1; q < avctx->qmax; q++) { for (q = 1; q < avctx->qmax; q++) {
ctx->qscale = q; ctx->qscale = q;
avctx->execute2(avctx, dnxhd_calc_bits_thread, NULL, NULL, ctx->m.mb_height); avctx->execute2(avctx, dnxhd_calc_bits_thread,
NULL, NULL, ctx->m.mb_height);
} }
up_step = down_step = 2 << LAMBDA_FRAC_BITS; up_step = down_step = 2 << LAMBDA_FRAC_BITS;
lambda = ctx->lambda; lambda = ctx->lambda;
@ -741,7 +821,8 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
if (bits > ctx->frame_bits) if (bits > ctx->frame_bits)
break; break;
} }
//av_dlog(ctx->m.avctx, "lambda %d, up %u, down %u, bits %d, frame %d\n", // 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); // lambda, last_higher, last_lower, bits, ctx->frame_bits);
if (end) { if (end) {
if (bits > ctx->frame_bits) if (bits > ctx->frame_bits)
@ -791,7 +872,8 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
bits = 0; bits = 0;
ctx->qscale = qscale; ctx->qscale = qscale;
// XXX avoid recalculating bits // XXX avoid recalculating bits
ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread, NULL, NULL, ctx->m.mb_height); ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread,
NULL, NULL, ctx->m.mb_height);
for (y = 0; y < ctx->m.mb_height; y++) { for (y = 0; y < ctx->m.mb_height; y++) {
for (x = 0; x < ctx->m.mb_width; x++) for (x = 0; x < ctx->m.mb_width; x++)
bits += ctx->mb_rc[qscale][y*ctx->m.mb_width+x].bits; bits += ctx->mb_rc[qscale][y*ctx->m.mb_width+x].bits;
@ -799,8 +881,10 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
if (bits > ctx->frame_bits) if (bits > ctx->frame_bits)
break; break;
} }
//av_dlog(ctx->m.avctx, "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n", // av_dlog(ctx->m.avctx,
// ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits, last_higher, last_lower); // "%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 (bits < ctx->frame_bits) {
if (qscale == 1) if (qscale == 1)
return 1; return 1;
@ -845,7 +929,8 @@ static inline int get_bucket(int value, int shift)
return NBUCKETS - 1 - value; return NBUCKETS - 1 - value;
} }
static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASSES][NBUCKETS]) static void radix_count(const RCCMPEntry *data, int size,
int buckets[RADIX_PASSES][NBUCKETS])
{ {
int i, j; int i, j;
memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS); memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS);
@ -865,7 +950,8 @@ static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASS
} }
} }
static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data, int size, int buckets[NBUCKETS], int pass) static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data,
int size, int buckets[NBUCKETS], int pass)
{ {
int shift = pass * BUCKET_BITS; int shift = pass * BUCKET_BITS;
int i; int i;
@ -904,10 +990,13 @@ static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale][mb].bits; ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale][mb].bits;
max_bits += ctx->mb_rc[ctx->qscale][mb].bits; max_bits += ctx->mb_rc[ctx->qscale][mb].bits;
if (!RC_VARIANCE) { if (!RC_VARIANCE) {
delta_bits = ctx->mb_rc[ctx->qscale][mb].bits-ctx->mb_rc[ctx->qscale+1][mb].bits; delta_bits = ctx->mb_rc[ctx->qscale][mb].bits -
ctx->mb_rc[ctx->qscale + 1][mb].bits;
ctx->mb_cmp[mb].mb = mb; ctx->mb_cmp[mb].mb = mb;
ctx->mb_cmp[mb].value = delta_bits ? ctx->mb_cmp[mb].value =
((ctx->mb_rc[ctx->qscale][mb].ssd-ctx->mb_rc[ctx->qscale+1][mb].ssd)*100)/delta_bits delta_bits ? ((ctx->mb_rc[ctx->qscale][mb].ssd -
ctx->mb_rc[ctx->qscale + 1][mb].ssd) * 100) /
delta_bits
: INT_MIN; // avoid increasing qscale : INT_MIN; // avoid increasing qscale
} }
} }
@ -915,11 +1004,13 @@ static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
} }
if (!ret) { if (!ret) {
if (RC_VARIANCE) if (RC_VARIANCE)
avctx->execute2(avctx, dnxhd_mb_var_thread, NULL, NULL, ctx->m.mb_height); avctx->execute2(avctx, dnxhd_mb_var_thread,
NULL, NULL, ctx->m.mb_height);
radix_sort(ctx->mb_cmp, ctx->m.mb_num); radix_sort(ctx->mb_cmp, ctx->m.mb_num);
for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) { for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
int mb = ctx->mb_cmp[x].mb; int mb = ctx->mb_cmp[x].mb;
max_bits -= ctx->mb_rc[ctx->qscale][mb].bits - ctx->mb_rc[ctx->qscale+1][mb].bits; max_bits -= ctx->mb_rc[ctx->qscale][mb].bits -
ctx->mb_rc[ctx->qscale + 1][mb].bits;
ctx->mb_qscale[mb] = ctx->qscale + 1; ctx->mb_qscale[mb] = ctx->qscale + 1;
ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale + 1][mb].bits; ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale + 1][mb].bits;
} }
@ -987,7 +1078,8 @@ static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height); avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
av_assert1(640 + offset + 4 <= ctx->cid_table->coding_unit_size); av_assert1(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
memset(buf + 640 + offset, 0, ctx->cid_table->coding_unit_size - 4 - offset - 640); memset(buf + 640 + offset, 0,
ctx->cid_table->coding_unit_size - 4 - offset - 640);
AV_WB32(buf + ctx->cid_table->coding_unit_size - 4, 0x600DC0DE); // EOF AV_WB32(buf + ctx->cid_table->coding_unit_size - 4, 0x600DC0DE); // EOF
@ -1051,9 +1143,11 @@ AVCodec ff_dnxhd_encoder = {
.encode2 = dnxhd_encode_picture, .encode2 = dnxhd_encode_picture,
.close = dnxhd_encode_end, .close = dnxhd_encode_end,
.capabilities = CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV422P, .pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_YUV422P,
AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P10,
AV_PIX_FMT_NONE }, AV_PIX_FMT_NONE
},
.priv_class = &dnxhd_class, .priv_class = &dnxhd_class,
.defaults = dnxhd_defaults, .defaults = dnxhd_defaults,
}; };

Write Preview
Loading…
Cancel
Save