27 #define RC_VARIANCE 1 // use variance or ssd for fast rc
36 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
37 #define DNX10BIT_QMAT_SHIFT 18 // The largest value that will not lead to overflow for 10bit samples.
45 #define LAMBDA_FRAC_BITS 10
50 for (i = 0; i < 4; i++) {
51 block[0] = pixels[0]; block[1] = pixels[1];
52 block[2] = pixels[2]; block[3] = pixels[3];
53 block[4] = pixels[4]; block[5] = pixels[5];
54 block[6] = pixels[6]; block[7] = pixels[7];
58 memcpy(block, block - 8,
sizeof(*block) * 8);
59 memcpy(block + 8, block - 16,
sizeof(*block) * 8);
60 memcpy(block + 16, block - 24,
sizeof(*block) * 8);
61 memcpy(block + 24, block - 32,
sizeof(*block) * 8);
70 for (i = 0; i < 4; i++) {
71 memcpy(block + i * 8, pixels + i * line_size, 8 *
sizeof(*block));
72 memcpy(block - (i+1) * 8, pixels + i * line_size, 8 *
sizeof(*block));
77 int n,
int qscale,
int *overflow)
81 int last_non_zero = 0;
87 block[0] = (block[0] + 2) >> 2;
89 for (i = 1; i < 64; ++i) {
91 int sign = block[j] >> 31;
92 int level = (block[j] ^ sign) - sign;
94 block[j] = (level ^ sign) - sign;
114 for (level = -max_level; level < max_level; level++) {
115 for (run = 0; run < 2; run++) {
116 int index = (level<<1)|run;
117 int sign, offset = 0, alevel =
level;
121 offset = (alevel-1)>>6;
124 for (j = 0; j < 257; j++) {
139 assert(!alevel || j < 257);
146 for (i = 0; i < 62; i++) {
160 uint16_t weight_matrix[64] = {1,};
171 for (i = 1; i < 64; i++) {
177 for (i = 1; i < 64; i++) {
184 for (qscale = 1; qscale <= ctx->
m.
avctx->
qmax; qscale++) {
185 for (i = 0; i < 64; i++) {
193 for (qscale = 1; qscale <= ctx->
m.
avctx->
qmax; qscale++) {
194 for (i = 1; i < 64; i++) {
233 int i,
index, bit_depth;
333 const uint8_t header_prefix[5] = { 0x00,0x00,0x02,0x80,0x01 };
337 memcpy(buf, header_prefix, 5);
357 ctx->
msip = buf + 0x170;
365 nbits = av_log2_16bit(-2*diff);
368 nbits = av_log2_16bit(2*diff);
376 int last_non_zero = 0;
382 for (i = 1; i <= last_index; i++) {
386 int run_level = i - last_non_zero - 1;
387 int rlevel = (slevel<<1)|!!run_level;
399 const uint8_t *weight_matrix;
405 for (i = 1; i <= last_index; i++) {
410 level = (1-2*
level) * qscale * weight_matrix[i];
412 if (weight_matrix[i] != 8)
416 if (weight_matrix[i] != 32)
422 level = (2*level+1) * qscale * weight_matrix[i];
424 if (weight_matrix[i] != 8)
428 if (weight_matrix[i] != 32)
442 for (i = 0; i < 64; i++)
443 score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
449 int last_non_zero = 0;
452 for (i = 1; i <= last_index; i++) {
456 int run_level = i - last_non_zero - 1;
467 const int bw = 1 << bs;
468 const uint8_t *ptr_y = ctx->
thread[0]->
src[0] + ((mb_y << 4) * ctx->
m.
linesize) + (mb_x << bs+1);
469 const uint8_t *ptr_u = ctx->
thread[0]->
src[1] + ((mb_y << 4) * ctx->
m.
uvlinesize) + (mb_x << bs);
470 const uint8_t *ptr_v = ctx->
thread[0]->
src[2] + ((mb_y << 4) * ctx->
m.
uvlinesize) + (mb_x << bs);
514 int mb_y = jobnr, mb_x;
517 ctx = ctx->
thread[threadnr];
523 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
524 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
532 for (i = 0; i < 8; i++) {
534 int overflow, nbits, diff, last_index;
542 if (diff < 0) nbits = av_log2_16bit(-2*diff);
543 else nbits = av_log2_16bit( 2*diff);
545 assert(nbits < ctx->cid_table->bit_depth + 4);
565 int mb_y = jobnr, mb_x;
566 ctx = ctx->
thread[threadnr];
572 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
573 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
581 for (i = 0; i < 8; i++) {
601 for (mb_y = 0; mb_y < ctx->
m.
mb_height; mb_y++) {
605 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
606 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
612 offset += thread_size;
619 int mb_y = jobnr, mb_x;
620 ctx = ctx->
thread[threadnr];
623 for (mb_x = 0; mb_x < ctx->
m.
mb_width; ++mb_x, pix += 16) {
624 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
631 int const linesize = ctx->
m.
linesize >> 1;
632 for (mb_x = 0; mb_x < ctx->
m.
mb_width; ++mb_x) {
633 uint16_t *pix = (uint16_t*)ctx->
thread[0]->
src[0] + ((mb_y << 4) * linesize) + (mb_x << 4);
634 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
640 for (i = 0; i < 16; ++i) {
641 for (j = 0; j < 16; ++j) {
643 int const sample = (unsigned)pix[j] >> 6;
645 sqsum += sample * sample;
661 int lambda, up_step, down_step;
662 int last_lower = INT_MAX, last_higher = 0;
665 for (q = 1; q < avctx->
qmax; q++) {
675 if (lambda == last_higher) {
681 unsigned min = UINT_MAX;
684 for (q = 1; q < avctx->
qmax; q++) {
685 unsigned score = ctx->
mb_rc[q][mb].
bits*lambda+
696 bits = (bits+31)&~31;
707 if (bits < ctx->frame_bits) {
708 last_lower =
FFMIN(lambda, last_lower);
709 if (last_higher != 0)
710 lambda = (lambda+last_higher)>>1;
713 down_step =
FFMIN((int64_t)down_step*5, INT_MAX);
715 lambda =
FFMAX(1, lambda);
716 if (lambda == last_lower)
719 last_higher =
FFMAX(lambda, last_higher);
720 if (last_lower != INT_MAX)
721 lambda = (lambda+last_lower)>>1;
722 else if ((int64_t)lambda + up_step > INT_MAX)
726 up_step =
FFMIN((int64_t)up_step*5, INT_MAX);
741 int last_lower = INT_MAX;
754 bits = (bits+31)&~31;
760 if (bits < ctx->frame_bits) {
763 if (last_higher == qscale - 1) {
764 qscale = last_higher;
767 last_lower =
FFMIN(qscale, last_lower);
768 if (last_higher != 0)
769 qscale = (qscale+last_higher)>>1;
771 qscale -= down_step++;
776 if (last_lower == qscale + 1)
778 last_higher =
FFMAX(qscale, last_higher);
779 if (last_lower != INT_MAX)
780 qscale = (qscale+last_lower)>>1;
793 #define BUCKET_BITS 8
794 #define RADIX_PASSES 4
795 #define NBUCKETS (1 << BUCKET_BITS)
807 memset(buckets, 0,
sizeof(buckets[0][0]) *
RADIX_PASSES * NBUCKETS);
808 for (i = 0; i <
size; i++) {
818 for (i = NBUCKETS - 1; i >= 0; i--)
819 buckets[j][i] = offset -= buckets[j][i];
820 assert(!buckets[j][0]);
828 for (i = 0; i <
size; i++) {
830 int pos = buckets[
v]++;
890 for (i = 0; i < 3; i++) {
912 if (buf_size < ctx->cid_table->frame_size) {
920 for (i = 0; i < 3; i++) {
934 "picture could not fit ratecontrol constraints, increase qmax\n");
959 goto encode_coding_unit;
1007 .priv_class = &
class,
static int dnxhd_encode_end(AVCodecContext *avctx)
static av_always_inline int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, DCTELEM *block, int last_index)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASSES][NBUCKETS])
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
int(* dct_quantize)(struct MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
static int dnxhd_encode_init(AVCodecContext *avctx)
const uint8_t ff_zigzag_direct[64]
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
av_cold int ff_dct_common_init(MpegEncContext *s)
const uint8_t * luma_weight
AVFrame * coded_frame
the picture in the bitstream
const CIDEntry ff_dnxhd_cid_table[]
const uint16_t * run_codes
void ff_convert_matrix(DSPContext *dsp, int(*qmat)[64], uint16_t(*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
int ff_dnxhd_find_cid(AVCodecContext *avctx, int bit_depth)
int intra_quant_bias
intra quantizer bias
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static const AVOption options[]
int mb_num
number of MBs of a picture
struct DNXHDEncContext * thread[MAX_THREADS]
int h263_aic
Advanded INTRA Coding (AIC)
int(* pix_sum)(uint8_t *pix, int line_size)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int get_bucket(int value, int shift)
static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
static void dnxhd_8bit_get_pixels_8x4_sym(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data, int size, int buckets[NBUCKETS], int pass)
uint8_t idct_permutation[64]
idct input permutation.
const uint8_t * scantable
int interlaced_frame
The content of the picture is interlaced.
int mb_height
number of MBs horizontally & vertically
unsigned int coding_unit_size
#define LOCAL_ALIGNED_16(t, v,...)
const uint8_t * ac_index_flag
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
static int init(AVCodecParserContext *s)
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)
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
int ff_dnxhd_get_cid_table(int cid)
int last_dc[3]
last DC values for MPEG1
static int dnxhd_find_qscale(DNXHDEncContext *ctx)
static int dnxhd_init_vlc(DNXHDEncContext *ctx)
static int dnxhd_init_rc(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 int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static av_always_inline void dnxhd_10bit_get_pixels_8x4_sym(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
void(* clear_block)(DCTELEM *block)
void(* idct)(DCTELEM *block)
static int put_bits_count(PutBitContext *s)
const uint8_t * chroma_weight
The simplest mpeg encoder (well, it was the simplest!).
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
MpegEncContext m
Used for quantization dsp functions.
int intra_quant_bias
bias for the quantizer
int width
picture width / height.
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.
int mb_decision
macroblock decision mode
void(* get_pixels_8x4_sym)(DCTELEM *, const uint8_t *, int)
static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, DCTELEM *block, int n, int qscale, int last_index)
#define MASK_ABS(mask, level)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
static void radix_sort(RCCMPEntry *data, int size)
static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
#define PIX_FMT_YUV422P10
const uint8_t * ac_run_flag
main external API structure.
static void close(AVCodecParserContext *s)
struct DNXHDEncContext DNXHDEncContext
ScanTable intra_scantable
#define FF_DEFAULT_QUANT_BIAS
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Describe the class of an AVClass context structure.
#define FF_MB_DECISION_RD
rate distortion
DSPContext dsp
pointers for accelerated dsp functions
int(* pix_norm1)(uint8_t *pix, int line_size)
static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
const CIDEntry * cid_table
uint16_t(* qmatrix_c16)[2][64]
static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, DCTELEM *block, int n, int qscale, int *overflow)
static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
#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)
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
void(* fdct)(DCTELEM *block)
static int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
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.
static av_always_inline void dnxhd_encode_block(DNXHDEncContext *ctx, DCTELEM *block, int last_index, int n)
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
int key_frame
1 -> keyframe, 0-> not
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
int linesize
line size, in bytes, may be different from width
int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
static int dnxhd_encode_picture(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data)
static int first_field(int fd)
int uvlinesize
line size, for chroma in bytes, may be different from width
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
void ff_dnxhd_init_mmx(DNXHDEncContext *ctx)
static av_always_inline int dnxhd_ssd_block(DCTELEM *qblock, DCTELEM *block)