Go to the documentation of this file.
34 #include "config_components.h"
82 #define QUANT_BIAS_SHIFT 8
84 #define QMAT_SHIFT_MMX 16
92 int16_t *
block,
int n,
113 uint16_t (*
qmat16)[2][64],
114 const uint16_t *quant_matrix,
115 int bias,
int qmin,
int qmax,
int intra)
126 else qscale2 =
qscale << 1;
133 for (
i = 0;
i < 64;
i++) {
134 const int j =
s->idsp.idct_permutation[
i];
135 int64_t den = (int64_t) qscale2 * quant_matrix[j];
145 for (
i = 0;
i < 64;
i++) {
146 const int j =
s->idsp.idct_permutation[
i];
147 int64_t den =
ff_aanscales[
i] * (int64_t) qscale2 * quant_matrix[j];
157 for (
i = 0;
i < 64;
i++) {
158 const int j =
s->idsp.idct_permutation[
i];
159 int64_t den = (int64_t) qscale2 * quant_matrix[j];
179 for (
i = intra;
i < 64;
i++) {
191 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
198 if (
s->q_scale_type == 1 && 0) {
200 int bestdiff=INT_MAX;
208 if (
diff < bestdiff) {
217 s->qscale =
av_clip(
s->qscale,
s->avctx->qmin,
s->vbv_ignore_qmax ? 31 :
s->avctx->qmax);
230 for (
i = 0;
i < 64;
i++) {
242 int8_t *
const qscale_table =
s->cur_pic.qscale_table;
245 for (
i = 0;
i <
s->mb_num;
i++) {
246 unsigned int lam =
s->lambda_table[
s->mb_index2xy[
i]];
248 qscale_table[
s->mb_index2xy[
i]] =
av_clip(qp,
s->avctx->qmin,
256 #define COPY(a) dst->a= src->a
271 for (
int i = -16;
i < 16;
i++)
290 s->input_picture_number = 0;
291 s->picture_in_gop_number = 0;
305 if (
s->avctx->trellis)
315 int mb_array_size, mv_table_size;
343 "keyframe interval too large!, reducing it from %d to %d\n",
355 "max b frames must be 0 or positive for mpegvideo based encoders\n");
366 s->rtp_mode = !!
s->rtp_payload_size;
370 if (
s->intra_dc_precision < 0) {
371 s->intra_dc_precision += 8;
372 }
else if (
s->intra_dc_precision >= 8)
373 s->intra_dc_precision -= 8;
375 if (
s->intra_dc_precision < 0) {
377 "intra dc precision must be positive, note some applications use"
378 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
388 if (
s->gop_size <= 1) {
442 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
459 "impossible bitrate constraints, this will fail\n");
469 if (!
s->fixed_qscale &&
475 if (nbt <= INT_MAX) {
488 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
489 "specified vbv buffer is too large for the given bitrate!\n");
501 "OBMC is only supported with simple mb decision\n");
516 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
569 if (
s->scenechange_threshold < 1000000000 &&
572 "closed gop with scene change detection are not supported yet, "
573 "set threshold to 1000000000\n");
581 "low delay forcing is only available for mpeg2, "
582 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
585 if (
s->max_b_frames != 0) {
587 "B-frames cannot be used with low delay\n");
592 if (
s->q_scale_type == 1) {
595 "non linear quant only supports qmax <= 28 currently\n");
608 "notice: b_frame_strategy only affects the first pass\n");
609 s->b_frame_strategy = 0;
623 s->inter_quant_bias = 0;
625 s->intra_quant_bias = 0;
640 "timebase %d/%d not supported by MPEG 4 standard, "
641 "the maximum admitted value for the timebase denominator "
649 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
656 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
660 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
674 if (!CONFIG_SPEEDHQ_ENCODER)
682 if (!CONFIG_H261_ENCODER)
693 if (!CONFIG_H263_ENCODER)
696 s->width,
s->height) == 8) {
698 "The specified picture size of %dx%d is not valid for "
699 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
700 "352x288, 704x576, and 1408x1152. "
701 "Try H.263+.\n",
s->width,
s->height);
713 s->modified_quant =
s->h263_aic;
715 s->unrestricted_mv =
s->obmc ||
s->loop_filter ||
s->umvplus;
725 s->unrestricted_mv = 1;
739 s->modified_quant = 1;
743 s->unrestricted_mv = 0;
748 s->unrestricted_mv = 1;
749 s->low_delay =
s->max_b_frames ? 0 : 1;
750 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
755 s->unrestricted_mv = 1;
763 s->unrestricted_mv = 1;
765 s->flipflop_rounding = 1;
772 s->unrestricted_mv = 1;
774 s->flipflop_rounding = 1;
781 s->unrestricted_mv = 1;
783 s->flipflop_rounding = 1;
795 s->progressive_frame =
800 if (
s->lmin >
s->lmax) {
830 mv_table_size = (
s->mb_height + 2) *
s->mb_stride + 1;
838 s->p_mv_table =
s->p_mv_table_base +
s->mb_stride + 1;
839 s->b_forw_mv_table =
s->b_forw_mv_table_base +
s->mb_stride + 1;
840 s->b_back_mv_table =
s->b_back_mv_table_base +
s->mb_stride + 1;
841 s->b_bidir_forw_mv_table =
s->b_bidir_forw_mv_table_base +
s->mb_stride + 1;
842 s->b_bidir_back_mv_table =
s->b_bidir_back_mv_table_base +
s->mb_stride + 1;
843 s->b_direct_mv_table =
s->b_direct_mv_table_base +
s->mb_stride + 1;
846 mb_array_size =
s->mb_stride *
s->mb_height;
856 #define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
861 if (!(tmp1 =
ALLOCZ_ARRAYS(
s->b_field_mv_table_base, 8, mv_table_size)) ||
862 !(tmp2 =
ALLOCZ_ARRAYS(
s->b_field_select_table[0][0], 2 * 4, mv_table_size)) ||
866 s->p_field_select_table[1] =
s->p_field_select_table[0] + 2 * mv_table_size;
867 tmp1 +=
s->mb_stride + 1;
869 for (
int i = 0;
i < 2;
i++) {
870 for (
int j = 0; j < 2; j++) {
871 for (
int k = 0; k < 2; k++) {
872 s->b_field_mv_table[
i][j][k] = tmp1;
873 tmp1 += mv_table_size;
875 s->b_field_select_table[
i][j] = tmp2;
876 tmp2 += 2 * mv_table_size;
881 if (
s->noise_reduction) {
889 s->dct_unquantize_intra =
s->dct_unquantize_mpeg2_intra;
890 s->dct_unquantize_inter =
s->dct_unquantize_mpeg2_inter;
892 s->dct_unquantize_intra =
s->dct_unquantize_h263_intra;
893 s->dct_unquantize_inter =
s->dct_unquantize_h263_inter;
895 s->dct_unquantize_intra =
s->dct_unquantize_mpeg1_intra;
896 s->dct_unquantize_inter =
s->dct_unquantize_mpeg1_inter;
899 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) &&
s->modified_quant)
902 if (
s->slice_context_count > 1) {
906 s->h263_slice_structured = 1;
909 s->quant_precision = 5;
916 if (CONFIG_H263_ENCODER &&
s->out_format ==
FMT_H263) {
918 #if CONFIG_MSMPEG4ENC
925 for (
i = 0;
i < 64;
i++) {
926 int j =
s->idsp.idct_permutation[
i];
939 s->chroma_intra_matrix[j] =
963 if (
s->b_frame_strategy == 2) {
964 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
966 if (!
s->tmp_frames[
i])
970 s->tmp_frames[
i]->width =
s->width >>
s->brd_scale;
971 s->tmp_frames[
i]->height =
s->height >>
s->brd_scale;
1000 if (
s->input_picture &&
s->reordered_input_picture) {
1016 av_freep(&
s->b_bidir_forw_mv_table_base);
1017 av_freep(&
s->b_bidir_back_mv_table_base);
1020 av_freep(&
s->b_field_select_table[0][0]);
1029 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
1030 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
1031 s->q_chroma_intra_matrix=
NULL;
1032 s->q_chroma_intra_matrix16=
NULL;
1047 #define IS_ENCODER 1
1055 for (
int i = 0;
i < 6;
i++) {
1056 for (
int j = 0; j < 64; j++) {
1058 block[
i][
s->idsp.idct_permutation[j]]);
1072 for (y = 0; y < 16; y++) {
1073 for (x = 0; x < 16; x++) {
1088 h =
s->height & ~15;
1090 for (y = 0; y <
h; y += 16) {
1091 for (x = 0; x <
w; x += 16) {
1098 acc += sae + 500 < sad;
1124 for (
int i = 0;
f->data[
i];
i++) {
1144 int display_picture_number = 0,
ret;
1145 int encoding_delay =
s->max_b_frames ?
s->max_b_frames
1146 : (
s->low_delay ? 0 : 1);
1147 int flush_offset = 1;
1154 display_picture_number =
s->input_picture_number++;
1158 int64_t last =
s->user_specified_pts;
1162 "Invalid pts (%"PRId64
") <= last (%"PRId64
")\n",
1167 if (!
s->low_delay && display_picture_number == 1)
1168 s->dts_delta =
pts - last;
1170 s->user_specified_pts =
pts;
1173 s->user_specified_pts =
1174 pts =
s->user_specified_pts + 1;
1176 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
1179 pts = display_picture_number;
1183 if (pic_arg->
linesize[0] !=
s->linesize ||
1184 pic_arg->
linesize[1] !=
s->uvlinesize ||
1187 if ((
s->width & 15) || (
s->height & 15))
1195 pic_arg->
linesize[1],
s->linesize,
s->uvlinesize);
1210 for (
int i = 0;
i < 3;
i++) {
1211 ptrdiff_t src_stride = pic_arg->
linesize[
i];
1212 ptrdiff_t dst_stride =
i ?
s->uvlinesize :
s->linesize;
1213 int h_shift =
i ?
s->chroma_x_shift : 0;
1214 int v_shift =
i ?
s->chroma_y_shift : 0;
1217 const uint8_t *
src = pic_arg->
data[
i];
1218 uint8_t *dst = pic->
f->
data[
i];
1222 && !
s->progressive_sequence
1223 &&
FFALIGN(
s->height, 32) -
s->height > 16)
1226 if (!
s->avctx->rc_buffer_size)
1229 if (src_stride == dst_stride)
1230 memcpy(dst,
src, src_stride *
h - src_stride +
w);
1233 uint8_t *dst2 = dst;
1235 memcpy(dst2,
src,
w);
1240 if ((
s->width & 15) || (
s->height & (vpad-1))) {
1241 s->mpvencdsp.draw_edges(dst, dst_stride,
1253 }
else if (!
s->reordered_input_picture[1]) {
1259 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1260 if (
s->input_picture[flush_offset])
1263 encoding_delay -= flush_offset - 1;
1268 s->input_picture[
i - flush_offset] =
s->input_picture[
i];
1270 s->input_picture[encoding_delay] = pic;
1282 int64_t score64 = 0;
1284 for (plane = 0; plane < 3; plane++) {
1286 const int bw = plane ? 1 : 2;
1287 for (y = 0; y <
s->mb_height * bw; y++) {
1288 for (x = 0; x <
s->mb_width * bw; x++) {
1289 int off = p->
shared ? 0 : 16;
1290 const uint8_t *dptr = p->
f->
data[plane] + 8 * (x + y *
stride) + off;
1291 const uint8_t *rptr =
ref->f->data[plane] + 8 * (x + y *
stride);
1292 int v =
s->mecc.frame_skip_cmp[1](
s, dptr, rptr,
stride, 8);
1294 switch (
FFABS(
s->frame_skip_exp)) {
1295 case 0: score =
FFMAX(score, v);
break;
1296 case 1: score +=
FFABS(v);
break;
1297 case 2: score64 += v * (int64_t)v;
break;
1298 case 3: score64 +=
FFABS(v * (int64_t)v * v);
break;
1299 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);
break;
1308 if (
s->frame_skip_exp < 0)
1309 score64 = pow(score64 / (
double)(
s->mb_width *
s->mb_height),
1310 -1.0/
s->frame_skip_exp);
1314 if (score64 < ((
s->frame_skip_factor * (int64_t)
s->lambda) >> 8))
1343 const int scale =
s->brd_scale;
1347 int64_t best_rd = INT64_MAX;
1348 int best_b_count = -1;
1362 b_lambda = p_lambda;
1366 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1367 const MPVPicture *pre_input_ptr =
i ?
s->input_picture[
i - 1] :
1370 if (pre_input_ptr) {
1371 const uint8_t *
data[4];
1374 if (!pre_input_ptr->
shared &&
i) {
1380 s->mpvencdsp.shrink[
scale](
s->tmp_frames[
i]->data[0],
1381 s->tmp_frames[
i]->linesize[0],
1385 s->mpvencdsp.shrink[
scale](
s->tmp_frames[
i]->data[1],
1386 s->tmp_frames[
i]->linesize[1],
1390 s->mpvencdsp.shrink[
scale](
s->tmp_frames[
i]->data[2],
1391 s->tmp_frames[
i]->linesize[2],
1398 for (j = 0; j <
s->max_b_frames + 1; j++) {
1402 if (!
s->input_picture[j])
1415 c->mb_decision =
s->avctx->mb_decision;
1416 c->me_cmp =
s->avctx->me_cmp;
1417 c->mb_cmp =
s->avctx->mb_cmp;
1418 c->me_sub_cmp =
s->avctx->me_sub_cmp;
1420 c->time_base =
s->avctx->time_base;
1421 c->max_b_frames =
s->max_b_frames;
1439 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1440 int is_p =
i % (j + 1) == j ||
i ==
s->max_b_frames;
1442 s->tmp_frames[
i + 1]->pict_type = is_p ?
1444 s->tmp_frames[
i + 1]->quality = is_p ? p_lambda : b_lambda;
1463 rd +=
c->error[0] +
c->error[1] +
c->error[2];
1481 return best_b_count;
1495 if (
s->reordered_input_picture[0] || !
s->input_picture[0])
1499 if (
s->frame_skip_threshold ||
s->frame_skip_factor) {
1500 if (
s->picture_in_gop_number <
s->gop_size &&
1513 !
s->next_pic.ptr ||
s->intra_only) {
1514 s->reordered_input_picture[0] =
s->input_picture[0];
1515 s->input_picture[0] =
NULL;
1517 s->reordered_input_picture[0]->coded_picture_number =
1518 s->coded_picture_number++;
1523 for (
int i = 0;
i <
s->max_b_frames + 1;
i++) {
1524 int pict_num =
s->input_picture[0]->display_picture_number +
i;
1526 if (pict_num >=
s->rc_context.num_entries)
1528 if (!
s->input_picture[
i]) {
1533 s->input_picture[
i]->f->pict_type =
1534 s->rc_context.entry[pict_num].new_pict_type;
1538 if (
s->b_frame_strategy == 0) {
1539 b_frames =
s->max_b_frames;
1540 while (b_frames && !
s->input_picture[b_frames])
1542 }
else if (
s->b_frame_strategy == 1) {
1544 for (
i = 1;
i <
s->max_b_frames + 1;
i++) {
1545 if (
s->input_picture[
i] &&
1546 s->input_picture[
i]->b_frame_score == 0) {
1547 s->input_picture[
i]->b_frame_score =
1549 s->input_picture[
i ]->f->data[0],
1550 s->input_picture[
i - 1]->f->data[0],
1554 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1555 if (!
s->input_picture[
i] ||
1556 s->input_picture[
i]->b_frame_score - 1 >
1557 s->mb_num /
s->b_sensitivity)
1561 b_frames =
FFMAX(0,
i - 1);
1564 for (
i = 0;
i < b_frames + 1;
i++) {
1565 s->input_picture[
i]->b_frame_score = 0;
1567 }
else if (
s->b_frame_strategy == 2) {
1577 for (
int i = b_frames - 1;
i >= 0;
i--) {
1578 int type =
s->input_picture[
i]->f->pict_type;
1583 b_frames ==
s->max_b_frames) {
1585 "warning, too many B-frames in a row\n");
1588 if (
s->picture_in_gop_number + b_frames >=
s->gop_size) {
1590 s->gop_size >
s->picture_in_gop_number) {
1591 b_frames =
s->gop_size -
s->picture_in_gop_number - 1;
1603 s->reordered_input_picture[0] =
s->input_picture[b_frames];
1604 s->input_picture[b_frames] =
NULL;
1607 s->reordered_input_picture[0]->coded_picture_number =
1608 s->coded_picture_number++;
1609 for (
int i = 0;
i < b_frames;
i++) {
1610 s->reordered_input_picture[
i + 1] =
s->input_picture[
i];
1611 s->input_picture[
i] =
NULL;
1612 s->reordered_input_picture[
i + 1]->f->pict_type =
1614 s->reordered_input_picture[
i + 1]->coded_picture_number =
1615 s->coded_picture_number++;
1629 s->reordered_input_picture[
i - 1] =
s->reordered_input_picture[
i];
1639 if (
s->reordered_input_picture[0]) {
1640 s->reordered_input_picture[0]->reference =
1643 if (
s->reordered_input_picture[0]->shared ||
s->avctx->rc_buffer_size) {
1657 if (
s->new_pic->data[
i])
1661 s->cur_pic.ptr =
s->reordered_input_picture[0];
1662 s->reordered_input_picture[0] =
NULL;
1663 av_assert1(
s->mb_width ==
s->buffer_pools.alloc_mb_width);
1664 av_assert1(
s->mb_height ==
s->buffer_pools.alloc_mb_height);
1665 av_assert1(
s->mb_stride ==
s->buffer_pools.alloc_mb_stride);
1667 &
s->sc, &
s->buffer_pools,
s->mb_height);
1672 s->picture_number =
s->cur_pic.ptr->display_picture_number;
1683 if (
s->unrestricted_mv &&
1684 s->cur_pic.reference &&
1686 int hshift =
s->chroma_x_shift;
1687 int vshift =
s->chroma_y_shift;
1688 s->mpvencdsp.draw_edges(
s->cur_pic.data[0],
1689 s->cur_pic.linesize[0],
1690 s->h_edge_pos,
s->v_edge_pos,
1693 s->mpvencdsp.draw_edges(
s->cur_pic.data[1],
1694 s->cur_pic.linesize[1],
1695 s->h_edge_pos >> hshift,
1696 s->v_edge_pos >> vshift,
1700 s->mpvencdsp.draw_edges(
s->cur_pic.data[2],
1701 s->cur_pic.linesize[2],
1702 s->h_edge_pos >> hshift,
1703 s->v_edge_pos >> vshift,
1711 s->last_pict_type =
s->pict_type;
1712 s->last_lambda_for [
s->pict_type] =
s->cur_pic.ptr->f->quality;
1714 s->last_non_b_pict_type =
s->pict_type;
1721 for (intra = 0; intra < 2; intra++) {
1722 if (
s->dct_count[intra] > (1 << 16)) {
1723 for (
i = 0;
i < 64;
i++) {
1724 s->dct_error_sum[intra][
i] >>= 1;
1726 s->dct_count[intra] >>= 1;
1729 for (
i = 0;
i < 64;
i++) {
1730 s->dct_offset[intra][
i] = (
s->noise_reduction *
1731 s->dct_count[intra] +
1732 s->dct_error_sum[intra][
i] / 2) /
1733 (
s->dct_error_sum[intra][
i] + 1);
1740 s->cur_pic.ptr->f->pict_type =
s->pict_type;
1747 if (
s->dct_error_sum) {
1754 const AVFrame *pic_arg,
int *got_packet)
1757 int stuffing_count,
ret;
1758 int context_count =
s->slice_context_count;
1762 s->vbv_ignore_qmax = 0;
1764 s->picture_in_gop_number++;
1774 if (
s->new_pic->data[0]) {
1775 int growing_buffer = context_count == 1 && !
s->data_partitioning;
1776 size_t pkt_size = 10000 +
s->mb_width *
s->mb_height *
1789 s->mb_width*
s->mb_height*12);
1790 s->prev_mb_info =
s->last_mb_info =
s->mb_info_size = 0;
1793 s->pict_type =
s->new_pic->pict_type;
1798 if (growing_buffer) {
1808 if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) &&
s->out_format ==
FMT_MJPEG)
1818 s->lambda <
s->lmax) {
1819 s->next_lambda =
FFMAX(
s->lambda + min_step,
s->lambda *
1820 (
s->qscale + 1) /
s->qscale);
1821 if (
s->adaptive_quant) {
1823 for (
i = 0;
i <
s->mb_height *
s->mb_stride;
i++)
1824 s->lambda_table[
i] =
1825 FFMAX(
s->lambda_table[
i] + min_step,
1826 s->lambda_table[
i] * (
s->qscale + 1) /
1832 if (
s->flipflop_rounding ||
1835 s->no_rounding ^= 1;
1838 s->time_base =
s->last_time_base;
1839 s->last_non_b_time =
s->time -
s->pp_time;
1841 s->vbv_ignore_qmax = 1;
1861 s->misc_bits +
s->i_tex_bits +
1867 s->stuffing_bits = 8*stuffing_count;
1868 if (stuffing_count) {
1874 switch (
s->codec_id) {
1877 while (stuffing_count--) {
1884 stuffing_count -= 4;
1885 while (stuffing_count--) {
1891 s->stuffing_bits = 0;
1909 int minbits =
s->frame_bits - 8 *
1910 (
s->vbv_delay_pos - 1);
1911 double bits =
s->rc_context.buffer_index + minbits - inbits;
1912 uint8_t *
const vbv_delay_ptr =
s->pb.buf +
s->vbv_delay_pos;
1916 "Internal error, negative bits\n");
1928 vbv_delay_ptr[0] &= 0xF8;
1931 vbv_delay_ptr[2] &= 0x07;
1940 (uint8_t*)props, props_size);
1946 s->total_bits +=
s->frame_bits;
1948 pkt->
pts =
s->cur_pic.ptr->f->pts;
1951 if (!
s->cur_pic.ptr->coded_picture_number)
1984 int n,
int threshold)
1986 static const char tab[64] = {
1987 3, 2, 2, 1, 1, 1, 1, 1,
1988 1, 1, 1, 1, 1, 1, 1, 1,
1989 1, 1, 1, 1, 1, 1, 1, 1,
1990 0, 0, 0, 0, 0, 0, 0, 0,
1991 0, 0, 0, 0, 0, 0, 0, 0,
1992 0, 0, 0, 0, 0, 0, 0, 0,
1993 0, 0, 0, 0, 0, 0, 0, 0,
1994 0, 0, 0, 0, 0, 0, 0, 0
1999 int16_t *
block =
s->block[n];
2000 const int last_index =
s->block_last_index[n];
2003 if (threshold < 0) {
2005 threshold = -threshold;
2010 if (last_index <= skip_dc - 1)
2013 for (
i = 0;
i <= last_index;
i++) {
2014 const int j =
s->intra_scantable.permutated[
i];
2017 if (skip_dc &&
i == 0)
2021 }
else if (
level > 1) {
2027 if (score >= threshold)
2029 for (
i = skip_dc;
i <= last_index;
i++) {
2030 const int j =
s->intra_scantable.permutated[
i];
2034 s->block_last_index[n] = 0;
2036 s->block_last_index[n] = -1;
2043 const int maxlevel =
s->max_qcoeff;
2044 const int minlevel =
s->min_qcoeff;
2052 for (;
i <= last_index;
i++) {
2053 const int j =
s->intra_scantable.permutated[
i];
2056 if (
level > maxlevel) {
2059 }
else if (
level < minlevel) {
2069 "warning, clipping %d dct coefficients to %d..%d\n",
2077 for (y = 0; y < 8; y++) {
2078 for (x = 0; x < 8; x++) {
2084 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
2085 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
2086 int v = ptr[x2 + y2 *
stride];
2098 int motion_x,
int motion_y,
2099 int mb_block_height,
2108 #define INTERLACED_DCT(s) ((chroma_format == CHROMA_420 || chroma_format == CHROMA_422) && \
2109 (s)->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
2111 int16_t orig[12][64];
2112 const int mb_x =
s->mb_x;
2113 const int mb_y =
s->mb_y;
2117 int uv_dct_offset =
s->uvlinesize * 8;
2118 const uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2119 ptrdiff_t wrap_y, wrap_c;
2121 for (
i = 0;
i < mb_block_count;
i++)
2122 skip_dct[
i] =
s->skipdct;
2124 if (
s->adaptive_quant) {
2125 const int last_qp =
s->qscale;
2126 const int mb_xy =
mb_x +
mb_y *
s->mb_stride;
2128 s->lambda =
s->lambda_table[mb_xy];
2132 s->qscale =
s->cur_pic.qscale_table[mb_xy];
2133 s->dquant =
s->qscale - last_qp;
2154 wrap_y =
s->linesize;
2155 wrap_c =
s->uvlinesize;
2156 ptr_y =
s->new_pic->data[0] +
2158 ptr_cb =
s->new_pic->data[1] +
2159 (
mb_y * mb_block_height * wrap_c) +
mb_x * mb_block_width;
2160 ptr_cr =
s->new_pic->data[2] +
2161 (
mb_y * mb_block_height * wrap_c) +
mb_x * mb_block_width;
2164 uint8_t *ebuf =
s->sc.edge_emu_buffer + 38 * wrap_y;
2167 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2170 s->width,
s->height);
2172 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2174 mb_block_width, mb_block_height,
2175 mb_x * mb_block_width,
mb_y * mb_block_height,
2177 ptr_cb = ebuf + 16 * wrap_y;
2178 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2180 mb_block_width, mb_block_height,
2181 mb_x * mb_block_width,
mb_y * mb_block_height,
2183 ptr_cr = ebuf + 16 * wrap_y + 16;
2188 int progressive_score, interlaced_score;
2190 s->interlaced_dct = 0;
2191 progressive_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
NULL, wrap_y, 8) +
2192 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y * 8,
2193 NULL, wrap_y, 8) - 400;
2195 if (progressive_score > 0) {
2196 interlaced_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
2197 NULL, wrap_y * 2, 8) +
2198 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y,
2199 NULL, wrap_y * 2, 8);
2200 if (progressive_score > interlaced_score) {
2201 s->interlaced_dct = 1;
2204 uv_dct_offset = wrap_c;
2213 s->pdsp.get_pixels(
s->block[0], ptr_y, wrap_y);
2214 s->pdsp.get_pixels(
s->block[1], ptr_y + 8, wrap_y);
2215 s->pdsp.get_pixels(
s->block[2], ptr_y +
dct_offset, wrap_y);
2216 s->pdsp.get_pixels(
s->block[3], ptr_y +
dct_offset + 8, wrap_y);
2222 s->pdsp.get_pixels(
s->block[4], ptr_cb, wrap_c);
2223 s->pdsp.get_pixels(
s->block[5], ptr_cr, wrap_c);
2225 s->pdsp.get_pixels(
s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2226 s->pdsp.get_pixels(
s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2228 s->pdsp.get_pixels(
s->block[ 6], ptr_cb + 8, wrap_c);
2229 s->pdsp.get_pixels(
s->block[ 7], ptr_cr + 8, wrap_c);
2230 s->pdsp.get_pixels(
s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2231 s->pdsp.get_pixels(
s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2232 s->pdsp.get_pixels(
s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2233 s->pdsp.get_pixels(
s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2239 uint8_t *dest_y, *dest_cb, *dest_cr;
2241 dest_y =
s->dest[0];
2242 dest_cb =
s->dest[1];
2243 dest_cr =
s->dest[2];
2246 op_pix =
s->hdsp.put_pixels_tab;
2247 op_qpix =
s->qdsp.put_qpel_pixels_tab;
2249 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
2250 op_qpix =
s->qdsp.put_no_rnd_qpel_pixels_tab;
2257 op_pix =
s->hdsp.avg_pixels_tab;
2258 op_qpix =
s->qdsp.avg_qpel_pixels_tab;
2267 int progressive_score, interlaced_score;
2269 s->interlaced_dct = 0;
2270 progressive_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y, wrap_y, 8) +
2271 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y * 8,
2276 progressive_score -= 400;
2278 if (progressive_score > 0) {
2279 interlaced_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y,
2281 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y,
2285 if (progressive_score > interlaced_score) {
2286 s->interlaced_dct = 1;
2289 uv_dct_offset = wrap_c;
2297 s->pdsp.diff_pixels(
s->block[0], ptr_y, dest_y, wrap_y);
2298 s->pdsp.diff_pixels(
s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2301 s->pdsp.diff_pixels(
s->block[3], ptr_y +
dct_offset + 8,
2308 s->pdsp.diff_pixels(
s->block[4], ptr_cb, dest_cb, wrap_c);
2309 s->pdsp.diff_pixels(
s->block[5], ptr_cr, dest_cr, wrap_c);
2311 s->pdsp.diff_pixels(
s->block[6], ptr_cb + uv_dct_offset,
2312 dest_cb + uv_dct_offset, wrap_c);
2313 s->pdsp.diff_pixels(
s->block[7], ptr_cr + uv_dct_offset,
2314 dest_cr + uv_dct_offset, wrap_c);
2318 if (
s->mc_mb_var[
s->mb_stride *
mb_y +
mb_x] < 2 *
s->qscale *
s->qscale) {
2320 if (
s->mecc.sad[1](
NULL, ptr_y, dest_y, wrap_y, 8) < 20 *
s->qscale)
2322 if (
s->mecc.sad[1](
NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 *
s->qscale)
2325 wrap_y, 8) < 20 *
s->qscale)
2328 wrap_y, 8) < 20 *
s->qscale)
2330 if (
s->mecc.sad[1](
NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 *
s->qscale)
2332 if (
s->mecc.sad[1](
NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 *
s->qscale)
2335 if (
s->mecc.sad[1](
NULL, ptr_cb + uv_dct_offset,
2336 dest_cb + uv_dct_offset,
2337 wrap_c, 8) < 20 *
s->qscale)
2339 if (
s->mecc.sad[1](
NULL, ptr_cr + uv_dct_offset,
2340 dest_cr + uv_dct_offset,
2341 wrap_c, 8) < 20 *
s->qscale)
2347 if (
s->quantizer_noise_shaping) {
2368 memcpy(orig[0],
s->block[0],
sizeof(int16_t) * 64 * mb_block_count);
2374 for (
i = 0;
i < mb_block_count;
i++) {
2377 s->block_last_index[
i] =
s->dct_quantize(
s,
s->block[
i],
i,
s->qscale, &
overflow);
2386 s->block_last_index[
i] = -1;
2388 if (
s->quantizer_noise_shaping) {
2389 for (
i = 0;
i < mb_block_count;
i++) {
2391 s->block_last_index[
i] =
2393 orig[
i],
i,
s->qscale);
2398 if (
s->luma_elim_threshold && !
s->mb_intra)
2399 for (
i = 0;
i < 4;
i++)
2401 if (
s->chroma_elim_threshold && !
s->mb_intra)
2402 for (
i = 4;
i < mb_block_count;
i++)
2406 for (
i = 0;
i < mb_block_count;
i++) {
2407 if (
s->block_last_index[
i] == -1)
2408 s->coded_score[
i] = INT_MAX / 256;
2414 s->block_last_index[4] =
2415 s->block_last_index[5] = 0;
2417 s->block[5][0] = (1024 +
s->c_dc_scale / 2) /
s->c_dc_scale;
2419 for (
i=6;
i<12;
i++) {
2420 s->block_last_index[
i] = 0;
2421 s->block[
i][0] =
s->block[4][0];
2428 for (
i = 0;
i < mb_block_count;
i++) {
2430 if (
s->block_last_index[
i] > 0) {
2431 for (j = 63; j > 0; j--) {
2432 if (
s->block[
i][
s->intra_scantable.permutated[j]])
2435 s->block_last_index[
i] = j;
2441 switch(
s->codec_id){
2444 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2448 if (CONFIG_MPEG4_ENCODER)
2454 if (CONFIG_MSMPEG4ENC)
2458 if (CONFIG_WMV2_ENCODER)
2462 if (CONFIG_H261_ENCODER)
2470 if (CONFIG_H263_ENCODER)
2473 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
2480 if (CONFIG_SPEEDHQ_ENCODER)
2503 memcpy(
d->last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2506 d->mb_skip_run=
s->mb_skip_run;
2508 d->last_dc[
i] =
s->last_dc[
i];
2511 d->mv_bits=
s->mv_bits;
2512 d->i_tex_bits=
s->i_tex_bits;
2513 d->p_tex_bits=
s->p_tex_bits;
2514 d->i_count=
s->i_count;
2515 d->misc_bits=
s->misc_bits;
2519 d->qscale=
s->qscale;
2520 d->dquant=
s->dquant;
2522 d->esc3_level_length=
s->esc3_level_length;
2530 memcpy(
d->mv,
s->mv, 2*4*2*
sizeof(
int));
2531 memcpy(
d->last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2534 d->mb_skip_run=
s->mb_skip_run;
2536 d->last_dc[
i] =
s->last_dc[
i];
2539 d->mv_bits=
s->mv_bits;
2540 d->i_tex_bits=
s->i_tex_bits;
2541 d->p_tex_bits=
s->p_tex_bits;
2542 d->i_count=
s->i_count;
2543 d->misc_bits=
s->misc_bits;
2545 d->mb_intra=
s->mb_intra;
2546 d->mb_skipped=
s->mb_skipped;
2547 d->mv_type=
s->mv_type;
2548 d->mv_dir=
s->mv_dir;
2550 if(
s->data_partitioning){
2552 d->tex_pb=
s->tex_pb;
2556 d->block_last_index[
i]=
s->block_last_index[
i];
2557 d->interlaced_dct=
s->interlaced_dct;
2558 d->qscale=
s->qscale;
2560 d->esc3_level_length=
s->esc3_level_length;
2565 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2568 uint8_t *dest_backup[3];
2572 s->block=
s->blocks[*next_block];
2573 s->pb=
pb[*next_block];
2574 if(
s->data_partitioning){
2575 s->pb2 =
pb2 [*next_block];
2576 s->tex_pb=
tex_pb[*next_block];
2580 memcpy(dest_backup,
s->dest,
sizeof(
s->dest));
2581 s->dest[0] =
s->sc.rd_scratchpad;
2582 s->dest[1] =
s->sc.rd_scratchpad + 16*
s->linesize;
2583 s->dest[2] =
s->sc.rd_scratchpad + 16*
s->linesize + 8;
2590 if(
s->data_partitioning){
2598 score *=
s->lambda2;
2603 memcpy(
s->dest, dest_backup,
sizeof(
s->dest));
2621 else if(
w==8 &&
h==8)
2638 int chroma_mb_w =
w >>
s->chroma_x_shift;
2639 int chroma_mb_h =
h >>
s->chroma_y_shift;
2641 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
2642 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
2646 return s->mecc.nsse[0](
s,
s->new_pic->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
2647 s->dest[0],
s->linesize, 16) +
2648 s->mecc.nsse[1](
s,
s->new_pic->data[1] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2649 s->dest[1],
s->uvlinesize, chroma_mb_h) +
2650 s->mecc.nsse[1](
s,
s->new_pic->data[2] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2651 s->dest[2],
s->uvlinesize, chroma_mb_h);
2653 return s->mecc.sse[0](
NULL,
s->new_pic->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
2654 s->dest[0],
s->linesize, 16) +
2655 s->mecc.sse[1](
NULL,
s->new_pic->data[1] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2656 s->dest[1],
s->uvlinesize, chroma_mb_h) +
2657 s->mecc.sse[1](
NULL,
s->new_pic->data[2] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2658 s->dest[2],
s->uvlinesize, chroma_mb_h);
2661 return sse(
s,
s->new_pic->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
2662 s->dest[0],
w,
h,
s->linesize) +
2663 sse(
s,
s->new_pic->data[1] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2664 s->dest[1],
w >>
s->chroma_x_shift,
h >>
s->chroma_y_shift,
s->uvlinesize) +
2665 sse(
s,
s->new_pic->data[2] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2666 s->dest[2],
w >>
s->chroma_x_shift,
h >>
s->chroma_y_shift,
s->uvlinesize);
2674 s->me.dia_size=
s->avctx->pre_dia_size;
2675 s->first_slice_line=1;
2676 for(
s->mb_y=
s->end_mb_y-1;
s->mb_y >=
s->start_mb_y;
s->mb_y--) {
2677 for(
s->mb_x=
s->mb_width-1;
s->mb_x >=0 ;
s->mb_x--) {
2680 s->first_slice_line=0;
2691 s->me.dia_size=
s->avctx->dia_size;
2692 s->first_slice_line=1;
2693 for(
s->mb_y=
s->start_mb_y;
s->mb_y <
s->end_mb_y;
s->mb_y++) {
2696 for(
s->mb_x=0;
s->mb_x <
s->mb_width;
s->mb_x++) {
2697 s->block_index[0]+=2;
2698 s->block_index[1]+=2;
2699 s->block_index[2]+=2;
2700 s->block_index[3]+=2;
2708 s->first_slice_line=0;
2721 const uint8_t *pix =
s->new_pic->data[0] + (yy *
s->linesize) + xx;
2723 int sum =
s->mpvencdsp.pix_sum(pix,
s->linesize);
2725 varc = (
s->mpvencdsp.pix_norm1(pix,
s->linesize) -
2726 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2728 s->mb_var [
s->mb_stride *
mb_y +
mb_x] = varc;
2729 s->mb_mean[
s->mb_stride *
mb_y +
mb_x] = (sum+128)>>8;
2730 s->me.mb_var_sum_temp += varc;
2738 if(
s->partitioned_frame){
2743 }
else if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) &&
2746 }
else if (CONFIG_SPEEDHQ_ENCODER &&
s->out_format ==
FMT_SPEEDHQ) {
2758 uint8_t *ptr =
s->mb_info_ptr +
s->mb_info_size - 12;
2760 int mba =
s->mb_x +
s->mb_width * (
s->mb_y %
s->gob_index);
2761 int gobn =
s->mb_y /
s->gob_index;
2763 if (CONFIG_H263_ENCODER)
2765 bytestream_put_le32(&ptr,
offset);
2766 bytestream_put_byte(&ptr,
s->qscale);
2767 bytestream_put_byte(&ptr, gobn);
2768 bytestream_put_le16(&ptr, mba);
2769 bytestream_put_byte(&ptr, pred_x);
2770 bytestream_put_byte(&ptr, pred_y);
2772 bytestream_put_byte(&ptr, 0);
2773 bytestream_put_byte(&ptr, 0);
2781 s->mb_info_size += 12;
2782 s->prev_mb_info =
s->last_mb_info;
2794 if (!
s->mb_info_size)
2795 s->mb_info_size += 12;
2802 &&
s->slice_context_count == 1
2803 &&
s->pb.buf ==
s->avctx->internal->byte_buffer) {
2804 int lastgob_pos =
s->ptr_lastgob -
s->pb.buf;
2806 uint8_t *new_buffer =
NULL;
2807 int new_buffer_size = 0;
2809 if ((
s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2817 s->avctx->internal->byte_buffer_size + size_increase);
2821 memcpy(new_buffer,
s->avctx->internal->byte_buffer,
s->avctx->internal->byte_buffer_size);
2822 av_free(
s->avctx->internal->byte_buffer);
2823 s->avctx->internal->byte_buffer = new_buffer;
2824 s->avctx->internal->byte_buffer_size = new_buffer_size;
2826 s->ptr_lastgob =
s->pb.buf + lastgob_pos;
2836 int chr_h= 16>>
s->chroma_y_shift;
2860 s->last_dc[
i] = 128 <<
s->intra_dc_precision;
2862 s->encoding_error[
i] = 0;
2865 s->last_dc[0] = 128*8/13;
2866 s->last_dc[1] = 128*8/14;
2867 s->last_dc[2] = 128*8/14;
2870 memset(
s->last_mv, 0,
sizeof(
s->last_mv));
2874 switch(
s->codec_id){
2878 if (CONFIG_H263_ENCODER)
2882 if(CONFIG_MPEG4_ENCODER &&
s->partitioned_frame)
2889 s->first_slice_line = 1;
2890 s->ptr_lastgob =
s->pb.buf;
2891 for (mb_y_order =
s->start_mb_y; mb_y_order < s->
end_mb_y; mb_y_order++) {
2895 if (first_in_slice && mb_y_order !=
s->start_mb_y)
2897 s->last_dc[0] =
s->last_dc[1] =
s->last_dc[2] = 1024 <<
s->intra_dc_precision;
2913 int size_increase =
s->avctx->internal->byte_buffer_size/4
2921 if(
s->data_partitioning){
2935 xy=
s->mb_y*
s->mb_stride +
s->mb_x;
2941 int current_packet_size, is_gob_start;
2944 - (
s->ptr_lastgob -
s->pb.buf);
2946 is_gob_start =
s->rtp_payload_size &&
2947 current_packet_size >=
s->rtp_payload_size &&
2950 if(
s->start_mb_y ==
mb_y &&
mb_y > 0 &&
mb_x==0) is_gob_start=1;
2952 switch(
s->codec_id){
2955 if(!
s->h263_slice_structured)
2956 if(
s->mb_x ||
s->mb_y%
s->gob_index) is_gob_start=0;
2959 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
2961 if(
s->mb_skip_run) is_gob_start=0;
2964 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
2980 if (
s->error_rate &&
s->resync_mb_x +
s->resync_mb_y > 0) {
2982 int d = 100 /
s->error_rate;
2984 current_packet_size=0;
2985 s->pb.buf_ptr=
s->ptr_lastgob;
2990 switch(
s->codec_id){
2992 if (CONFIG_MPEG4_ENCODER) {
2999 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3006 if (CONFIG_H263_ENCODER) {
3015 s->misc_bits+=
bits -
s->last_bits;
3019 s->ptr_lastgob += current_packet_size;
3020 s->first_slice_line=1;
3021 s->resync_mb_x=
mb_x;
3022 s->resync_mb_y=
mb_y;
3026 if( (
s->resync_mb_x ==
s->mb_x)
3027 &&
s->resync_mb_y+1 ==
s->mb_y){
3028 s->first_slice_line=0;
3038 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3044 if(
s->data_partitioning){
3045 backup_s.pb2=
s->pb2;
3046 backup_s.tex_pb=
s->tex_pb;
3053 s->mv[0][0][0] =
s->p_mv_table[xy][0];
3054 s->mv[0][0][1] =
s->p_mv_table[xy][1];
3056 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3063 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3064 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3065 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3068 &dmin, &next_block, 0, 0);
3077 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3084 s->mv[0][
i][0] =
s->cur_pic.motion_val[0][
s->block_index[
i]][0];
3085 s->mv[0][
i][1] =
s->cur_pic.motion_val[0][
s->block_index[
i]][1];
3088 &dmin, &next_block, 0, 0);
3094 s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3095 s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3097 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3103 s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3104 s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3106 &dmin, &next_block,
s->mv[1][0][0],
s->mv[1][0][1]);
3112 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3113 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3114 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3115 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3117 &dmin, &next_block, 0, 0);
3124 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3125 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3126 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3129 &dmin, &next_block, 0, 0);
3136 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3137 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3138 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3141 &dmin, &next_block, 0, 0);
3147 for(dir=0; dir<2; dir++){
3149 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3150 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3151 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3155 &dmin, &next_block, 0, 0);
3164 &dmin, &next_block, 0, 0);
3165 if(
s->h263_pred ||
s->h263_aic){
3167 s->mbintra_table[
mb_x +
mb_y*
s->mb_stride]=1;
3175 const int last_qp= backup_s.qscale;
3179 static const int dquant_tab[4]={-1,1,-2,2};
3180 int storecoefs =
s->mb_intra &&
s->dc_val[0];
3188 s->mv[0][0][0] = best_s.
mv[0][0][0];
3189 s->mv[0][0][1] = best_s.
mv[0][0][1];
3190 s->mv[1][0][0] = best_s.
mv[1][0][0];
3191 s->mv[1][0][1] = best_s.
mv[1][0][1];
3194 for(; qpi<4; qpi++){
3195 int dquant= dquant_tab[qpi];
3197 if(qp < s->
avctx->
qmin || qp >
s->avctx->qmax)
3202 dc[
i]=
s->dc_val[0][
s->block_index[
i] ];
3203 memcpy(ac[
i],
s->ac_val[0][
s->block_index[
i]],
sizeof(int16_t)*16);
3208 &dmin, &next_block,
s->mv[mvdir][0][0],
s->mv[mvdir][0][1]);
3212 s->dc_val[0][
s->block_index[
i] ]=
dc[
i];
3213 memcpy(
s->ac_val[0][
s->block_index[
i]], ac[
i],
sizeof(int16_t)*16);
3221 int mx=
s->b_direct_mv_table[xy][0];
3222 int my=
s->b_direct_mv_table[xy][1];
3224 backup_s.dquant = 0;
3229 &dmin, &next_block, mx, my);
3232 backup_s.dquant = 0;
3237 &dmin, &next_block, 0, 0);
3242 coded |=
s->block_last_index[
i];
3245 memcpy(
s->mv, best_s.
mv,
sizeof(
s->mv));
3267 &dmin, &next_block, mx, my);
3272 s->cur_pic.qscale_table[xy] = best_s.
qscale;
3278 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3281 if(
s->data_partitioning){
3284 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3285 s->pb2= backup_s.pb2;
3289 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3290 s->tex_pb= backup_s.tex_pb;
3294 if (CONFIG_H263_ENCODER &&
3299 s->hdsp.put_pixels_tab[0][0](
s->dest[0],
s->sc.rd_scratchpad ,
s->linesize ,16);
3300 s->hdsp.put_pixels_tab[1][0](
s->dest[1],
s->sc.rd_scratchpad + 16*
s->linesize ,
s->uvlinesize, 8);
3301 s->hdsp.put_pixels_tab[1][0](
s->dest[2],
s->sc.rd_scratchpad + 16*
s->linesize + 8,
s->uvlinesize, 8);
3307 int motion_x = 0, motion_y = 0;
3315 motion_x=
s->mv[0][0][0] = 0;
3316 motion_y=
s->mv[0][0][1] = 0;
3321 motion_x=
s->mv[0][0][0] =
s->p_mv_table[xy][0];
3322 motion_y=
s->mv[0][0][1] =
s->p_mv_table[xy][1];
3329 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3330 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3331 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3339 s->mv[0][
i][0] =
s->cur_pic.motion_val[0][
s->block_index[
i]][0];
3340 s->mv[0][
i][1] =
s->cur_pic.motion_val[0][
s->block_index[
i]][1];
3344 if (CONFIG_MPEG4_ENCODER) {
3347 motion_x=
s->b_direct_mv_table[xy][0];
3348 motion_y=
s->b_direct_mv_table[xy][1];
3353 if (CONFIG_MPEG4_ENCODER) {
3362 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3363 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3364 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3365 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3370 motion_x=
s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3371 motion_y=
s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3376 motion_x=
s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3377 motion_y=
s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3384 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3385 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3386 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3394 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3395 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3396 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3403 for(dir=0; dir<2; dir++){
3405 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3406 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3407 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3418 s->last_mv_dir =
s->mv_dir;
3420 if (CONFIG_H263_ENCODER &&
3429 s->p_mv_table[xy][0]=0;
3430 s->p_mv_table[xy][1]=0;
3437 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
3438 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
3440 s->encoding_error[0] +=
sse(
3441 s,
s->new_pic->data[0] +
s->mb_x*16 +
s->mb_y*
s->linesize*16,
3442 s->dest[0],
w,
h,
s->linesize);
3443 s->encoding_error[1] +=
sse(
3444 s,
s->new_pic->data[1] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3445 s->dest[1],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3446 s->encoding_error[2] +=
sse(
3447 s,
s->new_pic->data[2] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3448 s->dest[2],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3451 if(CONFIG_H263_ENCODER &&
s->out_format ==
FMT_H263)
3454 ff_dlog(
s->avctx,
"MB %d %d bits\n",
3459 #if CONFIG_MSMPEG4ENC
3471 #define MERGE(field) dst->field += src->field; src->field=0
3493 for(
i=0;
i<64;
i++){
3506 if (
s->next_lambda){
3507 s->cur_pic.ptr->f->quality =
s->next_lambda;
3508 if(!dry_run)
s->next_lambda= 0;
3509 }
else if (!
s->fixed_qscale) {
3511 s->cur_pic.ptr->f->quality =
quality;
3512 if (
s->cur_pic.ptr->f->quality < 0)
3516 if(
s->adaptive_quant){
3517 switch(
s->codec_id){
3519 if (CONFIG_MPEG4_ENCODER)
3525 if (CONFIG_H263_ENCODER)
3532 s->lambda=
s->lambda_table[0];
3535 s->lambda =
s->cur_pic.ptr->f->quality;
3543 s->time =
s->cur_pic.ptr->f->pts *
s->avctx->time_base.num;
3546 s->pb_time=
s->pp_time - (
s->last_non_b_time -
s->time);
3549 s->pp_time=
s->time -
s->last_non_b_time;
3550 s->last_non_b_time=
s->time;
3559 int context_count =
s->slice_context_count;
3562 s->me.mb_var_sum_temp =
3563 s->me.mc_mb_var_sum_temp = 0;
3572 s->me.scene_change_score=0;
3577 s->no_rounding =
s->msmpeg4_version >=
MSMP4_V3;
3580 s->no_rounding ^= 1;
3589 s->lambda=
s->last_lambda_for[
s->pict_type];
3591 s->lambda=
s->last_lambda_for[
s->last_non_b_pict_type];
3596 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
3597 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
3598 s->q_chroma_intra_matrix =
s->q_intra_matrix;
3599 s->q_chroma_intra_matrix16 =
s->q_intra_matrix16;
3606 for (
int i = 0;
i < context_count;
i++) {
3608 uint8_t *start, *end;
3627 s->lambda = (
s->lambda *
s->me_penalty_compensation + 128) >> 8;
3628 s->lambda2 = (
s->lambda2 * (int64_t)
s->me_penalty_compensation + 128) >> 8;
3639 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3642 if(!
s->fixed_qscale){
3644 s->avctx->execute(
s->avctx,
mb_var_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3647 for(
i=1;
i<context_count;
i++){
3650 s->mc_mb_var_sum =
s->me.mc_mb_var_sum_temp;
3651 s->mb_var_sum =
s->me. mb_var_sum_temp;
3654 if (
s->me.scene_change_score >
s->scenechange_threshold &&
3657 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3661 ff_dlog(
s,
"Scene change detected, encoding as I Frame %"PRId64
" %"PRId64
"\n",
3662 s->mb_var_sum,
s->mc_mb_var_sum);
3703 for(dir=0; dir<2; dir++){
3709 s->b_field_mv_table[dir][
i][j], dir ?
s->b_code :
s->f_code,
type, 1);
3720 if (
s->qscale < 3 &&
s->max_qcoeff <= 128 &&
3729 if (
s->avctx->intra_matrix) {
3731 luma_matrix =
s->avctx->intra_matrix;
3733 if (
s->avctx->chroma_intra_matrix)
3734 chroma_matrix =
s->avctx->chroma_intra_matrix;
3738 int j =
s->idsp.idct_permutation[
i];
3740 s->chroma_intra_matrix[j] =
av_clip_uint8((chroma_matrix[
i] *
s->qscale) >> 3);
3743 s->y_dc_scale_table=
3745 s->chroma_intra_matrix[0] =
3748 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3750 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3754 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};
3755 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};
3756 for (
int i = 1;
i < 64;
i++) {
3762 s->y_dc_scale_table = y;
3763 s->c_dc_scale_table =
c;
3764 s->intra_matrix[0] = 13;
3765 s->chroma_intra_matrix[0] = 14;
3767 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3769 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3779 s->cur_pic.ptr->f->pict_type =
s->pict_type;
3782 s->picture_in_gop_number=0;
3784 s->mb_x =
s->mb_y = 0;
3786 switch(
s->out_format) {
3787 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
3793 if (CONFIG_SPEEDHQ_ENCODER)
3797 if (CONFIG_H261_ENCODER)
3803 #if CONFIG_MSMPEG4ENC
3807 else if (CONFIG_MPEG4_ENCODER &&
s->h263_pred) {
3820 else if (CONFIG_H263_ENCODER)
3824 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3831 s->header_bits=
bits -
s->last_bits;
3833 for(
i=1;
i<context_count;
i++){
3836 s->avctx->execute(
s->avctx,
encode_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3837 for(
i=1;
i<context_count;
i++){
3838 if (
s->pb.buf_end ==
s->thread_context[
i]->pb.buf)
3847 const int intra=
s->mb_intra;
3850 s->dct_count[intra]++;
3852 for(
i=0;
i<64;
i++){
3857 s->dct_error_sum[intra][
i] +=
level;
3858 level -=
s->dct_offset[intra][
i];
3861 s->dct_error_sum[intra][
i] -=
level;
3862 level +=
s->dct_offset[intra][
i];
3871 int16_t *
block,
int n,
3875 const uint8_t *scantable;
3876 const uint8_t *perm_scantable;
3878 unsigned int threshold1, threshold2;
3890 int coeff_count[64];
3891 int qmul, qadd, start_i, last_non_zero,
i,
dc;
3892 const int esc_length=
s->ac_esc_length;
3894 uint8_t * last_length;
3900 if(
s->dct_error_sum)
3906 else mpeg2_qscale =
qscale << 1;
3910 scantable=
s->intra_scantable.scantable;
3911 perm_scantable=
s->intra_scantable.permutated;
3928 qmat = n < 4 ?
s->q_intra_matrix[
qscale] :
s->q_chroma_intra_matrix[
qscale];
3929 matrix = n < 4 ?
s->intra_matrix :
s->chroma_intra_matrix;
3933 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
3934 length =
s->intra_chroma_ac_vlc_length;
3935 last_length=
s->intra_chroma_ac_vlc_last_length;
3937 length =
s->intra_ac_vlc_length;
3938 last_length=
s->intra_ac_vlc_last_length;
3941 scantable=
s->inter_scantable.scantable;
3942 perm_scantable=
s->inter_scantable.permutated;
3945 qmat =
s->q_inter_matrix[
qscale];
3947 length =
s->inter_ac_vlc_length;
3948 last_length=
s->inter_ac_vlc_last_length;
3953 threshold2= (threshold1<<1);
3955 for(
i=63;
i>=start_i;
i--) {
3956 const int j = scantable[
i];
3959 if(((
unsigned)(
level+threshold1))>threshold2){
3965 for(
i=start_i;
i<=last_non_zero;
i++) {
3966 const int j = scantable[
i];
3971 if(((
unsigned)(
level+threshold1))>threshold2){
3994 if(last_non_zero < start_i){
3995 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
3996 return last_non_zero;
3999 score_tab[start_i]= 0;
4000 survivor[0]= start_i;
4003 for(
i=start_i;
i<=last_non_zero;
i++){
4004 int level_index, j, zero_distortion;
4006 int best_score=256*256*256*120;
4010 zero_distortion= dct_coeff*dct_coeff;
4012 for(level_index=0; level_index < coeff_count[
i]; level_index++){
4021 unquant_coeff= alevel*qmul + qadd;
4023 j =
s->idsp.idct_permutation[scantable[
i]];
4024 unquant_coeff = alevel *
matrix[j] * 8;
4026 j =
s->idsp.idct_permutation[scantable[
i]];
4028 unquant_coeff = (
int)( alevel * mpeg2_qscale *
matrix[j]) >> 4;
4029 unquant_coeff = (unquant_coeff - 1) | 1;
4031 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int)
matrix[j])) >> 5;
4032 unquant_coeff = (unquant_coeff - 1) | 1;
4037 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4039 if((
level&(~127)) == 0){
4040 for(j=survivor_count-1; j>=0; j--){
4041 int run=
i - survivor[j];
4043 score += score_tab[
i-
run];
4045 if(score < best_score){
4048 level_tab[
i+1]=
level-64;
4053 for(j=survivor_count-1; j>=0; j--){
4054 int run=
i - survivor[j];
4056 score += score_tab[
i-
run];
4057 if(score < last_score){
4060 last_level=
level-64;
4066 distortion += esc_length*
lambda;
4067 for(j=survivor_count-1; j>=0; j--){
4068 int run=
i - survivor[j];
4069 int score= distortion + score_tab[
i-
run];
4071 if(score < best_score){
4074 level_tab[
i+1]=
level-64;
4079 for(j=survivor_count-1; j>=0; j--){
4080 int run=
i - survivor[j];
4081 int score= distortion + score_tab[
i-
run];
4082 if(score < last_score){
4085 last_level=
level-64;
4093 score_tab[
i+1]= best_score;
4096 if(last_non_zero <= 27){
4097 for(; survivor_count; survivor_count--){
4098 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4102 for(; survivor_count; survivor_count--){
4103 if(score_tab[ survivor[survivor_count-1] ] <= best_score +
lambda)
4108 survivor[ survivor_count++ ]=
i+1;
4112 last_score= 256*256*256*120;
4113 for(
i= survivor[0];
i<=last_non_zero + 1;
i++){
4114 int score= score_tab[
i];
4118 if(score < last_score){
4121 last_level= level_tab[
i];
4122 last_run= run_tab[
i];
4127 s->coded_score[n] = last_score;
4130 last_non_zero= last_i - 1;
4131 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4133 if(last_non_zero < start_i)
4134 return last_non_zero;
4136 if(last_non_zero == 0 && start_i == 0){
4138 int best_score=
dc *
dc;
4140 for(
i=0;
i<coeff_count[0];
i++){
4143 int unquant_coeff, score, distortion;
4146 unquant_coeff= (alevel*qmul + qadd)>>3;
4148 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int)
matrix[0])) >> 5;
4149 unquant_coeff = (unquant_coeff - 1) | 1;
4151 unquant_coeff = (unquant_coeff + 4) >> 3;
4152 unquant_coeff<<= 3 + 3;
4154 distortion= (unquant_coeff -
dc) * (unquant_coeff -
dc);
4157 else score= distortion + esc_length*
lambda;
4159 if(score < best_score){
4161 best_level=
level - 64;
4164 block[0]= best_level;
4165 s->coded_score[n] = best_score -
dc*
dc;
4166 if(best_level == 0)
return -1;
4167 else return last_non_zero;
4173 block[ perm_scantable[last_non_zero] ]= last_level;
4176 for(;
i>start_i;
i -= run_tab[
i] + 1){
4177 block[ perm_scantable[
i-1] ]= level_tab[
i];
4180 return last_non_zero;
4195 if(
i==0)
s*= sqrt(0.5);
4196 if(j==0)
s*= sqrt(0.5);
4209 const uint8_t *scantable;
4210 const uint8_t *perm_scantable;
4216 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4217 const uint8_t *length;
4218 const uint8_t *last_length;
4220 int rle_index,
run, q = 1, sum;
4222 if(
basis[0][0] == 0)
4228 scantable=
s->intra_scantable.scantable;
4229 perm_scantable=
s->intra_scantable.permutated;
4247 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4248 length =
s->intra_chroma_ac_vlc_length;
4249 last_length=
s->intra_chroma_ac_vlc_last_length;
4251 length =
s->intra_ac_vlc_length;
4252 last_length=
s->intra_ac_vlc_last_length;
4255 scantable=
s->inter_scantable.scantable;
4256 perm_scantable=
s->inter_scantable.permutated;
4259 length =
s->inter_ac_vlc_length;
4260 last_length=
s->inter_ac_vlc_last_length;
4262 last_non_zero =
s->block_last_index[n];
4265 for(
i=0;
i<64;
i++){
4270 for(
i=0;
i<64;
i++){
4276 w= 15 + (48*qns*one +
w/2)/
w;
4289 for(
i=start_i;
i<=last_non_zero;
i++){
4290 int j= perm_scantable[
i];
4297 run_tab[rle_index++]=
run;
4307 int best_score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0], 0);
4310 int run2, best_unquant_change=0, analyze_gradient;
4311 analyze_gradient = last_non_zero > 2 ||
s->quantizer_noise_shaping >= 3;
4313 if(analyze_gradient){
4314 for(
i=0;
i<64;
i++){
4324 int change, old_coeff;
4330 for(change=-1; change<=1; change+=2){
4331 int new_level=
level + change;
4332 int score, new_coeff;
4334 new_coeff= q*new_level;
4335 if(new_coeff >= 2048 || new_coeff < 0)
4338 score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0],
4339 new_coeff - old_coeff);
4340 if(score<best_score){
4343 best_change= change;
4344 best_unquant_change= new_coeff - old_coeff;
4351 run2= run_tab[rle_index++];
4355 for(
i=start_i;
i<64;
i++){
4356 int j= perm_scantable[
i];
4358 int change, old_coeff;
4360 if(
s->quantizer_noise_shaping < 3 &&
i > last_non_zero + 1)
4365 else old_coeff= qmul*
level + qadd;
4366 run2= run_tab[rle_index++];
4373 for(change=-1; change<=1; change+=2){
4374 int new_level=
level + change;
4375 int score, new_coeff, unquant_change;
4382 if(new_level<0) new_coeff= qmul*new_level - qadd;
4383 else new_coeff= qmul*new_level + qadd;
4384 if(new_coeff >= 2048 || new_coeff <= -2048)
4389 if(level < 63 && level > -63){
4390 if(
i < last_non_zero)
4400 if(analyze_gradient){
4401 int g= d1[ scantable[
i] ];
4402 if(
g && (
g^new_level) >= 0)
4406 if(
i < last_non_zero){
4407 int next_i=
i + run2 + 1;
4408 int next_level=
block[ perm_scantable[next_i] ] + 64;
4410 if(next_level&(~127))
4413 if(next_i < last_non_zero)
4433 if(
i < last_non_zero){
4434 int next_i=
i + run2 + 1;
4435 int next_level=
block[ perm_scantable[next_i] ] + 64;
4437 if(next_level&(~127))
4440 if(next_i < last_non_zero)
4459 unquant_change= new_coeff - old_coeff;
4462 score +=
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[j],
4464 if(score<best_score){
4467 best_change= change;
4468 best_unquant_change= unquant_change;
4472 prev_level=
level + 64;
4473 if(prev_level&(~127))
4483 int j= perm_scantable[ best_coeff ];
4485 block[j] += best_change;
4487 if(best_coeff > last_non_zero){
4488 last_non_zero= best_coeff;
4491 for(; last_non_zero>=start_i; last_non_zero--){
4492 if(
block[perm_scantable[last_non_zero]])
4499 for(
i=start_i;
i<=last_non_zero;
i++){
4500 int j= perm_scantable[
i];
4504 run_tab[rle_index++]=
run;
4511 s->mpvencdsp.add_8x8basis(rem,
basis[j], best_unquant_change);
4517 return last_non_zero;
4532 const uint8_t *scantable,
int last)
4543 for (
i = 0;
i <= last;
i++) {
4544 const int j = scantable[
i];
4549 for (
i = 0;
i <= last;
i++) {
4550 const int j = scantable[
i];
4551 const int perm_j = permutation[j];
4557 int16_t *
block,
int n,
4560 int i, j,
level, last_non_zero, q, start_i;
4562 const uint8_t *scantable;
4565 unsigned int threshold1, threshold2;
4569 if(
s->dct_error_sum)
4573 scantable=
s->intra_scantable.scantable;
4588 qmat = n < 4 ?
s->q_intra_matrix[
qscale] :
s->q_chroma_intra_matrix[
qscale];
4591 scantable=
s->inter_scantable.scantable;
4594 qmat =
s->q_inter_matrix[
qscale];
4598 threshold2= (threshold1<<1);
4599 for(
i=63;
i>=start_i;
i--) {
4603 if(((
unsigned)(
level+threshold1))>threshold2){
4610 for(
i=start_i;
i<=last_non_zero;
i++) {
4616 if(((
unsigned)(
level+threshold1))>threshold2){
4634 scantable, last_non_zero);
4636 return last_non_zero;
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
static int encode_frame(AVCodecContext *c, const AVFrame *frame, AVPacket *pkt)
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
void ff_speedhq_end_slice(MpegEncContext *s)
int ff_encode_reordered_opaque(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame)
Propagate user opaque values from the frame to avctx/pkt as needed.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
static int encode_picture(MpegEncContext *s, const AVPacket *pkt)
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegvideoenc.h)
#define CANDIDATE_MB_TYPE_BIDIR
#define MV_TYPE_16X16
1 vector for the whole mb
#define AV_LOG_WARNING
Something somehow does not look correct.
av_cold int ff_speedhq_encode_init(MpegEncContext *s)
const AVClass ff_mpv_enc_class
int data_partitioning
data partitioning flag from header
static void set_frame_distances(MpegEncContext *s)
static int get_bits_diff(MpegEncContext *s)
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
unsigned int lambda
Lagrange multiplier used in rate distortion.
#define H263_GOB_HEIGHT(h)
av_cold int ff_h261_encode_init(MpegEncContext *s)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t *const *ref_picture, const op_pixels_func(*pix_op)[4], const qpel_mc_func(*qpix_op)[16])
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is actually possible in MPEG-4
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y)
int b_code
backward MV resolution for B-frames (MPEG-4)
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
int64_t rc_min_rate
minimum bitrate
void ff_fix_long_p_mvs(MpegEncContext *s, int type)
void ff_speedhq_encode_picture_header(MpegEncContext *s)
int ff_wmv2_encode_picture_header(MpegEncContext *s)
#define AVERROR_EOF
End of file.
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
void ff_h261_encode_picture_header(MpegEncContext *s)
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
static int sse_mb(MpegEncContext *s)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static int16_t basis[64][64]
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions,...
static const uint8_t mv_bits[2][16][10]
static int estimate_motion_thread(AVCodecContext *c, void *arg)
float lumi_masking
luminance masking (0-> disabled)
static void update_noise_reduction(MpegEncContext *s)
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int partitioned_frame
is current frame partitioned
#define CANDIDATE_MB_TYPE_INTER
uint16_t(* dct_offset)[64]
int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src)
This structure describes decoded (raw) audio or video data.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define INTERLACED_DCT(s)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int capabilities
Codec capabilities.
static const int32_t qmat16[MAT_SIZE]
static const int BUF_BITS
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Shrink the already allocated side data buffer.
static int put_bytes_count(const PutBitContext *s, int round_up)
const uint8_t ff_mpeg2_non_linear_qscale[32]
static int prepare_picture(MpegEncContext *s, AVFrame *f, const AVFrame *props_frame)
Allocates new buffers for an AVFrame and copies the properties from another AVFrame.
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
#define AV_LOG_VERBOSE
Detailed information.
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
void ff_init_block_index(MpegEncContext *s)
void ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
#define FF_MPV_FLAG_SKIP_RD
const uint8_t ff_mpeg12_dc_scale_table[4][32]
struct AVCodecContext * avctx
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
av_cold int ff_rate_control_init(MpegEncContext *s)
static double sqr(double in)
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg)
static void get_visual_weight(int16_t *weight, const uint8_t *ptr, int stride)
PutBitContext pb
bit output
int mb_decision
macroblock decision mode
int qmax
maximum quantizer
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
void ff_flv_encode_picture_header(MpegEncContext *s)
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
#define CANDIDATE_MB_TYPE_BACKWARD_I
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
#define FF_MPV_COMMON_MOTION_EST_OPTS
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
uint64_t encoding_error[MPV_MAX_PLANES]
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
static int skip_check(MpegEncContext *s, const MPVPicture *p, const MPVPicture *ref)
#define FF_MPV_COMMON_OPTS
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
static int estimate_qp(MpegEncContext *s, int dry_run)
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
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.
const struct AVCodec * codec
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src)
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
static void frame_start(MpegEncContext *s)
av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
static void ff_refstruct_pool_uninit(FFRefStructPool **poolp)
Mark the pool as being available for freeing.
static const struct twinvq_data tab
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
int flags
AV_CODEC_FLAG_*.
#define CANDIDATE_MB_TYPE_SKIPPED
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
#define FF_MPV_FLAG_CBP_RD
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
static void mpv_encode_init_static(void)
static int put_bytes_left(const PutBitContext *s, int round_up)
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define CANDIDATE_MB_TYPE_DIRECT
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
#define CANDIDATE_MB_TYPE_INTER_I
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
void ff_mpv_common_end(MpegEncContext *s)
static int ff_thread_once(char *control, void(*routine)(void))
void ff_init_qscale_tab(MpegEncContext *s)
init s->cur_pic.qscale_table from s->lambda_table
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
static void update_mb_info(MpegEncContext *s, int startcode)
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
static uint8_t default_fcode_tab[MAX_MV *2+1]
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
static void mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
static void build_basis(uint8_t *perm)
int has_b_frames
Size of the frame reordering buffer in the decoder.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
const uint8_t ff_h263_chroma_qscale_table[32]
static int get_sae(const uint8_t *src, int ref, int stride)
static void rebase_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Rebase the bit writer onto a reallocated buffer.
#define AV_CEIL_RSHIFT(a, b)
void ff_mpeg4_stuffing(PutBitContext *pbc)
add MPEG-4 stuffing bits (01...1)
static double av_q2d(AVRational a)
Convert an AVRational to a double.
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
#define LOCAL_ALIGNED_16(t, v,...)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
int64_t rc_max_rate
maximum bitrate
void ff_block_permute(int16_t *block, const uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permutation.
uint64_t error[AV_NUM_DATA_POINTERS]
error
This structure describes the bitrate properties of an encoded bitstream.
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
#define CANDIDATE_MB_TYPE_FORWARD
float p_masking
p block masking (0-> disabled)
static int mb_var_thread(AVCodecContext *c, void *arg)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
void ff_mpv_unref_picture(MPVWorkPicture *pic)
av_cold FFRefStructPool * ff_mpv_alloc_pic_pool(int init_progress)
Allocate a pool of MPVPictures.
int rc_buffer_size
decoder bitstream buffer size
PutBitContext pb2
used for data partitioned VOPs
#define LIBAVUTIL_VERSION_INT
void ff_write_pass1_stats(MpegEncContext *s)
#define CANDIDATE_MB_TYPE_FORWARD_I
void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Describe the class of an AVClass context structure.
#define PTRDIFF_SPECIFIER
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
static void write_mb_info(MpegEncContext *s)
int f_code
forward MV resolution
static int bias(int x, int c)
av_cold void ff_mpv_idct_init(MpegEncContext *s)
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
#define CANDIDATE_MB_TYPE_BACKWARD
struct AVCodecInternal * internal
Private context used for internal data.
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
int64_t bit_rate
the average bitrate
int display_picture_number
#define ROUNDED_DIV(a, b)
void ff_faandct(int16_t *data)
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
static void update_duplicate_context_after_me(MpegEncContext *dst, const MpegEncContext *src)
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
av_cold void ff_dct_encode_init(MpegEncContext *s)
static int dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
int ildct_cmp
interlaced DCT comparison function
int ff_vbv_update(MpegEncContext *s, int frame_size)
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
int trellis
trellis RD quantization
void ff_mpeg4_init_partitions(MpegEncContext *s)
void ff_mjpeg_amv_encode_picture_header(MpegEncContext *s)
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
int ff_mpeg4_encode_picture_header(MpegEncContext *s)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
void ff_mpeg1_encode_init(MpegEncContext *s)
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
static int weight(int i, int blen, int offset)
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in H.263 (limit difference to -2....
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
static void mpv_encode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for encoding.
static void denoise_dct_c(MpegEncContext *s, int16_t *block)
static void set_put_bits_buffer_size(PutBitContext *s, int size)
Change the end of the buffer.
void ff_mpeg4_merge_partitions(MpegEncContext *s)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
Allocate buffers for a frame.
#define FF_DEBUG_DCT_COEFF
void ff_dct_encode_init_x86(MpegEncContext *s)
char * stats_out
pass1 encoding statistics output buffer
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, int chroma_x_shift, int chroma_y_shift, int chroma_format)
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
void ff_mpeg4_clean_buffers(MpegEncContext *s)
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
static int shift(int a, int b)
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
int ff_pre_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
void ff_mpeg1_clean_buffers(MpegEncContext *s)
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
#define CANDIDATE_MB_TYPE_DIRECT0
const int16_t ff_mpeg4_default_intra_matrix[64]
void ff_msmpeg4_encode_ext_header(MpegEncContext *s)
#define CANDIDATE_MB_TYPE_INTRA
#define AV_NOPTS_VALUE
Undefined timestamp value.
static const AVOption mpv_generic_options[]
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
#define FF_MPV_FLAG_QP_RD
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
const uint16_t ff_mpeg1_default_intra_matrix[256]
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define FF_COMPLIANCE_NORMAL
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
const int16_t ff_mpeg4_default_non_intra_matrix[64]
#define ALLOCZ_ARRAYS(p, mult, numb)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define MV_TYPE_FIELD
2 vectors, one per field
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int flags
A combination of AV_PKT_FLAG values.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
unsigned int byte_buffer_size
uint8_t * scratchpad_buf
the other *_scratchpad point into this buffer
#define UNI_AC_ENC_INDEX(run, level)
#define CANDIDATE_MB_TYPE_BIDIR_I
#define AV_LOG_INFO
Standard information.
av_cold void ff_mpvenc_dct_init_mips(MpegEncContext *s)
#define CANDIDATE_MB_TYPE_INTER4V
static void update_qscale(MpegEncContext *s)
int ff_mjpeg_add_icc_profile_size(AVCodecContext *avctx, const AVFrame *frame, size_t *max_pkt_size)
void ff_msmpeg4_encode_picture_header(MpegEncContext *s)
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
@ AV_PKT_DATA_H263_MB_INFO
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
static int put_bits_count(PutBitContext *s)
static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
static int get_intra_count(MpegEncContext *s, const uint8_t *src, const uint8_t *ref, int stride)
static int encode_thread(AVCodecContext *c, void *arg)
void ff_jpeg_fdct_islow_8(int16_t *data)
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
const uint32_t ff_square_tab[512]
static int estimate_best_b_count(MpegEncContext *s)
int intra_dc_precision
precision of the intra DC coefficient - 8
PutBitContext tex_pb
used for data partitioned VOPs
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
void ff_h261_reorder_mb_index(MpegEncContext *s)
void ff_jpeg_fdct_islow_10(int16_t *data)
void ff_h263_encode_init(MpegEncContext *s)
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
const uint16_t ff_h263_format[8][2]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void copy_context_before_encode(MpegEncContext *d, const MpegEncContext *s)
int ff_init_me(MpegEncContext *s)
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
double buffer_index
amount of bits in the video/audio buffer
const uint8_t ff_zigzag_direct[64]
#define AV_CODEC_FLAG_CLOSED_GOP
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
void ff_fdct_ifast(int16_t *data)
const uint16_t ff_inv_aanscales[64]
static void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], int *dmin, int *next_block, int motion_x, int motion_y)
void ff_h263_loop_filter(MpegEncContext *s)
void ff_mpeg1_encode_picture_header(MpegEncContext *s)
#define AV_INPUT_BUFFER_PADDING_SIZE
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free.
void ff_set_mpeg4_time(MpegEncContext *s)
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)
int dquant
qscale difference to prev qscale
float dark_masking
darkness masking (0-> disabled)
main external API structure.
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
int qmin
minimum quantizer
static int select_input_picture(MpegEncContext *s)
static int set_bframe_chain_length(MpegEncContext *s)
Determines whether an input picture is discarded or not and if not determines the length of the next ...
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
static void frame_end(MpegEncContext *s)
static int ref[MAX_W *MAX_W]
int ff_mpv_pic_check_linesize(void *logctx, const AVFrame *f, ptrdiff_t *linesizep, ptrdiff_t *uvlinesizep)
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
static float mean(const float *input, int size)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define FF_MB_DECISION_RD
rate distortion
void ff_mpv_replace_picture(MPVWorkPicture *dst, const MPVWorkPicture *src)
void ff_h263_encode_picture_header(MpegEncContext *s)
@ AV_PICTURE_TYPE_P
Predicted.
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
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...
void ff_convert_matrix(MpegEncContext *s, int(*qmat)[64], uint16_t(*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
Undefined Behavior In the C some operations are like signed integer overflow
void(* fdct)(int16_t *block)
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
int ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale)
int ff_rv10_encode_picture_header(MpegEncContext *s)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static void copy_context_after_encode(MpegEncContext *d, const MpegEncContext *s)
int slices
Number of slices.
void ff_h263_update_mb(MpegEncContext *s)
#define FF_MB_DECISION_BITS
chooses the one which needs the fewest bits
This structure stores compressed data.
static void clip_coeffs(MpegEncContext *s, int16_t *block, int last_index)
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions,...
int width
picture width / height.
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
static const double coeff[2][5]
The exact code depends on how similar the blocks are and how related they are to the block
static int sse(MpegEncContext *s, const uint8_t *src1, const uint8_t *src2, int w, int h, int stride)
int misc_bits
cbp, mb_type
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
void ff_get_2pass_fcode(MpegEncContext *s)
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define FF_MPV_FLAG_STRICT_GOP
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
static const uint8_t sp5x_qscale_five_quant_table[][64]
@ AV_PICTURE_TYPE_S
S(GMC)-VOP MPEG-4.
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
int ff_mpv_alloc_pic_accessories(AVCodecContext *avctx, MPVWorkPicture *wpic, ScratchpadContext *sc, BufferPoolContext *pools, int mb_height)
Allocate an MPVPicture's accessories (but not the AVFrame's buffer itself) and set the MPVWorkPicture...
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
int ff_mjpeg_encode_stuffing(MpegEncContext *s)
Writes the complete JPEG frame when optimal huffman tables are enabled, otherwise writes the stuffing...
void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
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_rv20_encode_picture_header(MpegEncContext *s)
void * ff_refstruct_pool_get(FFRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
int ff_get_best_fcode(MpegEncContext *s, const int16_t(*mv_table)[2], int type)
const uint16_t ff_aanscales[64]
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
static void write_slice_end(MpegEncContext *s)
av_cold void ff_rate_control_uninit(RateControlContext *rcc)