41 #define DNX10BIT_QMAT_SHIFT 18
42 #define RC_VARIANCE 1 // use variance or ssd for fast rc
43 #define LAMBDA_FRAC_BITS 10
45 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
47 {
"nitris_compat",
"encode with Avid Nitris compatibility",
49 {
"ibias",
"intra quant bias",
51 { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
56 0, 0,
VE,
"profile" },
58 0, 0,
VE,
"profile" },
60 0, 0,
VE,
"profile" },
62 0, 0,
VE,
"profile" },
64 0, 0,
VE,
"profile" },
66 0, 0,
VE,
"profile" },
82 for (i = 0; i < 4; i++) {
94 memcpy(block, block - 8,
sizeof(*block) * 8);
95 memcpy(block + 8, block - 16,
sizeof(*block) * 8);
96 memcpy(block + 16, block - 24,
sizeof(*block) * 8);
97 memcpy(block + 24, block - 32,
sizeof(*block) * 8);
105 memcpy(block + 0 * 8, pixels + 0 * line_size, 8 *
sizeof(*block));
106 memcpy(block + 7 * 8, pixels + 0 * line_size, 8 *
sizeof(*block));
107 memcpy(block + 1 * 8, pixels + 1 * line_size, 8 *
sizeof(*block));
108 memcpy(block + 6 * 8, pixels + 1 * line_size, 8 *
sizeof(*block));
109 memcpy(block + 2 * 8, pixels + 2 * line_size, 8 *
sizeof(*block));
110 memcpy(block + 5 * 8, pixels + 2 * line_size, 8 *
sizeof(*block));
111 memcpy(block + 3 * 8, pixels + 3 * line_size, 8 *
sizeof(*block));
112 memcpy(block + 4 * 8, pixels + 3 * line_size, 8 *
sizeof(*block));
116 int n,
int qscale,
int *overflow)
118 int i, j,
level, last_non_zero, start_i;
123 unsigned int threshold1, threshold2;
127 block[0] = (block[0] + 2) >> 2;
132 threshold1 = (1 << 16) - bias - 1;
133 threshold2 = (threshold1 << 1);
135 for (i = 63; i >= start_i; i--) {
137 level = block[j] * qmat[j];
139 if (((
unsigned)(level + threshold1)) > threshold2) {
147 for (i = start_i; i <= last_non_zero; i++) {
149 level = block[j] * qmat[j];
151 if (((
unsigned)(level + threshold1)) > threshold2) {
153 level = (bias +
level) >> 16;
156 level = (bias -
level) >> 16;
169 scantable, last_non_zero);
171 return last_non_zero;
175 int n,
int qscale,
int *overflow)
179 int last_non_zero = 0;
185 block[0] = (block[0] + 2) >> 2;
187 for (i = 1; i < 64; ++i) {
188 int j = scantable[i];
190 int level = (block[j] ^ sign) - sign;
192 block[j] = (level ^ sign) - sign;
200 scantable, last_non_zero);
202 return last_non_zero;
208 int max_level = 1 << (ctx->
bit_depth + 2);
221 for (level = -max_level; level < max_level; level++) {
222 for (run = 0; run < 2; run++) {
223 int index = (level << 1) | run;
228 offset = (alevel - 1) >> 6;
229 alevel -= offset << 6;
231 for (j = 0; j < 257; j++) {
255 for (i = 0; i < 62; i++) {
269 uint16_t weight_matrix[64] = { 1, };
279 (ctx->
m.
avctx->
qmax + 1), 64 * 2 *
sizeof(uint16_t),
282 (ctx->
m.
avctx->
qmax + 1), 64 * 2 *
sizeof(uint16_t),
286 for (i = 1; i < 64; i++) {
293 for (i = 1; i < 64; i++) {
301 for (qscale = 1; qscale <= ctx->
m.
avctx->
qmax; qscale++) {
302 for (i = 0; i < 64; i++) {
313 for (qscale = 1; qscale <= ctx->
m.
avctx->
qmax; qscale++) {
314 for (i = 1; i < 64; i++) {
329 (qscale * luma_weight_table[i]);
331 (qscale * chroma_weight_table[i]);
368 result = (result + 2048) / 4096 * 4096;
369 return FFMAX(result, 8192);
388 "pixel format is incompatible with DNxHD\n");
397 "pixel format is incompatible with DNxHD profile\n");
403 "pixel format is incompatible with DNxHR HQX profile\n");
411 "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
420 "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
426 if (ctx->
cid >= 1270 && ctx->
cid <= 1274)
431 "Input dimensions too small, input must be at least 256x120\n");
499 #if FF_API_QUANT_BIAS
528 #if FF_API_CODED_FRAME
540 if (avctx->
qmax <= 1) {
564 if (ctx->
cid >= 1270 && ctx->
cid <= 1274)
576 buf[0x21] = ctx->
bit_depth == 10 ? 0x58 : 0x38;
588 ctx->
msip = buf + 0x170;
603 av_mod_uintp2(diff, nbits));
608 int last_index,
int n)
610 int last_non_zero = 0;
616 for (i = 1; i <= last_index; i++) {
620 int run_level = i - last_non_zero - 1;
621 int rlevel = (slevel << 1) | !!run_level;
634 int qscale,
int last_index)
648 for (i = 1; i <= last_index; i++) {
653 level = (1 - 2 *
level) * qscale * weight_matrix[i];
655 if (weight_matrix[i] != 8)
659 if (weight_matrix[i] != 32)
665 level = (2 * level + 1) * qscale * weight_matrix[i];
667 if (weight_matrix[i] != 8)
671 if (weight_matrix[i] != 32)
685 for (i = 0; i < 64; i++)
686 score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
693 int last_non_zero = 0;
696 for (i = 1; i <= last_index; i++) {
700 int run_level = i - last_non_zero - 1;
701 bits += ctx->
vlc_bits[(level << 1) |
702 !!run_level] + ctx->
run_bits[run_level];
713 const int bw = 1 << bs;
719 ((mb_y << 4) * ctx->
m.
linesize) + (mb_x << bs + 1);
731 int uv_w = (y_w + 1) / 2;
749 dct_y_offset = bw * linesize;
750 dct_uv_offset = bw * uvlinesize;
758 int uv_w = ctx->
is_444 ? y_w : (y_w + 1) / 2;
761 uvlinesize = 8 + 8 * ctx->
is_444;
776 dct_y_offset = bw * linesize;
777 dct_uv_offset = bw * uvlinesize;
792 ptr_y + dct_y_offset,
795 ptr_y + dct_y_offset + bw,
798 ptr_u + dct_uv_offset,
801 ptr_v + dct_uv_offset,
811 ptr_y + dct_y_offset, linesize);
813 ptr_y + dct_y_offset + bw, linesize);
815 ptr_u + dct_uv_offset, uvlinesize);
817 ptr_v + dct_uv_offset, uvlinesize);
845 const static uint8_t component[8]={0,0,1,2,0,0,1,2};
852 int jobnr,
int threadnr)
855 int mb_y = jobnr, mb_x;
858 ctx = ctx->
thread[threadnr];
864 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
873 for (i = 0; i < 8 + 4 * ctx->
is_444; i++) {
874 int16_t *src_block = ctx->
blocks[i];
875 int overflow, nbits,
diff, last_index;
878 memcpy(
block, src_block, 64 *
sizeof(*
block));
880 ctx->
is_444 ? 4 * (n > 0): 4 & (2*i),
909 int jobnr,
int threadnr)
912 int mb_y = jobnr, mb_x;
913 ctx = ctx->
thread[threadnr];
920 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
930 for (i = 0; i < 8 + 4 * ctx->
is_444; i++) {
934 ctx->
is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
951 for (mb_y = 0; mb_y < ctx->
m.
mb_height; mb_y++) {
955 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
962 offset += thread_size;
967 int jobnr,
int threadnr)
970 int mb_y = jobnr, mb_x, x, y;
971 int partial_last_row = (mb_y == ctx->
m.
mb_height - 1) &&
974 ctx = ctx->
thread[threadnr];
977 for (mb_x = 0; mb_x < ctx->
m.
mb_width; ++mb_x, pix += 16) {
982 if (!partial_last_row && mb_x * 16 <= avctx->
width - 16 && (avctx->
width % 16) == 0) {
989 for (y = 0; y < bh; y++) {
990 for (x = 0; x < bw; x++) {
997 varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8;
1003 const int linesize = ctx->
m.
linesize >> 1;
1004 for (mb_x = 0; mb_x < ctx->
m.
mb_width; ++mb_x) {
1005 uint16_t *pix = (uint16_t *)ctx->
thread[0]->
src[0] +
1006 ((mb_y << 4) * linesize) + (mb_x << 4);
1010 int bw =
FFMIN(avctx->
width - 16 * mb_x, 16);
1015 for (i = 0; i < bh; ++i) {
1016 for (j = 0; j < bw; ++j) {
1018 const int sample = (unsigned) pix[j] >> 6;
1020 sqsum += sample *
sample;
1026 sqmean = sqsum >> 8;
1036 int lambda, up_step, down_step;
1037 int last_lower = INT_MAX, last_higher = 0;
1040 for (q = 1; q < avctx->
qmax; q++) {
1051 if (lambda == last_higher) {
1057 unsigned min = UINT_MAX;
1061 for (q = 1; q < avctx->
qmax; q++) {
1062 int i = (q*ctx->
m.
mb_num) + mb;
1063 unsigned score = ctx->
mb_rc[i].
bits * lambda +
1075 bits = (bits + 31) & ~31;
1084 if (bits < ctx->frame_bits) {
1085 last_lower =
FFMIN(lambda, last_lower);
1086 if (last_higher != 0)
1087 lambda = (lambda+last_higher)>>1;
1089 lambda -= down_step;
1090 down_step =
FFMIN((int64_t)down_step*5, INT_MAX);
1092 lambda =
FFMAX(1, lambda);
1093 if (lambda == last_lower)
1096 last_higher =
FFMAX(lambda, last_higher);
1097 if (last_lower != INT_MAX)
1098 lambda = (lambda+last_lower)>>1;
1099 else if ((int64_t)lambda + up_step > INT_MAX)
1103 up_step =
FFMIN((int64_t)up_step*5, INT_MAX);
1116 int last_higher = 0;
1117 int last_lower = INT_MAX;
1131 bits = (bits+31)&~31;
1135 if (bits < ctx->frame_bits) {
1138 if (last_higher == qscale - 1) {
1139 qscale = last_higher;
1142 last_lower =
FFMIN(qscale, last_lower);
1143 if (last_higher != 0)
1144 qscale = (qscale + last_higher) >> 1;
1146 qscale -= down_step++;
1151 if (last_lower == qscale + 1)
1153 last_higher =
FFMAX(qscale, last_higher);
1154 if (last_lower != INT_MAX)
1155 qscale = (qscale + last_lower) >> 1;
1157 qscale += up_step++;
1167 #define BUCKET_BITS 8
1168 #define RADIX_PASSES 4
1169 #define NBUCKETS (1 << BUCKET_BITS)
1182 memset(buckets, 0,
sizeof(buckets[0][0]) *
RADIX_PASSES * NBUCKETS);
1183 for (i = 0; i <
size; i++) {
1184 int v = data[i].
value;
1193 for (i = NBUCKETS - 1; i >= 0; i--)
1194 buckets[j][i] = offset -= buckets[j][i];
1204 for (i = 0; i <
size; i++) {
1206 int pos = buckets[v]++;
1242 delta_bits ? ((ctx->
mb_rc[rc].
ssd -
1278 #if FF_API_CODED_FRAME
1301 for (i = 0; i < 3; i++) {
1315 "picture could not fit ratecontrol constraints, increase qmax\n");
1340 goto encode_coding_unit;
1343 #if FF_API_CODED_FRAME
1359 int max_level = 1 << (ctx->
bit_depth + 2);
static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
#define MASK_ABS(mask, level)
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASSES][NBUCKETS])
const char const char void * val
attribute_deprecated int intra_quant_bias
static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
static int shift(int a, int b)
This structure describes decoded (raw) audio or video data.
#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
ptrdiff_t const GLvoid * data
void(* clear_block)(int16_t *block)
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
const uint8_t * luma_weight
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
uint16_t(* q_chroma_intra_matrix16)[2][64]
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
#define AV_PIX_FMT_GBRP10
const CIDEntry ff_dnxhd_cid_table[]
const uint16_t * run_codes
static const AVClass dnxhd_class
void ff_convert_matrix(MpegEncContext *s, int(*qmat)[64], uint16_t(*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
int ff_dnxhd_find_cid(AVCodecContext *avctx, int bit_depth)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int mb_num
number of MBs of a picture
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
struct DNXHDEncContext * thread[MAX_THREADS]
int av_log2_16bit(unsigned v)
static av_always_inline int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
int h263_aic
Advanced INTRA Coding (AIC)
Macro definitions for various function/variable attributes.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permutation.
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
static int get_bucket(int value, int shift)
const AVProfile ff_dnxhd_profiles[]
static av_cold int end(AVCodecContext *avctx)
static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
int(* q_chroma_intra_matrix)[64]
static int dnxhd_get_hr_frame_size(const CIDEntry *profile, int mb_num)
static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data, int size, int buckets[NBUCKETS], int pass)
const uint8_t * scantable
int interlaced_frame
The content of the picture is interlaced.
av_cold void ff_mpv_idct_init(MpegEncContext *s)
int mb_height
number of MBs horizontally & vertically
static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
unsigned int coding_unit_size
int max_qcoeff
maximum encodable coefficient
high precision timer, useful to profile code
static int first_field(const struct video_data *s)
static av_cold int dnxhd_encode_end(AVCodecContext *avctx)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
static av_always_inline int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
const uint16_t * ac_codes
static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int ff_dnxhd_get_cid_table(int cid)
int last_dc[3]
last DC values for MPEG-1
static int dnxhd_find_qscale(DNXHDEncContext *ctx)
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n, int qscale, int last_index)
void(* get_pixels)(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t stride)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int flags
AV_CODEC_FLAG_*.
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
MpegvideoEncDSPContext mpvencdsp
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
#define FF_PROFILE_DNXHR_LB
static const uint8_t offset[127][2]
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
int flags
A combination of AV_PKT_FLAG values.
static int put_bits_count(PutBitContext *s)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
const uint8_t * chroma_weight
common internal API header
static const AVOption options[]
static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
enum AVPictureType pict_type
Picture type of the frame.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static const AVCodecDefault dnxhd_defaults[]
MpegEncContext m
Used for quantization dsp functions.
static av_always_inline void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block, int last_index, int n)
int intra_quant_bias
bias for the quantizer
int width
picture width / height.
int(* pix_sum)(uint8_t *pix, int line_size)
GLsizei GLboolean const GLfloat * value
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
static av_always_inline void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
uint16_t(* qmatrix_l16)[2][64]
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
uint8_t * msip
Macroblock Scan Indexes Payload.
uint8_t idct_permutation[64]
IDCT input permutation.
int mb_decision
macroblock decision mode
void ff_dnxhd_print_profiles(AVCodecContext *avctx, int loglevel)
#define FF_PROFILE_DNXHR_HQ
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Libavcodec external API header.
static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block, int n, int qscale, int *overflow)
ptrdiff_t linesize
line size, in bytes, may be different from width
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
void(* fdct)(int16_t *block)
main external API structure.
uint8_t edge_buf_uv[2][256]
ScanTable intra_scantable
#define FF_DEFAULT_QUANT_BIAS
int ff_dct_encode_init(MpegEncContext *s)
static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
void ff_dnxhdenc_init_x86(DNXHDEncContext *ctx)
Describe the class of an AVClass context structure.
int(* pix_norm1)(uint8_t *pix, int line_size)
#define FF_MB_DECISION_RD
rate distortion
const uint8_t ff_zigzag_direct[64]
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define FF_PROFILE_DNXHR_SQ
const CIDEntry * cid_table
uint16_t(* qmatrix_c16)[2][64]
static enum AVPixelFormat pix_fmts[]
static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
#define AV_PIX_FMT_YUV422P10
#define DNX10BIT_QMAT_SHIFT
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
struct AVCodecContext * avctx
PutBitContext pb
bit output
static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
#define FF_PROFILE_DNXHR_HQX
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block, int n, int qscale, int *overflow)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
#define FF_PROFILE_DNXHR_444
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define FF_ENABLE_DEPRECATION_WARNINGS
static void radix_sort(RCCMPEntry *data, RCCMPEntry *tmp, int size)
int top_field_first
If the content is interlaced, is top field displayed first.
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
void(* get_pixels_8x4_sym)(int16_t *av_restrictblock, const uint8_t *pixels, ptrdiff_t line_size)
int key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define LOCAL_ALIGNED_16(t, v,...)
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
#define MKTAG(a, b, c, d)
AVPixelFormat
Pixel format.
This structure stores compressed data.
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
enum idct_permutation_type perm_type
void(* idct)(int16_t *block)