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];
125 for (
i = 0;
i < 64;
i++) {
126 const int j =
s->idsp.idct_permutation[
i];
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];
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 &&
515 if (nbt <= INT_MAX) {
528 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
529 "specified vbv buffer is too large for the given bitrate!\n");
541 "OBMC is only supported with simple mb decision\n");
550 if (
s->max_b_frames &&
557 if (
s->max_b_frames < 0) {
559 "max b frames must be 0 or positive for mpegvideo based encoders\n");
569 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
577 (avctx->
width > 2048 ||
583 (avctx->
width > 65535 ||
584 avctx->
height > 65535 )) {
590 ((avctx->
width &3) ||
597 (avctx->
width > 4095 ||
604 (avctx->
width > 16383 ||
605 avctx->
height > 16383 )) {
606 av_log(avctx,
AV_LOG_ERROR,
"MPEG-2 does not support resolutions above 16383x16383\n");
637 #if FF_API_PRIVATE_OPT
648 "mpeg2 style quantization not supported by codec\n");
668 "QP RD is no longer compatible with MJPEG or AMV\n");
672 #if FF_API_PRIVATE_OPT
679 if (
s->scenechange_threshold < 1000000000 &&
682 "closed gop with scene change detection are not supported yet, "
683 "set threshold to 1000000000\n");
691 "low delay forcing is only available for mpeg2, "
692 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
695 if (
s->max_b_frames != 0) {
697 "B-frames cannot be used with low delay\n");
702 if (
s->q_scale_type == 1) {
703 if (avctx->
qmax > 28) {
705 "non linear quant only supports qmax <= 28 currently\n");
723 "multi threaded encoding not supported by codec\n");
729 "automatic thread number detection not supported by codec, "
739 #if FF_API_PRIVATE_OPT
750 "notice: b_frame_strategy only affects the first pass\n");
751 s->b_frame_strategy = 0;
765 s->inter_quant_bias = 0;
767 s->intra_quant_bias = 0;
773 av_log(avctx,
AV_LOG_ERROR,
"qmin and or qmax are invalid, they must be 0 < min <= max\n");
777 av_log(avctx,
AV_LOG_DEBUG,
"intra_quant_bias = %d inter_quant_bias = %d\n",
s->intra_quant_bias,
s->inter_quant_bias);
782 "timebase %d/%d not supported by MPEG 4 standard, "
783 "the maximum admitted value for the timebase denominator "
794 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
799 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
828 "The specified picture size of %dx%d is not valid for the "
829 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
830 s->width,
s->height);
842 s->width,
s->height) == 8) {
844 "The specified picture size of %dx%d is not valid for "
845 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
846 "352x288, 704x576, and 1408x1152. "
847 "Try H.263+.\n",
s->width,
s->height);
859 s->modified_quant =
s->h263_aic;
861 s->unrestricted_mv =
s->obmc ||
s->loop_filter ||
s->umvplus;
871 s->unrestricted_mv = 1;
885 s->modified_quant = 1;
889 s->unrestricted_mv = 0;
894 s->unrestricted_mv = 1;
895 s->low_delay =
s->max_b_frames ? 0 : 1;
896 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
901 s->unrestricted_mv = 1;
902 s->msmpeg4_version = 2;
909 s->unrestricted_mv = 1;
910 s->msmpeg4_version = 3;
911 s->flipflop_rounding = 1;
918 s->unrestricted_mv = 1;
919 s->msmpeg4_version = 4;
920 s->flipflop_rounding = 1;
927 s->unrestricted_mv = 1;
928 s->msmpeg4_version = 5;
929 s->flipflop_rounding = 1;
937 #if FF_API_PRIVATE_OPT
948 s->progressive_frame =
964 if (
s->msmpeg4_version) {
981 if (
s->noise_reduction) {
991 if (
s->slice_context_count > 1) {
995 s->h263_slice_structured = 1;
998 s->quant_precision = 5;
1000 #if FF_API_PRIVATE_OPT
1014 ff_set_cmp(&
s->mecc,
s->mecc.frame_skip_cmp,
s->frame_skip_cmp);
1027 for (
i = 0;
i < 64;
i++) {
1028 int j =
s->idsp.idct_permutation[
i];
1034 s->intra_matrix[j] =
1037 s->intra_matrix[j] =
1041 s->chroma_intra_matrix[j] =
1055 s->intra_matrix,
s->intra_quant_bias, avctx->
qmin,
1058 s->inter_matrix,
s->inter_quant_bias, avctx->
qmin,
1065 #if FF_API_PRIVATE_OPT
1075 if (
s->b_frame_strategy == 2) {
1076 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1078 if (!
s->tmp_frames[
i])
1082 s->tmp_frames[
i]->width =
s->width >>
s->brd_scale;
1083 s->tmp_frames[
i]->height =
s->height >>
s->brd_scale;
1125 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
1126 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
1127 s->q_chroma_intra_matrix=
NULL;
1128 s->q_chroma_intra_matrix16=
NULL;
1145 for (y = 0; y < 16; y++) {
1146 for (x = 0; x < 16; x++) {
1161 h =
s->height & ~15;
1163 for (y = 0; y <
h; y += 16) {
1164 for (x = 0; x <
w; x += 16) {
1171 acc += sae + 500 < sad;
1180 s->chroma_x_shift,
s->chroma_y_shift,
s->out_format,
1181 s->mb_stride,
s->mb_width,
s->mb_height,
s->b8_stride,
1182 &
s->linesize, &
s->uvlinesize);
1189 int i, display_picture_number = 0, ret;
1190 int encoding_delay =
s->max_b_frames ?
s->max_b_frames
1191 : (
s->low_delay ? 0 : 1);
1192 int flush_offset = 1;
1197 display_picture_number =
s->input_picture_number++;
1201 int64_t last =
s->user_specified_pts;
1205 "Invalid pts (%"PRId64
") <= last (%"PRId64
")\n",
1210 if (!
s->low_delay && display_picture_number == 1)
1211 s->dts_delta =
pts - last;
1213 s->user_specified_pts =
pts;
1216 s->user_specified_pts =
1217 pts =
s->user_specified_pts + 1;
1219 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
1222 pts = display_picture_number;
1226 if (!pic_arg->
buf[0] ||
1228 pic_arg->
linesize[1] !=
s->uvlinesize ||
1231 if ((
s->width & 15) || (
s->height & 15))
1239 pic_arg->
linesize[1],
s->linesize,
s->uvlinesize);
1245 pic = &
s->picture[
i];
1262 int h_chroma_shift, v_chroma_shift;
1267 for (
i = 0;
i < 3;
i++) {
1268 ptrdiff_t src_stride = pic_arg->
linesize[
i];
1269 ptrdiff_t dst_stride =
i ?
s->uvlinesize :
s->linesize;
1270 int h_shift =
i ? h_chroma_shift : 0;
1271 int v_shift =
i ? v_chroma_shift : 0;
1279 && !
s->progressive_sequence
1280 &&
FFALIGN(
s->height, 32) -
s->height > 16)
1283 if (!
s->avctx->rc_buffer_size)
1286 if (src_stride == dst_stride)
1287 memcpy(dst,
src, src_stride *
h - src_stride +
w);
1292 memcpy(dst2,
src,
w);
1297 if ((
s->width & 15) || (
s->height & (vpad-1))) {
1298 s->mpvencdsp.draw_edges(dst, dst_stride,
1317 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1318 if (
s->input_picture[flush_offset])
1321 if (flush_offset <= 1)
1324 encoding_delay = encoding_delay - flush_offset + 1;
1329 s->input_picture[
i - flush_offset] =
s->input_picture[
i];
1331 s->input_picture[
i] =
NULL;
1333 s->input_picture[encoding_delay] = (
Picture*) pic;
1344 for (plane = 0; plane < 3; plane++) {
1346 const int bw = plane ? 1 : 2;
1347 for (y = 0; y <
s->mb_height * bw; y++) {
1348 for (x = 0; x <
s->mb_width * bw; x++) {
1349 int off = p->
shared ? 0 : 16;
1352 int v =
s->mecc.frame_skip_cmp[1](
s, dptr, rptr,
stride, 8);
1354 switch (
FFABS(
s->frame_skip_exp)) {
1355 case 0: score =
FFMAX(score, v);
break;
1356 case 1: score +=
FFABS(v);
break;
1357 case 2: score64 += v * (
int64_t)v;
break;
1368 if (
s->frame_skip_exp < 0)
1369 score64 = pow(score64 / (
double)(
s->mb_width *
s->mb_height),
1370 -1.0/
s->frame_skip_exp);
1372 if (score64 < s->frame_skip_threshold)
1374 if (score64 < ((
s->frame_skip_factor * (
int64_t)
s->lambda) >> 8))
1404 const int scale =
s->brd_scale;
1405 int width =
s->width >> scale;
1406 int height =
s->height >> scale;
1407 int i, j,
out_size, p_lambda, b_lambda, lambda2;
1409 int best_b_count = -1;
1424 b_lambda = p_lambda;
1428 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1429 Picture pre_input, *pre_input_ptr =
i ?
s->input_picture[
i - 1] :
1430 s->next_picture_ptr;
1433 if (pre_input_ptr && (!
i ||
s->input_picture[
i - 1])) {
1434 pre_input = *pre_input_ptr;
1443 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[0],
1444 s->tmp_frames[
i]->linesize[0],
1448 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[1],
1449 s->tmp_frames[
i]->linesize[1],
1453 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[2],
1454 s->tmp_frames[
i]->linesize[2],
1461 for (j = 0; j <
s->max_b_frames + 1; j++) {
1465 if (!
s->input_picture[j])
1478 c->mb_decision =
s->avctx->mb_decision;
1479 c->me_cmp =
s->avctx->me_cmp;
1480 c->mb_cmp =
s->avctx->mb_cmp;
1481 c->me_sub_cmp =
s->avctx->me_sub_cmp;
1483 c->time_base =
s->avctx->time_base;
1484 c->max_b_frames =
s->max_b_frames;
1502 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1503 int is_p =
i % (j + 1) == j ||
i ==
s->max_b_frames;
1505 s->tmp_frames[
i + 1]->pict_type = is_p ?
1507 s->tmp_frames[
i + 1]->quality = is_p ? p_lambda : b_lambda;
1526 rd +=
c->error[0] +
c->error[1] +
c->error[2];
1544 return best_b_count;
1552 s->reordered_input_picture[
i - 1] =
s->reordered_input_picture[
i];
1556 if (!
s->reordered_input_picture[0] &&
s->input_picture[0]) {
1557 if (
s->frame_skip_threshold ||
s->frame_skip_factor) {
1558 if (
s->picture_in_gop_number <
s->gop_size &&
1559 s->next_picture_ptr &&
1571 !
s->next_picture_ptr ||
s->intra_only) {
1572 s->reordered_input_picture[0] =
s->input_picture[0];
1574 s->reordered_input_picture[0]->f->coded_picture_number =
1575 s->coded_picture_number++;
1580 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1581 int pict_num =
s->input_picture[0]->f->display_picture_number +
i;
1583 if (pict_num >=
s->rc_context.num_entries)
1585 if (!
s->input_picture[
i]) {
1590 s->input_picture[
i]->f->pict_type =
1591 s->rc_context.entry[pict_num].new_pict_type;
1595 if (
s->b_frame_strategy == 0) {
1596 b_frames =
s->max_b_frames;
1597 while (b_frames && !
s->input_picture[b_frames])
1599 }
else if (
s->b_frame_strategy == 1) {
1600 for (
i = 1;
i <
s->max_b_frames + 1;
i++) {
1601 if (
s->input_picture[
i] &&
1602 s->input_picture[
i]->b_frame_score == 0) {
1603 s->input_picture[
i]->b_frame_score =
1605 s->input_picture[
i ]->f->data[0],
1606 s->input_picture[
i - 1]->f->data[0],
1610 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1611 if (!
s->input_picture[
i] ||
1612 s->input_picture[
i]->b_frame_score - 1 >
1613 s->mb_num /
s->b_sensitivity)
1617 b_frames =
FFMAX(0,
i - 1);
1620 for (
i = 0;
i < b_frames + 1;
i++) {
1621 s->input_picture[
i]->b_frame_score = 0;
1623 }
else if (
s->b_frame_strategy == 2) {
1631 for (
i = b_frames - 1;
i >= 0;
i--) {
1632 int type =
s->input_picture[
i]->f->pict_type;
1637 b_frames ==
s->max_b_frames) {
1639 "warning, too many B-frames in a row\n");
1642 if (
s->picture_in_gop_number + b_frames >=
s->gop_size) {
1644 s->gop_size >
s->picture_in_gop_number) {
1645 b_frames =
s->gop_size -
s->picture_in_gop_number - 1;
1657 s->reordered_input_picture[0] =
s->input_picture[b_frames];
1660 s->reordered_input_picture[0]->f->coded_picture_number =
1661 s->coded_picture_number++;
1662 for (
i = 0;
i < b_frames;
i++) {
1663 s->reordered_input_picture[
i + 1] =
s->input_picture[
i];
1664 s->reordered_input_picture[
i + 1]->f->pict_type =
1666 s->reordered_input_picture[
i + 1]->f->coded_picture_number =
1667 s->coded_picture_number++;
1674 if (
s->reordered_input_picture[0]) {
1675 s->reordered_input_picture[0]->reference =
1676 s->reordered_input_picture[0]->f->pict_type !=
1682 if (
s->reordered_input_picture[0]->shared ||
s->avctx->rc_buffer_size) {
1690 pic = &
s->picture[
i];
1692 pic->
reference =
s->reordered_input_picture[0]->reference;
1703 s->reordered_input_picture[0]->shared = 0;
1705 s->current_picture_ptr = pic;
1708 s->current_picture_ptr =
s->reordered_input_picture[0];
1709 for (
i = 0;
i < 4;
i++) {
1710 if (
s->new_picture.f->data[
i])
1716 s->current_picture_ptr)) < 0)
1719 s->picture_number =
s->new_picture.f->display_picture_number;
1726 if (
s->unrestricted_mv &&
1727 s->current_picture.reference &&
1730 int hshift =
desc->log2_chroma_w;
1731 int vshift =
desc->log2_chroma_h;
1732 s->mpvencdsp.draw_edges(
s->current_picture.f->data[0],
1733 s->current_picture.f->linesize[0],
1734 s->h_edge_pos,
s->v_edge_pos,
1737 s->mpvencdsp.draw_edges(
s->current_picture.f->data[1],
1738 s->current_picture.f->linesize[1],
1739 s->h_edge_pos >> hshift,
1740 s->v_edge_pos >> vshift,
1744 s->mpvencdsp.draw_edges(
s->current_picture.f->data[2],
1745 s->current_picture.f->linesize[2],
1746 s->h_edge_pos >> hshift,
1747 s->v_edge_pos >> vshift,
1755 s->last_pict_type =
s->pict_type;
1756 s->last_lambda_for [
s->pict_type] =
s->current_picture_ptr->f->quality;
1758 s->last_non_b_pict_type =
s->pict_type;
1760 #if FF_API_CODED_FRAME
1766 #if FF_API_ERROR_FRAME
1768 memcpy(
s->current_picture.f->error,
s->current_picture.encoding_error,
1769 sizeof(
s->current_picture.encoding_error));
1778 for (intra = 0; intra < 2; intra++) {
1779 if (
s->dct_count[intra] > (1 << 16)) {
1780 for (
i = 0;
i < 64;
i++) {
1781 s->dct_error_sum[intra][
i] >>= 1;
1783 s->dct_count[intra] >>= 1;
1786 for (
i = 0;
i < 64;
i++) {
1787 s->dct_offset[intra][
i] = (
s->noise_reduction *
1788 s->dct_count[intra] +
1789 s->dct_error_sum[intra][
i] / 2) /
1790 (
s->dct_error_sum[intra][
i] + 1);
1801 s->last_picture_ptr !=
s->next_picture_ptr &&
1802 s->last_picture_ptr->f->buf[0]) {
1806 s->current_picture_ptr->f->pict_type =
s->pict_type;
1811 s->current_picture_ptr)) < 0)
1815 s->last_picture_ptr =
s->next_picture_ptr;
1817 s->next_picture_ptr =
s->current_picture_ptr;
1820 if (
s->last_picture_ptr) {
1822 if (
s->last_picture_ptr->f->buf[0] &&
1824 s->last_picture_ptr)) < 0)
1827 if (
s->next_picture_ptr) {
1829 if (
s->next_picture_ptr->f->buf[0] &&
1831 s->next_picture_ptr)) < 0)
1837 for (
i = 0;
i < 4;
i++) {
1839 s->current_picture.f->data[
i] +=
1840 s->current_picture.f->linesize[
i];
1842 s->current_picture.f->linesize[
i] *= 2;
1843 s->last_picture.f->linesize[
i] *= 2;
1844 s->next_picture.f->linesize[
i] *= 2;
1849 s->dct_unquantize_intra =
s->dct_unquantize_mpeg2_intra;
1850 s->dct_unquantize_inter =
s->dct_unquantize_mpeg2_inter;
1852 s->dct_unquantize_intra =
s->dct_unquantize_h263_intra;
1853 s->dct_unquantize_inter =
s->dct_unquantize_h263_inter;
1855 s->dct_unquantize_intra =
s->dct_unquantize_mpeg1_intra;
1856 s->dct_unquantize_inter =
s->dct_unquantize_mpeg1_inter;
1859 if (
s->dct_error_sum) {
1868 const AVFrame *pic_arg,
int *got_packet)
1871 int i, stuffing_count, ret;
1872 int context_count =
s->slice_context_count;
1874 s->vbv_ignore_qmax = 0;
1876 s->picture_in_gop_number++;
1886 if (
s->new_picture.f->data[0]) {
1887 int growing_buffer = context_count == 1 && !
pkt->
data && !
s->data_partitioning;
1896 s->mb_width*
s->mb_height*12);
1897 s->prev_mb_info =
s->last_mb_info =
s->mb_info_size = 0;
1900 for (
i = 0;
i < context_count;
i++) {
1901 int start_y =
s->thread_context[
i]->start_mb_y;
1902 int end_y =
s->thread_context[
i]-> end_mb_y;
1903 int h =
s->mb_height;
1910 s->pict_type =
s->new_picture.f->pict_type;
1917 if (growing_buffer) {
1925 #if FF_API_STAT_BITS
1934 avctx->
p_count =
s->mb_num -
s->i_count -
s->skip_count;
1951 s->lambda <
s->lmax) {
1952 s->next_lambda =
FFMAX(
s->lambda + min_step,
s->lambda *
1953 (
s->qscale + 1) /
s->qscale);
1954 if (
s->adaptive_quant) {
1956 for (
i = 0;
i <
s->mb_height *
s->mb_stride;
i++)
1957 s->lambda_table[
i] =
1958 FFMAX(
s->lambda_table[
i] + min_step,
1959 s->lambda_table[
i] * (
s->qscale + 1) /
1965 if (
s->flipflop_rounding ||
1968 s->no_rounding ^= 1;
1971 s->time_base =
s->last_time_base;
1972 s->last_non_b_time =
s->time -
s->pp_time;
1974 for (
i = 0;
i < context_count;
i++) {
1978 s->vbv_ignore_qmax = 1;
1989 for (
i = 0;
i < 4;
i++) {
1990 s->current_picture_ptr->encoding_error[
i] =
s->current_picture.encoding_error[
i];
1991 avctx->
error[
i] +=
s->current_picture_ptr->encoding_error[
i];
1994 s->current_picture_ptr->encoding_error,
2000 s->misc_bits +
s->i_tex_bits +
2006 s->stuffing_bits = 8*stuffing_count;
2007 if (stuffing_count) {
2009 stuffing_count + 50) {
2014 switch (
s->codec_id) {
2017 while (stuffing_count--) {
2024 stuffing_count -= 4;
2025 while (stuffing_count--) {
2031 s->stuffing_bits = 0;
2046 int vbv_delay, min_delay;
2049 int minbits =
s->frame_bits - 8 *
2050 (
s->vbv_delay_ptr -
s->pb.buf - 1);
2051 double bits =
s->rc_context.buffer_index + minbits - inbits;
2055 "Internal error, negative bits\n");
2060 min_delay = (minbits * 90000LL + avctx->
rc_max_rate - 1) /
2063 vbv_delay =
FFMAX(vbv_delay, min_delay);
2067 s->vbv_delay_ptr[0] &= 0xF8;
2068 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2069 s->vbv_delay_ptr[1] = vbv_delay >> 5;
2070 s->vbv_delay_ptr[2] &= 0x07;
2071 s->vbv_delay_ptr[2] |= vbv_delay << 3;
2085 #if FF_API_VBV_DELAY
2091 s->total_bits +=
s->frame_bits;
2092 #if FF_API_STAT_BITS
2099 pkt->
pts =
s->current_picture.f->pts;
2101 if (!
s->current_picture.f->coded_picture_number)
2108 if (
s->current_picture.f->key_frame)
2118 if (!
s->picture[
i].reference)
2130 int n,
int threshold)
2132 static const char tab[64] = {
2133 3, 2, 2, 1, 1, 1, 1, 1,
2134 1, 1, 1, 1, 1, 1, 1, 1,
2135 1, 1, 1, 1, 1, 1, 1, 1,
2136 0, 0, 0, 0, 0, 0, 0, 0,
2137 0, 0, 0, 0, 0, 0, 0, 0,
2138 0, 0, 0, 0, 0, 0, 0, 0,
2139 0, 0, 0, 0, 0, 0, 0, 0,
2140 0, 0, 0, 0, 0, 0, 0, 0
2145 int16_t *
block =
s->block[n];
2146 const int last_index =
s->block_last_index[n];
2149 if (threshold < 0) {
2151 threshold = -threshold;
2156 if (last_index <= skip_dc - 1)
2159 for (
i = 0;
i <= last_index;
i++) {
2160 const int j =
s->intra_scantable.permutated[
i];
2163 if (skip_dc &&
i == 0)
2167 }
else if (
level > 1) {
2173 if (score >= threshold)
2175 for (
i = skip_dc;
i <= last_index;
i++) {
2176 const int j =
s->intra_scantable.permutated[
i];
2180 s->block_last_index[n] = 0;
2182 s->block_last_index[n] = -1;
2189 const int maxlevel =
s->max_qcoeff;
2190 const int minlevel =
s->min_qcoeff;
2198 for (;
i <= last_index;
i++) {
2199 const int j =
s->intra_scantable.permutated[
i];
2202 if (
level > maxlevel) {
2205 }
else if (
level < minlevel) {
2215 "warning, clipping %d dct coefficients to %d..%d\n",
2216 overflow, minlevel, maxlevel);
2223 for (y = 0; y < 8; y++) {
2224 for (x = 0; x < 8; x++) {
2230 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
2231 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
2232 int v = ptr[x2 + y2 *
stride];
2238 weight[x + 8 * y]= (36 *
ff_sqrt(count * sqr - sum * sum)) / count;
2244 int motion_x,
int motion_y,
2245 int mb_block_height,
2250 int16_t orig[12][64];
2251 const int mb_x =
s->mb_x;
2252 const int mb_y =
s->mb_y;
2255 int dct_offset =
s->linesize * 8;
2256 int uv_dct_offset =
s->uvlinesize * 8;
2257 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2258 ptrdiff_t wrap_y, wrap_c;
2260 for (
i = 0;
i < mb_block_count;
i++)
2261 skip_dct[
i] =
s->skipdct;
2263 if (
s->adaptive_quant) {
2264 const int last_qp =
s->qscale;
2265 const int mb_xy = mb_x + mb_y *
s->mb_stride;
2267 s->lambda =
s->lambda_table[mb_xy];
2271 s->qscale =
s->current_picture_ptr->qscale_table[mb_xy];
2272 s->dquant =
s->qscale - last_qp;
2293 wrap_y =
s->linesize;
2294 wrap_c =
s->uvlinesize;
2295 ptr_y =
s->new_picture.f->data[0] +
2296 (mb_y * 16 * wrap_y) + mb_x * 16;
2297 ptr_cb =
s->new_picture.f->data[1] +
2298 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2299 ptr_cr =
s->new_picture.f->data[2] +
2300 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2302 if((mb_x * 16 + 16 >
s->width || mb_y * 16 + 16 >
s->height) &&
s->codec_id !=
AV_CODEC_ID_AMV){
2303 uint8_t *ebuf =
s->sc.edge_emu_buffer + 38 * wrap_y;
2304 int cw = (
s->width +
s->chroma_x_shift) >>
s->chroma_x_shift;
2305 int ch = (
s->height +
s->chroma_y_shift) >>
s->chroma_y_shift;
2306 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2308 16, 16, mb_x * 16, mb_y * 16,
2309 s->width,
s->height);
2311 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2313 mb_block_width, mb_block_height,
2314 mb_x * mb_block_width, mb_y * mb_block_height,
2316 ptr_cb = ebuf + 16 * wrap_y;
2317 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2319 mb_block_width, mb_block_height,
2320 mb_x * mb_block_width, mb_y * mb_block_height,
2322 ptr_cr = ebuf + 16 * wrap_y + 16;
2327 int progressive_score, interlaced_score;
2329 s->interlaced_dct = 0;
2330 progressive_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
NULL, wrap_y, 8) +
2331 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y * 8,
2332 NULL, wrap_y, 8) - 400;
2334 if (progressive_score > 0) {
2335 interlaced_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
2336 NULL, wrap_y * 2, 8) +
2337 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y,
2338 NULL, wrap_y * 2, 8);
2339 if (progressive_score > interlaced_score) {
2340 s->interlaced_dct = 1;
2342 dct_offset = wrap_y;
2343 uv_dct_offset = wrap_c;
2352 s->pdsp.get_pixels(
s->block[0], ptr_y, wrap_y);
2353 s->pdsp.get_pixels(
s->block[1], ptr_y + 8, wrap_y);
2354 s->pdsp.get_pixels(
s->block[2], ptr_y + dct_offset, wrap_y);
2355 s->pdsp.get_pixels(
s->block[3], ptr_y + dct_offset + 8, wrap_y);
2361 s->pdsp.get_pixels(
s->block[4], ptr_cb, wrap_c);
2362 s->pdsp.get_pixels(
s->block[5], ptr_cr, wrap_c);
2363 if (!
s->chroma_y_shift &&
s->chroma_x_shift) {
2364 s->pdsp.get_pixels(
s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2365 s->pdsp.get_pixels(
s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2366 }
else if (!
s->chroma_y_shift && !
s->chroma_x_shift) {
2367 s->pdsp.get_pixels(
s->block[ 6], ptr_cb + 8, wrap_c);
2368 s->pdsp.get_pixels(
s->block[ 7], ptr_cr + 8, wrap_c);
2369 s->pdsp.get_pixels(
s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2370 s->pdsp.get_pixels(
s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2371 s->pdsp.get_pixels(
s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2372 s->pdsp.get_pixels(
s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2378 uint8_t *dest_y, *dest_cb, *dest_cr;
2380 dest_y =
s->dest[0];
2381 dest_cb =
s->dest[1];
2382 dest_cr =
s->dest[2];
2385 op_pix =
s->hdsp.put_pixels_tab;
2386 op_qpix =
s->qdsp.put_qpel_pixels_tab;
2388 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
2389 op_qpix =
s->qdsp.put_no_rnd_qpel_pixels_tab;
2394 s->last_picture.f->data,
2396 op_pix =
s->hdsp.avg_pixels_tab;
2397 op_qpix =
s->qdsp.avg_qpel_pixels_tab;
2401 s->next_picture.f->data,
2406 int progressive_score, interlaced_score;
2408 s->interlaced_dct = 0;
2409 progressive_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y, wrap_y, 8) +
2410 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y * 8,
2415 progressive_score -= 400;
2417 if (progressive_score > 0) {
2418 interlaced_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y,
2420 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y,
2424 if (progressive_score > interlaced_score) {
2425 s->interlaced_dct = 1;
2427 dct_offset = wrap_y;
2428 uv_dct_offset = wrap_c;
2436 s->pdsp.diff_pixels(
s->block[0], ptr_y, dest_y, wrap_y);
2437 s->pdsp.diff_pixels(
s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2438 s->pdsp.diff_pixels(
s->block[2], ptr_y + dct_offset,
2439 dest_y + dct_offset, wrap_y);
2440 s->pdsp.diff_pixels(
s->block[3], ptr_y + dct_offset + 8,
2441 dest_y + dct_offset + 8, wrap_y);
2447 s->pdsp.diff_pixels(
s->block[4], ptr_cb, dest_cb, wrap_c);
2448 s->pdsp.diff_pixels(
s->block[5], ptr_cr, dest_cr, wrap_c);
2449 if (!
s->chroma_y_shift) {
2450 s->pdsp.diff_pixels(
s->block[6], ptr_cb + uv_dct_offset,
2451 dest_cb + uv_dct_offset, wrap_c);
2452 s->pdsp.diff_pixels(
s->block[7], ptr_cr + uv_dct_offset,
2453 dest_cr + uv_dct_offset, wrap_c);
2457 if (
s->current_picture.mc_mb_var[
s->mb_stride * mb_y + mb_x] <
2458 2 *
s->qscale *
s->qscale) {
2460 if (
s->mecc.sad[1](
NULL, ptr_y, dest_y, wrap_y, 8) < 20 *
s->qscale)
2462 if (
s->mecc.sad[1](
NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 *
s->qscale)
2464 if (
s->mecc.sad[1](
NULL, ptr_y + dct_offset, dest_y + dct_offset,
2465 wrap_y, 8) < 20 *
s->qscale)
2467 if (
s->mecc.sad[1](
NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2468 wrap_y, 8) < 20 *
s->qscale)
2470 if (
s->mecc.sad[1](
NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 *
s->qscale)
2472 if (
s->mecc.sad[1](
NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 *
s->qscale)
2474 if (!
s->chroma_y_shift) {
2475 if (
s->mecc.sad[1](
NULL, ptr_cb + uv_dct_offset,
2476 dest_cb + uv_dct_offset,
2477 wrap_c, 8) < 20 *
s->qscale)
2479 if (
s->mecc.sad[1](
NULL, ptr_cr + uv_dct_offset,
2480 dest_cr + uv_dct_offset,
2481 wrap_c, 8) < 20 *
s->qscale)
2487 if (
s->quantizer_noise_shaping) {
2500 if (!
s->chroma_y_shift) {
2508 memcpy(orig[0],
s->block[0],
sizeof(int16_t) * 64 * mb_block_count);
2514 for (
i = 0;
i < mb_block_count;
i++) {
2517 s->block_last_index[
i] =
s->dct_quantize(
s,
s->block[
i],
i,
s->qscale, &overflow);
2526 s->block_last_index[
i] = -1;
2528 if (
s->quantizer_noise_shaping) {
2529 for (
i = 0;
i < mb_block_count;
i++) {
2531 s->block_last_index[
i] =
2533 orig[
i],
i,
s->qscale);
2538 if (
s->luma_elim_threshold && !
s->mb_intra)
2539 for (
i = 0;
i < 4;
i++)
2541 if (
s->chroma_elim_threshold && !
s->mb_intra)
2542 for (
i = 4;
i < mb_block_count;
i++)
2546 for (
i = 0;
i < mb_block_count;
i++) {
2547 if (
s->block_last_index[
i] == -1)
2548 s->coded_score[
i] = INT_MAX / 256;
2554 s->block_last_index[4] =
2555 s->block_last_index[5] = 0;
2557 s->block[5][0] = (1024 +
s->c_dc_scale / 2) /
s->c_dc_scale;
2558 if (!
s->chroma_y_shift) {
2559 for (
i=6;
i<12;
i++) {
2560 s->block_last_index[
i] = 0;
2561 s->block[
i][0] =
s->block[4][0];
2568 for (
i = 0;
i < mb_block_count;
i++) {
2570 if (
s->block_last_index[
i] > 0) {
2571 for (j = 63; j > 0; j--) {
2572 if (
s->block[
i][
s->intra_scantable.permutated[j]])
2575 s->block_last_index[
i] = j;
2581 switch(
s->codec_id){
2637 memcpy(d->
last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2665 memcpy(d->
mv,
s->mv, 2*4*2*
sizeof(
int));
2666 memcpy(d->
last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2688 if(
s->data_partitioning){
2703 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2710 s->block=
s->blocks[*next_block];
2711 s->pb= pb[*next_block];
2712 if(
s->data_partitioning){
2713 s->pb2 = pb2 [*next_block];
2714 s->tex_pb= tex_pb[*next_block];
2718 memcpy(dest_backup,
s->dest,
sizeof(
s->dest));
2719 s->dest[0] =
s->sc.rd_scratchpad;
2720 s->dest[1] =
s->sc.rd_scratchpad + 16*
s->linesize;
2721 s->dest[2] =
s->sc.rd_scratchpad + 16*
s->linesize + 8;
2728 if(
s->data_partitioning){
2736 score *=
s->lambda2;
2741 memcpy(
s->dest, dest_backup,
sizeof(
s->dest));
2759 else if(
w==8 &&
h==8)
2777 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
2778 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
2782 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) +
2783 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) +
2784 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);
2786 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) +
2787 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) +
2788 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);
2791 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)
2792 +
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)
2793 +
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);
2801 s->me.dia_size=
s->avctx->pre_dia_size;
2802 s->first_slice_line=1;
2803 for(
s->mb_y=
s->end_mb_y-1;
s->mb_y >=
s->start_mb_y;
s->mb_y--) {
2804 for(
s->mb_x=
s->mb_width-1;
s->mb_x >=0 ;
s->mb_x--) {
2807 s->first_slice_line=0;
2818 s->me.dia_size=
s->avctx->dia_size;
2819 s->first_slice_line=1;
2820 for(
s->mb_y=
s->start_mb_y;
s->mb_y <
s->end_mb_y;
s->mb_y++) {
2823 for(
s->mb_x=0;
s->mb_x <
s->mb_width;
s->mb_x++) {
2824 s->block_index[0]+=2;
2825 s->block_index[1]+=2;
2826 s->block_index[2]+=2;
2827 s->block_index[3]+=2;
2835 s->first_slice_line=0;
2844 for(mb_y=
s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2845 for(mb_x=0; mb_x <
s->mb_width; mb_x++) {
2848 uint8_t *pix =
s->new_picture.f->data[0] + (yy *
s->linesize) + xx;
2850 int sum =
s->mpvencdsp.pix_sum(pix,
s->linesize);
2852 varc = (
s->mpvencdsp.pix_norm1(pix,
s->linesize) -
2853 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2855 s->current_picture.mb_var [
s->mb_stride * mb_y + mb_x] = varc;
2856 s->current_picture.mb_mean[
s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2857 s->me.mb_var_sum_temp += varc;
2865 if(
s->partitioned_frame){
2884 uint8_t *ptr =
s->mb_info_ptr +
s->mb_info_size - 12;
2886 int mba =
s->mb_x +
s->mb_width * (
s->mb_y %
s->gob_index);
2887 int gobn =
s->mb_y /
s->gob_index;
2891 bytestream_put_le32(&ptr,
offset);
2892 bytestream_put_byte(&ptr,
s->qscale);
2893 bytestream_put_byte(&ptr, gobn);
2894 bytestream_put_le16(&ptr, mba);
2895 bytestream_put_byte(&ptr, pred_x);
2896 bytestream_put_byte(&ptr, pred_y);
2898 bytestream_put_byte(&ptr, 0);
2899 bytestream_put_byte(&ptr, 0);
2907 s->mb_info_size += 12;
2908 s->prev_mb_info =
s->last_mb_info;
2920 if (!
s->mb_info_size)
2921 s->mb_info_size += 12;
2928 &&
s->slice_context_count == 1
2929 &&
s->pb.buf ==
s->avctx->internal->byte_buffer) {
2930 int lastgob_pos =
s->ptr_lastgob -
s->pb.buf;
2931 int vbv_pos =
s->vbv_delay_ptr -
s->pb.buf;
2934 int new_buffer_size = 0;
2936 if ((
s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2944 s->avctx->internal->byte_buffer_size + size_increase);
2948 memcpy(new_buffer,
s->avctx->internal->byte_buffer,
s->avctx->internal->byte_buffer_size);
2949 av_free(
s->avctx->internal->byte_buffer);
2950 s->avctx->internal->byte_buffer = new_buffer;
2951 s->avctx->internal->byte_buffer_size = new_buffer_size;
2953 s->ptr_lastgob =
s->pb.buf + lastgob_pos;
2954 s->vbv_delay_ptr =
s->pb.buf + vbv_pos;
2963 int mb_x, mb_y, mb_y_order;
2964 int chr_h= 16>>
s->chroma_y_shift;
2991 s->last_dc[
i] = 128 <<
s->intra_dc_precision;
2993 s->current_picture.encoding_error[
i] = 0;
2996 s->last_dc[0] = 128*8/13;
2997 s->last_dc[1] = 128*8/14;
2998 s->last_dc[2] = 128*8/14;
3001 memset(
s->last_mv, 0,
sizeof(
s->last_mv));
3005 switch(
s->codec_id){
3020 s->first_slice_line = 1;
3021 s->ptr_lastgob =
s->pb.buf;
3022 for (mb_y_order =
s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3026 if (first_in_slice && mb_y_order !=
s->start_mb_y)
3028 s->last_dc[0] =
s->last_dc[1] =
s->last_dc[2] = 1024 <<
s->intra_dc_precision;
3038 for(mb_x=0; mb_x <
s->mb_width; mb_x++) {
3039 int xy= mb_y*
s->mb_stride + mb_x;
3040 int mb_type=
s->mb_type[xy];
3044 int size_increase =
s->avctx->internal->byte_buffer_size/4
3052 if(
s->data_partitioning){
3066 xy=
s->mb_y*
s->mb_stride +
s->mb_x;
3067 mb_type=
s->mb_type[xy];
3072 int current_packet_size, is_gob_start;
3074 current_packet_size= ((
put_bits_count(&
s->pb)+7)>>3) - (
s->ptr_lastgob -
s->pb.buf);
3076 is_gob_start =
s->rtp_payload_size &&
3077 current_packet_size >=
s->rtp_payload_size &&
3080 if(
s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3082 switch(
s->codec_id){
3085 if(!
s->h263_slice_structured)
3086 if(
s->mb_x ||
s->mb_y%
s->gob_index) is_gob_start=0;
3089 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3091 if(
s->mb_skip_run) is_gob_start=0;
3094 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3099 if(
s->start_mb_y != mb_y || mb_x!=0){
3110 if (
s->error_rate &&
s->resync_mb_x +
s->resync_mb_y > 0) {
3112 int d = 100 /
s->error_rate;
3114 current_packet_size=0;
3115 s->pb.buf_ptr=
s->ptr_lastgob;
3120 #if FF_API_RTP_CALLBACK
3122 if (
s->avctx->rtp_callback){
3123 int number_mb = (mb_y -
s->resync_mb_y)*
s->mb_width + mb_x -
s->resync_mb_x;
3124 s->avctx->rtp_callback(
s->avctx,
s->ptr_lastgob, current_packet_size, number_mb);
3130 switch(
s->codec_id){
3153 s->misc_bits+=
bits -
s->last_bits;
3157 s->ptr_lastgob += current_packet_size;
3158 s->first_slice_line=1;
3159 s->resync_mb_x=mb_x;
3160 s->resync_mb_y=mb_y;
3164 if( (
s->resync_mb_x ==
s->mb_x)
3165 &&
s->resync_mb_y+1 ==
s->mb_y){
3166 s->first_slice_line=0;
3176 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3182 if(
s->data_partitioning){
3183 backup_s.pb2=
s->pb2;
3184 backup_s.tex_pb=
s->tex_pb;
3191 s->mv[0][0][0] =
s->p_mv_table[xy][0];
3192 s->mv[0][0][1] =
s->p_mv_table[xy][1];
3194 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3201 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3202 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3203 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3206 &dmin, &next_block, 0, 0);
3215 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3222 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3223 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3226 &dmin, &next_block, 0, 0);
3232 s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3233 s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3235 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3241 s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3242 s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3244 &dmin, &next_block,
s->mv[1][0][0],
s->mv[1][0][1]);
3250 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3251 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3252 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3253 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3255 &dmin, &next_block, 0, 0);
3262 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3263 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3264 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3267 &dmin, &next_block, 0, 0);
3274 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3275 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3276 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3279 &dmin, &next_block, 0, 0);
3285 for(dir=0; dir<2; dir++){
3287 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3288 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3289 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3293 &dmin, &next_block, 0, 0);
3302 &dmin, &next_block, 0, 0);
3303 if(
s->h263_pred ||
s->h263_aic){
3305 s->mbintra_table[mb_x + mb_y*
s->mb_stride]=1;
3313 const int last_qp= backup_s.qscale;
3317 static const int dquant_tab[4]={-1,1,-2,2};
3318 int storecoefs =
s->mb_intra &&
s->dc_val[0];
3326 s->mv[0][0][0] = best_s.
mv[0][0][0];
3327 s->mv[0][0][1] = best_s.
mv[0][0][1];
3328 s->mv[1][0][0] = best_s.
mv[1][0][0];
3329 s->mv[1][0][1] = best_s.
mv[1][0][1];
3332 for(; qpi<4; qpi++){
3333 int dquant= dquant_tab[qpi];
3334 qp= last_qp + dquant;
3335 if(qp < s->avctx->qmin || qp >
s->avctx->qmax)
3337 backup_s.dquant= dquant;
3340 dc[
i]=
s->dc_val[0][
s->block_index[
i] ];
3341 memcpy(ac[
i],
s->ac_val[0][
s->block_index[
i]],
sizeof(int16_t)*16);
3346 &dmin, &next_block,
s->mv[mvdir][0][0],
s->mv[mvdir][0][1]);
3350 s->dc_val[0][
s->block_index[
i] ]=
dc[
i];
3351 memcpy(
s->ac_val[0][
s->block_index[
i]], ac[
i],
sizeof(int16_t)*16);
3359 int mx=
s->b_direct_mv_table[xy][0];
3360 int my=
s->b_direct_mv_table[xy][1];
3362 backup_s.dquant = 0;
3367 &dmin, &next_block, mx, my);
3370 backup_s.dquant = 0;
3375 &dmin, &next_block, 0, 0);
3380 coded |=
s->block_last_index[
i];
3383 memcpy(
s->mv, best_s.
mv,
sizeof(
s->mv));
3405 &dmin, &next_block, mx, my);
3410 s->current_picture.qscale_table[xy] = best_s.
qscale;
3416 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3419 if(
s->data_partitioning){
3422 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3423 s->pb2= backup_s.pb2;
3427 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3428 s->tex_pb= backup_s.tex_pb;
3437 s->hdsp.put_pixels_tab[0][0](
s->dest[0],
s->sc.rd_scratchpad ,
s->linesize ,16);
3438 s->hdsp.put_pixels_tab[1][0](
s->dest[1],
s->sc.rd_scratchpad + 16*
s->linesize ,
s->uvlinesize, 8);
3439 s->hdsp.put_pixels_tab[1][0](
s->dest[2],
s->sc.rd_scratchpad + 16*
s->linesize + 8,
s->uvlinesize, 8);
3445 int motion_x = 0, motion_y = 0;
3453 motion_x=
s->mv[0][0][0] = 0;
3454 motion_y=
s->mv[0][0][1] = 0;
3459 motion_x=
s->mv[0][0][0] =
s->p_mv_table[xy][0];
3460 motion_y=
s->mv[0][0][1] =
s->p_mv_table[xy][1];
3467 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3468 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3469 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3477 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3478 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3485 motion_x=
s->b_direct_mv_table[xy][0];
3486 motion_y=
s->b_direct_mv_table[xy][1];
3500 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3501 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3502 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3503 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3508 motion_x=
s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3509 motion_y=
s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3514 motion_x=
s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3515 motion_y=
s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3522 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3523 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3524 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3532 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3533 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3534 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3541 for(dir=0; dir<2; dir++){
3543 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3544 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3545 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3556 s->last_mv_dir =
s->mv_dir;
3567 s->p_mv_table[xy][0]=0;
3568 s->p_mv_table[xy][1]=0;
3575 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
3576 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
3578 s->current_picture.encoding_error[0] +=
sse(
3579 s,
s->new_picture.f->data[0] +
s->mb_x*16 +
s->mb_y*
s->linesize*16,
3580 s->dest[0],
w,
h,
s->linesize);
3581 s->current_picture.encoding_error[1] +=
sse(
3582 s,
s->new_picture.f->data[1] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3583 s->dest[1],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3584 s->current_picture.encoding_error[2] +=
sse(
3585 s,
s->new_picture.f->data[2] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3586 s->dest[2],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3592 ff_dlog(
s->avctx,
"MB %d %d bits\n",
3603 #if FF_API_RTP_CALLBACK
3606 if (
s->avctx->rtp_callback) {
3607 int number_mb = (mb_y -
s->resync_mb_y)*
s->mb_width -
s->resync_mb_x;
3611 s->avctx->rtp_callback(
s->avctx,
s->ptr_lastgob, pdif, number_mb);
3619 #define MERGE(field) dst->field += src->field; src->field=0
3629 MERGE(dct_count[0]);
3630 MERGE(dct_count[1]);
3639 MERGE(er.error_count);
3640 MERGE(padding_bug_score);
3641 MERGE(current_picture.encoding_error[0]);
3642 MERGE(current_picture.encoding_error[1]);
3643 MERGE(current_picture.encoding_error[2]);
3646 for(
i=0;
i<64;
i++){
3647 MERGE(dct_error_sum[0][
i]);
3648 MERGE(dct_error_sum[1][
i]);
3659 if (
s->next_lambda){
3660 s->current_picture_ptr->f->quality =
3661 s->current_picture.f->quality =
s->next_lambda;
3662 if(!dry_run)
s->next_lambda= 0;
3663 }
else if (!
s->fixed_qscale) {
3665 s->current_picture_ptr->f->quality =
3666 s->current_picture.f->quality = quality;
3667 if (
s->current_picture.f->quality < 0)
3671 if(
s->adaptive_quant){
3672 switch(
s->codec_id){
3687 s->lambda=
s->lambda_table[0];
3690 s->lambda =
s->current_picture.f->quality;
3698 s->time =
s->current_picture_ptr->f->pts *
s->avctx->time_base.num;
3701 s->pb_time=
s->pp_time - (
s->last_non_b_time -
s->time);
3704 s->pp_time=
s->time -
s->last_non_b_time;
3705 s->last_non_b_time=
s->time;
3714 int context_count =
s->slice_context_count;
3716 s->picture_number = picture_number;
3719 s->me.mb_var_sum_temp =
3720 s->me.mc_mb_var_sum_temp = 0;
3729 s->me.scene_change_score=0;
3734 if(
s->msmpeg4_version >= 3)
s->no_rounding=1;
3735 else s->no_rounding=0;
3738 s->no_rounding ^= 1;
3747 s->lambda=
s->last_lambda_for[
s->pict_type];
3749 s->lambda=
s->last_lambda_for[
s->last_non_b_pict_type];
3754 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
3755 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
3756 s->q_chroma_intra_matrix =
s->q_intra_matrix;
3757 s->q_chroma_intra_matrix16 =
s->q_intra_matrix16;
3761 for(
i=1;
i<context_count;
i++){
3772 s->lambda = (
s->lambda *
s->me_penalty_compensation + 128) >> 8;
3773 s->lambda2 = (
s->lambda2 * (
int64_t)
s->me_penalty_compensation + 128) >> 8;
3784 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3787 if(!
s->fixed_qscale){
3789 s->avctx->execute(
s->avctx,
mb_var_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3792 for(
i=1;
i<context_count;
i++){
3795 s->current_picture.mc_mb_var_sum=
s->current_picture_ptr->mc_mb_var_sum=
s->me.mc_mb_var_sum_temp;
3796 s->current_picture. mb_var_sum=
s->current_picture_ptr-> mb_var_sum=
s->me. mb_var_sum_temp;
3799 if (
s->me.scene_change_score >
s->scenechange_threshold &&
3802 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3804 if(
s->msmpeg4_version >= 3)
3806 ff_dlog(
s,
"Scene change detected, encoding as I Frame %"PRId64
" %"PRId64
"\n",
3807 s->current_picture.mb_var_sum,
s->current_picture.mc_mb_var_sum);
3850 for(dir=0; dir<2; dir++){
3856 s->b_field_mv_table[dir][
i][j], dir ?
s->b_code :
s->f_code,
type, 1);
3867 if (
s->qscale < 3 &&
s->max_qcoeff <= 128 &&
3876 if (
s->avctx->intra_matrix) {
3878 luma_matrix =
s->avctx->intra_matrix;
3880 if (
s->avctx->chroma_intra_matrix)
3881 chroma_matrix =
s->avctx->chroma_intra_matrix;
3885 int j =
s->idsp.idct_permutation[
i];
3887 s->chroma_intra_matrix[j] =
av_clip_uint8((chroma_matrix[
i] *
s->qscale) >> 3);
3890 s->y_dc_scale_table=
3892 s->chroma_intra_matrix[0] =
3895 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3897 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3901 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};
3902 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};
3909 s->y_dc_scale_table= y;
3910 s->c_dc_scale_table=
c;
3911 s->intra_matrix[0] = 13;
3912 s->chroma_intra_matrix[0] = 14;
3914 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3916 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3921 s->y_dc_scale_table=
3926 s->current_picture_ptr->f->key_frame =
3928 s->current_picture_ptr->f->pict_type =
3929 s->current_picture.f->pict_type =
s->pict_type;
3931 if (
s->current_picture.f->key_frame)
3932 s->picture_in_gop_number=0;
3934 s->mb_x =
s->mb_y = 0;
3936 switch(
s->out_format) {
3940 s->pred,
s->intra_matrix,
s->chroma_intra_matrix);
3979 s->header_bits=
bits -
s->last_bits;
3981 for(
i=1;
i<context_count;
i++){
3984 s->avctx->execute(
s->avctx,
encode_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3985 for(
i=1;
i<context_count;
i++){
3986 if (
s->pb.buf_end ==
s->thread_context[
i]->pb.buf)
3995 const int intra=
s->mb_intra;
3998 s->dct_count[intra]++;
4000 for(
i=0;
i<64;
i++){
4005 s->dct_error_sum[intra][
i] +=
level;
4006 level -=
s->dct_offset[intra][
i];
4009 s->dct_error_sum[intra][
i] -=
level;
4010 level +=
s->dct_offset[intra][
i];
4019 int16_t *
block,
int n,
4020 int qscale,
int *overflow){
4022 const uint16_t *matrix;
4024 const uint8_t *perm_scantable;
4026 unsigned int threshold1, threshold2;
4038 int coeff_count[64];
4039 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4040 const int esc_length=
s->ac_esc_length;
4048 if(
s->dct_error_sum)
4051 qadd= ((qscale-1)|1)*8;
4054 else mpeg2_qscale = qscale << 1;
4058 scantable=
s->intra_scantable.scantable;
4059 perm_scantable=
s->intra_scantable.permutated;
4076 qmat = n < 4 ?
s->q_intra_matrix[qscale] :
s->q_chroma_intra_matrix[qscale];
4077 matrix = n < 4 ?
s->intra_matrix :
s->chroma_intra_matrix;
4081 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4082 length =
s->intra_chroma_ac_vlc_length;
4083 last_length=
s->intra_chroma_ac_vlc_last_length;
4085 length =
s->intra_ac_vlc_length;
4086 last_length=
s->intra_ac_vlc_last_length;
4089 scantable=
s->inter_scantable.scantable;
4090 perm_scantable=
s->inter_scantable.permutated;
4093 qmat =
s->q_inter_matrix[qscale];
4094 matrix =
s->inter_matrix;
4095 length =
s->inter_ac_vlc_length;
4096 last_length=
s->inter_ac_vlc_last_length;
4101 threshold2= (threshold1<<1);
4103 for(
i=63;
i>=start_i;
i--) {
4104 const int j = scantable[
i];
4107 if(((
unsigned)(
level+threshold1))>threshold2){
4113 for(
i=start_i;
i<=last_non_zero;
i++) {
4114 const int j = scantable[
i];
4119 if(((
unsigned)(
level+threshold1))>threshold2){
4140 *overflow=
s->max_qcoeff <
max;
4142 if(last_non_zero < start_i){
4143 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4144 return last_non_zero;
4147 score_tab[start_i]= 0;
4148 survivor[0]= start_i;
4151 for(
i=start_i;
i<=last_non_zero;
i++){
4152 int level_index, j, zero_distortion;
4154 int best_score=256*256*256*120;
4158 zero_distortion= dct_coeff*dct_coeff;
4160 for(level_index=0; level_index < coeff_count[
i]; level_index++){
4169 unquant_coeff= alevel*qmul + qadd;
4171 j =
s->idsp.idct_permutation[scantable[
i]];
4172 unquant_coeff = alevel * matrix[j] * 8;
4174 j =
s->idsp.idct_permutation[scantable[
i]];
4176 unquant_coeff = (
int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4177 unquant_coeff = (unquant_coeff - 1) | 1;
4179 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int) matrix[j])) >> 5;
4180 unquant_coeff = (unquant_coeff - 1) | 1;
4185 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4187 if((
level&(~127)) == 0){
4188 for(j=survivor_count-1; j>=0; j--){
4189 int run=
i - survivor[j];
4191 score += score_tab[
i-
run];
4193 if(score < best_score){
4196 level_tab[
i+1]=
level-64;
4201 for(j=survivor_count-1; j>=0; j--){
4202 int run=
i - survivor[j];
4204 score += score_tab[
i-
run];
4205 if(score < last_score){
4208 last_level=
level-64;
4214 distortion += esc_length*lambda;
4215 for(j=survivor_count-1; j>=0; j--){
4216 int run=
i - survivor[j];
4217 int score= distortion + score_tab[
i-
run];
4219 if(score < best_score){
4222 level_tab[
i+1]=
level-64;
4227 for(j=survivor_count-1; j>=0; j--){
4228 int run=
i - survivor[j];
4229 int score= distortion + score_tab[
i-
run];
4230 if(score < last_score){
4233 last_level=
level-64;
4241 score_tab[
i+1]= best_score;
4244 if(last_non_zero <= 27){
4245 for(; survivor_count; survivor_count--){
4246 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4250 for(; survivor_count; survivor_count--){
4251 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4256 survivor[ survivor_count++ ]=
i+1;
4260 last_score= 256*256*256*120;
4261 for(
i= survivor[0];
i<=last_non_zero + 1;
i++){
4262 int score= score_tab[
i];
4264 score += lambda * 2;
4266 if(score < last_score){
4269 last_level= level_tab[
i];
4270 last_run= run_tab[
i];
4275 s->coded_score[n] = last_score;
4278 last_non_zero= last_i - 1;
4279 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4281 if(last_non_zero < start_i)
4282 return last_non_zero;
4284 if(last_non_zero == 0 && start_i == 0){
4286 int best_score=
dc *
dc;
4288 for(
i=0;
i<coeff_count[0];
i++){
4291 int unquant_coeff, score, distortion;
4294 unquant_coeff= (alevel*qmul + qadd)>>3;
4296 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int) matrix[0])) >> 5;
4297 unquant_coeff = (unquant_coeff - 1) | 1;
4299 unquant_coeff = (unquant_coeff + 4) >> 3;
4300 unquant_coeff<<= 3 + 3;
4302 distortion= (unquant_coeff -
dc) * (unquant_coeff -
dc);
4305 else score= distortion + esc_length*lambda;
4307 if(score < best_score){
4309 best_level=
level - 64;
4312 block[0]= best_level;
4313 s->coded_score[n] = best_score -
dc*
dc;
4314 if(best_level == 0)
return -1;
4315 else return last_non_zero;
4321 block[ perm_scantable[last_non_zero] ]= last_level;
4324 for(;
i>start_i;
i -= run_tab[
i] + 1){
4325 block[ perm_scantable[
i-1] ]= level_tab[
i];
4328 return last_non_zero;
4343 if(
i==0)
s*= sqrt(0.5);
4344 if(j==0)
s*= sqrt(0.5);
4358 const uint8_t *perm_scantable;
4364 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4368 int rle_index,
run, q = 1, sum;
4370 if(
basis[0][0] == 0)
4376 scantable=
s->intra_scantable.scantable;
4377 perm_scantable=
s->intra_scantable.permutated;
4395 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4396 length =
s->intra_chroma_ac_vlc_length;
4397 last_length=
s->intra_chroma_ac_vlc_last_length;
4399 length =
s->intra_ac_vlc_length;
4400 last_length=
s->intra_ac_vlc_last_length;
4403 scantable=
s->inter_scantable.scantable;
4404 perm_scantable=
s->inter_scantable.permutated;
4407 length =
s->inter_ac_vlc_length;
4408 last_length=
s->inter_ac_vlc_last_length;
4410 last_non_zero =
s->block_last_index[n];
4413 for(
i=0;
i<64;
i++){
4418 for(
i=0;
i<64;
i++){
4424 w= 15 + (48*qns*one +
w/2)/
w;
4437 for(
i=start_i;
i<=last_non_zero;
i++){
4438 int j= perm_scantable[
i];
4445 run_tab[rle_index++]=
run;
4455 int best_score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0], 0);
4458 int run2, best_unquant_change=0, analyze_gradient;
4459 analyze_gradient = last_non_zero > 2 ||
s->quantizer_noise_shaping >= 3;
4461 if(analyze_gradient){
4462 for(
i=0;
i<64;
i++){
4472 int change, old_coeff;
4478 for(change=-1; change<=1; change+=2){
4479 int new_level=
level + change;
4480 int score, new_coeff;
4482 new_coeff= q*new_level;
4483 if(new_coeff >= 2048 || new_coeff < 0)
4486 score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0],
4487 new_coeff - old_coeff);
4488 if(score<best_score){
4491 best_change= change;
4492 best_unquant_change= new_coeff - old_coeff;
4499 run2= run_tab[rle_index++];
4503 for(
i=start_i;
i<64;
i++){
4504 int j= perm_scantable[
i];
4506 int change, old_coeff;
4508 if(
s->quantizer_noise_shaping < 3 &&
i > last_non_zero + 1)
4513 else old_coeff= qmul*
level + qadd;
4514 run2= run_tab[rle_index++];
4521 for(change=-1; change<=1; change+=2){
4522 int new_level=
level + change;
4523 int score, new_coeff, unquant_change;
4530 if(new_level<0) new_coeff= qmul*new_level - qadd;
4531 else new_coeff= qmul*new_level + qadd;
4532 if(new_coeff >= 2048 || new_coeff <= -2048)
4537 if(level < 63 && level > -63){
4538 if(
i < last_non_zero)
4548 if(analyze_gradient){
4549 int g= d1[ scantable[
i] ];
4550 if(
g && (
g^new_level) >= 0)
4554 if(
i < last_non_zero){
4555 int next_i=
i + run2 + 1;
4556 int next_level=
block[ perm_scantable[next_i] ] + 64;
4558 if(next_level&(~127))
4561 if(next_i < last_non_zero)
4581 if(
i < last_non_zero){
4582 int next_i=
i + run2 + 1;
4583 int next_level=
block[ perm_scantable[next_i] ] + 64;
4585 if(next_level&(~127))
4588 if(next_i < last_non_zero)
4607 unquant_change= new_coeff - old_coeff;
4608 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4610 score +=
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[j],
4612 if(score<best_score){
4615 best_change= change;
4616 best_unquant_change= unquant_change;
4620 prev_level=
level + 64;
4621 if(prev_level&(~127))
4631 int j= perm_scantable[ best_coeff ];
4633 block[j] += best_change;
4635 if(best_coeff > last_non_zero){
4636 last_non_zero= best_coeff;
4639 for(; last_non_zero>=start_i; last_non_zero--){
4640 if(
block[perm_scantable[last_non_zero]])
4647 for(
i=start_i;
i<=last_non_zero;
i++){
4648 int j= perm_scantable[
i];
4652 run_tab[rle_index++]=
run;
4659 s->mpvencdsp.add_8x8basis(rem,
basis[j], best_unquant_change);
4665 return last_non_zero;
4680 const uint8_t *scantable,
int last)
4691 for (
i = 0;
i <= last;
i++) {
4692 const int j = scantable[
i];
4697 for (
i = 0;
i <= last;
i++) {
4698 const int j = scantable[
i];
4699 const int perm_j = permutation[j];
4705 int16_t *
block,
int n,
4706 int qscale,
int *overflow)
4708 int i, j,
level, last_non_zero, q, start_i;
4713 unsigned int threshold1, threshold2;
4717 if(
s->dct_error_sum)
4721 scantable=
s->intra_scantable.scantable;
4736 qmat = n < 4 ?
s->q_intra_matrix[qscale] :
s->q_chroma_intra_matrix[qscale];
4739 scantable=
s->inter_scantable.scantable;
4742 qmat =
s->q_inter_matrix[qscale];
4746 threshold2= (threshold1<<1);
4747 for(
i=63;
i>=start_i;
i--) {
4751 if(((
unsigned)(
level+threshold1))>threshold2){
4758 for(
i=start_i;
i<=last_non_zero;
i++) {
4764 if(((
unsigned)(
level+threshold1))>threshold2){
4777 *overflow=
s->max_qcoeff <
max;
4782 scantable, last_non_zero);
4784 return last_non_zero;
4787 #define OFFSET(x) offsetof(MpegEncContext, x)
4788 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4791 {
"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 },
4821 {
"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},
4855 .
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 AV_CEIL_RSHIFT(a, b)
#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)