73 #define QUANT_BIAS_SHIFT 8
75 #define QMAT_SHIFT_MMX 16
94 const uint16_t *quant_matrix,
95 int bias,
int qmin,
int qmax,
int intra)
101 for (qscale = qmin; qscale <= qmax; qscale++) {
106 else qscale2 = qscale << 1;
113 for (
i = 0;
i < 64;
i++) {
114 const int j =
s->idsp.idct_permutation[
i];
115 int64_t den = (int64_t) qscale2 * quant_matrix[j];
125 for (
i = 0;
i < 64;
i++) {
126 const int j =
s->idsp.idct_permutation[
i];
127 int64_t den =
ff_aanscales[
i] * (int64_t) qscale2 * quant_matrix[j];
134 qmat[qscale][
i] = (
int)((UINT64_C(2) << (
QMAT_SHIFT + 14)) / den);
137 for (
i = 0;
i < 64;
i++) {
138 const int j =
s->idsp.idct_permutation[
i];
139 int64_t den = (int64_t) qscale2 * quant_matrix[j];
150 if (
qmat16[qscale][0][
i] == 0 ||
151 qmat16[qscale][0][
i] == 128 * 256)
152 qmat16[qscale][0][
i] = 128 * 256 - 1;
159 for (
i = intra;
i < 64;
i++) {
164 while (((
max * qmat[qscale][
i]) >>
shift) > INT_MAX) {
171 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
178 if (
s->q_scale_type == 1 && 0) {
180 int bestdiff=INT_MAX;
188 if (
diff < bestdiff) {
197 s->qscale =
av_clip(
s->qscale,
s->avctx->qmin,
s->vbv_ignore_qmax ? 31 :
s->avctx->qmax);
210 for (
i = 0;
i < 64;
i++) {
222 int8_t *
const qscale_table =
s->current_picture.qscale_table;
225 for (
i = 0;
i <
s->mb_num;
i++) {
226 unsigned int lam =
s->lambda_table[
s->mb_index2xy[
i]];
228 qscale_table[
s->mb_index2xy[
i]] =
av_clip(qp,
s->avctx->qmin,
236 #define COPY(a) dst->a= src->a
238 COPY(current_picture);
244 COPY(picture_in_gop_number);
245 COPY(gop_picture_number);
246 COPY(frame_pred_frame_dct);
247 COPY(progressive_frame);
248 COPY(partitioned_frame);
254 for (
int i = -16;
i < 16;
i++)
273 s->input_picture_number = 0;
274 s->picture_in_gop_number = 0;
284 if (!
s->dct_quantize)
288 s->fast_dct_quantize =
s->dct_quantize;
289 if (
s->avctx->trellis)
300 int i, ret, format_supported;
309 "only YUV420 and YUV422 are supported\n");
315 format_supported = 0;
324 format_supported = 1;
330 format_supported = 1;
332 if (!format_supported) {
342 "only YUV420/YUV422/YUV444 are supported (no alpha support yet)\n");
371 #if FF_API_PRIVATE_OPT
388 "keyframe interval too large!, reducing it from %d to %d\n",
403 s->rtp_mode = !!
s->rtp_payload_size;
407 if (
s->intra_dc_precision < 0) {
408 s->intra_dc_precision += 8;
409 }
else if (
s->intra_dc_precision >= 8)
410 s->intra_dc_precision -= 8;
412 if (
s->intra_dc_precision < 0) {
414 "intra dc precision must be positive, note some applications use"
415 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
428 if (
s->gop_size <= 1) {
476 av_log(avctx,
AV_LOG_ERROR,
"Either both buffer size and max rate or neither must be specified\n");
482 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
499 "impossible bitrate constraints, this will fail\n");
509 if (!
s->fixed_qscale &&
524 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
525 "specified vbv buffer is too large for the given bitrate!\n");
537 "OBMC is only supported with simple mb decision\n");
546 if (
s->max_b_frames &&
553 if (
s->max_b_frames < 0) {
555 "max b frames must be 0 or positive for mpegvideo based encoders\n");
565 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
573 (avctx->
width > 2048 ||
580 ((avctx->
width &3) ||
587 (avctx->
width > 4095 ||
594 (avctx->
width > 16383 ||
595 avctx->
height > 16383 )) {
596 av_log(avctx,
AV_LOG_ERROR,
"MPEG-2 does not support resolutions above 16383x16383\n");
627 #if FF_API_PRIVATE_OPT
638 "mpeg2 style quantization not supported by codec\n");
658 "QP RD is no longer compatible with MJPEG or AMV\n");
662 #if FF_API_PRIVATE_OPT
669 if (
s->scenechange_threshold < 1000000000 &&
672 "closed gop with scene change detection are not supported yet, "
673 "set threshold to 1000000000\n");
681 "low delay forcing is only available for mpeg2, "
682 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
685 if (
s->max_b_frames != 0) {
687 "B-frames cannot be used with low delay\n");
692 if (
s->q_scale_type == 1) {
693 if (avctx->
qmax > 28) {
695 "non linear quant only supports qmax <= 28 currently\n");
713 "multi threaded encoding not supported by codec\n");
719 "automatic thread number detection not supported by codec, "
729 #if FF_API_PRIVATE_OPT
740 "notice: b_frame_strategy only affects the first pass\n");
741 s->b_frame_strategy = 0;
755 s->inter_quant_bias = 0;
757 s->intra_quant_bias = 0;
763 av_log(avctx,
AV_LOG_ERROR,
"qmin and or qmax are invalid, they must be 0 < min <= max\n");
767 av_log(avctx,
AV_LOG_DEBUG,
"intra_quant_bias = %d inter_quant_bias = %d\n",
s->intra_quant_bias,
s->inter_quant_bias);
772 "timebase %d/%d not supported by MPEG 4 standard, "
773 "the maximum admitted value for the timebase denominator "
784 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
789 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
818 "The specified picture size of %dx%d is not valid for the "
819 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
820 s->width,
s->height);
832 s->width,
s->height) == 8) {
834 "The specified picture size of %dx%d is not valid for "
835 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
836 "352x288, 704x576, and 1408x1152. "
837 "Try H.263+.\n",
s->width,
s->height);
849 s->modified_quant =
s->h263_aic;
851 s->unrestricted_mv =
s->obmc ||
s->loop_filter ||
s->umvplus;
861 s->unrestricted_mv = 1;
875 s->modified_quant = 1;
879 s->unrestricted_mv = 0;
884 s->unrestricted_mv = 1;
885 s->low_delay =
s->max_b_frames ? 0 : 1;
886 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
891 s->unrestricted_mv = 1;
892 s->msmpeg4_version = 2;
899 s->unrestricted_mv = 1;
900 s->msmpeg4_version = 3;
901 s->flipflop_rounding = 1;
908 s->unrestricted_mv = 1;
909 s->msmpeg4_version = 4;
910 s->flipflop_rounding = 1;
917 s->unrestricted_mv = 1;
918 s->msmpeg4_version = 5;
919 s->flipflop_rounding = 1;
927 #if FF_API_PRIVATE_OPT
938 s->progressive_frame =
954 if (
s->msmpeg4_version) {
971 if (
s->noise_reduction) {
981 if (
s->slice_context_count > 1) {
985 s->h263_slice_structured = 1;
988 s->quant_precision = 5;
990 #if FF_API_PRIVATE_OPT
1004 ff_set_cmp(&
s->mecc,
s->mecc.frame_skip_cmp,
s->frame_skip_cmp);
1017 for (
i = 0;
i < 64;
i++) {
1018 int j =
s->idsp.idct_permutation[
i];
1024 s->intra_matrix[j] =
1027 s->intra_matrix[j] =
1031 s->chroma_intra_matrix[j] =
1045 s->intra_matrix,
s->intra_quant_bias, avctx->
qmin,
1048 s->inter_matrix,
s->inter_quant_bias, avctx->
qmin,
1055 #if FF_API_PRIVATE_OPT
1065 if (
s->b_frame_strategy == 2) {
1066 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1068 if (!
s->tmp_frames[
i])
1072 s->tmp_frames[
i]->width =
s->width >>
s->brd_scale;
1073 s->tmp_frames[
i]->height =
s->height >>
s->brd_scale;
1115 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
1116 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
1117 s->q_chroma_intra_matrix=
NULL;
1118 s->q_chroma_intra_matrix16=
NULL;
1135 for (y = 0; y < 16; y++) {
1136 for (x = 0; x < 16; x++) {
1151 h =
s->height & ~15;
1153 for (y = 0; y <
h; y += 16) {
1154 for (x = 0; x <
w; x += 16) {
1161 acc += sae + 500 < sad;
1170 s->chroma_x_shift,
s->chroma_y_shift,
s->out_format,
1171 s->mb_stride,
s->mb_width,
s->mb_height,
s->b8_stride,
1172 &
s->linesize, &
s->uvlinesize);
1179 int i, display_picture_number = 0, ret;
1180 int encoding_delay =
s->max_b_frames ?
s->max_b_frames
1181 : (
s->low_delay ? 0 : 1);
1182 int flush_offset = 1;
1187 display_picture_number =
s->input_picture_number++;
1191 int64_t last =
s->user_specified_pts;
1195 "Invalid pts (%"PRId64
") <= last (%"PRId64
")\n",
1200 if (!
s->low_delay && display_picture_number == 1)
1201 s->dts_delta =
pts - last;
1203 s->user_specified_pts =
pts;
1206 s->user_specified_pts =
1207 pts =
s->user_specified_pts + 1;
1209 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
1212 pts = display_picture_number;
1216 if (!pic_arg->
buf[0] ||
1218 pic_arg->
linesize[1] !=
s->uvlinesize ||
1221 if ((
s->width & 15) || (
s->height & 15))
1229 pic_arg->
linesize[1],
s->linesize,
s->uvlinesize);
1235 pic = &
s->picture[
i];
1252 int h_chroma_shift, v_chroma_shift;
1257 for (
i = 0;
i < 3;
i++) {
1259 int dst_stride =
i ?
s->uvlinesize :
s->linesize;
1260 int h_shift =
i ? h_chroma_shift : 0;
1261 int v_shift =
i ? v_chroma_shift : 0;
1262 int w =
s->width >> h_shift;
1263 int h =
s->height >> v_shift;
1269 && !
s->progressive_sequence
1270 &&
FFALIGN(
s->height, 32) -
s->height > 16)
1273 if (!
s->avctx->rc_buffer_size)
1276 if (src_stride == dst_stride)
1277 memcpy(dst,
src, src_stride *
h);
1282 memcpy(dst2,
src,
w);
1287 if ((
s->width & 15) || (
s->height & (vpad-1))) {
1288 s->mpvencdsp.draw_edges(dst, dst_stride,
1307 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1308 if (
s->input_picture[flush_offset])
1311 if (flush_offset <= 1)
1314 encoding_delay = encoding_delay - flush_offset + 1;
1319 s->input_picture[
i - flush_offset] =
s->input_picture[
i];
1321 s->input_picture[encoding_delay] = (
Picture*) pic;
1330 int64_t score64 = 0;
1332 for (plane = 0; plane < 3; plane++) {
1334 const int bw = plane ? 1 : 2;
1335 for (y = 0; y <
s->mb_height * bw; y++) {
1336 for (x = 0; x <
s->mb_width * bw; x++) {
1337 int off = p->
shared ? 0 : 16;
1340 int v =
s->mecc.frame_skip_cmp[1](
s, dptr, rptr,
stride, 8);
1342 switch (
FFABS(
s->frame_skip_exp)) {
1343 case 0: score =
FFMAX(score, v);
break;
1344 case 1: score +=
FFABS(v);
break;
1345 case 2: score64 += v * (int64_t)v;
break;
1346 case 3: score64 +=
FFABS(v * (int64_t)v * v);
break;
1347 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);
break;
1356 if (
s->frame_skip_exp < 0)
1357 score64 = pow(score64 / (
double)(
s->mb_width *
s->mb_height),
1358 -1.0/
s->frame_skip_exp);
1360 if (score64 < s->frame_skip_threshold)
1362 if (score64 < ((
s->frame_skip_factor * (int64_t)
s->lambda) >> 8))
1392 const int scale =
s->brd_scale;
1393 int width =
s->width >> scale;
1394 int height =
s->height >> scale;
1395 int i, j,
out_size, p_lambda, b_lambda, lambda2;
1396 int64_t best_rd = INT64_MAX;
1397 int best_b_count = -1;
1412 b_lambda = p_lambda;
1416 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1417 Picture pre_input, *pre_input_ptr =
i ?
s->input_picture[
i - 1] :
1418 s->next_picture_ptr;
1421 if (pre_input_ptr && (!
i ||
s->input_picture[
i - 1])) {
1422 pre_input = *pre_input_ptr;
1431 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[0],
1432 s->tmp_frames[
i]->linesize[0],
1436 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[1],
1437 s->tmp_frames[
i]->linesize[1],
1441 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[2],
1442 s->tmp_frames[
i]->linesize[2],
1449 for (j = 0; j <
s->max_b_frames + 1; j++) {
1453 if (!
s->input_picture[j])
1466 c->mb_decision =
s->avctx->mb_decision;
1467 c->me_cmp =
s->avctx->me_cmp;
1468 c->mb_cmp =
s->avctx->mb_cmp;
1469 c->me_sub_cmp =
s->avctx->me_sub_cmp;
1471 c->time_base =
s->avctx->time_base;
1472 c->max_b_frames =
s->max_b_frames;
1490 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1491 int is_p =
i % (j + 1) == j ||
i ==
s->max_b_frames;
1493 s->tmp_frames[
i + 1]->pict_type = is_p ?
1495 s->tmp_frames[
i + 1]->quality = is_p ? p_lambda : b_lambda;
1514 rd +=
c->error[0] +
c->error[1] +
c->error[2];
1532 return best_b_count;
1540 s->reordered_input_picture[
i - 1] =
s->reordered_input_picture[
i];
1544 if (!
s->reordered_input_picture[0] &&
s->input_picture[0]) {
1545 if (
s->frame_skip_threshold ||
s->frame_skip_factor) {
1546 if (
s->picture_in_gop_number <
s->gop_size &&
1547 s->next_picture_ptr &&
1559 !
s->next_picture_ptr ||
s->intra_only) {
1560 s->reordered_input_picture[0] =
s->input_picture[0];
1562 s->reordered_input_picture[0]->f->coded_picture_number =
1563 s->coded_picture_number++;
1568 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1569 int pict_num =
s->input_picture[0]->f->display_picture_number +
i;
1571 if (pict_num >=
s->rc_context.num_entries)
1573 if (!
s->input_picture[
i]) {
1578 s->input_picture[
i]->f->pict_type =
1579 s->rc_context.entry[pict_num].new_pict_type;
1583 if (
s->b_frame_strategy == 0) {
1584 b_frames =
s->max_b_frames;
1585 while (b_frames && !
s->input_picture[b_frames])
1587 }
else if (
s->b_frame_strategy == 1) {
1588 for (
i = 1;
i <
s->max_b_frames + 1;
i++) {
1589 if (
s->input_picture[
i] &&
1590 s->input_picture[
i]->b_frame_score == 0) {
1591 s->input_picture[
i]->b_frame_score =
1593 s->input_picture[
i ]->f->data[0],
1594 s->input_picture[
i - 1]->f->data[0],
1598 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1599 if (!
s->input_picture[
i] ||
1600 s->input_picture[
i]->b_frame_score - 1 >
1601 s->mb_num /
s->b_sensitivity)
1605 b_frames =
FFMAX(0,
i - 1);
1608 for (
i = 0;
i < b_frames + 1;
i++) {
1609 s->input_picture[
i]->b_frame_score = 0;
1611 }
else if (
s->b_frame_strategy == 2) {
1619 for (
i = b_frames - 1;
i >= 0;
i--) {
1620 int type =
s->input_picture[
i]->f->pict_type;
1625 b_frames ==
s->max_b_frames) {
1627 "warning, too many B-frames in a row\n");
1630 if (
s->picture_in_gop_number + b_frames >=
s->gop_size) {
1632 s->gop_size >
s->picture_in_gop_number) {
1633 b_frames =
s->gop_size -
s->picture_in_gop_number - 1;
1645 s->reordered_input_picture[0] =
s->input_picture[b_frames];
1648 s->reordered_input_picture[0]->f->coded_picture_number =
1649 s->coded_picture_number++;
1650 for (
i = 0;
i < b_frames;
i++) {
1651 s->reordered_input_picture[
i + 1] =
s->input_picture[
i];
1652 s->reordered_input_picture[
i + 1]->f->pict_type =
1654 s->reordered_input_picture[
i + 1]->f->coded_picture_number =
1655 s->coded_picture_number++;
1662 if (
s->reordered_input_picture[0]) {
1663 s->reordered_input_picture[0]->reference =
1664 s->reordered_input_picture[0]->f->pict_type !=
1670 if (
s->reordered_input_picture[0]->shared ||
s->avctx->rc_buffer_size) {
1678 pic = &
s->picture[
i];
1680 pic->
reference =
s->reordered_input_picture[0]->reference;
1691 s->reordered_input_picture[0]->shared = 0;
1693 s->current_picture_ptr = pic;
1696 s->current_picture_ptr =
s->reordered_input_picture[0];
1697 for (
i = 0;
i < 4;
i++) {
1698 if (
s->new_picture.f->data[
i])
1704 s->current_picture_ptr)) < 0)
1707 s->picture_number =
s->new_picture.f->display_picture_number;
1714 if (
s->unrestricted_mv &&
1715 s->current_picture.reference &&
1718 int hshift =
desc->log2_chroma_w;
1719 int vshift =
desc->log2_chroma_h;
1720 s->mpvencdsp.draw_edges(
s->current_picture.f->data[0],
1721 s->current_picture.f->linesize[0],
1722 s->h_edge_pos,
s->v_edge_pos,
1725 s->mpvencdsp.draw_edges(
s->current_picture.f->data[1],
1726 s->current_picture.f->linesize[1],
1727 s->h_edge_pos >> hshift,
1728 s->v_edge_pos >> vshift,
1732 s->mpvencdsp.draw_edges(
s->current_picture.f->data[2],
1733 s->current_picture.f->linesize[2],
1734 s->h_edge_pos >> hshift,
1735 s->v_edge_pos >> vshift,
1743 s->last_pict_type =
s->pict_type;
1744 s->last_lambda_for [
s->pict_type] =
s->current_picture_ptr->f->quality;
1746 s->last_non_b_pict_type =
s->pict_type;
1748 #if FF_API_CODED_FRAME
1754 #if FF_API_ERROR_FRAME
1756 memcpy(
s->current_picture.f->error,
s->current_picture.encoding_error,
1757 sizeof(
s->current_picture.encoding_error));
1766 for (intra = 0; intra < 2; intra++) {
1767 if (
s->dct_count[intra] > (1 << 16)) {
1768 for (
i = 0;
i < 64;
i++) {
1769 s->dct_error_sum[intra][
i] >>= 1;
1771 s->dct_count[intra] >>= 1;
1774 for (
i = 0;
i < 64;
i++) {
1775 s->dct_offset[intra][
i] = (
s->noise_reduction *
1776 s->dct_count[intra] +
1777 s->dct_error_sum[intra][
i] / 2) /
1778 (
s->dct_error_sum[intra][
i] + 1);
1789 s->last_picture_ptr !=
s->next_picture_ptr &&
1790 s->last_picture_ptr->f->buf[0]) {
1794 s->current_picture_ptr->f->pict_type =
s->pict_type;
1799 s->current_picture_ptr)) < 0)
1803 s->last_picture_ptr =
s->next_picture_ptr;
1805 s->next_picture_ptr =
s->current_picture_ptr;
1808 if (
s->last_picture_ptr) {
1810 if (
s->last_picture_ptr->f->buf[0] &&
1812 s->last_picture_ptr)) < 0)
1815 if (
s->next_picture_ptr) {
1817 if (
s->next_picture_ptr->f->buf[0] &&
1819 s->next_picture_ptr)) < 0)
1825 for (
i = 0;
i < 4;
i++) {
1827 s->current_picture.f->data[
i] +=
1828 s->current_picture.f->linesize[
i];
1830 s->current_picture.f->linesize[
i] *= 2;
1831 s->last_picture.f->linesize[
i] *= 2;
1832 s->next_picture.f->linesize[
i] *= 2;
1837 s->dct_unquantize_intra =
s->dct_unquantize_mpeg2_intra;
1838 s->dct_unquantize_inter =
s->dct_unquantize_mpeg2_inter;
1840 s->dct_unquantize_intra =
s->dct_unquantize_h263_intra;
1841 s->dct_unquantize_inter =
s->dct_unquantize_h263_inter;
1843 s->dct_unquantize_intra =
s->dct_unquantize_mpeg1_intra;
1844 s->dct_unquantize_inter =
s->dct_unquantize_mpeg1_inter;
1847 if (
s->dct_error_sum) {
1856 const AVFrame *pic_arg,
int *got_packet)
1859 int i, stuffing_count, ret;
1860 int context_count =
s->slice_context_count;
1862 s->vbv_ignore_qmax = 0;
1864 s->picture_in_gop_number++;
1874 if (
s->new_picture.f->data[0]) {
1875 int growing_buffer = context_count == 1 && !
pkt->
data && !
s->data_partitioning;
1884 s->mb_width*
s->mb_height*12);
1885 s->prev_mb_info =
s->last_mb_info =
s->mb_info_size = 0;
1888 for (
i = 0;
i < context_count;
i++) {
1889 int start_y =
s->thread_context[
i]->start_mb_y;
1890 int end_y =
s->thread_context[
i]-> end_mb_y;
1891 int h =
s->mb_height;
1898 s->pict_type =
s->new_picture.f->pict_type;
1905 if (growing_buffer) {
1913 #if FF_API_STAT_BITS
1922 avctx->
p_count =
s->mb_num -
s->i_count -
s->skip_count;
1939 s->lambda <
s->lmax) {
1940 s->next_lambda =
FFMAX(
s->lambda + min_step,
s->lambda *
1941 (
s->qscale + 1) /
s->qscale);
1942 if (
s->adaptive_quant) {
1944 for (
i = 0;
i <
s->mb_height *
s->mb_stride;
i++)
1945 s->lambda_table[
i] =
1946 FFMAX(
s->lambda_table[
i] + min_step,
1947 s->lambda_table[
i] * (
s->qscale + 1) /
1953 if (
s->flipflop_rounding ||
1956 s->no_rounding ^= 1;
1959 s->time_base =
s->last_time_base;
1960 s->last_non_b_time =
s->time -
s->pp_time;
1962 for (
i = 0;
i < context_count;
i++) {
1966 s->vbv_ignore_qmax = 1;
1977 for (
i = 0;
i < 4;
i++) {
1978 s->current_picture_ptr->encoding_error[
i] =
s->current_picture.encoding_error[
i];
1979 avctx->
error[
i] +=
s->current_picture_ptr->encoding_error[
i];
1982 s->current_picture_ptr->encoding_error,
1988 s->misc_bits +
s->i_tex_bits +
1994 s->stuffing_bits = 8*stuffing_count;
1995 if (stuffing_count) {
1997 stuffing_count + 50) {
2002 switch (
s->codec_id) {
2005 while (stuffing_count--) {
2012 stuffing_count -= 4;
2013 while (stuffing_count--) {
2033 int vbv_delay, min_delay;
2036 int minbits =
s->frame_bits - 8 *
2037 (
s->vbv_delay_ptr -
s->pb.buf - 1);
2038 double bits =
s->rc_context.buffer_index + minbits - inbits;
2042 "Internal error, negative bits\n");
2047 min_delay = (minbits * 90000LL + avctx->
rc_max_rate - 1) /
2050 vbv_delay =
FFMAX(vbv_delay, min_delay);
2054 s->vbv_delay_ptr[0] &= 0xF8;
2055 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2056 s->vbv_delay_ptr[1] = vbv_delay >> 5;
2057 s->vbv_delay_ptr[2] &= 0x07;
2058 s->vbv_delay_ptr[2] |= vbv_delay << 3;
2072 #if FF_API_VBV_DELAY
2078 s->total_bits +=
s->frame_bits;
2079 #if FF_API_STAT_BITS
2086 pkt->
pts =
s->current_picture.f->pts;
2088 if (!
s->current_picture.f->coded_picture_number)
2095 if (
s->current_picture.f->key_frame)
2105 if (!
s->picture[
i].reference)
2117 int n,
int threshold)
2119 static const char tab[64] = {
2120 3, 2, 2, 1, 1, 1, 1, 1,
2121 1, 1, 1, 1, 1, 1, 1, 1,
2122 1, 1, 1, 1, 1, 1, 1, 1,
2123 0, 0, 0, 0, 0, 0, 0, 0,
2124 0, 0, 0, 0, 0, 0, 0, 0,
2125 0, 0, 0, 0, 0, 0, 0, 0,
2126 0, 0, 0, 0, 0, 0, 0, 0,
2127 0, 0, 0, 0, 0, 0, 0, 0
2132 int16_t *
block =
s->block[n];
2133 const int last_index =
s->block_last_index[n];
2136 if (threshold < 0) {
2138 threshold = -threshold;
2143 if (last_index <= skip_dc - 1)
2146 for (
i = 0;
i <= last_index;
i++) {
2147 const int j =
s->intra_scantable.permutated[
i];
2150 if (skip_dc &&
i == 0)
2154 }
else if (
level > 1) {
2160 if (score >= threshold)
2162 for (
i = skip_dc;
i <= last_index;
i++) {
2163 const int j =
s->intra_scantable.permutated[
i];
2167 s->block_last_index[n] = 0;
2169 s->block_last_index[n] = -1;
2176 const int maxlevel =
s->max_qcoeff;
2177 const int minlevel =
s->min_qcoeff;
2185 for (;
i <= last_index;
i++) {
2186 const int j =
s->intra_scantable.permutated[
i];
2189 if (
level > maxlevel) {
2192 }
else if (
level < minlevel) {
2202 "warning, clipping %d dct coefficients to %d..%d\n",
2203 overflow, minlevel, maxlevel);
2210 for (y = 0; y < 8; y++) {
2211 for (x = 0; x < 8; x++) {
2217 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
2218 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
2219 int v = ptr[x2 + y2 *
stride];
2225 weight[x + 8 * y]= (36 *
ff_sqrt(count * sqr - sum * sum)) / count;
2231 int motion_x,
int motion_y,
2232 int mb_block_height,
2237 int16_t orig[12][64];
2238 const int mb_x =
s->mb_x;
2239 const int mb_y =
s->mb_y;
2242 int dct_offset =
s->linesize * 8;
2243 int uv_dct_offset =
s->uvlinesize * 8;
2244 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2245 ptrdiff_t wrap_y, wrap_c;
2247 for (
i = 0;
i < mb_block_count;
i++)
2248 skip_dct[
i] =
s->skipdct;
2250 if (
s->adaptive_quant) {
2251 const int last_qp =
s->qscale;
2252 const int mb_xy = mb_x + mb_y *
s->mb_stride;
2254 s->lambda =
s->lambda_table[mb_xy];
2258 s->qscale =
s->current_picture_ptr->qscale_table[mb_xy];
2259 s->dquant =
s->qscale - last_qp;
2280 wrap_y =
s->linesize;
2281 wrap_c =
s->uvlinesize;
2282 ptr_y =
s->new_picture.f->data[0] +
2283 (mb_y * 16 * wrap_y) + mb_x * 16;
2284 ptr_cb =
s->new_picture.f->data[1] +
2285 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2286 ptr_cr =
s->new_picture.f->data[2] +
2287 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2289 if((mb_x * 16 + 16 >
s->width || mb_y * 16 + 16 >
s->height) &&
s->codec_id !=
AV_CODEC_ID_AMV){
2290 uint8_t *ebuf =
s->sc.edge_emu_buffer + 38 * wrap_y;
2291 int cw = (
s->width +
s->chroma_x_shift) >>
s->chroma_x_shift;
2292 int ch = (
s->height +
s->chroma_y_shift) >>
s->chroma_y_shift;
2293 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2295 16, 16, mb_x * 16, mb_y * 16,
2296 s->width,
s->height);
2298 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2300 mb_block_width, mb_block_height,
2301 mb_x * mb_block_width, mb_y * mb_block_height,
2303 ptr_cb = ebuf + 16 * wrap_y;
2304 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2306 mb_block_width, mb_block_height,
2307 mb_x * mb_block_width, mb_y * mb_block_height,
2309 ptr_cr = ebuf + 16 * wrap_y + 16;
2314 int progressive_score, interlaced_score;
2316 s->interlaced_dct = 0;
2317 progressive_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
NULL, wrap_y, 8) +
2318 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y * 8,
2319 NULL, wrap_y, 8) - 400;
2321 if (progressive_score > 0) {
2322 interlaced_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
2323 NULL, wrap_y * 2, 8) +
2324 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y,
2325 NULL, wrap_y * 2, 8);
2326 if (progressive_score > interlaced_score) {
2327 s->interlaced_dct = 1;
2329 dct_offset = wrap_y;
2330 uv_dct_offset = wrap_c;
2339 s->pdsp.get_pixels(
s->block[0], ptr_y, wrap_y);
2340 s->pdsp.get_pixels(
s->block[1], ptr_y + 8, wrap_y);
2341 s->pdsp.get_pixels(
s->block[2], ptr_y + dct_offset, wrap_y);
2342 s->pdsp.get_pixels(
s->block[3], ptr_y + dct_offset + 8, wrap_y);
2348 s->pdsp.get_pixels(
s->block[4], ptr_cb, wrap_c);
2349 s->pdsp.get_pixels(
s->block[5], ptr_cr, wrap_c);
2350 if (!
s->chroma_y_shift &&
s->chroma_x_shift) {
2351 s->pdsp.get_pixels(
s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2352 s->pdsp.get_pixels(
s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2353 }
else if (!
s->chroma_y_shift && !
s->chroma_x_shift) {
2354 s->pdsp.get_pixels(
s->block[ 6], ptr_cb + 8, wrap_c);
2355 s->pdsp.get_pixels(
s->block[ 7], ptr_cr + 8, wrap_c);
2356 s->pdsp.get_pixels(
s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2357 s->pdsp.get_pixels(
s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2358 s->pdsp.get_pixels(
s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2359 s->pdsp.get_pixels(
s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2365 uint8_t *dest_y, *dest_cb, *dest_cr;
2367 dest_y =
s->dest[0];
2368 dest_cb =
s->dest[1];
2369 dest_cr =
s->dest[2];
2372 op_pix =
s->hdsp.put_pixels_tab;
2373 op_qpix =
s->qdsp.put_qpel_pixels_tab;
2375 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
2376 op_qpix =
s->qdsp.put_no_rnd_qpel_pixels_tab;
2381 s->last_picture.f->data,
2383 op_pix =
s->hdsp.avg_pixels_tab;
2384 op_qpix =
s->qdsp.avg_qpel_pixels_tab;
2388 s->next_picture.f->data,
2393 int progressive_score, interlaced_score;
2395 s->interlaced_dct = 0;
2396 progressive_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y, wrap_y, 8) +
2397 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y * 8,
2402 progressive_score -= 400;
2404 if (progressive_score > 0) {
2405 interlaced_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y,
2407 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y,
2411 if (progressive_score > interlaced_score) {
2412 s->interlaced_dct = 1;
2414 dct_offset = wrap_y;
2415 uv_dct_offset = wrap_c;
2423 s->pdsp.diff_pixels(
s->block[0], ptr_y, dest_y, wrap_y);
2424 s->pdsp.diff_pixels(
s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2425 s->pdsp.diff_pixels(
s->block[2], ptr_y + dct_offset,
2426 dest_y + dct_offset, wrap_y);
2427 s->pdsp.diff_pixels(
s->block[3], ptr_y + dct_offset + 8,
2428 dest_y + dct_offset + 8, wrap_y);
2434 s->pdsp.diff_pixels(
s->block[4], ptr_cb, dest_cb, wrap_c);
2435 s->pdsp.diff_pixels(
s->block[5], ptr_cr, dest_cr, wrap_c);
2436 if (!
s->chroma_y_shift) {
2437 s->pdsp.diff_pixels(
s->block[6], ptr_cb + uv_dct_offset,
2438 dest_cb + uv_dct_offset, wrap_c);
2439 s->pdsp.diff_pixels(
s->block[7], ptr_cr + uv_dct_offset,
2440 dest_cr + uv_dct_offset, wrap_c);
2444 if (
s->current_picture.mc_mb_var[
s->mb_stride * mb_y + mb_x] <
2445 2 *
s->qscale *
s->qscale) {
2447 if (
s->mecc.sad[1](
NULL, ptr_y, dest_y, wrap_y, 8) < 20 *
s->qscale)
2449 if (
s->mecc.sad[1](
NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 *
s->qscale)
2451 if (
s->mecc.sad[1](
NULL, ptr_y + dct_offset, dest_y + dct_offset,
2452 wrap_y, 8) < 20 *
s->qscale)
2454 if (
s->mecc.sad[1](
NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2455 wrap_y, 8) < 20 *
s->qscale)
2457 if (
s->mecc.sad[1](
NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 *
s->qscale)
2459 if (
s->mecc.sad[1](
NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 *
s->qscale)
2461 if (!
s->chroma_y_shift) {
2462 if (
s->mecc.sad[1](
NULL, ptr_cb + uv_dct_offset,
2463 dest_cb + uv_dct_offset,
2464 wrap_c, 8) < 20 *
s->qscale)
2466 if (
s->mecc.sad[1](
NULL, ptr_cr + uv_dct_offset,
2467 dest_cr + uv_dct_offset,
2468 wrap_c, 8) < 20 *
s->qscale)
2474 if (
s->quantizer_noise_shaping) {
2487 if (!
s->chroma_y_shift) {
2495 memcpy(orig[0],
s->block[0],
sizeof(int16_t) * 64 * mb_block_count);
2501 for (
i = 0;
i < mb_block_count;
i++) {
2504 s->block_last_index[
i] =
s->dct_quantize(
s,
s->block[
i],
i,
s->qscale, &overflow);
2513 s->block_last_index[
i] = -1;
2515 if (
s->quantizer_noise_shaping) {
2516 for (
i = 0;
i < mb_block_count;
i++) {
2518 s->block_last_index[
i] =
2520 orig[
i],
i,
s->qscale);
2525 if (
s->luma_elim_threshold && !
s->mb_intra)
2526 for (
i = 0;
i < 4;
i++)
2528 if (
s->chroma_elim_threshold && !
s->mb_intra)
2529 for (
i = 4;
i < mb_block_count;
i++)
2533 for (
i = 0;
i < mb_block_count;
i++) {
2534 if (
s->block_last_index[
i] == -1)
2535 s->coded_score[
i] = INT_MAX / 256;
2541 s->block_last_index[4] =
2542 s->block_last_index[5] = 0;
2544 s->block[5][0] = (1024 +
s->c_dc_scale / 2) /
s->c_dc_scale;
2545 if (!
s->chroma_y_shift) {
2546 for (
i=6;
i<12;
i++) {
2547 s->block_last_index[
i] = 0;
2548 s->block[
i][0] =
s->block[4][0];
2555 for (
i = 0;
i < mb_block_count;
i++) {
2557 if (
s->block_last_index[
i] > 0) {
2558 for (j = 63; j > 0; j--) {
2559 if (
s->block[
i][
s->intra_scantable.permutated[j]])
2562 s->block_last_index[
i] = j;
2568 switch(
s->codec_id){
2624 memcpy(d->
last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2652 memcpy(d->
mv,
s->mv, 2*4*2*
sizeof(
int));
2653 memcpy(d->
last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2675 if(
s->data_partitioning){
2690 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2697 s->block=
s->blocks[*next_block];
2698 s->pb= pb[*next_block];
2699 if(
s->data_partitioning){
2700 s->pb2 = pb2 [*next_block];
2701 s->tex_pb= tex_pb[*next_block];
2705 memcpy(dest_backup,
s->dest,
sizeof(
s->dest));
2706 s->dest[0] =
s->sc.rd_scratchpad;
2707 s->dest[1] =
s->sc.rd_scratchpad + 16*
s->linesize;
2708 s->dest[2] =
s->sc.rd_scratchpad + 16*
s->linesize + 8;
2715 if(
s->data_partitioning){
2723 score *=
s->lambda2;
2728 memcpy(
s->dest, dest_backup,
sizeof(
s->dest));
2746 else if(
w==8 &&
h==8)
2764 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
2765 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
2769 return s->mecc.nsse[0](
s,
s->new_picture.f->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
s->dest[0],
s->linesize, 16) +
2770 s->mecc.nsse[1](
s,
s->new_picture.f->data[1] +
s->mb_x * 8 +
s->mb_y *
s->uvlinesize * 8,
s->dest[1],
s->uvlinesize, 8) +
2771 s->mecc.nsse[1](
s,
s->new_picture.f->data[2] +
s->mb_x * 8 +
s->mb_y *
s->uvlinesize * 8,
s->dest[2],
s->uvlinesize, 8);
2773 return s->mecc.sse[0](
NULL,
s->new_picture.f->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
s->dest[0],
s->linesize, 16) +
2774 s->mecc.sse[1](
NULL,
s->new_picture.f->data[1] +
s->mb_x * 8 +
s->mb_y *
s->uvlinesize * 8,
s->dest[1],
s->uvlinesize, 8) +
2775 s->mecc.sse[1](
NULL,
s->new_picture.f->data[2] +
s->mb_x * 8 +
s->mb_y *
s->uvlinesize * 8,
s->dest[2],
s->uvlinesize, 8);
2778 return sse(
s,
s->new_picture.f->data[0] +
s->mb_x*16 +
s->mb_y*
s->linesize*16,
s->dest[0],
w,
h,
s->linesize)
2779 +
sse(
s,
s->new_picture.f->data[1] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*8,
s->dest[1],
w>>1,
h>>1,
s->uvlinesize)
2780 +
sse(
s,
s->new_picture.f->data[2] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*8,
s->dest[2],
w>>1,
h>>1,
s->uvlinesize);
2788 s->me.dia_size=
s->avctx->pre_dia_size;
2789 s->first_slice_line=1;
2790 for(
s->mb_y=
s->end_mb_y-1;
s->mb_y >=
s->start_mb_y;
s->mb_y--) {
2791 for(
s->mb_x=
s->mb_width-1;
s->mb_x >=0 ;
s->mb_x--) {
2794 s->first_slice_line=0;
2805 s->me.dia_size=
s->avctx->dia_size;
2806 s->first_slice_line=1;
2807 for(
s->mb_y=
s->start_mb_y;
s->mb_y <
s->end_mb_y;
s->mb_y++) {
2810 for(
s->mb_x=0;
s->mb_x <
s->mb_width;
s->mb_x++) {
2811 s->block_index[0]+=2;
2812 s->block_index[1]+=2;
2813 s->block_index[2]+=2;
2814 s->block_index[3]+=2;
2822 s->first_slice_line=0;
2831 for(mb_y=
s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2832 for(mb_x=0; mb_x <
s->mb_width; mb_x++) {
2835 uint8_t *pix =
s->new_picture.f->data[0] + (yy *
s->linesize) + xx;
2837 int sum =
s->mpvencdsp.pix_sum(pix,
s->linesize);
2839 varc = (
s->mpvencdsp.pix_norm1(pix,
s->linesize) -
2840 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2842 s->current_picture.mb_var [
s->mb_stride * mb_y + mb_x] = varc;
2843 s->current_picture.mb_mean[
s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2844 s->me.mb_var_sum_temp += varc;
2852 if(
s->partitioned_frame){
2871 uint8_t *ptr =
s->mb_info_ptr +
s->mb_info_size - 12;
2873 int mba =
s->mb_x +
s->mb_width * (
s->mb_y %
s->gob_index);
2874 int gobn =
s->mb_y /
s->gob_index;
2878 bytestream_put_le32(&ptr,
offset);
2879 bytestream_put_byte(&ptr,
s->qscale);
2880 bytestream_put_byte(&ptr, gobn);
2881 bytestream_put_le16(&ptr, mba);
2882 bytestream_put_byte(&ptr, pred_x);
2883 bytestream_put_byte(&ptr, pred_y);
2885 bytestream_put_byte(&ptr, 0);
2886 bytestream_put_byte(&ptr, 0);
2894 s->mb_info_size += 12;
2895 s->prev_mb_info =
s->last_mb_info;
2907 if (!
s->mb_info_size)
2908 s->mb_info_size += 12;
2915 &&
s->slice_context_count == 1
2916 &&
s->pb.buf ==
s->avctx->internal->byte_buffer) {
2917 int lastgob_pos =
s->ptr_lastgob -
s->pb.buf;
2918 int vbv_pos =
s->vbv_delay_ptr -
s->pb.buf;
2921 int new_buffer_size = 0;
2923 if ((
s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2931 s->avctx->internal->byte_buffer_size + size_increase);
2935 memcpy(new_buffer,
s->avctx->internal->byte_buffer,
s->avctx->internal->byte_buffer_size);
2936 av_free(
s->avctx->internal->byte_buffer);
2937 s->avctx->internal->byte_buffer = new_buffer;
2938 s->avctx->internal->byte_buffer_size = new_buffer_size;
2940 s->ptr_lastgob =
s->pb.buf + lastgob_pos;
2941 s->vbv_delay_ptr =
s->pb.buf + vbv_pos;
2950 int mb_x, mb_y, mb_y_order;
2951 int chr_h= 16>>
s->chroma_y_shift;
2978 s->last_dc[
i] = 128 <<
s->intra_dc_precision;
2980 s->current_picture.encoding_error[
i] = 0;
2983 s->last_dc[0] = 128*8/13;
2984 s->last_dc[1] = 128*8/14;
2985 s->last_dc[2] = 128*8/14;
2988 memset(
s->last_mv, 0,
sizeof(
s->last_mv));
2992 switch(
s->codec_id){
3007 s->first_slice_line = 1;
3008 s->ptr_lastgob =
s->pb.buf;
3009 for (mb_y_order =
s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3013 if (first_in_slice && mb_y_order !=
s->start_mb_y)
3015 s->last_dc[0] =
s->last_dc[1] =
s->last_dc[2] = 1024 <<
s->intra_dc_precision;
3025 for(mb_x=0; mb_x <
s->mb_width; mb_x++) {
3026 int xy= mb_y*
s->mb_stride + mb_x;
3027 int mb_type=
s->mb_type[xy];
3031 int size_increase =
s->avctx->internal->byte_buffer_size/4
3039 if(
s->data_partitioning){
3053 xy=
s->mb_y*
s->mb_stride +
s->mb_x;
3054 mb_type=
s->mb_type[xy];
3059 int current_packet_size, is_gob_start;
3061 current_packet_size= ((
put_bits_count(&
s->pb)+7)>>3) - (
s->ptr_lastgob -
s->pb.buf);
3063 is_gob_start =
s->rtp_payload_size &&
3064 current_packet_size >=
s->rtp_payload_size &&
3067 if(
s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3069 switch(
s->codec_id){
3072 if(!
s->h263_slice_structured)
3073 if(
s->mb_x ||
s->mb_y%
s->gob_index) is_gob_start=0;
3076 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3078 if(
s->mb_skip_run) is_gob_start=0;
3081 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3086 if(
s->start_mb_y != mb_y || mb_x!=0){
3097 if (
s->error_rate &&
s->resync_mb_x +
s->resync_mb_y > 0) {
3099 int d = 100 /
s->error_rate;
3101 current_packet_size=0;
3102 s->pb.buf_ptr=
s->ptr_lastgob;
3107 #if FF_API_RTP_CALLBACK
3109 if (
s->avctx->rtp_callback){
3110 int number_mb = (mb_y -
s->resync_mb_y)*
s->mb_width + mb_x -
s->resync_mb_x;
3111 s->avctx->rtp_callback(
s->avctx,
s->ptr_lastgob, current_packet_size, number_mb);
3117 switch(
s->codec_id){
3140 s->misc_bits+=
bits -
s->last_bits;
3144 s->ptr_lastgob += current_packet_size;
3145 s->first_slice_line=1;
3146 s->resync_mb_x=mb_x;
3147 s->resync_mb_y=mb_y;
3151 if( (
s->resync_mb_x ==
s->mb_x)
3152 &&
s->resync_mb_y+1 ==
s->mb_y){
3153 s->first_slice_line=0;
3163 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3169 if(
s->data_partitioning){
3170 backup_s.pb2=
s->pb2;
3171 backup_s.tex_pb=
s->tex_pb;
3178 s->mv[0][0][0] =
s->p_mv_table[xy][0];
3179 s->mv[0][0][1] =
s->p_mv_table[xy][1];
3181 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3188 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3189 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3190 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3193 &dmin, &next_block, 0, 0);
3202 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3209 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3210 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3213 &dmin, &next_block, 0, 0);
3219 s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3220 s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3222 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3228 s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3229 s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3231 &dmin, &next_block,
s->mv[1][0][0],
s->mv[1][0][1]);
3237 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3238 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3239 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3240 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3242 &dmin, &next_block, 0, 0);
3249 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3250 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3251 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3254 &dmin, &next_block, 0, 0);
3261 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3262 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3263 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3266 &dmin, &next_block, 0, 0);
3272 for(dir=0; dir<2; dir++){
3274 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3275 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3276 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3280 &dmin, &next_block, 0, 0);
3289 &dmin, &next_block, 0, 0);
3290 if(
s->h263_pred ||
s->h263_aic){
3292 s->mbintra_table[mb_x + mb_y*
s->mb_stride]=1;
3300 const int last_qp= backup_s.qscale;
3304 static const int dquant_tab[4]={-1,1,-2,2};
3305 int storecoefs =
s->mb_intra &&
s->dc_val[0];
3313 s->mv[0][0][0] = best_s.
mv[0][0][0];
3314 s->mv[0][0][1] = best_s.
mv[0][0][1];
3315 s->mv[1][0][0] = best_s.
mv[1][0][0];
3316 s->mv[1][0][1] = best_s.
mv[1][0][1];
3319 for(; qpi<4; qpi++){
3320 int dquant= dquant_tab[qpi];
3321 qp= last_qp + dquant;
3322 if(qp < s->avctx->qmin || qp >
s->avctx->qmax)
3324 backup_s.dquant= dquant;
3327 dc[
i]=
s->dc_val[0][
s->block_index[
i] ];
3328 memcpy(ac[
i],
s->ac_val[0][
s->block_index[
i]],
sizeof(int16_t)*16);
3333 &dmin, &next_block,
s->mv[mvdir][0][0],
s->mv[mvdir][0][1]);
3337 s->dc_val[0][
s->block_index[
i] ]=
dc[
i];
3338 memcpy(
s->ac_val[0][
s->block_index[
i]], ac[
i],
sizeof(int16_t)*16);
3346 int mx=
s->b_direct_mv_table[xy][0];
3347 int my=
s->b_direct_mv_table[xy][1];
3349 backup_s.dquant = 0;
3354 &dmin, &next_block, mx, my);
3357 backup_s.dquant = 0;
3362 &dmin, &next_block, 0, 0);
3367 coded |=
s->block_last_index[
i];
3370 memcpy(
s->mv, best_s.
mv,
sizeof(
s->mv));
3392 &dmin, &next_block, mx, my);
3397 s->current_picture.qscale_table[xy] = best_s.
qscale;
3403 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3406 if(
s->data_partitioning){
3409 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3410 s->pb2= backup_s.pb2;
3414 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3415 s->tex_pb= backup_s.tex_pb;
3424 s->hdsp.put_pixels_tab[0][0](
s->dest[0],
s->sc.rd_scratchpad ,
s->linesize ,16);
3425 s->hdsp.put_pixels_tab[1][0](
s->dest[1],
s->sc.rd_scratchpad + 16*
s->linesize ,
s->uvlinesize, 8);
3426 s->hdsp.put_pixels_tab[1][0](
s->dest[2],
s->sc.rd_scratchpad + 16*
s->linesize + 8,
s->uvlinesize, 8);
3432 int motion_x = 0, motion_y = 0;
3440 motion_x=
s->mv[0][0][0] = 0;
3441 motion_y=
s->mv[0][0][1] = 0;
3446 motion_x=
s->mv[0][0][0] =
s->p_mv_table[xy][0];
3447 motion_y=
s->mv[0][0][1] =
s->p_mv_table[xy][1];
3454 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3455 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3456 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3464 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3465 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3472 motion_x=
s->b_direct_mv_table[xy][0];
3473 motion_y=
s->b_direct_mv_table[xy][1];
3487 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3488 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3489 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3490 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3495 motion_x=
s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3496 motion_y=
s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3501 motion_x=
s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3502 motion_y=
s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3509 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3510 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3511 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3519 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3520 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3521 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3528 for(dir=0; dir<2; dir++){
3530 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3531 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3532 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3543 s->last_mv_dir =
s->mv_dir;
3554 s->p_mv_table[xy][0]=0;
3555 s->p_mv_table[xy][1]=0;
3562 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
3563 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
3565 s->current_picture.encoding_error[0] +=
sse(
3566 s,
s->new_picture.f->data[0] +
s->mb_x*16 +
s->mb_y*
s->linesize*16,
3567 s->dest[0],
w,
h,
s->linesize);
3568 s->current_picture.encoding_error[1] +=
sse(
3569 s,
s->new_picture.f->data[1] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3570 s->dest[1],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3571 s->current_picture.encoding_error[2] +=
sse(
3572 s,
s->new_picture.f->data[2] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3573 s->dest[2],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3579 ff_dlog(
s->avctx,
"MB %d %d bits\n",
3590 #if FF_API_RTP_CALLBACK
3593 if (
s->avctx->rtp_callback) {
3594 int number_mb = (mb_y -
s->resync_mb_y)*
s->mb_width -
s->resync_mb_x;
3598 s->avctx->rtp_callback(
s->avctx,
s->ptr_lastgob, pdif, number_mb);
3606 #define MERGE(field) dst->field += src->field; src->field=0
3616 MERGE(dct_count[0]);
3617 MERGE(dct_count[1]);
3626 MERGE(er.error_count);
3627 MERGE(padding_bug_score);
3628 MERGE(current_picture.encoding_error[0]);
3629 MERGE(current_picture.encoding_error[1]);
3630 MERGE(current_picture.encoding_error[2]);
3633 for(
i=0;
i<64;
i++){
3634 MERGE(dct_error_sum[0][
i]);
3635 MERGE(dct_error_sum[1][
i]);
3646 if (
s->next_lambda){
3647 s->current_picture_ptr->f->quality =
3648 s->current_picture.f->quality =
s->next_lambda;
3649 if(!dry_run)
s->next_lambda= 0;
3650 }
else if (!
s->fixed_qscale) {
3652 s->current_picture_ptr->f->quality =
3653 s->current_picture.f->quality = quality;
3654 if (
s->current_picture.f->quality < 0)
3658 if(
s->adaptive_quant){
3659 switch(
s->codec_id){
3674 s->lambda=
s->lambda_table[0];
3677 s->lambda =
s->current_picture.f->quality;
3685 s->time =
s->current_picture_ptr->f->pts *
s->avctx->time_base.num;
3688 s->pb_time=
s->pp_time - (
s->last_non_b_time -
s->time);
3691 s->pp_time=
s->time -
s->last_non_b_time;
3692 s->last_non_b_time=
s->time;
3701 int context_count =
s->slice_context_count;
3703 s->picture_number = picture_number;
3706 s->me.mb_var_sum_temp =
3707 s->me.mc_mb_var_sum_temp = 0;
3716 s->me.scene_change_score=0;
3721 if(
s->msmpeg4_version >= 3)
s->no_rounding=1;
3722 else s->no_rounding=0;
3725 s->no_rounding ^= 1;
3734 s->lambda=
s->last_lambda_for[
s->pict_type];
3736 s->lambda=
s->last_lambda_for[
s->last_non_b_pict_type];
3741 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
3742 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
3743 s->q_chroma_intra_matrix =
s->q_intra_matrix;
3744 s->q_chroma_intra_matrix16 =
s->q_intra_matrix16;
3748 for(
i=1;
i<context_count;
i++){
3759 s->lambda = (
s->lambda *
s->me_penalty_compensation + 128) >> 8;
3760 s->lambda2 = (
s->lambda2 * (int64_t)
s->me_penalty_compensation + 128) >> 8;
3771 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3774 if(!
s->fixed_qscale){
3776 s->avctx->execute(
s->avctx,
mb_var_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3779 for(
i=1;
i<context_count;
i++){
3782 s->current_picture.mc_mb_var_sum=
s->current_picture_ptr->mc_mb_var_sum=
s->me.mc_mb_var_sum_temp;
3783 s->current_picture. mb_var_sum=
s->current_picture_ptr-> mb_var_sum=
s->me. mb_var_sum_temp;
3786 if (
s->me.scene_change_score >
s->scenechange_threshold &&
3789 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3791 if(
s->msmpeg4_version >= 3)
3793 ff_dlog(
s,
"Scene change detected, encoding as I Frame %"PRId64
" %"PRId64
"\n",
3794 s->current_picture.mb_var_sum,
s->current_picture.mc_mb_var_sum);
3837 for(dir=0; dir<2; dir++){
3843 s->b_field_mv_table[dir][
i][j], dir ?
s->b_code :
s->f_code,
type, 1);
3854 if (
s->qscale < 3 &&
s->max_qcoeff <= 128 &&
3863 if (
s->avctx->intra_matrix) {
3865 luma_matrix =
s->avctx->intra_matrix;
3867 if (
s->avctx->chroma_intra_matrix)
3868 chroma_matrix =
s->avctx->chroma_intra_matrix;
3872 int j =
s->idsp.idct_permutation[
i];
3874 s->chroma_intra_matrix[j] =
av_clip_uint8((chroma_matrix[
i] *
s->qscale) >> 3);
3877 s->y_dc_scale_table=
3879 s->chroma_intra_matrix[0] =
3882 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3884 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3888 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};
3889 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};
3896 s->y_dc_scale_table= y;
3897 s->c_dc_scale_table=
c;
3898 s->intra_matrix[0] = 13;
3899 s->chroma_intra_matrix[0] = 14;
3901 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3903 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3908 s->y_dc_scale_table=
3913 s->current_picture_ptr->f->key_frame =
3915 s->current_picture_ptr->f->pict_type =
3916 s->current_picture.f->pict_type =
s->pict_type;
3918 if (
s->current_picture.f->key_frame)
3919 s->picture_in_gop_number=0;
3921 s->mb_x =
s->mb_y = 0;
3923 switch(
s->out_format) {
3927 s->pred,
s->intra_matrix,
s->chroma_intra_matrix);
3966 s->header_bits=
bits -
s->last_bits;
3968 for(
i=1;
i<context_count;
i++){
3971 s->avctx->execute(
s->avctx,
encode_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3972 for(
i=1;
i<context_count;
i++){
3973 if (
s->pb.buf_end ==
s->thread_context[
i]->pb.buf)
3982 const int intra=
s->mb_intra;
3985 s->dct_count[intra]++;
3987 for(
i=0;
i<64;
i++){
3992 s->dct_error_sum[intra][
i] +=
level;
3993 level -=
s->dct_offset[intra][
i];
3996 s->dct_error_sum[intra][
i] -=
level;
3997 level +=
s->dct_offset[intra][
i];
4006 int16_t *
block,
int n,
4007 int qscale,
int *overflow){
4009 const uint16_t *matrix;
4011 const uint8_t *perm_scantable;
4013 unsigned int threshold1, threshold2;
4025 int coeff_count[64];
4026 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4027 const int esc_length=
s->ac_esc_length;
4035 if(
s->dct_error_sum)
4038 qadd= ((qscale-1)|1)*8;
4041 else mpeg2_qscale = qscale << 1;
4045 scantable=
s->intra_scantable.scantable;
4046 perm_scantable=
s->intra_scantable.permutated;
4063 qmat = n < 4 ?
s->q_intra_matrix[qscale] :
s->q_chroma_intra_matrix[qscale];
4064 matrix = n < 4 ?
s->intra_matrix :
s->chroma_intra_matrix;
4068 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4069 length =
s->intra_chroma_ac_vlc_length;
4070 last_length=
s->intra_chroma_ac_vlc_last_length;
4072 length =
s->intra_ac_vlc_length;
4073 last_length=
s->intra_ac_vlc_last_length;
4076 scantable=
s->inter_scantable.scantable;
4077 perm_scantable=
s->inter_scantable.permutated;
4080 qmat =
s->q_inter_matrix[qscale];
4081 matrix =
s->inter_matrix;
4082 length =
s->inter_ac_vlc_length;
4083 last_length=
s->inter_ac_vlc_last_length;
4088 threshold2= (threshold1<<1);
4090 for(
i=63;
i>=start_i;
i--) {
4091 const int j = scantable[
i];
4094 if(((
unsigned)(
level+threshold1))>threshold2){
4100 for(
i=start_i;
i<=last_non_zero;
i++) {
4101 const int j = scantable[
i];
4106 if(((
unsigned)(
level+threshold1))>threshold2){
4127 *overflow=
s->max_qcoeff <
max;
4129 if(last_non_zero < start_i){
4130 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4131 return last_non_zero;
4134 score_tab[start_i]= 0;
4135 survivor[0]= start_i;
4138 for(
i=start_i;
i<=last_non_zero;
i++){
4139 int level_index, j, zero_distortion;
4141 int best_score=256*256*256*120;
4145 zero_distortion= dct_coeff*dct_coeff;
4147 for(level_index=0; level_index < coeff_count[
i]; level_index++){
4156 unquant_coeff= alevel*qmul + qadd;
4158 j =
s->idsp.idct_permutation[scantable[
i]];
4159 unquant_coeff = alevel * matrix[j] * 8;
4161 j =
s->idsp.idct_permutation[scantable[
i]];
4163 unquant_coeff = (
int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4164 unquant_coeff = (unquant_coeff - 1) | 1;
4166 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int) matrix[j])) >> 5;
4167 unquant_coeff = (unquant_coeff - 1) | 1;
4172 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4174 if((
level&(~127)) == 0){
4175 for(j=survivor_count-1; j>=0; j--){
4176 int run=
i - survivor[j];
4178 score += score_tab[
i-
run];
4180 if(score < best_score){
4183 level_tab[
i+1]=
level-64;
4188 for(j=survivor_count-1; j>=0; j--){
4189 int run=
i - survivor[j];
4191 score += score_tab[
i-
run];
4192 if(score < last_score){
4195 last_level=
level-64;
4201 distortion += esc_length*lambda;
4202 for(j=survivor_count-1; j>=0; j--){
4203 int run=
i - survivor[j];
4204 int score= distortion + score_tab[
i-
run];
4206 if(score < best_score){
4209 level_tab[
i+1]=
level-64;
4214 for(j=survivor_count-1; j>=0; j--){
4215 int run=
i - survivor[j];
4216 int score= distortion + score_tab[
i-
run];
4217 if(score < last_score){
4220 last_level=
level-64;
4228 score_tab[
i+1]= best_score;
4231 if(last_non_zero <= 27){
4232 for(; survivor_count; survivor_count--){
4233 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4237 for(; survivor_count; survivor_count--){
4238 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4243 survivor[ survivor_count++ ]=
i+1;
4247 last_score= 256*256*256*120;
4248 for(
i= survivor[0];
i<=last_non_zero + 1;
i++){
4249 int score= score_tab[
i];
4251 score += lambda * 2;
4253 if(score < last_score){
4256 last_level= level_tab[
i];
4257 last_run= run_tab[
i];
4262 s->coded_score[n] = last_score;
4265 last_non_zero= last_i - 1;
4266 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4268 if(last_non_zero < start_i)
4269 return last_non_zero;
4271 if(last_non_zero == 0 && start_i == 0){
4273 int best_score=
dc *
dc;
4275 for(
i=0;
i<coeff_count[0];
i++){
4278 int unquant_coeff, score, distortion;
4281 unquant_coeff= (alevel*qmul + qadd)>>3;
4283 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int) matrix[0])) >> 5;
4284 unquant_coeff = (unquant_coeff - 1) | 1;
4286 unquant_coeff = (unquant_coeff + 4) >> 3;
4287 unquant_coeff<<= 3 + 3;
4289 distortion= (unquant_coeff -
dc) * (unquant_coeff -
dc);
4292 else score= distortion + esc_length*lambda;
4294 if(score < best_score){
4296 best_level=
level - 64;
4299 block[0]= best_level;
4300 s->coded_score[n] = best_score -
dc*
dc;
4301 if(best_level == 0)
return -1;
4302 else return last_non_zero;
4308 block[ perm_scantable[last_non_zero] ]= last_level;
4311 for(;
i>start_i;
i -= run_tab[
i] + 1){
4312 block[ perm_scantable[
i-1] ]= level_tab[
i];
4315 return last_non_zero;
4330 if(
i==0)
s*= sqrt(0.5);
4331 if(j==0)
s*= sqrt(0.5);
4345 const uint8_t *perm_scantable;
4351 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4355 int rle_index,
run, q = 1, sum;
4357 if(
basis[0][0] == 0)
4363 scantable=
s->intra_scantable.scantable;
4364 perm_scantable=
s->intra_scantable.permutated;
4382 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4383 length =
s->intra_chroma_ac_vlc_length;
4384 last_length=
s->intra_chroma_ac_vlc_last_length;
4386 length =
s->intra_ac_vlc_length;
4387 last_length=
s->intra_ac_vlc_last_length;
4390 scantable=
s->inter_scantable.scantable;
4391 perm_scantable=
s->inter_scantable.permutated;
4394 length =
s->inter_ac_vlc_length;
4395 last_length=
s->inter_ac_vlc_last_length;
4397 last_non_zero =
s->block_last_index[n];
4400 for(
i=0;
i<64;
i++){
4405 for(
i=0;
i<64;
i++){
4411 w= 15 + (48*qns*one +
w/2)/
w;
4424 for(
i=start_i;
i<=last_non_zero;
i++){
4425 int j= perm_scantable[
i];
4432 run_tab[rle_index++]=
run;
4442 int best_score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0], 0);
4445 int run2, best_unquant_change=0, analyze_gradient;
4446 analyze_gradient = last_non_zero > 2 ||
s->quantizer_noise_shaping >= 3;
4448 if(analyze_gradient){
4449 for(
i=0;
i<64;
i++){
4459 int change, old_coeff;
4465 for(change=-1; change<=1; change+=2){
4466 int new_level=
level + change;
4467 int score, new_coeff;
4469 new_coeff= q*new_level;
4470 if(new_coeff >= 2048 || new_coeff < 0)
4473 score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0],
4474 new_coeff - old_coeff);
4475 if(score<best_score){
4478 best_change= change;
4479 best_unquant_change= new_coeff - old_coeff;
4486 run2= run_tab[rle_index++];
4490 for(
i=start_i;
i<64;
i++){
4491 int j= perm_scantable[
i];
4493 int change, old_coeff;
4495 if(
s->quantizer_noise_shaping < 3 &&
i > last_non_zero + 1)
4500 else old_coeff= qmul*
level + qadd;
4501 run2= run_tab[rle_index++];
4508 for(change=-1; change<=1; change+=2){
4509 int new_level=
level + change;
4510 int score, new_coeff, unquant_change;
4517 if(new_level<0) new_coeff= qmul*new_level - qadd;
4518 else new_coeff= qmul*new_level + qadd;
4519 if(new_coeff >= 2048 || new_coeff <= -2048)
4524 if(level < 63 && level > -63){
4525 if(
i < last_non_zero)
4535 if(analyze_gradient){
4536 int g= d1[ scantable[
i] ];
4537 if(
g && (
g^new_level) >= 0)
4541 if(
i < last_non_zero){
4542 int next_i=
i + run2 + 1;
4543 int next_level=
block[ perm_scantable[next_i] ] + 64;
4545 if(next_level&(~127))
4548 if(next_i < last_non_zero)
4568 if(
i < last_non_zero){
4569 int next_i=
i + run2 + 1;
4570 int next_level=
block[ perm_scantable[next_i] ] + 64;
4572 if(next_level&(~127))
4575 if(next_i < last_non_zero)
4594 unquant_change= new_coeff - old_coeff;
4595 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4597 score +=
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[j],
4599 if(score<best_score){
4602 best_change= change;
4603 best_unquant_change= unquant_change;
4607 prev_level=
level + 64;
4608 if(prev_level&(~127))
4618 int j= perm_scantable[ best_coeff ];
4620 block[j] += best_change;
4622 if(best_coeff > last_non_zero){
4623 last_non_zero= best_coeff;
4626 for(; last_non_zero>=start_i; last_non_zero--){
4627 if(
block[perm_scantable[last_non_zero]])
4634 for(
i=start_i;
i<=last_non_zero;
i++){
4635 int j= perm_scantable[
i];
4639 run_tab[rle_index++]=
run;
4646 s->mpvencdsp.add_8x8basis(rem,
basis[j], best_unquant_change);
4652 return last_non_zero;
4667 const uint8_t *scantable,
int last)
4678 for (
i = 0;
i <= last;
i++) {
4679 const int j = scantable[
i];
4684 for (
i = 0;
i <= last;
i++) {
4685 const int j = scantable[
i];
4686 const int perm_j = permutation[j];
4692 int16_t *
block,
int n,
4693 int qscale,
int *overflow)
4695 int i, j,
level, last_non_zero, q, start_i;
4700 unsigned int threshold1, threshold2;
4704 if(
s->dct_error_sum)
4708 scantable=
s->intra_scantable.scantable;
4723 qmat = n < 4 ?
s->q_intra_matrix[qscale] :
s->q_chroma_intra_matrix[qscale];
4726 scantable=
s->inter_scantable.scantable;
4729 qmat =
s->q_inter_matrix[qscale];
4733 threshold2= (threshold1<<1);
4734 for(
i=63;
i>=start_i;
i--) {
4738 if(((
unsigned)(
level+threshold1))>threshold2){
4745 for(
i=start_i;
i<=last_non_zero;
i++) {
4751 if(((
unsigned)(
level+threshold1))>threshold2){
4764 *overflow=
s->max_qcoeff <
max;
4769 scantable, last_non_zero);
4771 return last_non_zero;
4774 #define OFFSET(x) offsetof(MpegEncContext, x)
4775 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4778 {
"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 },
4808 {
"structured_slices",
"Write slice start position at every GOB header instead of just GOB number.",
OFFSET(h263_slice_structured),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE},
4842 .
name =
"msmpeg4v2",
const uint16_t ff_aanscales[64]
const uint16_t ff_inv_aanscales[64]
AAN (Arai, Agui and Nakajima) (I)DCT tables.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
#define FF_MB_DECISION_RD
rate distortion
#define FF_COMPLIANCE_NORMAL
#define FF_MB_DECISION_BITS
chooses the one which needs the fewest bits
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
static av_cold int init(AVCodecContext *avctx)
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
#define ROUNDED_DIV(a, b)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define CONFIG_H261_ENCODER
#define CONFIG_WMV2_ENCODER
#define CONFIG_MPEG2VIDEO_ENCODER
#define CONFIG_RV20_ENCODER
#define CONFIG_MPEG1VIDEO_ENCODER
#define CONFIG_SPEEDHQ_ENCODER
#define CONFIG_FLV_ENCODER
#define CONFIG_RV10_ENCODER
#define CONFIG_H263P_ENCODER
#define CONFIG_H263_ENCODER
#define CONFIG_MJPEG_ENCODER
#define CONFIG_MPEG4_ENCODER
void ff_fdct_ifast(int16_t *data)
void ff_jpeg_fdct_islow_10(int16_t *data)
void ff_jpeg_fdct_islow_8(int16_t *data)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
void ff_faandct(int16_t *data)
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
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...
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
FF_ENABLE_DEPRECATION_WARNINGS 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.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
@ 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...
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_EOF
End of file.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
@ AV_PICTURE_TYPE_S
S(GMC)-VOP MPEG-4.
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define LIBAVUTIL_VERSION_INT
void ff_h261_encode_init(MpegEncContext *s)
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_h261_reorder_mb_index(MpegEncContext *s)
int ff_h261_get_picture_format(int width, int height)
void ff_h263_update_motion_val(MpegEncContext *s)
void ff_h263_loop_filter(MpegEncContext *s)
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in H.263 (limit difference to -2....
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
void ff_h263_encode_init(MpegEncContext *s)
#define H263_GOB_HEIGHT(h)
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
const uint8_t ff_h263_chroma_qscale_table[32]
const uint16_t ff_h263_format[8][2]
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
static const int32_t qmat16[MAT_SIZE]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static int weight(int i, int blen, int offset)
void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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.
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
static void direct(const float *in, const FFTComplex *ir, int len, float *out)
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define PTRDIFF_SPECIFIER
#define FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
static int ff_thread_once(char *control, void(*routine)(void))
static enum AVPixelFormat pix_fmts[]
const uint8_t ff_zigzag_direct[64]
const uint32_t ff_square_tab[512]
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
#define LOCAL_ALIGNED_16(t, v,...)
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
int ff_mjpeg_encode_stuffing(MpegEncContext *s)
Writes the complete JPEG frame when optimal huffman tables are enabled, otherwise writes the stuffing...
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
@ HUFFMAN_TABLE_OPTIMAL
Compute and use optimal Huffman tables.
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, ScanTable *intra_scantable, int pred, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64])
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
static const uint8_t mv_bits[2][16][10]
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
void ff_fix_long_p_mvs(MpegEncContext *s, int type)
int ff_init_me(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 ff_pre_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
int ff_get_best_fcode(MpegEncContext *s, int16_t(*mv_table)[2], int type)
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
void ff_mpeg1_clean_buffers(MpegEncContext *s)
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y)
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_mpeg1_encode_init(MpegEncContext *s)
const uint16_t ff_mpeg1_default_intra_matrix[256]
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
const int16_t ff_mpeg4_default_intra_matrix[64]
const int16_t ff_mpeg4_default_non_intra_matrix[64]
void ff_mpeg4_clean_buffers(MpegEncContext *s)
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
void ff_mpeg4_stuffing(PutBitContext *pbc)
add MPEG-4 stuffing bits (01...1)
void ff_mpeg4_merge_partitions(MpegEncContext *s)
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is actually possible in MPEG-4
int ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
void ff_set_mpeg4_time(MpegEncContext *s)
void ff_mpeg4_init_partitions(MpegEncContext *s)
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
void ff_free_picture_tables(Picture *pic)
#define MAX_PICTURE_COUNT
#define CANDIDATE_MB_TYPE_INTRA
#define CANDIDATE_MB_TYPE_BACKWARD
#define CANDIDATE_MB_TYPE_FORWARD_I
#define CANDIDATE_MB_TYPE_INTER_I
#define CANDIDATE_MB_TYPE_BIDIR_I
#define CANDIDATE_MB_TYPE_BACKWARD_I
#define CANDIDATE_MB_TYPE_SKIPPED
#define CANDIDATE_MB_TYPE_INTER
#define CANDIDATE_MB_TYPE_DIRECT
#define CANDIDATE_MB_TYPE_BIDIR
#define CANDIDATE_MB_TYPE_FORWARD
#define CANDIDATE_MB_TYPE_INTER4V
#define PICT_BOTTOM_FIELD
#define CANDIDATE_MB_TYPE_DIRECT0
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
void ff_mpv_common_end(MpegEncContext *s)
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
av_cold void ff_mpv_idct_init(MpegEncContext *s)
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
void ff_init_block_index(MpegEncContext *s)
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
#define FF_MPV_FLAG_CBP_RD
void ff_dct_encode_init_x86(MpegEncContext *s)
static int get_bits_diff(MpegEncContext *s)
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])
#define MV_TYPE_FIELD
2 vectors, one per field
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
#define FF_MPV_FLAG_QP_RD
#define UNI_AC_ENC_INDEX(run, level)
#define FF_MPV_COMMON_OPTS
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
#define MV_TYPE_16X16
1 vector for the whole mb
#define FF_MPV_FLAG_SKIP_RD
static void ff_update_block_index(MpegEncContext *s)
#define FF_MPV_FLAG_STRICT_GOP
static int estimate_qp(MpegEncContext *s, int dry_run)
static void update_noise_reduction(MpegEncContext *s)
static void denoise_dct_c(MpegEncContext *s, int16_t *block)
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride)
AVCodec ff_msmpeg4v2_encoder
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)
static void set_frame_distances(MpegEncContext *s)
const AVOption ff_mpv_generic_options[]
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
static const AVClass h263p_class
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
static int estimate_best_b_count(MpegEncContext *s)
static int mb_var_thread(AVCodecContext *c, void *arg)
static int estimate_motion_thread(AVCodecContext *c, void *arg)
static int select_input_picture(MpegEncContext *s)
static const AVOption h263p_options[]
static const AVClass wmv1_class
static const AVClass msmpeg4v3_class
static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg)
static int get_sae(uint8_t *src, int ref, int stride)
AVCodec ff_msmpeg4v3_encoder
static const AVClass h263_class
static uint8_t default_fcode_tab[MAX_MV *2+1]
static void build_basis(uint8_t *perm)
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)
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
static void clip_coeffs(MpegEncContext *s, int16_t *block, int last_index)
static void frame_end(MpegEncContext *s)
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale)
static void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type)
static void mpv_encode_init_static(void)
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
static int sse_mb(MpegEncContext *s)
static int frame_start(MpegEncContext *s)
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
static void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
static int16_t basis[64][64]
static void mpv_encode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for encoding.
static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
static int encode_picture(MpegEncContext *s, int picture_number)
static const AVOption h263_options[]
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src)
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
static void write_mb_info(MpegEncContext *s)
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permutation.
static const AVClass msmpeg4v2_class
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src)
static void update_qscale(MpegEncContext *s)
static int encode_thread(AVCodecContext *c, void *arg)
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
static void write_slice_end(MpegEncContext *s)
static void update_mb_info(MpegEncContext *s, int startcode)
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
av_cold int ff_dct_encode_init(MpegEncContext *s)
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type)
static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
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)
const uint8_t *const ff_mpeg2_dc_scale_table[4]
const uint8_t ff_mpeg2_non_linear_qscale[32]
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
void ff_msmpeg4_encode_init(MpegEncContext *s)
#define CONFIG_MSMPEG4_ENCODER
void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_msmpeg4_encode_ext_header(MpegEncContext *s)
void ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
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.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
@ AVCOL_RANGE_JPEG
Full range content.
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void rebase_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Rebase the bit writer onto a reallocated buffer.
static void set_put_bits_buffer_size(PutBitContext *s, int size)
Change the end of the buffer.
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
static int put_bits_count(PutBitContext *s)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static const int BUF_BITS
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
av_cold int ff_rate_control_init(MpegEncContext *s)
av_cold void ff_rate_control_uninit(MpegEncContext *s)
void ff_get_2pass_fcode(MpegEncContext *s)
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
int ff_vbv_update(MpegEncContext *s, int frame_size)
void ff_write_pass1_stats(MpegEncContext *s)
int ff_rv10_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_rv20_encode_picture_header(MpegEncContext *s, int picture_number)
#define FF_ARRAY_ELEMS(a)
static int shift(int a, int b)
static const uint8_t sp5x_qscale_five_quant_table[][64]
void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
void ff_speedhq_end_slice(MpegEncContext *s)
av_cold int ff_speedhq_encode_init(MpegEncContext *s)
int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
void ff_speedhq_encode_picture_header(MpegEncContext *s)
This structure describes the bitrate properties of an encoded bitstream.
int avg_bitrate
Average bitrate of the stream, in bits per second.
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
int min_bitrate
Minimum bitrate of the stream, in bits per second.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
attribute_deprecated int brd_scale
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow.
int trellis
trellis RD quantization
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
attribute_deprecated int pre_me
int width
picture width / height.
attribute_deprecated int i_count
char * stats_out
pass1 encoding statistics output buffer
int rc_buffer_size
decoder bitstream buffer size
attribute_deprecated int header_bits
attribute_deprecated int scenechange_threshold
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
attribute_deprecated int frame_bits
attribute_deprecated int mv_bits
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...
int qmin
minimum quantizer
attribute_deprecated int b_sensitivity
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions,...
int active_thread_type
Which multithreading methods are in use by the codec.
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
int mb_decision
macroblock decision mode
attribute_deprecated int misc_bits
int has_b_frames
Size of the frame reordering buffer in the decoder.
attribute_deprecated int frame_skip_threshold
int64_t bit_rate
the average bitrate
const struct AVCodec * codec
attribute_deprecated int frame_skip_cmp
attribute_deprecated int p_count
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
attribute_deprecated int mpeg_quant
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
float p_masking
p block masking (0-> disabled)
float dark_masking
darkness masking (0-> disabled)
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
attribute_deprecated int rtp_payload_size
int ildct_cmp
interlaced DCT comparison function
int64_t rc_max_rate
maximum bitrate
attribute_deprecated int me_penalty_compensation
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int qmax
maximum quantizer
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions,...
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
attribute_deprecated int i_tex_bits
int flags
AV_CODEC_FLAG_*.
attribute_deprecated int frame_skip_exp
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
attribute_deprecated int prediction_method
int64_t rc_min_rate
minimum bitrate
int intra_dc_precision
precision of the intra DC coefficient - 8
uint64_t error[AV_NUM_DATA_POINTERS]
error
attribute_deprecated int p_tex_bits
attribute_deprecated int noise_reduction
attribute_deprecated int skip_count
attribute_deprecated int b_frame_strategy
float lumi_masking
luminance masking (0-> disabled)
attribute_deprecated int frame_skip_factor
attribute_deprecated uint64_t vbv_delay
VBV delay coded in the last frame (in periods of a 27 MHz clock).
struct AVCodecInternal * internal
Private context used for internal data.
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
int slices
Number of slices.
unsigned int byte_buffer_size
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int display_picture_number
picture number in display order
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
void(* fdct)(int16_t *block)
int partitioned_frame
is current frame partitioned
int16_t(* block)[64]
points to one of the following blocks
PutBitContext tex_pb
used for data partitioned VOPs
int data_partitioning
data partitioning flag from header
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
int last_bits
temp var used for calculating the above vars
PutBitContext pb2
used for data partitioned VOPs
int block_last_index[12]
last non zero coefficient in block
int misc_bits
cbp, mb_type
int last_dc[3]
last DC values for MPEG-1
PutBitContext pb
bit output
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
int mb_skipped
MUST BE SET only during DECODING.
int dquant
qscale difference to prev qscale
double buffer_index
amount of bits in the video/audio buffer
static int ref[MAX_W *MAX_W]
static const struct twinvq_data tab
static float mean(const float *input, int size)
static const double coeff[2][5]
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const uint8_t offset[127][2]
int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)