32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/opt.h"
70 uint16_t (*qmat16)[2][64],
71 const uint16_t *quant_matrix,
72 int bias,
int qmin,
int qmax,
int intra)
77 for (qscale = qmin; qscale <= qmax; qscale++) {
82 for (i = 0; i < 64; i++) {
91 (qscale * quant_matrix[j]));
94 for (i = 0; i < 64; i++) {
106 for (i = 0; i < 64; i++) {
114 (qscale * quant_matrix[j]));
118 (qscale * quant_matrix[j]);
120 if (qmat16[qscale][0][i] == 0 ||
121 qmat16[qscale][0][i] == 128 * 256)
122 qmat16[
qscale][0][i] = 128 * 256 - 1;
125 qmat16[qscale][0][i]);
129 for (i = intra; i < 64; i++) {
134 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
141 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
162 for (i = 0; i < 64; i++) {
177 for (i = 0; i < s->
mb_num; i++) {
188 #define COPY(a) dst->a= src->a
213 for (i = -16; i < 16; i++) {
240 int chroma_h_shift, chroma_v_shift;
249 "only YUV420 and YUV422 are supported\n");
310 "keyframe interval too large!, reducing it from %d to %d\n",
377 av_log(avctx,
AV_LOG_ERROR,
"Either both buffer size and max rate or neither must be specified\n");
384 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
401 "impossible bitrate constraints, this will fail\n");
415 "bitrate tolerance too small for bitrate\n");
426 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
427 "specified vbv buffer is too large for the given bitrate!\n");
439 "OBMC is only supported with simple mb decision\n");
462 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
470 (avctx->
width > 2048 ||
477 ((avctx->
width &3) ||
484 (avctx->
width > 4095 ||
491 (avctx->
width > 16383 ||
492 avctx->
height > 16383 )) {
493 av_log(avctx,
AV_LOG_ERROR,
"MPEG-2 does not support resolutions above 16383x16383\n");
528 "mpeg2 style quantization not supported by codec\n");
546 "closed gop with scene change detection are not supported yet, "
547 "set threshold to 1000000000\n");
554 "low delay forcing is only available for mpeg2\n");
559 "b frames cannot be used with low delay\n");
565 if (avctx->
qmax > 12) {
567 "non linear quant only supports qmax <= 12 currently\n");
579 "multi threaded encoding not supported by codec\n");
585 "automatic thread number detection not supported by codec, "
601 i = (INT_MAX / 2 + 128) >> 8;
610 "notice: b_frame_strategy only affects the first pass\n");
633 av_log(avctx,
AV_LOG_ERROR,
"qmin and or qmax are invalid, they must be 0 < min <= max\n");
649 "timebase %d/%d not supported by MPEG 4 standard, "
650 "the maximum admitted value for the timebase denominator "
703 "The specified picture size of %dx%d is not valid for the "
704 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
718 "The specified picture size of %dx%d is not valid for "
719 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
720 "352x288, 704x576, and 1408x1152. "
845 for (i = 0; i < 64; i++) {
903 for (y = 0; y < 16; y++) {
904 for (x = 0; x < 16; x++) {
905 acc +=
FFABS(src[x + y * stride] - ref);
921 for (y = 0; y < h; y += 16) {
922 for (x = 0; x < w; x += 16) {
926 int mean = (s->
dsp.
pix_sum(src + offset, stride) + 128) >> 8;
927 int sae =
get_sae(src + offset, mean, stride);
929 acc += sae + 500 < sad;
940 int i, display_picture_number = 0,
ret;
955 "Invalid pts (%"PRId64
") <= last (%"PRId64
")\n",
960 if (!s->
low_delay && display_picture_number == 1)
969 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
972 pts = display_picture_number;
978 if (!pic_arg->
buf[0])
1020 int h_chroma_shift, v_chroma_shift;
1025 for (i = 0; i < 3; i++) {
1026 int src_stride = pic_arg->
linesize[i];
1028 int h_shift = i ? h_chroma_shift : 0;
1029 int v_shift = i ? v_chroma_shift : 0;
1030 int w = s->
width >> h_shift;
1031 int h = s->
height >> v_shift;
1036 h = ((s->
height + 15)/16*16) >> v_shift;
1042 if (src_stride == dst_stride)
1043 memcpy(dst, src, src_stride * h);
1048 memcpy(dst2, src, w);
1084 int64_t score64 = 0;
1086 for (plane = 0; plane < 3; plane++) {
1088 const int bw = plane ? 1 : 2;
1089 for (y = 0; y < s->
mb_height * bw; y++) {
1090 for (x = 0; x < s->
mb_width * bw; x++) {
1097 case 0: score =
FFMAX(score, v);
break;
1098 case 1: score +=
FFABS(v);
break;
1099 case 2: score += v *
v;
break;
1100 case 3: score64 +=
FFABS(v * v * (int64_t)v);
break;
1101 case 4: score64 += v * v * (int64_t)(v * v);
break;
1120 int ret, got_output;
1138 int i, j, out_size, p_lambda, b_lambda,
lambda2;
1139 int64_t best_rd = INT64_MAX;
1140 int best_b_count = -1;
1150 b_lambda = p_lambda;
1178 input[i].
data[1] = input[i].
data[0] + ysize;
1179 input[i].
data[2] = input[i].
data[1] + csize;
1185 pre_input = *pre_input_ptr;
1187 if (!pre_input.
shared && i) {
1225 input[i + 1].
quality = is_p ? p_lambda : b_lambda;
1253 return best_b_count;
1326 b_frames =
FFMAX(0, i - 1);
1329 for (i = 0; i < b_frames + 1; i++) {
1341 for (i = b_frames - 1; i >= 0; i--) {
1349 "warning, too many b frames in a row\n");
1372 for (i = 0; i < b_frames; i++) {
1418 for (i = 0; i < 4; i++) {
1435 AVFrame *pic_arg,
int *got_packet)
1438 int i, stuffing_count,
ret;
1461 for (i = 0; i < context_count; i++) {
1522 for (i = 0; i < context_count; i++) {
1535 for (i = 0; i < 4; i++) {
1549 if (stuffing_count) {
1551 stuffing_count + 50) {
1559 while (stuffing_count--) {
1566 stuffing_count -= 4;
1567 while (stuffing_count--) {
1593 "Internal error, negative bits\n");
1601 vbv_delay =
FFMAX(vbv_delay, min_delay);
1641 *got_packet = !!pkt->
size;
1646 int n,
int threshold)
1648 static const char tab[64] = {
1649 3, 2, 2, 1, 1, 1, 1, 1,
1650 1, 1, 1, 1, 1, 1, 1, 1,
1651 1, 1, 1, 1, 1, 1, 1, 1,
1652 0, 0, 0, 0, 0, 0, 0, 0,
1653 0, 0, 0, 0, 0, 0, 0, 0,
1654 0, 0, 0, 0, 0, 0, 0, 0,
1655 0, 0, 0, 0, 0, 0, 0, 0,
1656 0, 0, 0, 0, 0, 0, 0, 0
1665 if (threshold < 0) {
1667 threshold = -threshold;
1672 if (last_index <= skip_dc - 1)
1675 for (i = 0; i <= last_index; i++) {
1679 if (skip_dc && i == 0)
1683 }
else if (level > 1) {
1689 if (score >= threshold)
1691 for (i = skip_dc; i <= last_index; i++) {
1714 for (; i <= last_index; i++) {
1716 int level = block[j];
1718 if (level > maxlevel) {
1721 }
else if (level < minlevel) {
1731 "warning, clipping %d dct coefficients to %d..%d\n",
1732 overflow, minlevel, maxlevel);
1739 for (y = 0; y < 8; y++) {
1740 for (x = 0; x < 8; x++) {
1746 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
1747 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
1748 int v = ptr[x2 + y2 *
stride];
1754 weight[x + 8 *
y]= (36 *
ff_sqrt(count * sqr - sum * sum)) / count;
1760 int motion_x,
int motion_y,
1761 int mb_block_height,
1766 int16_t orig[12][64];
1773 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1774 ptrdiff_t wrap_y, wrap_c;
1776 for (i = 0; i < mb_block_count; i++)
1780 const int last_qp = s->
qscale;
1781 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1812 (mb_y * 16 * wrap_y) + mb_x * 16;
1814 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1816 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1826 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1828 ptr_cb = ebuf + 18 * wrap_y;
1830 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1832 ptr_cr = ebuf + 18 * wrap_y + 16;
1837 int progressive_score, interlaced_score;
1843 NULL, wrap_y, 8) - 400;
1845 if (progressive_score > 0) {
1847 NULL, wrap_y * 2, 8) +
1849 NULL, wrap_y * 2, 8);
1850 if (progressive_score > interlaced_score) {
1853 dct_offset = wrap_y;
1854 uv_dct_offset = wrap_c;
1889 uint8_t *dest_y, *dest_cb, *dest_cr;
1891 dest_y = s->
dest[0];
1892 dest_cb = s->
dest[1];
1893 dest_cr = s->
dest[2];
1917 int progressive_score, interlaced_score;
1924 ptr_y + wrap_y * 8, wrap_y,
1928 progressive_score -= 400;
1930 if (progressive_score > 0) {
1938 if (progressive_score > interlaced_score) {
1941 dct_offset = wrap_y;
1942 uv_dct_offset = wrap_c;
1953 dest_y + dct_offset, wrap_y);
1955 dest_y + dct_offset + 8, wrap_y);
1965 dest_cb + uv_dct_offset, wrap_c);
1967 dest_cr + uv_dct_offset, wrap_c);
1974 if (s->
dsp.
sad[1](NULL, ptr_y , dest_y,
1975 wrap_y, 8) < 20 * s->
qscale)
1977 if (s->
dsp.
sad[1](NULL, ptr_y + 8,
1978 dest_y + 8, wrap_y, 8) < 20 * s->
qscale)
1980 if (s->
dsp.
sad[1](NULL, ptr_y + dct_offset,
1981 dest_y + dct_offset, wrap_y, 8) < 20 * s->
qscale)
1983 if (s->
dsp.
sad[1](NULL, ptr_y + dct_offset + 8,
1984 dest_y + dct_offset + 8,
1985 wrap_y, 8) < 20 * s->
qscale)
1987 if (s->
dsp.
sad[1](NULL, ptr_cb, dest_cb,
1988 wrap_c, 8) < 20 * s->
qscale)
1990 if (s->
dsp.
sad[1](NULL, ptr_cr, dest_cr,
1991 wrap_c, 8) < 20 * s->
qscale)
1994 if (s->
dsp.
sad[1](NULL, ptr_cb + uv_dct_offset,
1995 dest_cb + uv_dct_offset,
1996 wrap_c, 8) < 20 * s->
qscale)
1998 if (s->
dsp.
sad[1](NULL, ptr_cr + uv_dct_offset,
1999 dest_cr + uv_dct_offset,
2000 wrap_c, 8) < 20 * s->
qscale)
2027 memcpy(orig[0], s->
block[0],
sizeof(int16_t) * 64 * mb_block_count);
2033 for (i = 0; i < mb_block_count; i++) {
2048 for (i = 0; i < mb_block_count; i++) {
2058 for (i = 0; i < 4; i++)
2061 for (i = 4; i < mb_block_count; i++)
2065 for (i = 0; i < mb_block_count; i++) {
2078 for (i=6; i<12; i++) {
2087 for (i = 0; i < mb_block_count; i++) {
2090 for (j = 63; j > 0; j--) {
2180 memcpy(d->
mv, s->
mv, 2*4*2*
sizeof(
int));
2218 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2226 s->
pb= pb[*next_block];
2228 s->
pb2 = pb2 [*next_block];
2229 s->
tex_pb= tex_pb[*next_block];
2233 memcpy(dest_backup, s->
dest,
sizeof(s->
dest));
2256 memcpy(s->
dest, dest_backup,
sizeof(s->
dest));
2274 else if(w==8 && h==8)
2364 for(mb_x=0; mb_x < s->
mb_width; mb_x++) {
2408 bytestream_put_le32(&ptr, offset);
2409 bytestream_put_byte(&ptr, s->
qscale);
2410 bytestream_put_byte(&ptr, gobn);
2411 bytestream_put_le16(&ptr, mba);
2412 bytestream_put_byte(&ptr, pred_x);
2413 bytestream_put_byte(&ptr, pred_y);
2415 bytestream_put_byte(&ptr, 0);
2416 bytestream_put_byte(&ptr, 0);
2512 for(mb_x=0; mb_x < s->
mb_width; mb_x++) {
2543 int current_packet_size, is_gob_start;
2549 if(s->
start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2558 if(s->
mb_x==0 && s->
mb_y!=0) is_gob_start=1;
2563 if(s->
mb_x==0 && s->
mb_y!=0) is_gob_start=1;
2582 current_packet_size=0;
2640 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2657 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2658 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2669 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2670 &dmin, &next_block, 0, 0);
2678 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2679 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2689 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2690 &dmin, &next_block, 0, 0);
2698 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2699 &dmin, &next_block, s->
mv[0][0][0], s->
mv[0][0][1]);
2707 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2708 &dmin, &next_block, s->
mv[1][0][0], s->
mv[1][0][1]);
2718 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2719 &dmin, &next_block, 0, 0);
2730 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2731 &dmin, &next_block, 0, 0);
2742 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2743 &dmin, &next_block, 0, 0);
2749 for(dir=0; dir<2; dir++){
2756 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2757 &dmin, &next_block, 0, 0);
2765 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2766 &dmin, &next_block, 0, 0);
2777 const int last_qp= backup_s.
qscale;
2781 static const int dquant_tab[4]={-1,1,-2,2};
2790 s->
mv[0][0][0] = best_s.
mv[0][0][0];
2791 s->
mv[0][0][1] = best_s.
mv[0][0][1];
2792 s->
mv[1][0][0] = best_s.
mv[1][0][0];
2793 s->
mv[1][0][1] = best_s.
mv[1][0][1];
2796 for(; qpi<4; qpi++){
2797 int dquant= dquant_tab[qpi];
2809 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
2810 &dmin, &next_block, s->
mv[mvdir][0][0], s->
mv[mvdir][0][1]);
2830 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2831 &dmin, &next_block, mx, my);
2838 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2839 &dmin, &next_block, 0, 0);
2847 memcpy(s->
mv, best_s.
mv,
sizeof(s->
mv));
2868 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
2869 &dmin, &next_block, mx, my);
2909 int motion_x = 0, motion_y = 0;
2917 motion_x= s->
mv[0][0][0] = 0;
2918 motion_y= s->
mv[0][0][1] = 0;
3005 for(dir=0; dir<2; dir++){
3079 #define MERGE(field) dst->field += src->field; src->field=0
3106 for(i=0; i<64; i++){
3220 for(i=1; i<context_count; i++){
3250 for(i=1; i<context_count; i++){
3263 av_dlog(s,
"Scene change detected, encoding as I Frame %d %d\n",
3307 for(dir=0; dir<2; dir++){
3342 static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
3343 static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
3407 for(i=1; i<context_count; i++){
3411 for(i=1; i<context_count; i++){
3424 for(i=0; i<64; i++){
3425 int level= block[i];
3431 if(level<0) level=0;
3435 if(level>0) level=0;
3444 int qscale,
int *overflow){
3449 unsigned int threshold1, threshold2;
3461 int coeff_count[64];
3462 int qmul, qadd, start_i, last_non_zero, i,
dc;
3473 qadd= ((qscale-1)|1)*8;
3490 block[0] = (block[0] + (q >> 1)) / q;
3508 threshold2= (threshold1<<1);
3510 for(i=63; i>=start_i; i--) {
3511 const int j = scantable[i];
3512 int level = block[j] * qmat[j];
3514 if(((
unsigned)(level+threshold1))>threshold2){
3520 for(i=start_i; i<=last_non_zero; i++) {
3521 const int j = scantable[i];
3522 int level = block[j] * qmat[j];
3526 if(((
unsigned)(level+threshold1))>threshold2){
3530 coeff[1][i]= level-1;
3534 coeff[0][i]= -
level;
3535 coeff[1][i]= -level+1;
3538 coeff_count[i]=
FFMIN(level, 2);
3542 coeff[0][i]= (level>>31)|1;
3549 if(last_non_zero < start_i){
3550 memset(block + start_i, 0, (64-start_i)*
sizeof(int16_t));
3551 return last_non_zero;
3554 score_tab[start_i]= 0;
3555 survivor[0]= start_i;
3558 for(i=start_i; i<=last_non_zero; i++){
3559 int level_index, j, zero_distortion;
3560 int dct_coeff=
FFABS(block[ scantable[i] ]);
3561 int best_score=256*256*256*120;
3565 zero_distortion= dct_coeff*dct_coeff;
3567 for(level_index=0; level_index < coeff_count[i]; level_index++){
3569 int level= coeff[level_index][i];
3570 const int alevel=
FFABS(level);
3576 unquant_coeff= alevel*qmul + qadd;
3580 unquant_coeff = (int)( alevel * qscale * s->
intra_matrix[j]) >> 3;
3581 unquant_coeff = (unquant_coeff - 1) | 1;
3583 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->
inter_matrix[j])) >> 4;
3584 unquant_coeff = (unquant_coeff - 1) | 1;
3589 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3591 if((level&(~127)) == 0){
3592 for(j=survivor_count-1; j>=0; j--){
3593 int run= i - survivor[j];
3595 score += score_tab[i-
run];
3597 if(score < best_score){
3600 level_tab[i+1]= level-64;
3605 for(j=survivor_count-1; j>=0; j--){
3606 int run= i - survivor[j];
3608 score += score_tab[i-
run];
3609 if(score < last_score){
3612 last_level= level-64;
3618 distortion += esc_length*
lambda;
3619 for(j=survivor_count-1; j>=0; j--){
3620 int run= i - survivor[j];
3621 int score= distortion + score_tab[i-
run];
3623 if(score < best_score){
3626 level_tab[i+1]= level-64;
3631 for(j=survivor_count-1; j>=0; j--){
3632 int run= i - survivor[j];
3633 int score= distortion + score_tab[i-
run];
3634 if(score < last_score){
3637 last_level= level-64;
3645 score_tab[i+1]= best_score;
3648 if(last_non_zero <= 27){
3649 for(; survivor_count; survivor_count--){
3650 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3654 for(; survivor_count; survivor_count--){
3655 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3660 survivor[ survivor_count++ ]= i+1;
3664 last_score= 256*256*256*120;
3665 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3666 int score= score_tab[i];
3667 if(i) score += lambda*2;
3669 if(score < last_score){
3672 last_level= level_tab[i];
3673 last_run= run_tab[i];
3680 dc=
FFABS(block[0]);
3681 last_non_zero= last_i - 1;
3682 memset(block + start_i, 0, (64-start_i)*
sizeof(int16_t));
3684 if(last_non_zero < start_i)
3685 return last_non_zero;
3687 if(last_non_zero == 0 && start_i == 0){
3689 int best_score= dc *
dc;
3691 for(i=0; i<coeff_count[0]; i++){
3692 int level= coeff[i][0];
3693 int alevel=
FFABS(level);
3694 int unquant_coeff, score, distortion;
3697 unquant_coeff= (alevel*qmul + qadd)>>3;
3699 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->
inter_matrix[0])) >> 4;
3700 unquant_coeff = (unquant_coeff - 1) | 1;
3702 unquant_coeff = (unquant_coeff + 4) >> 3;
3703 unquant_coeff<<= 3 + 3;
3705 distortion= (unquant_coeff -
dc) * (unquant_coeff - dc);
3708 else score= distortion + esc_length*
lambda;
3710 if(score < best_score){
3712 best_level= level - 64;
3715 block[0]= best_level;
3717 if(best_level == 0)
return -1;
3718 else return last_non_zero;
3724 block[ perm_scantable[last_non_zero] ]= last_level;
3727 for(; i>start_i; i -= run_tab[i] + 1){
3728 block[ perm_scantable[i-1] ]= level_tab[i];
3731 return last_non_zero;
3746 int perm_index= perm[
index];
3747 if(i==0) s*= sqrt(0.5);
3748 if(j==0) s*= sqrt(0.5);
3749 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)));
3768 int qmul, qadd, start_i, last_non_zero, i,
dc;
3772 int rle_index,
run, q = 1, sum;
3775 static int after_last=0;
3776 static int to_zero=0;
3777 static int from_zero=0;
3780 static int messed_sign=0;
3783 if(basis[0][0] == 0)
3820 for(i=0; i<64; i++){
3827 for(i=0; i<64; i++){
3832 w=
FFABS(weight[i]) + qns*one;
3833 w= 15 + (48*qns*one + w/2)/w;
3848 for(i=start_i; i<=last_non_zero; i++){
3849 int j= perm_scantable[i];
3850 const int level= block[j];
3854 if(level<0) coeff= qmul*level - qadd;
3855 else coeff= qmul*level + qadd;
3856 run_tab[rle_index++]=
run;
3865 if(last_non_zero>0){
3876 int run2, best_unquant_change=0, analyze_gradient;
3882 if(analyze_gradient){
3886 for(i=0; i<64; i++){
3902 const int level= block[0];
3903 int change, old_coeff;
3909 for(change=-1; change<=1; change+=2){
3910 int new_level= level + change;
3911 int score, new_coeff;
3913 new_coeff= q*new_level;
3914 if(new_coeff >= 2048 || new_coeff < 0)
3917 score= s->
dsp.
try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3918 if(score<best_score){
3921 best_change= change;
3922 best_unquant_change= new_coeff - old_coeff;
3929 run2= run_tab[rle_index++];
3933 for(i=start_i; i<64; i++){
3934 int j= perm_scantable[i];
3935 const int level= block[j];
3936 int change, old_coeff;
3942 if(level<0) old_coeff= qmul*level - qadd;
3943 else old_coeff= qmul*level + qadd;
3944 run2= run_tab[rle_index++];
3951 for(change=-1; change<=1; change+=2){
3952 int new_level= level + change;
3953 int score, new_coeff, unquant_change;
3960 if(new_level<0) new_coeff= qmul*new_level - qadd;
3961 else new_coeff= qmul*new_level + qadd;
3962 if(new_coeff >= 2048 || new_coeff <= -2048)
3967 if(level < 63 && level > -63){
3968 if(i < last_non_zero)
3978 if(analyze_gradient){
3979 int g= d1[ scantable[i] ];
3980 if(g && (g^new_level) >= 0)
3984 if(i < last_non_zero){
3985 int next_i= i + run2 + 1;
3986 int next_level= block[ perm_scantable[next_i] ] + 64;
3988 if(next_level&(~127))
3991 if(next_i < last_non_zero)
4011 if(i < last_non_zero){
4012 int next_i= i + run2 + 1;
4013 int next_level= block[ perm_scantable[next_i] ] + 64;
4015 if(next_level&(~127))
4018 if(next_i < last_non_zero)
4037 unquant_change= new_coeff - old_coeff;
4038 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4041 if(score<best_score){
4044 best_change= change;
4045 best_unquant_change= unquant_change;
4049 prev_level= level + 64;
4050 if(prev_level&(~127))
4063 int j= perm_scantable[ best_coeff ];
4065 block[j] += best_change;
4067 if(best_coeff > last_non_zero){
4068 last_non_zero= best_coeff;
4076 if(block[j] - best_change){
4077 if(
FFABS(block[j]) >
FFABS(block[j] - best_change)){
4089 for(; last_non_zero>=start_i; last_non_zero--){
4090 if(block[perm_scantable[last_non_zero]])
4096 if(256*256*256*64 % count == 0){
4097 av_log(s->
avctx,
AV_LOG_DEBUG,
"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);
4102 for(i=start_i; i<=last_non_zero; i++){
4103 int j= perm_scantable[i];
4104 const int level= block[j];
4107 run_tab[rle_index++]=
run;
4120 if(last_non_zero>0){
4126 return last_non_zero;
4131 int qscale,
int *overflow)
4133 int i, j,
level, last_non_zero, q, start_i;
4138 unsigned int threshold1, threshold2;
4157 block[0] = (block[0] + (q >> 1)) / q;
4169 threshold2= (threshold1<<1);
4170 for(i=63;i>=start_i;i--) {
4172 level = block[j] * qmat[j];
4174 if(((
unsigned)(level+threshold1))>threshold2){
4181 for(i=start_i; i<=last_non_zero; i++) {
4183 level = block[j] * qmat[j];
4187 if(((
unsigned)(level+threshold1))>threshold2){
4206 return last_non_zero;
4209 #define OFFSET(x) offsetof(MpegEncContext, x)
4210 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4214 {
"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 },
4271 .
name =
"msmpeg4v2",
4280 .priv_class = &msmpeg4v2_class,
4295 .priv_class = &msmpeg4v3_class,
4310 .priv_class = &wmv1_class,
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
void ff_h261_reorder_mb_index(MpegEncContext *s)
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
int chroma_elim_threshold
void ff_jpeg_fdct_islow_10(int16_t *data)
static const AVOption h263_options[]
int frame_bits
bits used for the current frame
int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
av_cold void ff_rate_control_uninit(MpegEncContext *s)
#define FF_MPV_FLAG_STRICT_GOP
void ff_init_block_index(MpegEncContext *s)
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
#define MAX_PICTURE_COUNT
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[6][64])
static int shift(int a, int b)
#define CONFIG_WMV2_ENCODER
me_cmp_func frame_skip_cmp[6]
void av_free_packet(AVPacket *pkt)
Free a packet.
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)
This structure describes decoded (raw) audio or video data.
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 ff_fdct_ifast(int16_t *data)
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)
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
void(* emulated_edge_mc)(uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *src, ptrdiff_t src_stride, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
uint8_t * mb_mean
Table for MB luminance.
#define CONFIG_LJPEG_ENCODER
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG1 & B-frame MPEG4
int pre_pass
= 1 for the pre pass
#define CONFIG_RV10_ENCODER
av_cold int ff_MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
#define FF_MPV_FLAG_SKIP_RD
void(* get_pixels)(int16_t *block, const uint8_t *pixels, int line_size)
#define FF_MPV_GENERIC_CLASS(name)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
void(* shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height)
#define AV_LOG_WARNING
Something somehow does not look correct.
float border_masking
Border processing masking, raises the quantizer for mbs on the borders of the picture.
#define LIBAVUTIL_VERSION_INT
#define CANDIDATE_MB_TYPE_BACKWARD_I
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
void ff_h263_encode_init(MpegEncContext *s)
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
static av_cold int init(AVCodecContext *avctx)
uint16_t * mb_var
Table for MB variances.
uint16_t(* q_chroma_intra_matrix16)[2][64]
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block.
uint16_t chroma_intra_matrix[64]
static int estimate_qp(MpegEncContext *s, int dry_run)
#define CANDIDATE_MB_TYPE_BIDIR
void ff_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 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 mpeg4 AC prediction, all 3 arrays must be continuous
int ff_MPV_encode_end(AVCodecContext *avctx)
int mjpeg_hsample[3]
horizontal sampling factors, default = {2, 1, 1}
#define FF_MPV_COMMON_OPTS
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
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
void(* rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb)
void ff_get_2pass_fcode(MpegEncContext *s)
#define CONFIG_MJPEG_ENCODER
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
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 ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int ff_h261_get_picture_format(int width, int height)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
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)
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)
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
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
int mpv_flags
flags set by private options
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
int frame_skip_cmp
frame skip comparison function
static void clip_coeffs(MpegEncContext *s, int16_t *block, int last_index)
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
static void write_mb_info(MpegEncContext *s)
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.
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
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).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define CODEC_FLAG_QPEL
Use qpel MC.
int scenechange_threshold
scene change detection threshold 0 is default, larger means fewer detected scene changes.
#define CONFIG_RV20_ENCODER
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)
#define CODEC_FLAG_INPUT_PRESERVED
The parent program guarantees that the input for B-frames containing streams is not written to for at...
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 *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
#define FF_MPV_FLAG_CBP_RD
int skipdct
skip dct and code zero residual
packed RGB 8:8:8, 24bpp, BGRBGR...
void ff_mpeg4_clean_buffers(MpegEncContext *s)
#define FF_MB_DECISION_RD
rate distortion
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
float p_masking
p block masking (0-> disabled)
int picture_in_gop_number
0-> first pic in gop, ...
int alt_inter_vlc
alternative inter vlc
int64_t time
time of current frame
const AVOption ff_mpv_generic_options[]
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) ...
const char * av_default_item_name(void *ctx)
Return the context name.
Picture ** input_picture
next pictures on display order for encoding
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
void(* denoise_dct)(struct MpegEncContext *s, int16_t *block)
PutBitContext pb2
used for data partitioned VOPs
enum OutputFormat out_format
output format
static const uint8_t offset[511][2]
uint16_t(* dct_offset)[64]
void ff_dct_encode_init_x86(MpegEncContext *s)
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
static av_cold int end(AVCodecContext *avctx)
Multithreading support functions.
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).
int misc_bits
cbp, mb_type
const char * name
Name of the codec implementation.
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
int(* q_chroma_intra_matrix)[64]
int me_cmp
motion estimation comparison function
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by a given frame.
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
Picture current_picture
copy of the current picture structure.
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
#define CONFIG_MPEG1VIDEO_ENCODER
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)
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
void ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
int mb_threshold
Macroblock threshold below which the user specified macroblock types will be used.
void ff_rv10_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
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 mb_height
number of MBs horizontally & vertically
void ff_MPV_frame_end(MpegEncContext *s)
float lumi_masking
luminance masking (0-> disabled)
int max_qcoeff
maximum encodable coefficient
#define FF_MPV_FLAG_QP_RD
#define CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
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)
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.
int(* q_inter_matrix)[64]
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int ff_MPV_encode_init(AVCodecContext *avctx)
static int get_bits_diff(MpegEncContext *s)
#define CODEC_FLAG_LOOP_FILTER
loop filter
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
int intra_only
if true, only intra pictures are generated
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
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)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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.
int last_dc[3]
last DC values for MPEG1
uint8_t * inter_ac_vlc_last_length
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);ff_audio_convert_init_arm(ac);ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
#define CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
packed BGR 8:8:8, 32bpp, BGR0BGR0...
int mb_skipped
MUST BE SET only during DECODING.
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
av_cold int ff_rate_control_init(MpegEncContext *s)
int me_sub_cmp
subpixel motion estimation comparison function
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_...
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
int qmax
maximum quantizer
static void update_mb_info(MpegEncContext *s, int startcode)
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 AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
int h263_slice_structured
void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
#define CODEC_FLAG_QSCALE
Use fixed qscale.
int rc_max_rate
maximum bitrate
#define CANDIDATE_MB_TYPE_INTER
int64_t av_const av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
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.
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Shrink the already allocated side data buffer.
int low_delay
no reordering needed / has no b-frames
void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
Deallocate a picture.
uint8_t *[2][2] b_field_select_table
Libavcodec external API header.
AVPixelFormat
Pixel format.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
#define CODEC_FLAG_LOW_DELAY
Force low delay.
int flags
A combination of AV_PKT_FLAG values.
static int put_bits_count(PutBitContext *s)
int resync_mb_x
x position of last resync marker
int rc_buffer_size
decoder bitstream buffer size
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually 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 int estimate_best_b_count(MpegEncContext *s)
int intra_dc_precision
precision of the intra DC coefficient - 8
int me_penalty_compensation
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
common internal API header
uint8_t * intra_ac_vlc_last_length
#define FF_ARRAY_ELEMS(a)
static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_width, int mb_block_count)
void ff_h263_loop_filter(MpegEncContext *s)
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
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.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
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 actually possible in mpeg4
int me_method
ME algorithm.
int umvplus
== H263+ && unrestricted_mv
Picture new_picture
copy of the source picture structure for encoding.
uint16_t * intra_matrix
custom intra quantization matrix
int intra_quant_bias
bias for the quantizer
int width
picture width / height.
int16_t(*[2] motion_val)[2]
Picture * current_picture_ptr
pointer to the current picture
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
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)
uint64_t error[AV_NUM_DATA_POINTERS]
error
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int block_last_index[12]
last non zero coefficient in block
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale)
const int16_t ff_mpeg4_default_non_intra_matrix[64]
int mb_decision
macroblock decision mode
#define CONFIG_FLV_ENCODER
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 avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function for encode/decode called after coding/decoding the header and before a frame is code...
int ac_esc_length
num of bits needed to encode the longest esc
#define CANDIDATE_MB_TYPE_BACKWARD
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
#define CANDIDATE_MB_TYPE_SKIPPED
preferred ID for MPEG-1/2 video decoding
int AC3_NAME() encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
int block_index[6]
index to current MB in block based arrays with edges
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
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]
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
int mjpeg_vsample[3]
vertical sampling factors, default = {2, 1, 1}
static void build_basis(uint8_t *perm)
#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
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
uint16_t * mc_mb_var
Table for motion compensated MB variances.
void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
const uint8_t *const ff_mpeg2_dc_scale_table[4]
int coded_picture_number
picture number in bitstream order
#define AV_LOG_INFO
Standard information.
uint16_t inter_matrix[64]
void ff_jpeg_fdct_islow_8(int16_t *data)
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
struct MpegEncContext * thread_context[MAX_THREADS]
#define CONFIG_MSMPEG4_ENCODER
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
void ff_faandct(int16_t *data)
double buffer_index
amount of bits in the video/audio buffer
void ff_h263_update_motion_val(MpegEncContext *s)
int h263_flv
use flv h263 header
static const AVClass h263p_class
ptrdiff_t linesize
line size, in bytes, may be different from width
static av_const unsigned int ff_sqrt(unsigned int a)
int idct_permutation_type
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)
ScanTable intra_scantable
void(* qpel_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
int pre_me
prepass for motion estimation
int qmin
minimum quantizer
int height
picture size. must be a multiple of 16
int ff_dct_encode_init(MpegEncContext *s)
static void write_slice_end(MpegEncContext *s)
int64_t dts_delta
pts difference between the first and second input frame, used for calculating dts of the first frame ...
void ff_mjpeg_encode_picture_trailer(MpegEncContext *s)
int64_t user_specified_pts
last non-zero pts from AVFrame which was passed into avcodec_encode_video2()
void(* diff_pixels)(int16_t *block, const uint8_t *s1, const uint8_t *s2, int stride)
static void denoise_dct_c(MpegEncContext *s, int16_t *block)
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
void ff_fix_long_p_mvs(MpegEncContext *s)
Picture * picture
main picture buffer
int data_partitioning
data partitioning flag from header
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
uint8_t * inter_ac_vlc_length
void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64])
#define FF_DEFAULT_QUANT_BIAS
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Describe the class of an AVClass context structure.
int stuffing_bits
bits used for stuffing
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced b-frame encoding.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type)
const uint16_t ff_mpeg1_default_intra_matrix[256]
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)
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
int mb_info
interval for outputting info about mb offsets as side data
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
void ff_set_mpeg4_time(MpegEncContext *s)
static void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type)
DSPContext dsp
pointers for accelerated dsp functions
int(* pix_norm1)(uint8_t *pix, int line_size)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
uint64_t error[AV_NUM_DATA_POINTERS]
error
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
int frame_skip_exp
frame skip exponent
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
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]
#define CODEC_FLAG_CLOSED_GOP
static int weight(int i, int blen, int offset)
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, ...
#define FF_MB_DECISION_BITS
chooses the one which needs the fewest bits
int bit_rate
wanted bit rate
#define ROUNDED_DIV(a, b)
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
int last_mv_dir
last mv_dir, used for b frame encoding
#define CANDIDATE_MB_TYPE_FORWARD_I
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.
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
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)
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
PutBitContext pb
bit output
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
#define CONFIG_MPEG4_ENCODER
#define CONFIG_MPEG2VIDEO_ENCODER
#define CODEC_FLAG_EMU_EDGE
Don't draw edges.
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
static void update_qscale(MpegEncContext *s)
int mb_cmp
macroblock comparison function (not supported yet)
int quantizer_noise_shaping
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg)
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
common internal api header.
const uint8_t ff_zigzag_direct[64]
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.
void ff_MPV_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
const uint8_t ff_h263_chroma_qscale_table[32]
void ff_mjpeg_encode_stuffing(MpegEncContext *s)
#define CONFIG_H261_ENCODER
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int adaptive_quant
use adaptive quantization
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
static int16_t basis[64][64]
void ff_msmpeg4_encode_ext_header(MpegEncContext *s)
static int score_tab[256]
Picture last_picture
copy of the previous picture structure.
int64_t reordered_pts
reordered pts to be used as dts for the next output frame when there's a delay
int ff_vbv_update(MpegEncContext *s, int frame_size)
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
#define CONFIG_H263_ENCODER
#define CONFIG_H263P_ENCODER
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
AVCodec ff_msmpeg4v3_encoder
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
int trellis
trellis RD quantization
#define CANDIDATE_MB_TYPE_DIRECT0
void ff_mpeg4_stuffing(PutBitContext *pbc)
add mpeg4 stuffing bits (01...1)
int16_t(* blocks)[12][64]
int slices
Number of slices.
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
int last_bits
temp var used for calculating the above vars
void ff_mpeg4_init_partitions(MpegEncContext *s)
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.
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src)
void ff_MPV_common_end(MpegEncContext *s)
void(* fdct)(int16_t *block)
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
int16_t(* block)[64]
points to one of the following blocks
void ff_rv20_encode_picture_header(MpegEncContext *s, int picture_number)
PutBitContext tex_pb
used for data partitioned VOPs
Picture next_picture
copy of the next picture structure.
int key_frame
1 -> keyframe, 0-> not
static void set_frame_distances(MpegEncContext *s)
static const double coeff[2][5]
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
uint16_t * inter_matrix
custom inter quantization matrix
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 struct twinvq_data tab
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int mb_var_sum
sum of MB variance for current frame
static int encode_thread(AVCodecContext *c, void *arg)
int flags
AVCodecContext.flags (HQ, MV4, ...)
int(* fast_dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int mc_mb_var_sum
motion compensated MB variance for current frame
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
#define LOCAL_ALIGNED_16(t, v,...)
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src)
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int inter_quant_bias
bias for the quantizer
int me_method
Motion estimation algorithm used for video coding.
int ff_find_unused_picture(MpegEncContext *s, int shared)
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
#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)
#define CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
void ff_h261_encode_init(MpegEncContext *s)
static void MPV_encode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for encoding.
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_...
This structure stores compressed data.
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, AVFrame *frame, int *got_packet)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#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
AVCodec ff_msmpeg4v2_encoder
uint16_t pb_time
time distance between the last b and p,s,i frame
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static const uint8_t sp5x_quant_table[20][64]
int next_lambda
next lambda used for retrying to encode a frame