26 #define RC_VARIANCE 1 // use variance or ssd for fast rc
38 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
39 #define DNX10BIT_QMAT_SHIFT 18 // The largest value that will not lead to overflow for 10bit samples.
47 #define LAMBDA_FRAC_BITS 10
52 for (i = 0; i < 4; i++) {
53 block[0] = pixels[0]; block[1] = pixels[1];
54 block[2] = pixels[2]; block[3] = pixels[3];
55 block[4] = pixels[4]; block[5] = pixels[5];
56 block[6] = pixels[6]; block[7] = pixels[7];
60 memcpy(block, block - 8,
sizeof(*block) * 8);
61 memcpy(block + 8, block - 16,
sizeof(*block) * 8);
62 memcpy(block + 16, block - 24,
sizeof(*block) * 8);
63 memcpy(block + 24, block - 32,
sizeof(*block) * 8);
72 for (i = 0; i < 4; i++) {
73 memcpy(block + i * 8, pixels + i * line_size, 8 *
sizeof(*block));
74 memcpy(block - (i+1) * 8, pixels + i * line_size, 8 *
sizeof(*block));
79 int n,
int qscale,
int *overflow)
83 int last_non_zero = 0;
89 block[0] = (block[0] + 2) >> 2;
91 for (i = 1; i < 64; ++i) {
93 int sign = block[j] >> 31;
94 int level = (block[j] ^ sign) - sign;
96 block[j] = (level ^ sign) - sign;
101 return last_non_zero;
116 for (level = -max_level; level < max_level; level++) {
117 for (run = 0; run < 2; run++) {
118 int index = (level<<1)|run;
119 int sign, offset = 0, alevel =
level;
123 offset = (alevel-1)>>6;
126 for (j = 0; j < 257; j++) {
141 assert(!alevel || j < 257);
148 for (i = 0; i < 62; i++) {
162 uint16_t weight_matrix[64] = {1,};
173 for (i = 1; i < 64; i++) {
179 for (i = 1; i < 64; i++) {
186 for (qscale = 1; qscale <= ctx->
m.
avctx->
qmax; qscale++) {
187 for (i = 0; i < 64; i++) {
195 for (qscale = 1; qscale <= ctx->
m.
avctx->
qmax; qscale++) {
196 for (i = 1; i < 64; i++) {
235 int i,
index, bit_depth;
337 const uint8_t header_prefix[5] = { 0x00,0x00,0x02,0x80,0x01 };
341 memcpy(buf, header_prefix, 5);
361 ctx->
msip = buf + 0x170;
380 int last_non_zero = 0;
386 for (i = 1; i <= last_index; i++) {
390 int run_level = i - last_non_zero - 1;
391 int rlevel = (slevel<<1)|!!run_level;
409 for (i = 1; i <= last_index; i++) {
414 level = (1-2*
level) * qscale * weight_matrix[i];
416 if (weight_matrix[i] != 8)
420 if (weight_matrix[i] != 32)
426 level = (2*level+1) * qscale * weight_matrix[i];
428 if (weight_matrix[i] != 8)
432 if (weight_matrix[i] != 32)
446 for (i = 0; i < 64; i++)
447 score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
453 int last_non_zero = 0;
456 for (i = 1; i <= last_index; i++) {
460 int run_level = i - last_non_zero - 1;
471 const int bw = 1 << bs;
518 int mb_y = jobnr, mb_x;
521 ctx = ctx->
thread[threadnr];
527 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
528 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
536 for (i = 0; i < 8; i++) {
537 int16_t *src_block = ctx->
blocks[i];
538 int overflow, nbits, diff, last_index;
549 assert(nbits < ctx->cid_table->bit_depth + 4);
569 int mb_y = jobnr, mb_x;
570 ctx = ctx->
thread[threadnr];
576 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
577 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
585 for (i = 0; i < 8; i++) {
605 for (mb_y = 0; mb_y < ctx->
m.
mb_height; mb_y++) {
609 for (mb_x = 0; mb_x < ctx->
m.
mb_width; mb_x++) {
610 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
616 offset += thread_size;
623 int mb_y = jobnr, mb_x, x, y;
624 int partial_last_row = (mb_y == ctx->
m.
mb_height - 1) &&
627 ctx = ctx->
thread[threadnr];
630 for (mb_x = 0; mb_x < ctx->
m.
mb_width; ++mb_x, pix += 16) {
631 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
635 if (!partial_last_row && mb_x * 16 <= avctx->
width - 16) {
642 for (y = 0; y < bh; y++) {
643 for (x = 0; x < bw; x++) {
650 varc = (varc - (((unsigned)sum * sum) >> 8) + 128) >> 8;
656 int const linesize = ctx->
m.
linesize >> 1;
657 for (mb_x = 0; mb_x < ctx->
m.
mb_width; ++mb_x) {
658 uint16_t *pix = (uint16_t*)ctx->
thread[0]->
src[0] + ((mb_y << 4) * linesize) + (mb_x << 4);
659 unsigned mb = mb_y * ctx->
m.
mb_width + mb_x;
665 for (i = 0; i < 16; ++i) {
666 for (j = 0; j < 16; ++j) {
668 int const sample = (unsigned)pix[j] >> 6;
686 int lambda, up_step, down_step;
687 int last_lower = INT_MAX, last_higher = 0;
690 for (q = 1; q < avctx->
qmax; q++) {
700 if (lambda == last_higher) {
706 unsigned min = UINT_MAX;
709 for (q = 1; q < avctx->
qmax; q++) {
710 unsigned score = ctx->
mb_rc[q][mb].
bits*lambda+
721 bits = (bits+31)&~31;
732 if (bits < ctx->frame_bits) {
733 last_lower =
FFMIN(lambda, last_lower);
734 if (last_higher != 0)
735 lambda = (lambda+last_higher)>>1;
738 down_step =
FFMIN((int64_t)down_step*5, INT_MAX);
740 lambda =
FFMAX(1, lambda);
741 if (lambda == last_lower)
744 last_higher =
FFMAX(lambda, last_higher);
745 if (last_lower != INT_MAX)
746 lambda = (lambda+last_lower)>>1;
747 else if ((int64_t)lambda + up_step > INT_MAX)
751 up_step =
FFMIN((int64_t)up_step*5, INT_MAX);
766 int last_lower = INT_MAX;
779 bits = (bits+31)&~31;
785 if (bits < ctx->frame_bits) {
788 if (last_higher == qscale - 1) {
789 qscale = last_higher;
792 last_lower =
FFMIN(qscale, last_lower);
793 if (last_higher != 0)
794 qscale = (qscale+last_higher)>>1;
796 qscale -= down_step++;
801 if (last_lower == qscale + 1)
803 last_higher =
FFMAX(qscale, last_higher);
804 if (last_lower != INT_MAX)
805 qscale = (qscale+last_lower)>>1;
818 #define BUCKET_BITS 8
819 #define RADIX_PASSES 4
820 #define NBUCKETS (1 << BUCKET_BITS)
832 memset(buckets, 0,
sizeof(buckets[0][0]) *
RADIX_PASSES * NBUCKETS);
833 for (i = 0; i <
size; i++) {
834 int v = data[i].
value;
843 for (i = NBUCKETS - 1; i >= 0; i--)
844 buckets[j][i] = offset -= buckets[j][i];
845 assert(!buckets[j][0]);
853 for (i = 0; i <
size; i++) {
855 int pos = buckets[v]++;
927 const AVFrame *frame,
int *got_packet)
943 for (i = 0; i < 3; i++) {
957 "picture could not fit ratecontrol constraints, increase qmax\n");
981 goto encode_coding_unit;
1035 .priv_class = &
class,