73 uint16_t (*qmat16)[2][64],
74 const uint16_t *quant_matrix,
75 int bias,
int qmin,
int qmax,
int intra)
80 for (qscale = qmin; qscale <= qmax; qscale++) {
85 for (i = 0; i < 64; i++) {
94 (qscale * quant_matrix[j]));
97 for (i = 0; i < 64; i++) {
110 for (i = 0; i < 64; i++) {
118 (qscale * quant_matrix[j]));
122 (qscale * quant_matrix[j]);
124 if (qmat16[qscale][0][i] == 0 ||
125 qmat16[qscale][0][i] == 128 * 256)
126 qmat16[
qscale][0][i] = 128 * 256 - 1;
129 qmat16[qscale][0][i]);
133 for (i = intra; i < 64; i++) {
138 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
145 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
166 for (i = 0; i < 64; i++) {
181 for (i = 0; i < s->
mb_num; i++) {
213 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
219 for (i = 0; i < 2; i++) {
227 2 * stride * height *
sizeof(int16_t));
240 #define COPY(a) dst->a= src->a
265 for (i = -16; i < 16; i++) {
277 int chroma_h_shift, chroma_v_shift;
286 "only YUV420 and YUV422 are supported\n");
338 "Warning keyframe interval too large! reducing it ...\n");
347 #if FF_API_MPV_GLOBAL_OPTS
348 if (avctx->luma_elim_threshold)
350 if (avctx->chroma_elim_threshold)
372 #if FF_API_MPV_GLOBAL_OPTS
390 "a vbv buffer size is needed, "
391 "for encoding with a maximum bitrate\n");
397 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
414 "impossible bitrate constraints, this will fail\n");
428 "bitrate tolerance too small for bitrate\n");
439 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
440 "specified vbv buffer is too large for the given bitrate!\n");
452 "OBMC is only supported with simple mb decision\n");
475 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
489 "mpeg2 style quantization not supported by codec\n");
493 #if FF_API_MPV_GLOBAL_OPTS
512 "closed gop with scene change detection are not supported yet, "
513 "set threshold to 1000000000\n");
520 "low delay forcing is only available for mpeg2\n");
525 "b frames cannot be used with low delay\n");
531 if (avctx->
qmax > 12) {
533 "non linear quant only supports qmax <= 12 currently\n");
544 "multi threaded encoding not supported by codec\n");
550 "automatic thread number detection not supported by codec,"
563 i = (INT_MAX / 2 + 128) >> 8;
577 "notice: b_frame_strategy only affects the first pass\n");
611 "timebase %d/%d not supported by MPEG 4 standard, "
612 "the maximum admitted value for the timebase denominator "
619 #if FF_API_MPV_GLOBAL_OPTS
624 if (avctx->quantizer_noise_shaping)
668 "The specified picture size of %dx%d is not valid for the "
669 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
683 "The specified picture size of %dx%d is not valid for "
684 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
685 "352x288, 704x576, and 1408x1152."
819 for (i = 0; i < 64; i++) {
877 for (y = 0; y < 16; y++) {
878 for (x = 0; x < 16; x++) {
879 acc +=
FFABS(src[x + y * stride] - ref);
895 for (y = 0; y < h; y += 16) {
896 for (x = 0; x < w; x += 16) {
897 int offset = x + y *
stride;
900 int mean = (s->
dsp.
pix_sum(src + offset, stride) + 128) >> 8;
901 int sae =
get_sae(src + offset, mean, stride);
903 acc += sae + 500 < sad;
930 "Error, Invalid timestamp=%"PRId64
", "
944 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
973 for (i = 0; i < 4; i++) {
997 int h_chroma_shift, v_chroma_shift;
1002 for (i = 0; i < 3; i++) {
1003 int src_stride = pic_arg->
linesize[i];
1005 int h_shift = i ? h_chroma_shift : 0;
1006 int v_shift = i ? v_chroma_shift : 0;
1007 int w = s->
width >> h_shift;
1008 int h = s->
height >> v_shift;
1015 if (src_stride == dst_stride)
1016 memcpy(dst, src, src_stride * h);
1019 memcpy(dst, src, w);
1044 int64_t score64 = 0;
1046 for (plane = 0; plane < 3; plane++) {
1048 const int bw = plane ? 1 : 2;
1049 for (y = 0; y < s->
mb_height * bw; y++) {
1050 for (x = 0; x < s->
mb_width * bw; x++) {
1057 case 0: score =
FFMAX(score, v);
break;
1058 case 1: score +=
FFABS(v);
break;
1059 case 2: score += v * v;
break;
1060 case 3: score64 +=
FFABS(v * v * (int64_t)v);
break;
1061 case 4: score64 += v * v * (int64_t)(v * v);
break;
1080 int ret, got_output;
1098 int i, j, out_size, p_lambda, b_lambda,
lambda2;
1099 int64_t best_rd = INT64_MAX;
1100 int best_b_count = -1;
1102 assert(scale >= 0 && scale <= 3);
1110 b_lambda = p_lambda;
1138 input[i].
data[1] = input[i].
data[0] + ysize;
1139 input[i].
data[2] = input[i].
data[1] + csize;
1145 pre_input = *pre_input_ptr;
1185 input[i + 1].
quality = is_p ? p_lambda : b_lambda;
1213 return best_b_count;
1240 for (i = 0; i < 4; i++)
1296 b_frames =
FFMAX(0, i - 1);
1299 for (i = 0; i < b_frames + 1; i++) {
1311 for (i = b_frames - 1; i >= 0; i--) {
1319 "warning, too many b frames in a row\n");
1342 for (i = 0; i < b_frames; i++) {
1379 for (i = 0; i < 4; i++)
1396 for (i = 0; i < 4; i++) {
1410 const AVFrame *pic_arg,
int *got_packet)
1413 int i, stuffing_count, ret;
1437 for (i = 0; i < context_count; i++) {
1441 uint8_t *start = pkt->
data + (size_t)(((int64_t) pkt->
size) * start_y / h);
1442 uint8_t *end = pkt->
data + (size_t)(((int64_t) pkt->
size) * end_y / h);
1497 for (i = 0; i < context_count; i++) {
1510 for (i = 0; i < 4; i++) {
1523 if (stuffing_count) {
1525 stuffing_count + 50) {
1533 while (stuffing_count--) {
1540 stuffing_count -= 4;
1541 while (stuffing_count--) {
1558 int vbv_delay, min_delay;
1567 "Internal error, negative bits\n");
1575 vbv_delay =
FFMAX(vbv_delay, min_delay);
1577 assert(vbv_delay < 0xFFFF);
1608 *got_packet = !!pkt->
size;
1613 int n,
int threshold)
1615 static const char tab[64] = {
1616 3, 2, 2, 1, 1, 1, 1, 1,
1617 1, 1, 1, 1, 1, 1, 1, 1,
1618 1, 1, 1, 1, 1, 1, 1, 1,
1619 0, 0, 0, 0, 0, 0, 0, 0,
1620 0, 0, 0, 0, 0, 0, 0, 0,
1621 0, 0, 0, 0, 0, 0, 0, 0,
1622 0, 0, 0, 0, 0, 0, 0, 0,
1623 0, 0, 0, 0, 0, 0, 0, 0
1632 if (threshold < 0) {
1634 threshold = -threshold;
1639 if (last_index <= skip_dc - 1)
1642 for (i = 0; i <= last_index; i++) {
1646 if (skip_dc && i == 0)
1650 }
else if (level > 1) {
1656 if (score >= threshold)
1658 for (i = skip_dc; i <= last_index; i++) {
1681 for (; i <= last_index; i++) {
1683 int level = block[j];
1685 if (level > maxlevel) {
1688 }
else if (level < minlevel) {
1698 "warning, clipping %d dct coefficients to %d..%d\n",
1699 overflow, minlevel, maxlevel);
1706 for (y = 0; y < 8; y++) {
1707 for (x = 0; x < 8; x++) {
1713 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
1714 for (x2=
FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1715 int v = ptr[x2 + y2 *
stride];
1721 weight[x + 8 * y]= (36 *
ff_sqrt(count * sqr - sum * sum)) / count;
1727 int motion_x,
int motion_y,
1728 int mb_block_height,
1731 int16_t weight[8][64];
1738 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1741 for (i = 0; i < mb_block_count; i++)
1745 const int last_qp = s->
qscale;
1746 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1777 (mb_y * 16 * wrap_y) + mb_x * 16;
1779 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1781 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1783 if (mb_x * 16 + 16 > s->
width || mb_y * 16 + 16 > s->
height) {
1789 mb_block_height, mb_x * 8, mb_y * 8,
1791 ptr_cb = ebuf + 18 * wrap_y;
1793 mb_block_height, mb_x * 8, mb_y * 8,
1795 ptr_cr = ebuf + 18 * wrap_y + 8;
1800 int progressive_score, interlaced_score;
1806 NULL, wrap_y, 8) - 400;
1808 if (progressive_score > 0) {
1810 NULL, wrap_y * 2, 8) +
1812 NULL, wrap_y * 2, 8);
1813 if (progressive_score > interlaced_score) {
1816 dct_offset = wrap_y;
1837 ptr_cb + (dct_offset >> 1), wrap_c);
1839 ptr_cr + (dct_offset >> 1), wrap_c);
1845 uint8_t *dest_y, *dest_cb, *dest_cr;
1847 dest_y = s->
dest[0];
1848 dest_cb = s->
dest[1];
1849 dest_cr = s->
dest[2];
1873 int progressive_score, interlaced_score;
1880 ptr_y + wrap_y * 8, wrap_y,
1884 progressive_score -= 400;
1886 if (progressive_score > 0) {
1894 if (progressive_score > interlaced_score) {
1897 dct_offset = wrap_y;
1908 dest_y + dct_offset, wrap_y);
1910 dest_y + dct_offset + 8, wrap_y);
1920 dest_cb + (dct_offset >> 1), wrap_c);
1922 dest_cr + (dct_offset >> 1), wrap_c);
1930 wrap_y, 8) < 20 * s->
qscale)
1933 dest_y + 8, wrap_y, 8) < 20 * s->
qscale)
1936 dest_y + dct_offset, wrap_y, 8) < 20 * s->
qscale)
1938 if (s->
dsp.
sad[1](
NULL, ptr_y + dct_offset + 8,
1939 dest_y + dct_offset + 8,
1940 wrap_y, 8) < 20 * s->
qscale)
1943 wrap_c, 8) < 20 * s->
qscale)
1946 wrap_c, 8) < 20 * s->
qscale)
1949 if (s->
dsp.
sad[1](
NULL, ptr_cb + (dct_offset >> 1),
1950 dest_cb + (dct_offset >> 1),
1951 wrap_c, 8) < 20 * s->
qscale)
1953 if (s->
dsp.
sad[1](
NULL, ptr_cr + (dct_offset >> 1),
1954 dest_cr + (dct_offset >> 1),
1955 wrap_c, 8) < 20 * s->
qscale)
1982 memcpy(orig[0], s->
block[0],
sizeof(
DCTELEM) * 64 * mb_block_count);
1988 for (i = 0; i < mb_block_count; i++) {
2003 for (i = 0; i < mb_block_count; i++) {
2013 for (i = 0; i < 4; i++)
2016 for (i = 4; i < mb_block_count; i++)
2020 for (i = 0; i < mb_block_count; i++) {
2036 for (i = 0; i < mb_block_count; i++) {
2039 for (j = 63; j > 0; j--) {
2127 memcpy(d->
mv, s->
mv, 2*4*2*
sizeof(
int));
2165 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2173 s->
pb= pb[*next_block];
2175 s->
pb2 = pb2 [*next_block];
2176 s->
tex_pb= tex_pb[*next_block];
2180 memcpy(dest_backup, s->
dest,
sizeof(s->
dest));
2203 memcpy(s->
dest, dest_backup,
sizeof(s->
dest));
2221 else if(w==8 && h==8)
2311 for(mb_x=0; mb_x < s->
mb_width; mb_x++) {
2355 bytestream_put_le32(&ptr, offset);
2356 bytestream_put_byte(&ptr, s->
qscale);
2357 bytestream_put_byte(&ptr, gobn);
2358 bytestream_put_le16(&ptr, mba);
2359 bytestream_put_byte(&ptr, pred_x);
2360 bytestream_put_byte(&ptr, pred_y);
2362 bytestream_put_byte(&ptr, 0);
2363 bytestream_put_byte(&ptr, 0);
2454 for(mb_x=0; mb_x < s->
mb_width; mb_x++) {
2485 int current_packet_size, is_gob_start;
2491 if(s->
start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2500 if(s->
mb_x==0 && s->
mb_y!=0) is_gob_start=1;
2522 current_packet_size=0;
2580 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2597 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2598 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2609 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2610 &dmin, &next_block, 0, 0);
2618 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2619 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2629 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2630 &dmin, &next_block, 0, 0);
2638 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2639 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2647 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2648 &dmin, &next_block, s->
mv[1][0][0], s->
mv[1][0][1]);
2658 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2659 &dmin, &next_block, 0, 0);
2670 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2671 &dmin, &next_block, 0, 0);
2682 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2683 &dmin, &next_block, 0, 0);
2689 for(dir=0; dir<2; dir++){
2696 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2697 &dmin, &next_block, 0, 0);
2705 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2706 &dmin, &next_block, 0, 0);
2717 const int last_qp= backup_s.
qscale;
2721 static const int dquant_tab[4]={-1,1,-2,2};
2723 assert(backup_s.
dquant == 0);
2729 s->
mv[0][0][0] = best_s.
mv[0][0][0];
2730 s->
mv[0][0][1] = best_s.
mv[0][0][1];
2731 s->
mv[1][0][0] = best_s.
mv[1][0][0];
2732 s->
mv[1][0][1] = best_s.
mv[1][0][1];
2735 for(; qpi<4; qpi++){
2736 int dquant= dquant_tab[qpi];
2748 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
2749 &dmin, &next_block, s->
mv[mvdir][0][0], s->
mv[mvdir][0][1]);
2769 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2770 &dmin, &next_block, mx, my);
2777 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2778 &dmin, &next_block, 0, 0);
2786 memcpy(s->
mv, best_s.
mv,
sizeof(s->
mv));
2807 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
2808 &dmin, &next_block, mx, my);
2848 int motion_x = 0, motion_y = 0;
2856 motion_x= s->
mv[0][0][0] = 0;
2857 motion_y= s->
mv[0][0][1] = 0;
2944 for(dir=0; dir<2; dir++){
3018 #define MERGE(field) dst->field += src->field; src->field=0
3045 for(i=0; i<64; i++){
3152 for(i=1; i<context_count; i++){
3182 for(i=1; i<context_count; i++){
3193 av_dlog(s,
"Scene change detected, encoding as I Frame %d %d\n",
3237 for(dir=0; dir<2; dir++){
3319 for(i=1; i<context_count; i++){
3323 for(i=1; i<context_count; i++){
3336 for(i=0; i<64; i++){
3337 int level= block[i];
3343 if(level<0) level=0;
3347 if(level>0) level=0;
3356 int qscale,
int *overflow){
3361 unsigned int threshold1, threshold2;
3373 int coeff_count[64];
3374 int qmul, qadd, start_i, last_non_zero, i, dc;
3385 qadd= ((qscale-1)|1)*8;
3402 block[0] = (block[0] + (q >> 1)) / q;
3420 threshold2= (threshold1<<1);
3422 for(i=63; i>=start_i; i--) {
3423 const int j = scantable[i];
3424 int level = block[j] * qmat[j];
3426 if(((
unsigned)(level+threshold1))>threshold2){
3432 for(i=start_i; i<=last_non_zero; i++) {
3433 const int j = scantable[i];
3434 int level = block[j] * qmat[j];
3438 if(((
unsigned)(level+threshold1))>threshold2){
3442 coeff[1][i]= level-1;
3446 coeff[0][i]= -
level;
3447 coeff[1][i]= -level+1;
3450 coeff_count[i]=
FFMIN(level, 2);
3451 assert(coeff_count[i]);
3454 coeff[0][i]= (level>>31)|1;
3461 if(last_non_zero < start_i){
3462 memset(block + start_i, 0, (64-start_i)*
sizeof(
DCTELEM));
3463 return last_non_zero;
3466 score_tab[start_i]= 0;
3467 survivor[0]= start_i;
3470 for(i=start_i; i<=last_non_zero; i++){
3471 int level_index, j, zero_distortion;
3472 int dct_coeff=
FFABS(block[ scantable[i] ]);
3473 int best_score=256*256*256*120;
3477 zero_distortion= dct_coeff*dct_coeff;
3479 for(level_index=0; level_index < coeff_count[i]; level_index++){
3481 int level= coeff[level_index][i];
3482 const int alevel=
FFABS(level);
3488 unquant_coeff= alevel*qmul + qadd;
3492 unquant_coeff = (int)( alevel * qscale * s->
intra_matrix[j]) >> 3;
3493 unquant_coeff = (unquant_coeff - 1) | 1;
3495 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->
inter_matrix[j])) >> 4;
3496 unquant_coeff = (unquant_coeff - 1) | 1;
3501 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3503 if((level&(~127)) == 0){
3504 for(j=survivor_count-1; j>=0; j--){
3505 int run= i - survivor[j];
3507 score += score_tab[i-
run];
3509 if(score < best_score){
3512 level_tab[i+1]= level-64;
3517 for(j=survivor_count-1; j>=0; j--){
3518 int run= i - survivor[j];
3520 score += score_tab[i-
run];
3521 if(score < last_score){
3524 last_level= level-64;
3530 distortion += esc_length*
lambda;
3531 for(j=survivor_count-1; j>=0; j--){
3532 int run= i - survivor[j];
3533 int score= distortion + score_tab[i-
run];
3535 if(score < best_score){
3538 level_tab[i+1]= level-64;
3543 for(j=survivor_count-1; j>=0; j--){
3544 int run= i - survivor[j];
3545 int score= distortion + score_tab[i-
run];
3546 if(score < last_score){
3549 last_level= level-64;
3557 score_tab[i+1]= best_score;
3560 if(last_non_zero <= 27){
3561 for(; survivor_count; survivor_count--){
3562 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3566 for(; survivor_count; survivor_count--){
3567 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3572 survivor[ survivor_count++ ]= i+1;
3576 last_score= 256*256*256*120;
3577 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3578 int score= score_tab[i];
3579 if(i) score += lambda*2;
3581 if(score < last_score){
3584 last_level= level_tab[i];
3585 last_run= run_tab[i];
3592 dc=
FFABS(block[0]);
3593 last_non_zero= last_i - 1;
3594 memset(block + start_i, 0, (64-start_i)*
sizeof(
DCTELEM));
3596 if(last_non_zero < start_i)
3597 return last_non_zero;
3599 if(last_non_zero == 0 && start_i == 0){
3601 int best_score= dc * dc;
3603 for(i=0; i<coeff_count[0]; i++){
3604 int level= coeff[i][0];
3605 int alevel=
FFABS(level);
3606 int unquant_coeff, score, distortion;
3609 unquant_coeff= (alevel*qmul + qadd)>>3;
3611 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->
inter_matrix[0])) >> 4;
3612 unquant_coeff = (unquant_coeff - 1) | 1;
3614 unquant_coeff = (unquant_coeff + 4) >> 3;
3615 unquant_coeff<<= 3 + 3;
3617 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3620 else score= distortion + esc_length*
lambda;
3622 if(score < best_score){
3624 best_level= level - 64;
3627 block[0]= best_level;
3629 if(best_level == 0)
return -1;
3630 else return last_non_zero;
3636 block[ perm_scantable[last_non_zero] ]= last_level;
3639 for(; i>start_i; i -= run_tab[i] + 1){
3640 block[ perm_scantable[i-1] ]= level_tab[i];
3643 return last_non_zero;
3658 int perm_index= perm[
index];
3659 if(i==0) s*= sqrt(0.5);
3660 if(j==0) s*= sqrt(0.5);
3661 basis[perm_index][8*x + y]=
lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
3680 int qmul, qadd, start_i, last_non_zero, i, dc;
3684 int rle_index,
run, q = 1, sum;
3687 static int after_last=0;
3688 static int to_zero=0;
3689 static int from_zero=0;
3692 static int messed_sign=0;
3695 if(basis[0][0] == 0)
3732 for(i=0; i<64; i++){
3739 for(i=0; i<64; i++){
3744 w=
FFABS(weight[i]) + qns*one;
3745 w= 15 + (48*qns*one + w/2)/w;
3760 for(i=start_i; i<=last_non_zero; i++){
3761 int j= perm_scantable[i];
3762 const int level= block[j];
3766 if(level<0) coeff= qmul*level - qadd;
3767 else coeff= qmul*level + qadd;
3768 run_tab[rle_index++]=
run;
3777 if(last_non_zero>0){
3788 int run2, best_unquant_change=0, analyze_gradient;
3794 if(analyze_gradient){
3798 for(i=0; i<64; i++){
3814 const int level= block[0];
3815 int change, old_coeff;
3821 for(change=-1; change<=1; change+=2){
3822 int new_level= level + change;
3823 int score, new_coeff;
3825 new_coeff= q*new_level;
3826 if(new_coeff >= 2048 || new_coeff < 0)
3829 score= s->
dsp.
try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3830 if(score<best_score){
3833 best_change= change;
3834 best_unquant_change= new_coeff - old_coeff;
3841 run2= run_tab[rle_index++];
3845 for(i=start_i; i<64; i++){
3846 int j= perm_scantable[i];
3847 const int level= block[j];
3848 int change, old_coeff;
3854 if(level<0) old_coeff= qmul*level - qadd;
3855 else old_coeff= qmul*level + qadd;
3856 run2= run_tab[rle_index++];
3860 assert(run2>=0 || i >= last_non_zero );
3863 for(change=-1; change<=1; change+=2){
3864 int new_level= level + change;
3865 int score, new_coeff, unquant_change;
3872 if(new_level<0) new_coeff= qmul*new_level - qadd;
3873 else new_coeff= qmul*new_level + qadd;
3874 if(new_coeff >= 2048 || new_coeff <= -2048)
3879 if(level < 63 && level > -63){
3880 if(i < last_non_zero)
3888 assert(
FFABS(new_level)==1);
3890 if(analyze_gradient){
3891 int g= d1[ scantable[i] ];
3892 if(g && (g^new_level) >= 0)
3896 if(i < last_non_zero){
3897 int next_i= i + run2 + 1;
3898 int next_level= block[ perm_scantable[next_i] ] + 64;
3900 if(next_level&(~127))
3903 if(next_i < last_non_zero)
3921 assert(
FFABS(level)==1);
3923 if(i < last_non_zero){
3924 int next_i= i + run2 + 1;
3925 int next_level= block[ perm_scantable[next_i] ] + 64;
3927 if(next_level&(~127))
3930 if(next_i < last_non_zero)
3949 unquant_change= new_coeff - old_coeff;
3950 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
3953 if(score<best_score){
3956 best_change= change;
3957 best_unquant_change= unquant_change;
3961 prev_level= level + 64;
3962 if(prev_level&(~127))
3975 int j= perm_scantable[ best_coeff ];
3977 block[j] += best_change;
3979 if(best_coeff > last_non_zero){
3980 last_non_zero= best_coeff;
3988 if(block[j] - best_change){
3989 if(
FFABS(block[j]) >
FFABS(block[j] - best_change)){
4001 for(; last_non_zero>=start_i; last_non_zero--){
4002 if(block[perm_scantable[last_non_zero]])
4008 if(256*256*256*64 % count == 0){
4009 printf(
"after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero,
raise, lower, messed_sign, s->
mb_x, s->
mb_y, s->
picture_number);
4014 for(i=start_i; i<=last_non_zero; i++){
4015 int j= perm_scantable[i];
4016 const int level= block[j];
4019 run_tab[rle_index++]=
run;
4032 if(last_non_zero>0){
4038 return last_non_zero;
4043 int qscale,
int *overflow)
4045 int i, j,
level, last_non_zero, q, start_i;
4050 unsigned int threshold1, threshold2;
4069 block[0] = (block[0] + (q >> 1)) / q;
4081 threshold2= (threshold1<<1);
4082 for(i=63;i>=start_i;i--) {
4084 level = block[j] * qmat[j];
4086 if(((
unsigned)(level+threshold1))>threshold2){
4093 for(i=start_i; i<=last_non_zero; i++) {
4095 level = block[j] * qmat[j];
4099 if(((
unsigned)(level+threshold1))>threshold2){
4118 return last_non_zero;
4121 #define OFFSET(x) offsetof(MpegEncContext, x)
4122 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4126 {
"mb_info",
"emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size",
OFFSET(
mb_info),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
4183 .
name =
"msmpeg4v2",
4192 .priv_class = &msmpeg4v2_class,
4207 .priv_class = &msmpeg4v3_class,
4222 .priv_class = &wmv1_class,