66 uint16_t (*qmat16)[2][64],
67 const uint16_t *quant_matrix,
68 int bias,
int qmin,
int qmax,
int intra)
73 for (qscale = qmin; qscale <= qmax; qscale++) {
81 for (i = 0; i < 64; i++) {
90 (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++) {
142 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
149 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
170 for (i = 0; i < 64; i++) {
185 for (i = 0; i < s->
mb_num; i++) {
217 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
223 for (i = 0; i < 2; i++) {
231 2 * stride * height *
sizeof(int16_t));
244 #define COPY(a) dst->a= src->a
269 for (i = -16; i < 16; i++) {
281 int chroma_h_shift, chroma_v_shift;
290 "only YUV420 and YUV422 are supported\n");
342 "Warning keyframe interval too large! reducing it ...\n");
354 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
355 if (avctx->
flags & CODEC_FLAG_PART)
386 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
390 s->
obmc = !!(s->
flags & CODEC_FLAG_OBMC);
395 "a vbv buffer size is needed, "
396 "for encoding with a maximum bitrate\n");
402 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
419 "impossible bitrate constraints, this will fail\n");
433 "bitrate tolerance too small for bitrate\n");
444 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
445 "specified vbv buffer is too large for the given bitrate!\n");
457 "OBMC is only supported with simple mb decision\n");
461 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
474 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
477 "data partitioning not supported by codec\n");
496 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
503 | CODEC_FLAG_ALT_SCAN
514 "mpeg2 style quantization not supported by codec\n");
532 "closed gop with scene change detection are not supported yet, "
533 "set threshold to 1000000000\n");
537 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
538 if ((s->
flags2 & CODEC_FLAG2_INTRA_VLC) &&
541 "intra vlc table not supported by codec\n");
549 "low delay forcing is only available for mpeg2\n");
554 "b frames cannot be used with low delay\n");
560 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
563 "non linear quant is only available for mpeg2\n");
567 if (avctx->
qmax > 12) {
569 "non linear quant only supports qmax <= 12 currently\n");
580 || !(s->
flags & CODEC_FLAG_H263P_SLICE_STRUCT)
584 "multi threaded encoding not supported by codec\n");
590 "automatic thread number detection not supported by codec,"
603 i = (INT_MAX / 2 + 128) >> 8;
617 "notice: b_frame_strategy only affects the first pass\n");
651 "timebase %d/%d not supported by MPEG 4 standard, "
652 "the maximum admitted value for the timebase denominator "
699 "The specified picture size of %dx%d is not valid for the "
700 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
714 "The specified picture size of %dx%d is not valid for "
715 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
716 "352x288, 704x576, and 1408x1152."
728 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
729 if (avctx->
flags & CODEC_FLAG_H263P_UMV)
731 if (avctx->
flags & CODEC_FLAG_H263P_AIV)
733 if (avctx->
flags & CODEC_FLAG_H263P_SLICE_STRUCT)
855 for (i = 0; i < 64; i++) {
913 for (y = 0; y < 16; y++) {
914 for (x = 0; x < 16; x++) {
915 acc +=
FFABS(src[x + y * stride] - ref);
931 for (y = 0; y < h; y += 16) {
932 for (x = 0; x < w; x += 16) {
933 int offset = x + y *
stride;
936 int mean = (s->
dsp.
pix_sum(src + offset, stride) + 128) >> 8;
937 int sae =
get_sae(src + offset, mean, stride);
939 acc += sae + 500 < sad;
965 "Error, Invalid timestamp=%"PRId64
", "
976 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
1005 for (i = 0; i < 4; i++) {
1029 int h_chroma_shift, v_chroma_shift;
1033 for (i = 0; i < 3; i++) {
1034 int src_stride = pic_arg->
linesize[i];
1036 int h_shift = i ? h_chroma_shift : 0;
1037 int v_shift = i ? v_chroma_shift : 0;
1038 int w = s->
width >> h_shift;
1039 int h = s->
height >> v_shift;
1040 uint8_t *src = pic_arg->
data[i];
1041 uint8_t *dst = pic->
data[i];
1046 if (src_stride == dst_stride)
1047 memcpy(dst, src, src_stride * h);
1050 memcpy(dst, src, w);
1075 int64_t score64 = 0;
1077 for (plane = 0; plane < 3; plane++) {
1079 const int bw = plane ? 1 : 2;
1080 for (y = 0; y < s->
mb_height * bw; y++) {
1081 for (x = 0; x < s->
mb_width * bw; x++) {
1083 uint8_t *dptr = p->
f.
data[plane] + 8 * (x + y *
stride) + off;
1084 uint8_t *rptr = ref->
f.
data[plane] + 8 * (x + y *
stride);
1088 case 0: score =
FFMAX(score, v);
break;
1089 case 1: score +=
FFABS(v);
break;
1090 case 2: score += v *
v;
break;
1091 case 3: score64 +=
FFABS(v * v * (int64_t)v);
break;
1092 case 4: score64 += v * v * (int64_t)(v * v);
break;
1114 int i, j, out_size, p_lambda, b_lambda,
lambda2;
1116 uint8_t *outbuf =
av_malloc(outbuf_size);
1118 int best_b_count = -1;
1120 assert(scale >= 0 && scale <= 3);
1128 b_lambda = p_lambda;
1156 input[i].
data[1] = input[i].
data[0] + ysize;
1157 input[i].
data[2] = input[i].
data[1] + csize;
1163 pre_input = *pre_input_ptr;
1194 outbuf_size, &input[0]);
1202 input[i + 1].
quality = is_p ? p_lambda : b_lambda;
1230 return best_b_count;
1261 for (i = 0; i < 4; i++)
1317 b_frames =
FFMAX(0, i - 1);
1320 for (i = 0; i < b_frames + 1; i++) {
1335 for (i = b_frames - 1; i >= 0; i--) {
1343 "warning, too many b frames in a row\n");
1366 for (i = 0; i < b_frames; i++) {
1403 for (i = 0; i < 4; i++)
1420 for (i = 0; i < 4; i++) {
1435 unsigned char *buf,
int buf_size,
void *
data)
1439 int i, stuffing_count;
1442 for (i = 0; i < context_count; i++) {
1446 uint8_t *start = buf + (size_t)(((int64_t) buf_size) * start_y / h);
1447 uint8_t *end = buf + (size_t)(((int64_t) buf_size) * end_y / h);
1516 for (i = 0; i < context_count; i++) {
1529 for (i = 0; i < 4; i++) {
1542 if (stuffing_count) {
1544 stuffing_count + 50) {
1552 while (stuffing_count--) {
1559 stuffing_count -= 4;
1560 while (stuffing_count--) {
1577 int vbv_delay, min_delay;
1586 "Internal error, negative bits\n");
1594 vbv_delay =
FFMAX(vbv_delay, min_delay);
1596 assert(vbv_delay < 0xFFFF);
1617 int n,
int threshold)
1619 static const char tab[64] = {
1620 3, 2, 2, 1, 1, 1, 1, 1,
1621 1, 1, 1, 1, 1, 1, 1, 1,
1622 1, 1, 1, 1, 1, 1, 1, 1,
1623 0, 0, 0, 0, 0, 0, 0, 0,
1624 0, 0, 0, 0, 0, 0, 0, 0,
1625 0, 0, 0, 0, 0, 0, 0, 0,
1626 0, 0, 0, 0, 0, 0, 0, 0,
1627 0, 0, 0, 0, 0, 0, 0, 0
1636 if (threshold < 0) {
1638 threshold = -threshold;
1643 if (last_index <= skip_dc - 1)
1646 for (i = 0; i <= last_index; i++) {
1650 if (skip_dc && i == 0)
1654 }
else if (level > 1) {
1660 if (score >= threshold)
1662 for (i = skip_dc; i <= last_index; i++) {
1685 for (; i <= last_index; i++) {
1687 int level = block[j];
1689 if (level > maxlevel) {
1692 }
else if (level < minlevel) {
1702 "warning, clipping %d dct coefficients to %d..%d\n",
1703 overflow, minlevel, maxlevel);
1710 for (y = 0; y < 8; y++) {
1711 for (x = 0; x < 8; x++) {
1717 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
1718 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
1719 int v = ptr[x2 + y2 *
stride];
1725 weight[x + 8 * y]= (36 *
ff_sqrt(count * sqr - sum * sum)) / count;
1731 int motion_x,
int motion_y,
1732 int mb_block_height,
1735 int16_t weight[8][64];
1742 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1745 for (i = 0; i < mb_block_count; i++)
1749 const int last_qp = s->
qscale;
1750 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1781 (mb_y * 16 * wrap_y) + mb_x * 16;
1783 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1785 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1787 if (mb_x * 16 + 16 > s->
width || mb_y * 16 + 16 > s->
height) {
1793 mb_block_height, mb_x * 8, mb_y * 8,
1795 ptr_cb = ebuf + 18 * wrap_y;
1797 mb_block_height, mb_x * 8, mb_y * 8,
1799 ptr_cr = ebuf + 18 * wrap_y + 8;
1804 int progressive_score, interlaced_score;
1810 NULL, wrap_y, 8) - 400;
1812 if (progressive_score > 0) {
1814 NULL, wrap_y * 2, 8) +
1816 NULL, wrap_y * 2, 8);
1817 if (progressive_score > interlaced_score) {
1820 dct_offset = wrap_y;
1841 ptr_cb + (dct_offset >> 1), wrap_c);
1843 ptr_cr + (dct_offset >> 1), wrap_c);
1849 uint8_t *dest_y, *dest_cb, *dest_cr;
1851 dest_y = s->
dest[0];
1852 dest_cb = s->
dest[1];
1853 dest_cr = s->
dest[2];
1875 int progressive_score, interlaced_score;
1882 ptr_y + wrap_y * 8, wrap_y,
1886 progressive_score -= 400;
1888 if (progressive_score > 0) {
1896 if (progressive_score > interlaced_score) {
1899 dct_offset = wrap_y;
1910 dest_y + dct_offset, wrap_y);
1912 dest_y + dct_offset + 8, wrap_y);
1922 dest_cb + (dct_offset >> 1), wrap_c);
1924 dest_cr + (dct_offset >> 1), wrap_c);
1932 wrap_y, 8) < 20 * s->
qscale)
1935 dest_y + 8, wrap_y, 8) < 20 * s->
qscale)
1938 dest_y + dct_offset, wrap_y, 8) < 20 * s->
qscale)
1940 if (s->
dsp.
sad[1](
NULL, ptr_y + dct_offset + 8,
1941 dest_y + dct_offset + 8,
1942 wrap_y, 8) < 20 * s->
qscale)
1945 wrap_c, 8) < 20 * s->
qscale)
1948 wrap_c, 8) < 20 * s->
qscale)
1951 if (s->
dsp.
sad[1](
NULL, ptr_cb + (dct_offset >> 1),
1952 dest_cb + (dct_offset >> 1),
1953 wrap_c, 8) < 20 * s->
qscale)
1955 if (s->
dsp.
sad[1](
NULL, ptr_cr + (dct_offset >> 1),
1956 dest_cr + (dct_offset >> 1),
1957 wrap_c, 8) < 20 * s->
qscale)
1984 memcpy(orig[0], s->
block[0],
sizeof(
DCTELEM) * 64 * mb_block_count);
1990 for (i = 0; i < mb_block_count; i++) {
2005 for (i = 0; i < mb_block_count; i++) {
2015 for (i = 0; i < 4; i++)
2018 for (i = 4; i < mb_block_count; i++)
2022 for (i = 0; i < mb_block_count; i++) {
2038 for (i = 0; i < mb_block_count; i++) {
2041 for (j = 63; j > 0; j--) {
2129 memcpy(d->
mv, s->
mv, 2*4*2*
sizeof(
int));
2167 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2170 uint8_t *dest_backup[3];
2175 s->
pb= pb[*next_block];
2177 s->
pb2 = pb2 [*next_block];
2178 s->
tex_pb= tex_pb[*next_block];
2182 memcpy(dest_backup, s->
dest,
sizeof(s->
dest));
2205 memcpy(s->
dest, dest_backup,
sizeof(s->
dest));
2223 else if(w==8 && h==8)
2313 for(mb_x=0; mb_x < s->
mb_width; mb_x++) {
2415 for(mb_x=0; mb_x < s->
mb_width; mb_x++) {
2446 int current_packet_size, is_gob_start;
2452 if(s->
start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2461 if(s->
mb_x==0 && s->
mb_y!=0) is_gob_start=1;
2483 current_packet_size=0;
2538 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2555 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2556 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2567 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2568 &dmin, &next_block, 0, 0);
2576 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2577 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2587 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2588 &dmin, &next_block, 0, 0);
2596 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2597 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2605 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2606 &dmin, &next_block, s->
mv[1][0][0], s->
mv[1][0][1]);
2616 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2617 &dmin, &next_block, 0, 0);
2628 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2629 &dmin, &next_block, 0, 0);
2640 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2641 &dmin, &next_block, 0, 0);
2647 for(dir=0; dir<2; dir++){
2654 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2655 &dmin, &next_block, 0, 0);
2663 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2664 &dmin, &next_block, 0, 0);
2675 const int last_qp= backup_s.
qscale;
2679 static const int dquant_tab[4]={-1,1,-2,2};
2681 assert(backup_s.
dquant == 0);
2687 s->
mv[0][0][0] = best_s.
mv[0][0][0];
2688 s->
mv[0][0][1] = best_s.
mv[0][0][1];
2689 s->
mv[1][0][0] = best_s.
mv[1][0][0];
2690 s->
mv[1][0][1] = best_s.
mv[1][0][1];
2693 for(; qpi<4; qpi++){
2694 int dquant= dquant_tab[qpi];
2706 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
2707 &dmin, &next_block, s->
mv[mvdir][0][0], s->
mv[mvdir][0][1]);
2727 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2728 &dmin, &next_block, mx, my);
2735 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2736 &dmin, &next_block, 0, 0);
2744 memcpy(s->
mv, best_s.
mv,
sizeof(s->
mv));
2765 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
2766 &dmin, &next_block, mx, my);
2806 int motion_x = 0, motion_y = 0;
2814 motion_x= s->
mv[0][0][0] = 0;
2815 motion_y= s->
mv[0][0][1] = 0;
2903 for(dir=0; dir<2; dir++){
2976 #define MERGE(field) dst->field += src->field; src->field=0
3003 for(i=0; i<64; i++){
3111 for(i=1; i<context_count; i++){
3139 for(i=1; i<context_count; i++){
3193 for(dir=0; dir<2; dir++){
3275 for(i=1; i<context_count; i++){
3279 for(i=1; i<context_count; i++){
3292 for(i=0; i<64; i++){
3293 int level= block[i];
3299 if(level<0) level=0;
3303 if(level>0) level=0;
3312 int qscale,
int *overflow){
3317 unsigned int threshold1, threshold2;
3329 int coeff_count[64];
3330 int qmul, qadd, start_i, last_non_zero, i, dc;
3333 uint8_t * last_length;
3341 qadd= ((qscale-1)|1)*8;
3358 block[0] = (block[0] + (q >> 1)) / q;
3376 threshold2= (threshold1<<1);
3378 for(i=63; i>=start_i; i--) {
3379 const int j = scantable[i];
3380 int level = block[j] * qmat[j];
3382 if(((
unsigned)(level+threshold1))>threshold2){
3388 for(i=start_i; i<=last_non_zero; i++) {
3389 const int j = scantable[i];
3390 int level = block[j] * qmat[j];
3394 if(((
unsigned)(level+threshold1))>threshold2){
3398 coeff[1][i]= level-1;
3402 coeff[0][i]= -
level;
3403 coeff[1][i]= -level+1;
3406 coeff_count[i]=
FFMIN(level, 2);
3407 assert(coeff_count[i]);
3410 coeff[0][i]= (level>>31)|1;
3417 if(last_non_zero < start_i){
3418 memset(block + start_i, 0, (64-start_i)*
sizeof(
DCTELEM));
3419 return last_non_zero;
3422 score_tab[start_i]= 0;
3423 survivor[0]= start_i;
3426 for(i=start_i; i<=last_non_zero; i++){
3427 int level_index, j, zero_distortion;
3428 int dct_coeff=
FFABS(block[ scantable[i] ]);
3429 int best_score=256*256*256*120;
3437 zero_distortion= dct_coeff*dct_coeff;
3439 for(level_index=0; level_index < coeff_count[i]; level_index++){
3441 int level= coeff[level_index][i];
3442 const int alevel=
FFABS(level);
3448 unquant_coeff= alevel*qmul + qadd;
3452 unquant_coeff = (int)( alevel * qscale * s->
intra_matrix[j]) >> 3;
3453 unquant_coeff = (unquant_coeff - 1) | 1;
3455 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->
inter_matrix[j])) >> 4;
3456 unquant_coeff = (unquant_coeff - 1) | 1;
3461 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3463 if((level&(~127)) == 0){
3464 for(j=survivor_count-1; j>=0; j--){
3465 int run= i - survivor[j];
3467 score += score_tab[i-
run];
3469 if(score < best_score){
3472 level_tab[i+1]= level-64;
3477 for(j=survivor_count-1; j>=0; j--){
3478 int run= i - survivor[j];
3480 score += score_tab[i-
run];
3481 if(score < last_score){
3484 last_level= level-64;
3490 distortion += esc_length*
lambda;
3491 for(j=survivor_count-1; j>=0; j--){
3492 int run= i - survivor[j];
3493 int score= distortion + score_tab[i-
run];
3495 if(score < best_score){
3498 level_tab[i+1]= level-64;
3503 for(j=survivor_count-1; j>=0; j--){
3504 int run= i - survivor[j];
3505 int score= distortion + score_tab[i-
run];
3506 if(score < last_score){
3509 last_level= level-64;
3517 score_tab[i+1]= best_score;
3520 if(last_non_zero <= 27){
3521 for(; survivor_count; survivor_count--){
3522 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3526 for(; survivor_count; survivor_count--){
3527 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3532 survivor[ survivor_count++ ]= i+1;
3536 last_score= 256*256*256*120;
3537 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3538 int score= score_tab[i];
3539 if(i) score += lambda*2;
3541 if(score < last_score){
3544 last_level= level_tab[i];
3545 last_run= run_tab[i];
3552 dc=
FFABS(block[0]);
3553 last_non_zero= last_i - 1;
3554 memset(block + start_i, 0, (64-start_i)*
sizeof(
DCTELEM));
3556 if(last_non_zero < start_i)
3557 return last_non_zero;
3559 if(last_non_zero == 0 && start_i == 0){
3561 int best_score= dc * dc;
3563 for(i=0; i<coeff_count[0]; i++){
3564 int level= coeff[i][0];
3565 int alevel=
FFABS(level);
3566 int unquant_coeff, score, distortion;
3569 unquant_coeff= (alevel*qmul + qadd)>>3;
3571 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->
inter_matrix[0])) >> 4;
3572 unquant_coeff = (unquant_coeff - 1) | 1;
3574 unquant_coeff = (unquant_coeff + 4) >> 3;
3575 unquant_coeff<<= 3 + 3;
3577 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3580 else score= distortion + esc_length*
lambda;
3582 if(score < best_score){
3584 best_level= level - 64;
3587 block[0]= best_level;
3589 if(best_level == 0)
return -1;
3590 else return last_non_zero;
3596 block[ perm_scantable[last_non_zero] ]= last_level;
3599 for(; i>start_i; i -= run_tab[i] + 1){
3600 block[ perm_scantable[i-1] ]= level_tab[i];
3603 return last_non_zero;
3618 int perm_index= perm[
index];
3619 if(i==0) s*= sqrt(0.5);
3620 if(j==0) s*= sqrt(0.5);
3621 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)));
3640 int qmul, qadd, start_i, last_non_zero, i, dc;
3642 uint8_t * last_length;
3644 int rle_index,
run, q = 1, sum;
3647 static int after_last=0;
3648 static int to_zero=0;
3649 static int from_zero=0;
3652 static int messed_sign=0;
3655 if(basis[0][0] == 0)
3692 for(i=0; i<64; i++){
3699 for(i=0; i<64; i++){
3704 w=
FFABS(weight[i]) + qns*one;
3705 w= 15 + (48*qns*one + w/2)/w;
3720 for(i=start_i; i<=last_non_zero; i++){
3721 int j= perm_scantable[i];
3722 const int level= block[j];
3726 if(level<0) coeff= qmul*level - qadd;
3727 else coeff= qmul*level + qadd;
3728 run_tab[rle_index++]=
run;
3737 if(last_non_zero>0){
3748 int run2, best_unquant_change=0, analyze_gradient;
3754 if(analyze_gradient){
3758 for(i=0; i<64; i++){
3774 const int level= block[0];
3775 int change, old_coeff;
3781 for(change=-1; change<=1; change+=2){
3782 int new_level= level + change;
3783 int score, new_coeff;
3785 new_coeff= q*new_level;
3786 if(new_coeff >= 2048 || new_coeff < 0)
3789 score= s->
dsp.
try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3790 if(score<best_score){
3793 best_change= change;
3794 best_unquant_change= new_coeff - old_coeff;
3801 run2= run_tab[rle_index++];
3805 for(i=start_i; i<64; i++){
3806 int j= perm_scantable[i];
3807 const int level= block[j];
3808 int change, old_coeff;
3814 if(level<0) old_coeff= qmul*level - qadd;
3815 else old_coeff= qmul*level + qadd;
3816 run2= run_tab[rle_index++];
3820 assert(run2>=0 || i >= last_non_zero );
3823 for(change=-1; change<=1; change+=2){
3824 int new_level= level + change;
3825 int score, new_coeff, unquant_change;
3832 if(new_level<0) new_coeff= qmul*new_level - qadd;
3833 else new_coeff= qmul*new_level + qadd;
3834 if(new_coeff >= 2048 || new_coeff <= -2048)
3839 if(level < 63 && level > -63){
3840 if(i < last_non_zero)
3848 assert(
FFABS(new_level)==1);
3850 if(analyze_gradient){
3851 int g= d1[ scantable[i] ];
3852 if(g && (g^new_level) >= 0)
3856 if(i < last_non_zero){
3857 int next_i= i + run2 + 1;
3858 int next_level= block[ perm_scantable[next_i] ] + 64;
3860 if(next_level&(~127))
3863 if(next_i < last_non_zero)
3881 assert(
FFABS(level)==1);
3883 if(i < last_non_zero){
3884 int next_i= i + run2 + 1;
3885 int next_level= block[ perm_scantable[next_i] ] + 64;
3887 if(next_level&(~127))
3890 if(next_i < last_non_zero)
3909 unquant_change= new_coeff - old_coeff;
3910 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
3913 if(score<best_score){
3916 best_change= change;
3917 best_unquant_change= unquant_change;
3921 prev_level= level + 64;
3922 if(prev_level&(~127))
3935 int j= perm_scantable[ best_coeff ];
3937 block[j] += best_change;
3939 if(best_coeff > last_non_zero){
3940 last_non_zero= best_coeff;
3948 if(block[j] - best_change){
3949 if(
FFABS(block[j]) >
FFABS(block[j] - best_change)){
3961 for(; last_non_zero>=start_i; last_non_zero--){
3962 if(block[perm_scantable[last_non_zero]])
3968 if(256*256*256*64 % count == 0){
3969 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);
3974 for(i=start_i; i<=last_non_zero; i++){
3975 int j= perm_scantable[i];
3976 const int level= block[j];
3979 run_tab[rle_index++]=
run;
3992 if(last_non_zero>0){
3998 return last_non_zero;
4003 int qscale,
int *overflow)
4005 int i, j,
level, last_non_zero, q, start_i;
4010 unsigned int threshold1, threshold2;
4029 block[0] = (block[0] + (q >> 1)) / q;
4041 threshold2= (threshold1<<1);
4042 for(i=63;i>=start_i;i--) {
4044 level = block[j] * qmat[j];
4046 if(((
unsigned)(level+threshold1))>threshold2){
4053 for(i=start_i; i<=last_non_zero; i++) {
4055 level = block[j] * qmat[j];
4059 if(((
unsigned)(level+threshold1))>threshold2){
4078 return last_non_zero;
4081 #define OFFSET(x) offsetof(MpegEncContext, x)
4082 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4138 .
name =
"msmpeg4v2",
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
void ff_h263_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
int chroma_elim_threshold
static const AVOption h263_options[]
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int frame_bits
bits used for the current frame
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, int linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Motion estimation with emulated edge values.
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
void ff_init_block_index(MpegEncContext *s)
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
#define MAX_PICTURE_COUNT
int(* dct_quantize)(struct MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
const uint8_t ff_zigzag_direct[64]
me_cmp_func frame_skip_cmp[6]
static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
int time_increment_bits
number of bits to represent the fractional part of time
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
struct MpegEncContext MpegEncContext
MpegEncContext.
int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
Allocate a Picture.
int16_t(* p_mv_table)[2]
MV table (1MV per MB) p-frame encoding.
int mpeg_quant
0-> h263 quant 1-> mpeg quant
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
void msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
#define FF_MB_DECISION_BITS
chooses the one which needs the fewest bits
uint8_t * fcode_tab
smallest fcode needed for each MV
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
#define MV_TYPE_FIELD
2 vectors, one per field
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
uint8_t * mb_mean
Table for MB luminance.
uint64_t error[AV_NUM_DATA_POINTERS]
error
AVCodec * avcodec_find_encoder(enum CodecID id)
Find a registered encoder with a matching codec ID.
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG1 & B-frame MPEG4
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
int pre_pass
= 1 for the pre pass
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
void(* shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height)
float border_masking
Border processing masking, raises the quantizer for mbs on the borders of the picture.
#define CANDIDATE_MB_TYPE_BACKWARD_I
void ff_h263_encode_init(MpegEncContext *s)
#define CODEC_FLAG_CBP_RD
Use rate distortion optimization for cbp.
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
static void denoise_dct_c(MpegEncContext *s, DCTELEM *block)
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
int chroma_elim_threshold
chroma single coeff elimination threshold
uint16_t * mb_var
Table for MB variances.
static int estimate_qp(MpegEncContext *s, int dry_run)
#define CANDIDATE_MB_TYPE_BIDIR
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
int16_t(*[3] ac_val)[16]
used for for mpeg4 AC prediction, all 3 arrays must be continuous
av_cold int MPV_encode_end(AVCodecContext *avctx)
int mjpeg_hsample[3]
horizontal sampling factors, default = {2, 1, 1}
int(* try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale)
#define CANDIDATE_MB_TYPE_INTRA
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
static const uint8_t level_tab[7][2]
void(* rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb)
void ff_get_2pass_fcode(MpegEncContext *s)
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_...
int obmc
overlapped block motion compensation
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
void ff_mpeg1_clean_buffers(MpegEncContext *s)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
void msmpeg4_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced p-frame encoding.
static int select_input_picture(MpegEncContext *s)
int min_qcoeff
minimum encodable coefficient
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
int ildct_cmp
interlaced DCT comparison function
#define FF_ARRAY_ELEMS(a)
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
int intra_quant_bias
intra quantizer bias
static const AVClass h263_class
uint8_t * intra_ac_vlc_length
int padding_bug_score
used to detect the VERY common padding bug in MPEG4
const uint16_t ff_h263_format[8][2]
#define UNI_AC_ENC_INDEX(run, level)
int mb_num
number of MBs of a picture
int lmax
maximum Lagrange multipler
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
int frame_skip_cmp
frame skip comparison function
int time_base
time in seconds of last I,P,S Frame
int h263_aic
Advanded INTRA Coding (AIC)
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode b-frame encoding.
int encoding
true if we are encoding (vs decoding)
uint64_t vbv_delay
VBV delay coded in the last frame (in periods of a 27 MHz clock).
int scenechange_threshold
scene change detection threshold 0 is default, larger means fewer detected scene changes.
int(* pix_sum)(uint8_t *pix, int line_size)
void ff_mpeg4_merge_partitions(MpegEncContext *s)
static int mb_var_thread(AVCodecContext *c, void *arg)
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
int skipdct
skip dct and code zero residual
void ff_mpeg4_clean_buffers(MpegEncContext *s)
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_...
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
float p_masking
p block masking (0-> disabled)
int picture_in_gop_number
0-> first pic in gop, ...
static av_const unsigned int ff_sqrt(unsigned int a)
int alt_inter_vlc
alternative inter vlc
#define FF_API_MPEGVIDEO_GLOBAL_OPTS
#define CODEC_FLAG_INPUT_PRESERVED
The parent program guarantees that the input for B-frames containing streams is not written to for at...
int64_t time
time of current frame
static int encode_picture(MpegEncContext *s, int picture_number)
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (mpeg4) ...
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
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)
Picture ** input_picture
next pictures on display order for encoding
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
PutBitContext pb2
used for data partitioned VOPs
enum OutputFormat out_format
output format
void(* qpel_mc_func)(uint8_t *dst, uint8_t *src, int stride)
int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
uint16_t(* dct_offset)[64]
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale)
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
int pre_dia_size
ME prepass diamond size & shape.
static const AVOption h263p_options[]
static int get_sae(uint8_t *src, int ref, int stride)
int64_t pts
presentation timestamp in time_base units (time when frame should be shown to user) If AV_NOPTS_VALUE...
int misc_bits
cbp, mb_type
uint8_t motion_subsample_log2
log2 of the size of the block which a single vector in motion_val represents: (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
int me_cmp
motion estimation comparison function
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
Picture current_picture
copy of the current picture structure.
#define CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
void mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
void mpeg4_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
int MPV_encode_picture(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data)
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
static double av_q2d(AVRational a)
Convert rational to double.
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode b-frame encoding.
static void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
const uint16_t ff_aanscales[64]
uint8_t(* mv_penalty)[MAX_MV *2+1]
amount of bits needed to encode a MV
void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
int mb_threshold
Macroblock threshold below which the user specified macroblock types will be used.
#define CODEC_FLAG2_SKIP_RD
RD optimal MB level residual skipping.
AVCodecContext * avcodec_alloc_context3(AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
uint16_t pp_time
time distance between the last 2 p,s,i frames
uint8_t idct_permutation[64]
idct input permutation.
const uint8_t * scantable
int flags2
AVCodecContext.flags2.
int interlaced_frame
The content of the picture is interlaced.
int mb_height
number of MBs horizontally & vertically
#define LOCAL_ALIGNED_16(t, v,...)
void MPV_common_end(MpegEncContext *s)
float lumi_masking
luminance masking (0-> disabled)
int max_qcoeff
maximum encodable coefficient
void ff_h261_encode_init(MpegEncContext *s)
#define FF_BUFFER_TYPE_INTERNAL
int dquant
qscale difference to prev qscale
int num_entries
number of RateControlEntries
int gop_picture_number
index of the first picture of a GOP based on fake_pic_num & mpeg1 specific
static void ff_update_block_index(MpegEncContext *s)
static int init(AVCodecParserContext *s)
qpel_mc_func put_qpel_pixels_tab[2][16]
#define CANDIDATE_MB_TYPE_FORWARD
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
#define ROUNDED_DIV(a, b)
int(* q_inter_matrix)[64]
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
preferred ID for MPEG-1/2 video decoding
static int get_bits_diff(MpegEncContext *s)
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
int intra_only
if true, only intra pictures are generated
const uint16_t ff_mpeg1_default_intra_matrix[64]
int16_t * dc_val[3]
used for mpeg4 DC prediction, all 3 arrays must be continuous
int h263_plus
h263 plus headers
int slice_context_count
number of used thread_contexts
#define CANDIDATE_MB_TYPE_DIRECT
int last_non_b_pict_type
used for mpeg4 gmc b-frames & ratecontrol
int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
int has_b_frames
Size of the frame reordering buffer in the decoder.
static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
int last_dc[3]
last DC values for MPEG1
uint8_t * inter_ac_vlc_last_length
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Multithreading support functions.
int mb_skipped
MUST BE SET only during DECODING.
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
int strict_std_compliance
strictly follow the std (MPEG4, ...)
int partitioned_frame
is current frame partitioned
qpel_mc_func avg_qpel_pixels_tab[2][16]
int frame_skip_threshold
frame skip threshold
int me_sub_cmp
subpixel motion estimation comparison function
int qmax
maximum quantizer
void ff_write_pass1_stats(MpegEncContext *s)
int unrestricted_mv
mv can point outside of the coded picture
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int last_lambda_for[5]
last lambda for a specific pict type
static int sse_mb(MpegEncContext *s)
#define CODEC_FLAG_QP_RD
Use rate distortion optimization for qp selectioon.
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
#define FF_BUFFER_TYPE_USER
direct rendering buffers (image is (de)allocated by user)
int h263_slice_structured
int rc_max_rate
maximum bitrate
void ff_rate_control_uninit(MpegEncContext *s)
#define CANDIDATE_MB_TYPE_INTER
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
int ff_check_alignment(void)
int quarter_sample
1->qpel, 0->half pel ME/MC
uint16_t * mb_type
Table for candidate MB types for encoding.
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
int low_delay
no reordering needed / has no b-frames
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
uint8_t *[2][2] b_field_select_table
#define CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static int put_bits_count(PutBitContext *s)
void MPV_frame_end(MpegEncContext *s)
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
int resync_mb_x
x position of last resync marker
static av_always_inline void emms_c(void)
Empty mmx state.
int rc_buffer_size
decoder bitstream buffer size
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
int coded_picture_number
used to set pic->coded_picture_number, should not be used for/by anything else
static void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
static int estimate_best_b_count(MpegEncContext *s)
int intra_dc_precision
precision of the intra DC coefficient - 8
int me_penalty_compensation
uint8_t * intra_ac_vlc_last_length
The simplest mpeg encoder (well, it was the simplest!).
void ff_h263_loop_filter(MpegEncContext *s)
void fdct_ifast(DCTELEM *data)
uint32_t ff_squareTbl[512]
int bit_rate
the average bitrate
void ff_mjpeg_encode_picture_header(MpegEncContext *s)
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
int ff_h263_get_gob_height(MpegEncContext *s)
Get the GOB height based on picture height.
int display_picture_number
picture number in display order
uint16_t(* q_inter_matrix16)[2][64]
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
int fixed_qscale
fixed qscale if non zero
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is acually possible in mpeg4
int me_method
ME algorithm.
int umvplus
== H263+ && unrestricted_mv
Picture new_picture
copy of the source picture structure for encoding.
int intra_quant_bias
bias for the quantizer
int width
picture width / height.
int type
type of the buffer (to keep track of who has to deallocate data[*])
Picture * current_picture_ptr
pointer to the current picture
void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64])
void ff_copy_picture(Picture *dst, Picture *src)
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow. ...
#define CANDIDATE_MB_TYPE_INTER4V
void ff_msmpeg4_encode_init(MpegEncContext *s)
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
static av_always_inline av_const long int lrintf(float x)
void msmpeg4_encode_ext_header(MpegEncContext *s)
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
#define CODEC_FLAG_LOOP_FILTER
loop filter
int block_last_index[12]
last non zero coefficient in block
void ff_wmv2_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
const int16_t ff_mpeg4_default_non_intra_matrix[64]
int mb_decision
macroblock decision mode
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride)
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
void rv20_encode_picture_header(MpegEncContext *s, int picture_number)
int ac_esc_length
num of bits needed to encode the longest esc
#define CANDIDATE_MB_TYPE_BACKWARD
#define CANDIDATE_MB_TYPE_SKIPPED
av_cold int MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
int block_index[6]
index to current MB in block based arrays with edges
#define sq(reg, off, base)
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
int inter_quant_bias
inter quantizer bias
static uint8_t default_fcode_tab[MAX_MV *2+1]
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
int mjpeg_vsample[3]
vertical sampling factors, default = {2, 1, 1}
static void build_basis(uint8_t *perm)
uint32_t * mb_type
macroblock type table mb_type_base + mb_width + 2
void ff_jpeg_fdct_islow_10(DCTELEM *data)
#define MV_TYPE_16X16
1 vector for the whole mb
int frame_skip_factor
frame skip factor
int first_slice_line
used in mpeg4 too to handle resync markers
#define CODEC_FLAG_LOW_DELAY
Force low delay.
uint16_t * mc_mb_var
Table for motion compensated MB variances.
void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_faandct(DCTELEM *data)
const uint8_t *const ff_mpeg2_dc_scale_table[4]
void avcodec_get_chroma_sub_sample(enum PixelFormat pix_fmt, int *h_shift, int *v_shift)
int coded_picture_number
picture number in bitstream order
uint16_t inter_matrix[64]
uint64_t error[AV_NUM_DATA_POINTERS]
error
int(* fast_dct_quantize)(struct MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
struct MpegEncContext * thread_context[MAX_THREADS]
#define CONFIG_MSMPEG4_ENCODER
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
double buffer_index
amount of bits in the video/audio buffer
int me_threshold
Motion estimation threshold below which no motion estimation is performed, but instead the user speci...
void ff_h263_update_motion_val(MpegEncContext *s)
int h263_flv
use flv h263 header
static const AVClass h263p_class
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
int idct_permutation_type
void(* denoise_dct)(struct MpegEncContext *s, DCTELEM *block)
const uint16_t ff_inv_aanscales[64]
int frame_bits
number of bits used for the previously encoded frame
void ff_mjpeg_encode_close(MpegEncContext *s)
main external API structure.
static void close(AVCodecParserContext *s)
void ff_h261_reorder_mb_index(MpegEncContext *s)
ScanTable intra_scantable
int pre_me
prepass for motion estimation
#define CODEC_FLAG_QSCALE
Use fixed qscale.
int qmin
minimum quantizer
int height
picture size. must be a multiple of 16
#define FF_DEFAULT_QUANT_BIAS
void(* diff_pixels)(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride)
void ff_mjpeg_encode_stuffing(PutBitContext *pbc)
static void write_slice_end(MpegEncContext *s)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void ff_mjpeg_encode_picture_trailer(MpegEncContext *s)
int16_t(*[2] motion_val)[2]
motion vector table
int64_t user_specified_pts
last non zero pts from AVFrame which was passed into avcodec_encode_video()
int ff_h261_get_picture_format(int width, int height)
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
#define CODEC_FLAG_QPEL
Use qpel MC.
void ff_fix_long_p_mvs(MpegEncContext *s)
Picture * picture
main picture buffer
int data_partitioning
data partitioning flag from header
uint8_t * inter_ac_vlc_length
uint16_t * intra_matrix
custom intra quantization matrix
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src)
Describe the class of an AVClass context structure.
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced b-frame encoding.
#define FF_MB_DECISION_RD
rate distortion
static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type)
int input_picture_number
used to set pic->display_picture_number, should not be used for/by anything else
void(* add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale)
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
void ff_set_mpeg4_time(MpegEncContext *s)
static void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type)
int8_t * ref_index[2]
motion reference frame index the order in which these are stored can depend on the codec...
DSPContext dsp
pointers for accelerated dsp functions
int(* pix_norm1)(uint8_t *pix, int line_size)
void MPV_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVFrame *pict)
Encode a video frame from pict into buf.
int frame_skip_exp
frame skip exponent
const int16_t ff_mpeg4_default_intra_matrix[64]
int f_code
forward MV resolution
int ff_pre_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
#define CANDIDATE_MB_TYPE_BIDIR_I
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV *2+1]
uint16_t * inter_matrix
custom inter quantization matrix
int max_b_frames
max number of b-frames for encoding
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
int bit_rate
wanted bit rate
DCTELEM(* block)[64]
points to one of the following blocks
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
int last_mv_dir
last mv_dir, used for b frame encoding
#define CANDIDATE_MB_TYPE_FORWARD_I
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
int h263_pred
use mpeg4/h263 ac/dc predictions
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode b-frame encoding.
float dark_masking
darkness masking (0-> disabled)
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
int ff_init_me(MpegEncContext *s)
uint8_t *[2] p_field_select_table
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode b-frame encoding.
static const uint16_t scale[4]
AAN (Arai Agui Nakajima) (I)DCT tables.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
int8_t * qscale_table
QP table.
#define CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode b-frame encoding.
int noise_reduction
noise reduction strength
static int estimate_motion_thread(AVCodecContext *c, void *arg)
void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block.
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
struct AVCodecContext * avctx
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
#define CODEC_FLAG_CLOSED_GOP
PutBitContext pb
bit output
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
static void update_qscale(MpegEncContext *s)
int mb_cmp
macroblock comparison function (not supported yet)
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg)
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
av_cold int MPV_encode_init(AVCodecContext *avctx)
void ff_jpeg_fdct_islow_8(DCTELEM *data)
const uint8_t ff_h263_chroma_qscale_table[32]
void(* fdct)(DCTELEM *block)
int adaptive_quant
use adaptive quantization
static int16_t basis[64][64]
static int score_tab[256]
Picture last_picture
copy of the previous picture structure.
int ff_rate_control_init(MpegEncContext *s)
int ff_vbv_update(MpegEncContext *s, int frame_size)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
AVCodec ff_msmpeg4v3_encoder
int trellis
trellis RD quantization
#define CANDIDATE_MB_TYPE_DIRECT0
void ff_mpeg4_stuffing(PutBitContext *pbc)
add mpeg4 stuffing bits (01...1)
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
void ff_h261_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
int last_bits
temp var used for calculating the above vars
void ff_mpeg4_init_partitions(MpegEncContext *s)
int quantizer_noise_shaping
quantizer noise shaping
int dia_size
ME diamond size & shape.
int b_sensitivity
Adjust sensitivity of b_frame_strategy 1.
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
int top_field_first
If the content is interlaced, is top field displayed first.
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src)
int error_rate
Simulates errors in the bitstream to test error concealment.
int ff_get_best_fcode(MpegEncContext *s, int16_t(*mv_table)[2], int type)
int resync_mb_y
y position of last resync marker
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
PutBitContext tex_pb
used for data partitioned VOPs
Picture next_picture
copy of the next picture structure.
static void MPV_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
int key_frame
1 -> keyframe, 0-> not
static void set_frame_distances(MpegEncContext *s)
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
int linesize
line size, in bytes, may be different from width
void ff_fix_long_mvs(MpegEncContext *s, uint8_t *field_select_table, int field_select, int16_t(*mv_table)[2], int f_code, int type, int truncate)
Picture ** reordered_input_picture
pointer to the next pictures in codedorder for encoding
static const struct @46 tab
TwinVQ codebooks.
void ff_mpeg1_encode_init(MpegEncContext *s)
static int encode_thread(AVCodecContext *c, void *arg)
int flags
AVCodecContext.flags (HQ, MV4, ...)
int mc_mb_var_sum
motion compensated MB variance for current frame
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src)
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]
int inter_quant_bias
bias for the quantizer
int me_method
Motion estimation algorithm used for video coding.
#define FF_BUFFER_TYPE_SHARED
Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared...
int ff_find_unused_picture(MpegEncContext *s, int shared)
#define MV_TYPE_8X8
4 vectors (h263, mpeg4 4MV)
int rc_min_rate
minimum bitrate
int b_code
backward MV resolution for B Frames (mpeg4)
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function for encode/decode called after coding/decoding the header and before a frame is code...
static void MPV_encode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for encoding.
int uvlinesize
line size, for chroma in bytes, may be different from width
int delay
Number of frames the decoded output will be delayed relative to the encoded input.
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
#define CANDIDATE_MB_TYPE_INTER_I
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
#define AV_NOPTS_VALUE
Undefined timestamp value.
static void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], int *dmin, int *next_block, int motion_x, int motion_y)
unsigned int lambda
lagrange multipler used in rate distortion
#define CODEC_FLAG2_STRICT_GOP
Strictly enforce GOP size.
AVCodec ff_msmpeg4v2_encoder
uint16_t pb_time
time distance between the last b and p,s,i frame
int luma_elim_threshold
luma single coefficient elimination threshold
int next_lambda
next lambda used for retrying to encode a frame