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 ||
584 ((avctx->
width &3) ||
591 (avctx->
width > 4095 ||
598 (avctx->
width > 16383 ||
599 avctx->
height > 16383 )) {
600 av_log(avctx,
AV_LOG_ERROR,
"MPEG-2 does not support resolutions above 16383x16383\n");
631 #if FF_API_PRIVATE_OPT
642 "mpeg2 style quantization not supported by codec\n");
662 "QP RD is no longer compatible with MJPEG or AMV\n");
666 #if FF_API_PRIVATE_OPT
673 if (
s->scenechange_threshold < 1000000000 &&
676 "closed gop with scene change detection are not supported yet, "
677 "set threshold to 1000000000\n");
685 "low delay forcing is only available for mpeg2, "
686 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
689 if (
s->max_b_frames != 0) {
691 "B-frames cannot be used with low delay\n");
696 if (
s->q_scale_type == 1) {
697 if (avctx->
qmax > 28) {
699 "non linear quant only supports qmax <= 28 currently\n");
717 "multi threaded encoding not supported by codec\n");
723 "automatic thread number detection not supported by codec, "
733 #if FF_API_PRIVATE_OPT
744 "notice: b_frame_strategy only affects the first pass\n");
745 s->b_frame_strategy = 0;
759 s->inter_quant_bias = 0;
761 s->intra_quant_bias = 0;
767 av_log(avctx,
AV_LOG_ERROR,
"qmin and or qmax are invalid, they must be 0 < min <= max\n");
771 av_log(avctx,
AV_LOG_DEBUG,
"intra_quant_bias = %d inter_quant_bias = %d\n",
s->intra_quant_bias,
s->inter_quant_bias);
776 "timebase %d/%d not supported by MPEG 4 standard, "
777 "the maximum admitted value for the timebase denominator "
788 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
793 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
822 "The specified picture size of %dx%d is not valid for the "
823 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
824 s->width,
s->height);
836 s->width,
s->height) == 8) {
838 "The specified picture size of %dx%d is not valid for "
839 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
840 "352x288, 704x576, and 1408x1152. "
841 "Try H.263+.\n",
s->width,
s->height);
853 s->modified_quant =
s->h263_aic;
855 s->unrestricted_mv =
s->obmc ||
s->loop_filter ||
s->umvplus;
865 s->unrestricted_mv = 1;
879 s->modified_quant = 1;
883 s->unrestricted_mv = 0;
888 s->unrestricted_mv = 1;
889 s->low_delay =
s->max_b_frames ? 0 : 1;
890 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
895 s->unrestricted_mv = 1;
896 s->msmpeg4_version = 2;
903 s->unrestricted_mv = 1;
904 s->msmpeg4_version = 3;
905 s->flipflop_rounding = 1;
912 s->unrestricted_mv = 1;
913 s->msmpeg4_version = 4;
914 s->flipflop_rounding = 1;
921 s->unrestricted_mv = 1;
922 s->msmpeg4_version = 5;
923 s->flipflop_rounding = 1;
931 #if FF_API_PRIVATE_OPT
942 s->progressive_frame =
958 if (
s->msmpeg4_version) {
975 if (
s->noise_reduction) {
985 if (
s->slice_context_count > 1) {
989 s->h263_slice_structured = 1;
992 s->quant_precision = 5;
994 #if FF_API_PRIVATE_OPT
1008 ff_set_cmp(&
s->mecc,
s->mecc.frame_skip_cmp,
s->frame_skip_cmp);
1021 for (
i = 0;
i < 64;
i++) {
1022 int j =
s->idsp.idct_permutation[
i];
1028 s->intra_matrix[j] =
1031 s->intra_matrix[j] =
1035 s->chroma_intra_matrix[j] =
1049 s->intra_matrix,
s->intra_quant_bias, avctx->
qmin,
1052 s->inter_matrix,
s->inter_quant_bias, avctx->
qmin,
1059 #if FF_API_PRIVATE_OPT
1069 if (
s->b_frame_strategy == 2) {
1070 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1072 if (!
s->tmp_frames[
i])
1076 s->tmp_frames[
i]->width =
s->width >>
s->brd_scale;
1077 s->tmp_frames[
i]->height =
s->height >>
s->brd_scale;
1119 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
1120 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
1121 s->q_chroma_intra_matrix=
NULL;
1122 s->q_chroma_intra_matrix16=
NULL;
1139 for (y = 0; y < 16; y++) {
1140 for (x = 0; x < 16; x++) {
1155 h =
s->height & ~15;
1157 for (y = 0; y <
h; y += 16) {
1158 for (x = 0; x <
w; x += 16) {
1165 acc += sae + 500 < sad;
1174 s->chroma_x_shift,
s->chroma_y_shift,
s->out_format,
1175 s->mb_stride,
s->mb_width,
s->mb_height,
s->b8_stride,
1176 &
s->linesize, &
s->uvlinesize);
1183 int i, display_picture_number = 0, ret;
1184 int encoding_delay =
s->max_b_frames ?
s->max_b_frames
1185 : (
s->low_delay ? 0 : 1);
1186 int flush_offset = 1;
1191 display_picture_number =
s->input_picture_number++;
1195 int64_t last =
s->user_specified_pts;
1199 "Invalid pts (%"PRId64
") <= last (%"PRId64
")\n",
1204 if (!
s->low_delay && display_picture_number == 1)
1205 s->dts_delta =
pts - last;
1207 s->user_specified_pts =
pts;
1210 s->user_specified_pts =
1211 pts =
s->user_specified_pts + 1;
1213 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
1216 pts = display_picture_number;
1220 if (!pic_arg->
buf[0] ||
1222 pic_arg->
linesize[1] !=
s->uvlinesize ||
1225 if ((
s->width & 15) || (
s->height & 15))
1233 pic_arg->
linesize[1],
s->linesize,
s->uvlinesize);
1239 pic = &
s->picture[
i];
1256 int h_chroma_shift, v_chroma_shift;
1261 for (
i = 0;
i < 3;
i++) {
1262 ptrdiff_t src_stride = pic_arg->
linesize[
i];
1263 ptrdiff_t dst_stride =
i ?
s->uvlinesize :
s->linesize;
1264 int h_shift =
i ? h_chroma_shift : 0;
1265 int v_shift =
i ? v_chroma_shift : 0;
1273 && !
s->progressive_sequence
1274 &&
FFALIGN(
s->height, 32) -
s->height > 16)
1277 if (!
s->avctx->rc_buffer_size)
1280 if (src_stride == dst_stride)
1281 memcpy(dst,
src, src_stride *
h - src_stride +
w);
1286 memcpy(dst2,
src,
w);
1291 if ((
s->width & 15) || (
s->height & (vpad-1))) {
1292 s->mpvencdsp.draw_edges(dst, dst_stride,
1311 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1312 if (
s->input_picture[flush_offset])
1315 if (flush_offset <= 1)
1318 encoding_delay = encoding_delay - flush_offset + 1;
1323 s->input_picture[
i - flush_offset] =
s->input_picture[
i];
1325 s->input_picture[
i] =
NULL;
1327 s->input_picture[encoding_delay] = (
Picture*) pic;
1338 for (plane = 0; plane < 3; plane++) {
1340 const int bw = plane ? 1 : 2;
1341 for (y = 0; y <
s->mb_height * bw; y++) {
1342 for (x = 0; x <
s->mb_width * bw; x++) {
1343 int off = p->
shared ? 0 : 16;
1346 int v =
s->mecc.frame_skip_cmp[1](
s, dptr, rptr,
stride, 8);
1348 switch (
FFABS(
s->frame_skip_exp)) {
1349 case 0: score =
FFMAX(score, v);
break;
1350 case 1: score +=
FFABS(v);
break;
1351 case 2: score64 += v * (
int64_t)v;
break;
1362 if (
s->frame_skip_exp < 0)
1363 score64 = pow(score64 / (
double)(
s->mb_width *
s->mb_height),
1364 -1.0/
s->frame_skip_exp);
1366 if (score64 < s->frame_skip_threshold)
1368 if (score64 < ((
s->frame_skip_factor * (
int64_t)
s->lambda) >> 8))
1398 const int scale =
s->brd_scale;
1399 int width =
s->width >> scale;
1400 int height =
s->height >> scale;
1401 int i, j,
out_size, p_lambda, b_lambda, lambda2;
1403 int best_b_count = -1;
1418 b_lambda = p_lambda;
1422 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1423 Picture pre_input, *pre_input_ptr =
i ?
s->input_picture[
i - 1] :
1424 s->next_picture_ptr;
1427 if (pre_input_ptr && (!
i ||
s->input_picture[
i - 1])) {
1428 pre_input = *pre_input_ptr;
1437 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[0],
1438 s->tmp_frames[
i]->linesize[0],
1442 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[1],
1443 s->tmp_frames[
i]->linesize[1],
1447 s->mpvencdsp.shrink[scale](
s->tmp_frames[
i]->data[2],
1448 s->tmp_frames[
i]->linesize[2],
1455 for (j = 0; j <
s->max_b_frames + 1; j++) {
1459 if (!
s->input_picture[j])
1472 c->mb_decision =
s->avctx->mb_decision;
1473 c->me_cmp =
s->avctx->me_cmp;
1474 c->mb_cmp =
s->avctx->mb_cmp;
1475 c->me_sub_cmp =
s->avctx->me_sub_cmp;
1477 c->time_base =
s->avctx->time_base;
1478 c->max_b_frames =
s->max_b_frames;
1496 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1497 int is_p =
i % (j + 1) == j ||
i ==
s->max_b_frames;
1499 s->tmp_frames[
i + 1]->pict_type = is_p ?
1501 s->tmp_frames[
i + 1]->quality = is_p ? p_lambda : b_lambda;
1520 rd +=
c->error[0] +
c->error[1] +
c->error[2];
1538 return best_b_count;
1546 s->reordered_input_picture[
i - 1] =
s->reordered_input_picture[
i];
1550 if (!
s->reordered_input_picture[0] &&
s->input_picture[0]) {
1551 if (
s->frame_skip_threshold ||
s->frame_skip_factor) {
1552 if (
s->picture_in_gop_number <
s->gop_size &&
1553 s->next_picture_ptr &&
1565 !
s->next_picture_ptr ||
s->intra_only) {
1566 s->reordered_input_picture[0] =
s->input_picture[0];
1568 s->reordered_input_picture[0]->f->coded_picture_number =
1569 s->coded_picture_number++;
1574 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1575 int pict_num =
s->input_picture[0]->f->display_picture_number +
i;
1577 if (pict_num >=
s->rc_context.num_entries)
1579 if (!
s->input_picture[
i]) {
1584 s->input_picture[
i]->f->pict_type =
1585 s->rc_context.entry[pict_num].new_pict_type;
1589 if (
s->b_frame_strategy == 0) {
1590 b_frames =
s->max_b_frames;
1591 while (b_frames && !
s->input_picture[b_frames])
1593 }
else if (
s->b_frame_strategy == 1) {
1594 for (
i = 1;
i <
s->max_b_frames + 1;
i++) {
1595 if (
s->input_picture[
i] &&
1596 s->input_picture[
i]->b_frame_score == 0) {
1597 s->input_picture[
i]->b_frame_score =
1599 s->input_picture[
i ]->f->data[0],
1600 s->input_picture[
i - 1]->f->data[0],
1604 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1605 if (!
s->input_picture[
i] ||
1606 s->input_picture[
i]->b_frame_score - 1 >
1607 s->mb_num /
s->b_sensitivity)
1611 b_frames =
FFMAX(0,
i - 1);
1614 for (
i = 0;
i < b_frames + 1;
i++) {
1615 s->input_picture[
i]->b_frame_score = 0;
1617 }
else if (
s->b_frame_strategy == 2) {
1625 for (
i = b_frames - 1;
i >= 0;
i--) {
1626 int type =
s->input_picture[
i]->f->pict_type;
1631 b_frames ==
s->max_b_frames) {
1633 "warning, too many B-frames in a row\n");
1636 if (
s->picture_in_gop_number + b_frames >=
s->gop_size) {
1638 s->gop_size >
s->picture_in_gop_number) {
1639 b_frames =
s->gop_size -
s->picture_in_gop_number - 1;
1651 s->reordered_input_picture[0] =
s->input_picture[b_frames];
1654 s->reordered_input_picture[0]->f->coded_picture_number =
1655 s->coded_picture_number++;
1656 for (
i = 0;
i < b_frames;
i++) {
1657 s->reordered_input_picture[
i + 1] =
s->input_picture[
i];
1658 s->reordered_input_picture[
i + 1]->f->pict_type =
1660 s->reordered_input_picture[
i + 1]->f->coded_picture_number =
1661 s->coded_picture_number++;
1668 if (
s->reordered_input_picture[0]) {
1669 s->reordered_input_picture[0]->reference =
1670 s->reordered_input_picture[0]->f->pict_type !=
1676 if (
s->reordered_input_picture[0]->shared ||
s->avctx->rc_buffer_size) {
1684 pic = &
s->picture[
i];
1686 pic->
reference =
s->reordered_input_picture[0]->reference;
1697 s->reordered_input_picture[0]->shared = 0;
1699 s->current_picture_ptr = pic;
1702 s->current_picture_ptr =
s->reordered_input_picture[0];
1703 for (
i = 0;
i < 4;
i++) {
1704 if (
s->new_picture.f->data[
i])
1710 s->current_picture_ptr)) < 0)
1713 s->picture_number =
s->new_picture.f->display_picture_number;
1720 if (
s->unrestricted_mv &&
1721 s->current_picture.reference &&
1724 int hshift =
desc->log2_chroma_w;
1725 int vshift =
desc->log2_chroma_h;
1726 s->mpvencdsp.draw_edges(
s->current_picture.f->data[0],
1727 s->current_picture.f->linesize[0],
1728 s->h_edge_pos,
s->v_edge_pos,
1731 s->mpvencdsp.draw_edges(
s->current_picture.f->data[1],
1732 s->current_picture.f->linesize[1],
1733 s->h_edge_pos >> hshift,
1734 s->v_edge_pos >> vshift,
1738 s->mpvencdsp.draw_edges(
s->current_picture.f->data[2],
1739 s->current_picture.f->linesize[2],
1740 s->h_edge_pos >> hshift,
1741 s->v_edge_pos >> vshift,
1749 s->last_pict_type =
s->pict_type;
1750 s->last_lambda_for [
s->pict_type] =
s->current_picture_ptr->f->quality;
1752 s->last_non_b_pict_type =
s->pict_type;
1754 #if FF_API_CODED_FRAME
1760 #if FF_API_ERROR_FRAME
1762 memcpy(
s->current_picture.f->error,
s->current_picture.encoding_error,
1763 sizeof(
s->current_picture.encoding_error));
1772 for (intra = 0; intra < 2; intra++) {
1773 if (
s->dct_count[intra] > (1 << 16)) {
1774 for (
i = 0;
i < 64;
i++) {
1775 s->dct_error_sum[intra][
i] >>= 1;
1777 s->dct_count[intra] >>= 1;
1780 for (
i = 0;
i < 64;
i++) {
1781 s->dct_offset[intra][
i] = (
s->noise_reduction *
1782 s->dct_count[intra] +
1783 s->dct_error_sum[intra][
i] / 2) /
1784 (
s->dct_error_sum[intra][
i] + 1);
1795 s->last_picture_ptr !=
s->next_picture_ptr &&
1796 s->last_picture_ptr->f->buf[0]) {
1800 s->current_picture_ptr->f->pict_type =
s->pict_type;
1805 s->current_picture_ptr)) < 0)
1809 s->last_picture_ptr =
s->next_picture_ptr;
1811 s->next_picture_ptr =
s->current_picture_ptr;
1814 if (
s->last_picture_ptr) {
1816 if (
s->last_picture_ptr->f->buf[0] &&
1818 s->last_picture_ptr)) < 0)
1821 if (
s->next_picture_ptr) {
1823 if (
s->next_picture_ptr->f->buf[0] &&
1825 s->next_picture_ptr)) < 0)
1831 for (
i = 0;
i < 4;
i++) {
1833 s->current_picture.f->data[
i] +=
1834 s->current_picture.f->linesize[
i];
1836 s->current_picture.f->linesize[
i] *= 2;
1837 s->last_picture.f->linesize[
i] *= 2;
1838 s->next_picture.f->linesize[
i] *= 2;
1843 s->dct_unquantize_intra =
s->dct_unquantize_mpeg2_intra;
1844 s->dct_unquantize_inter =
s->dct_unquantize_mpeg2_inter;
1846 s->dct_unquantize_intra =
s->dct_unquantize_h263_intra;
1847 s->dct_unquantize_inter =
s->dct_unquantize_h263_inter;
1849 s->dct_unquantize_intra =
s->dct_unquantize_mpeg1_intra;
1850 s->dct_unquantize_inter =
s->dct_unquantize_mpeg1_inter;
1853 if (
s->dct_error_sum) {
1862 const AVFrame *pic_arg,
int *got_packet)
1865 int i, stuffing_count, ret;
1866 int context_count =
s->slice_context_count;
1868 s->vbv_ignore_qmax = 0;
1870 s->picture_in_gop_number++;
1880 if (
s->new_picture.f->data[0]) {
1881 int growing_buffer = context_count == 1 && !
pkt->
data && !
s->data_partitioning;
1890 s->mb_width*
s->mb_height*12);
1891 s->prev_mb_info =
s->last_mb_info =
s->mb_info_size = 0;
1894 for (
i = 0;
i < context_count;
i++) {
1895 int start_y =
s->thread_context[
i]->start_mb_y;
1896 int end_y =
s->thread_context[
i]-> end_mb_y;
1897 int h =
s->mb_height;
1904 s->pict_type =
s->new_picture.f->pict_type;
1911 if (growing_buffer) {
1919 #if FF_API_STAT_BITS
1928 avctx->
p_count =
s->mb_num -
s->i_count -
s->skip_count;
1945 s->lambda <
s->lmax) {
1946 s->next_lambda =
FFMAX(
s->lambda + min_step,
s->lambda *
1947 (
s->qscale + 1) /
s->qscale);
1948 if (
s->adaptive_quant) {
1950 for (
i = 0;
i <
s->mb_height *
s->mb_stride;
i++)
1951 s->lambda_table[
i] =
1952 FFMAX(
s->lambda_table[
i] + min_step,
1953 s->lambda_table[
i] * (
s->qscale + 1) /
1959 if (
s->flipflop_rounding ||
1962 s->no_rounding ^= 1;
1965 s->time_base =
s->last_time_base;
1966 s->last_non_b_time =
s->time -
s->pp_time;
1968 for (
i = 0;
i < context_count;
i++) {
1972 s->vbv_ignore_qmax = 1;
1983 for (
i = 0;
i < 4;
i++) {
1984 s->current_picture_ptr->encoding_error[
i] =
s->current_picture.encoding_error[
i];
1985 avctx->
error[
i] +=
s->current_picture_ptr->encoding_error[
i];
1988 s->current_picture_ptr->encoding_error,
1994 s->misc_bits +
s->i_tex_bits +
2000 s->stuffing_bits = 8*stuffing_count;
2001 if (stuffing_count) {
2003 stuffing_count + 50) {
2008 switch (
s->codec_id) {
2011 while (stuffing_count--) {
2018 stuffing_count -= 4;
2019 while (stuffing_count--) {
2025 s->stuffing_bits = 0;
2040 int vbv_delay, min_delay;
2043 int minbits =
s->frame_bits - 8 *
2044 (
s->vbv_delay_ptr -
s->pb.buf - 1);
2045 double bits =
s->rc_context.buffer_index + minbits - inbits;
2049 "Internal error, negative bits\n");
2054 min_delay = (minbits * 90000LL + avctx->
rc_max_rate - 1) /
2057 vbv_delay =
FFMAX(vbv_delay, min_delay);
2061 s->vbv_delay_ptr[0] &= 0xF8;
2062 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2063 s->vbv_delay_ptr[1] = vbv_delay >> 5;
2064 s->vbv_delay_ptr[2] &= 0x07;
2065 s->vbv_delay_ptr[2] |= vbv_delay << 3;
2079 #if FF_API_VBV_DELAY
2085 s->total_bits +=
s->frame_bits;
2086 #if FF_API_STAT_BITS
2093 pkt->
pts =
s->current_picture.f->pts;
2095 if (!
s->current_picture.f->coded_picture_number)
2102 if (
s->current_picture.f->key_frame)
2112 if (!
s->picture[
i].reference)
2124 int n,
int threshold)
2126 static const char tab[64] = {
2127 3, 2, 2, 1, 1, 1, 1, 1,
2128 1, 1, 1, 1, 1, 1, 1, 1,
2129 1, 1, 1, 1, 1, 1, 1, 1,
2130 0, 0, 0, 0, 0, 0, 0, 0,
2131 0, 0, 0, 0, 0, 0, 0, 0,
2132 0, 0, 0, 0, 0, 0, 0, 0,
2133 0, 0, 0, 0, 0, 0, 0, 0,
2134 0, 0, 0, 0, 0, 0, 0, 0
2139 int16_t *
block =
s->block[n];
2140 const int last_index =
s->block_last_index[n];
2143 if (threshold < 0) {
2145 threshold = -threshold;
2150 if (last_index <= skip_dc - 1)
2153 for (
i = 0;
i <= last_index;
i++) {
2154 const int j =
s->intra_scantable.permutated[
i];
2157 if (skip_dc &&
i == 0)
2161 }
else if (
level > 1) {
2167 if (score >= threshold)
2169 for (
i = skip_dc;
i <= last_index;
i++) {
2170 const int j =
s->intra_scantable.permutated[
i];
2174 s->block_last_index[n] = 0;
2176 s->block_last_index[n] = -1;
2183 const int maxlevel =
s->max_qcoeff;
2184 const int minlevel =
s->min_qcoeff;
2192 for (;
i <= last_index;
i++) {
2193 const int j =
s->intra_scantable.permutated[
i];
2196 if (
level > maxlevel) {
2199 }
else if (
level < minlevel) {
2209 "warning, clipping %d dct coefficients to %d..%d\n",
2210 overflow, minlevel, maxlevel);
2217 for (y = 0; y < 8; y++) {
2218 for (x = 0; x < 8; x++) {
2224 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
2225 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
2226 int v = ptr[x2 + y2 *
stride];
2232 weight[x + 8 * y]= (36 *
ff_sqrt(count * sqr - sum * sum)) / count;
2238 int motion_x,
int motion_y,
2239 int mb_block_height,
2244 int16_t orig[12][64];
2245 const int mb_x =
s->mb_x;
2246 const int mb_y =
s->mb_y;
2249 int dct_offset =
s->linesize * 8;
2250 int uv_dct_offset =
s->uvlinesize * 8;
2251 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2252 ptrdiff_t wrap_y, wrap_c;
2254 for (
i = 0;
i < mb_block_count;
i++)
2255 skip_dct[
i] =
s->skipdct;
2257 if (
s->adaptive_quant) {
2258 const int last_qp =
s->qscale;
2259 const int mb_xy = mb_x + mb_y *
s->mb_stride;
2261 s->lambda =
s->lambda_table[mb_xy];
2265 s->qscale =
s->current_picture_ptr->qscale_table[mb_xy];
2266 s->dquant =
s->qscale - last_qp;
2287 wrap_y =
s->linesize;
2288 wrap_c =
s->uvlinesize;
2289 ptr_y =
s->new_picture.f->data[0] +
2290 (mb_y * 16 * wrap_y) + mb_x * 16;
2291 ptr_cb =
s->new_picture.f->data[1] +
2292 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2293 ptr_cr =
s->new_picture.f->data[2] +
2294 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2296 if((mb_x * 16 + 16 >
s->width || mb_y * 16 + 16 >
s->height) &&
s->codec_id !=
AV_CODEC_ID_AMV){
2297 uint8_t *ebuf =
s->sc.edge_emu_buffer + 38 * wrap_y;
2298 int cw = (
s->width +
s->chroma_x_shift) >>
s->chroma_x_shift;
2299 int ch = (
s->height +
s->chroma_y_shift) >>
s->chroma_y_shift;
2300 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2302 16, 16, mb_x * 16, mb_y * 16,
2303 s->width,
s->height);
2305 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2307 mb_block_width, mb_block_height,
2308 mb_x * mb_block_width, mb_y * mb_block_height,
2310 ptr_cb = ebuf + 16 * wrap_y;
2311 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2313 mb_block_width, mb_block_height,
2314 mb_x * mb_block_width, mb_y * mb_block_height,
2316 ptr_cr = ebuf + 16 * wrap_y + 16;
2321 int progressive_score, interlaced_score;
2323 s->interlaced_dct = 0;
2324 progressive_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
NULL, wrap_y, 8) +
2325 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y * 8,
2326 NULL, wrap_y, 8) - 400;
2328 if (progressive_score > 0) {
2329 interlaced_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
2330 NULL, wrap_y * 2, 8) +
2331 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y,
2332 NULL, wrap_y * 2, 8);
2333 if (progressive_score > interlaced_score) {
2334 s->interlaced_dct = 1;
2336 dct_offset = wrap_y;
2337 uv_dct_offset = wrap_c;
2346 s->pdsp.get_pixels(
s->block[0], ptr_y, wrap_y);
2347 s->pdsp.get_pixels(
s->block[1], ptr_y + 8, wrap_y);
2348 s->pdsp.get_pixels(
s->block[2], ptr_y + dct_offset, wrap_y);
2349 s->pdsp.get_pixels(
s->block[3], ptr_y + dct_offset + 8, wrap_y);
2355 s->pdsp.get_pixels(
s->block[4], ptr_cb, wrap_c);
2356 s->pdsp.get_pixels(
s->block[5], ptr_cr, wrap_c);
2357 if (!
s->chroma_y_shift &&
s->chroma_x_shift) {
2358 s->pdsp.get_pixels(
s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2359 s->pdsp.get_pixels(
s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2360 }
else if (!
s->chroma_y_shift && !
s->chroma_x_shift) {
2361 s->pdsp.get_pixels(
s->block[ 6], ptr_cb + 8, wrap_c);
2362 s->pdsp.get_pixels(
s->block[ 7], ptr_cr + 8, wrap_c);
2363 s->pdsp.get_pixels(
s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2364 s->pdsp.get_pixels(
s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2365 s->pdsp.get_pixels(
s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2366 s->pdsp.get_pixels(
s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2372 uint8_t *dest_y, *dest_cb, *dest_cr;
2374 dest_y =
s->dest[0];
2375 dest_cb =
s->dest[1];
2376 dest_cr =
s->dest[2];
2379 op_pix =
s->hdsp.put_pixels_tab;
2380 op_qpix =
s->qdsp.put_qpel_pixels_tab;
2382 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
2383 op_qpix =
s->qdsp.put_no_rnd_qpel_pixels_tab;
2388 s->last_picture.f->data,
2390 op_pix =
s->hdsp.avg_pixels_tab;
2391 op_qpix =
s->qdsp.avg_qpel_pixels_tab;
2395 s->next_picture.f->data,
2400 int progressive_score, interlaced_score;
2402 s->interlaced_dct = 0;
2403 progressive_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y, wrap_y, 8) +
2404 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y * 8,
2409 progressive_score -= 400;
2411 if (progressive_score > 0) {
2412 interlaced_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y,
2414 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y,
2418 if (progressive_score > interlaced_score) {
2419 s->interlaced_dct = 1;
2421 dct_offset = wrap_y;
2422 uv_dct_offset = wrap_c;
2430 s->pdsp.diff_pixels(
s->block[0], ptr_y, dest_y, wrap_y);
2431 s->pdsp.diff_pixels(
s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2432 s->pdsp.diff_pixels(
s->block[2], ptr_y + dct_offset,
2433 dest_y + dct_offset, wrap_y);
2434 s->pdsp.diff_pixels(
s->block[3], ptr_y + dct_offset + 8,
2435 dest_y + dct_offset + 8, wrap_y);
2441 s->pdsp.diff_pixels(
s->block[4], ptr_cb, dest_cb, wrap_c);
2442 s->pdsp.diff_pixels(
s->block[5], ptr_cr, dest_cr, wrap_c);
2443 if (!
s->chroma_y_shift) {
2444 s->pdsp.diff_pixels(
s->block[6], ptr_cb + uv_dct_offset,
2445 dest_cb + uv_dct_offset, wrap_c);
2446 s->pdsp.diff_pixels(
s->block[7], ptr_cr + uv_dct_offset,
2447 dest_cr + uv_dct_offset, wrap_c);
2451 if (
s->current_picture.mc_mb_var[
s->mb_stride * mb_y + mb_x] <
2452 2 *
s->qscale *
s->qscale) {
2454 if (
s->mecc.sad[1](
NULL, ptr_y, dest_y, wrap_y, 8) < 20 *
s->qscale)
2456 if (
s->mecc.sad[1](
NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 *
s->qscale)
2458 if (
s->mecc.sad[1](
NULL, ptr_y + dct_offset, dest_y + dct_offset,
2459 wrap_y, 8) < 20 *
s->qscale)
2461 if (
s->mecc.sad[1](
NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2462 wrap_y, 8) < 20 *
s->qscale)
2464 if (
s->mecc.sad[1](
NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 *
s->qscale)
2466 if (
s->mecc.sad[1](
NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 *
s->qscale)
2468 if (!
s->chroma_y_shift) {
2469 if (
s->mecc.sad[1](
NULL, ptr_cb + uv_dct_offset,
2470 dest_cb + uv_dct_offset,
2471 wrap_c, 8) < 20 *
s->qscale)
2473 if (
s->mecc.sad[1](
NULL, ptr_cr + uv_dct_offset,
2474 dest_cr + uv_dct_offset,
2475 wrap_c, 8) < 20 *
s->qscale)
2481 if (
s->quantizer_noise_shaping) {
2494 if (!
s->chroma_y_shift) {
2502 memcpy(orig[0],
s->block[0],
sizeof(int16_t) * 64 * mb_block_count);
2508 for (
i = 0;
i < mb_block_count;
i++) {
2511 s->block_last_index[
i] =
s->dct_quantize(
s,
s->block[
i],
i,
s->qscale, &overflow);
2520 s->block_last_index[
i] = -1;
2522 if (
s->quantizer_noise_shaping) {
2523 for (
i = 0;
i < mb_block_count;
i++) {
2525 s->block_last_index[
i] =
2527 orig[
i],
i,
s->qscale);
2532 if (
s->luma_elim_threshold && !
s->mb_intra)
2533 for (
i = 0;
i < 4;
i++)
2535 if (
s->chroma_elim_threshold && !
s->mb_intra)
2536 for (
i = 4;
i < mb_block_count;
i++)
2540 for (
i = 0;
i < mb_block_count;
i++) {
2541 if (
s->block_last_index[
i] == -1)
2542 s->coded_score[
i] = INT_MAX / 256;
2548 s->block_last_index[4] =
2549 s->block_last_index[5] = 0;
2551 s->block[5][0] = (1024 +
s->c_dc_scale / 2) /
s->c_dc_scale;
2552 if (!
s->chroma_y_shift) {
2553 for (
i=6;
i<12;
i++) {
2554 s->block_last_index[
i] = 0;
2555 s->block[
i][0] =
s->block[4][0];
2562 for (
i = 0;
i < mb_block_count;
i++) {
2564 if (
s->block_last_index[
i] > 0) {
2565 for (j = 63; j > 0; j--) {
2566 if (
s->block[
i][
s->intra_scantable.permutated[j]])
2569 s->block_last_index[
i] = j;
2575 switch(
s->codec_id){
2631 memcpy(d->
last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2659 memcpy(d->
mv,
s->mv, 2*4*2*
sizeof(
int));
2660 memcpy(d->
last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2682 if(
s->data_partitioning){
2697 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2704 s->block=
s->blocks[*next_block];
2705 s->pb= pb[*next_block];
2706 if(
s->data_partitioning){
2707 s->pb2 = pb2 [*next_block];
2708 s->tex_pb= tex_pb[*next_block];
2712 memcpy(dest_backup,
s->dest,
sizeof(
s->dest));
2713 s->dest[0] =
s->sc.rd_scratchpad;
2714 s->dest[1] =
s->sc.rd_scratchpad + 16*
s->linesize;
2715 s->dest[2] =
s->sc.rd_scratchpad + 16*
s->linesize + 8;
2722 if(
s->data_partitioning){
2730 score *=
s->lambda2;
2735 memcpy(
s->dest, dest_backup,
sizeof(
s->dest));
2753 else if(
w==8 &&
h==8)
2771 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
2772 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
2776 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) +
2777 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) +
2778 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);
2780 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) +
2781 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) +
2782 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);
2785 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)
2786 +
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)
2787 +
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);
2795 s->me.dia_size=
s->avctx->pre_dia_size;
2796 s->first_slice_line=1;
2797 for(
s->mb_y=
s->end_mb_y-1;
s->mb_y >=
s->start_mb_y;
s->mb_y--) {
2798 for(
s->mb_x=
s->mb_width-1;
s->mb_x >=0 ;
s->mb_x--) {
2801 s->first_slice_line=0;
2812 s->me.dia_size=
s->avctx->dia_size;
2813 s->first_slice_line=1;
2814 for(
s->mb_y=
s->start_mb_y;
s->mb_y <
s->end_mb_y;
s->mb_y++) {
2817 for(
s->mb_x=0;
s->mb_x <
s->mb_width;
s->mb_x++) {
2818 s->block_index[0]+=2;
2819 s->block_index[1]+=2;
2820 s->block_index[2]+=2;
2821 s->block_index[3]+=2;
2829 s->first_slice_line=0;
2838 for(mb_y=
s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2839 for(mb_x=0; mb_x <
s->mb_width; mb_x++) {
2842 uint8_t *pix =
s->new_picture.f->data[0] + (yy *
s->linesize) + xx;
2844 int sum =
s->mpvencdsp.pix_sum(pix,
s->linesize);
2846 varc = (
s->mpvencdsp.pix_norm1(pix,
s->linesize) -
2847 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2849 s->current_picture.mb_var [
s->mb_stride * mb_y + mb_x] = varc;
2850 s->current_picture.mb_mean[
s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2851 s->me.mb_var_sum_temp += varc;
2859 if(
s->partitioned_frame){
2878 uint8_t *ptr =
s->mb_info_ptr +
s->mb_info_size - 12;
2880 int mba =
s->mb_x +
s->mb_width * (
s->mb_y %
s->gob_index);
2881 int gobn =
s->mb_y /
s->gob_index;
2885 bytestream_put_le32(&ptr,
offset);
2886 bytestream_put_byte(&ptr,
s->qscale);
2887 bytestream_put_byte(&ptr, gobn);
2888 bytestream_put_le16(&ptr, mba);
2889 bytestream_put_byte(&ptr, pred_x);
2890 bytestream_put_byte(&ptr, pred_y);
2892 bytestream_put_byte(&ptr, 0);
2893 bytestream_put_byte(&ptr, 0);
2901 s->mb_info_size += 12;
2902 s->prev_mb_info =
s->last_mb_info;
2914 if (!
s->mb_info_size)
2915 s->mb_info_size += 12;
2922 &&
s->slice_context_count == 1
2923 &&
s->pb.buf ==
s->avctx->internal->byte_buffer) {
2924 int lastgob_pos =
s->ptr_lastgob -
s->pb.buf;
2925 int vbv_pos =
s->vbv_delay_ptr -
s->pb.buf;
2928 int new_buffer_size = 0;
2930 if ((
s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2938 s->avctx->internal->byte_buffer_size + size_increase);
2942 memcpy(new_buffer,
s->avctx->internal->byte_buffer,
s->avctx->internal->byte_buffer_size);
2943 av_free(
s->avctx->internal->byte_buffer);
2944 s->avctx->internal->byte_buffer = new_buffer;
2945 s->avctx->internal->byte_buffer_size = new_buffer_size;
2947 s->ptr_lastgob =
s->pb.buf + lastgob_pos;
2948 s->vbv_delay_ptr =
s->pb.buf + vbv_pos;
2957 int mb_x, mb_y, mb_y_order;
2958 int chr_h= 16>>
s->chroma_y_shift;
2985 s->last_dc[
i] = 128 <<
s->intra_dc_precision;
2987 s->current_picture.encoding_error[
i] = 0;
2990 s->last_dc[0] = 128*8/13;
2991 s->last_dc[1] = 128*8/14;
2992 s->last_dc[2] = 128*8/14;
2995 memset(
s->last_mv, 0,
sizeof(
s->last_mv));
2999 switch(
s->codec_id){
3014 s->first_slice_line = 1;
3015 s->ptr_lastgob =
s->pb.buf;
3016 for (mb_y_order =
s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3020 if (first_in_slice && mb_y_order !=
s->start_mb_y)
3022 s->last_dc[0] =
s->last_dc[1] =
s->last_dc[2] = 1024 <<
s->intra_dc_precision;
3032 for(mb_x=0; mb_x <
s->mb_width; mb_x++) {
3033 int xy= mb_y*
s->mb_stride + mb_x;
3034 int mb_type=
s->mb_type[xy];
3038 int size_increase =
s->avctx->internal->byte_buffer_size/4
3046 if(
s->data_partitioning){
3060 xy=
s->mb_y*
s->mb_stride +
s->mb_x;
3061 mb_type=
s->mb_type[xy];
3066 int current_packet_size, is_gob_start;
3068 current_packet_size= ((
put_bits_count(&
s->pb)+7)>>3) - (
s->ptr_lastgob -
s->pb.buf);
3070 is_gob_start =
s->rtp_payload_size &&
3071 current_packet_size >=
s->rtp_payload_size &&
3074 if(
s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3076 switch(
s->codec_id){
3079 if(!
s->h263_slice_structured)
3080 if(
s->mb_x ||
s->mb_y%
s->gob_index) is_gob_start=0;
3083 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3085 if(
s->mb_skip_run) is_gob_start=0;
3088 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3093 if(
s->start_mb_y != mb_y || mb_x!=0){
3104 if (
s->error_rate &&
s->resync_mb_x +
s->resync_mb_y > 0) {
3106 int d = 100 /
s->error_rate;
3108 current_packet_size=0;
3109 s->pb.buf_ptr=
s->ptr_lastgob;
3114 #if FF_API_RTP_CALLBACK
3116 if (
s->avctx->rtp_callback){
3117 int number_mb = (mb_y -
s->resync_mb_y)*
s->mb_width + mb_x -
s->resync_mb_x;
3118 s->avctx->rtp_callback(
s->avctx,
s->ptr_lastgob, current_packet_size, number_mb);
3124 switch(
s->codec_id){
3147 s->misc_bits+=
bits -
s->last_bits;
3151 s->ptr_lastgob += current_packet_size;
3152 s->first_slice_line=1;
3153 s->resync_mb_x=mb_x;
3154 s->resync_mb_y=mb_y;
3158 if( (
s->resync_mb_x ==
s->mb_x)
3159 &&
s->resync_mb_y+1 ==
s->mb_y){
3160 s->first_slice_line=0;
3170 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3176 if(
s->data_partitioning){
3177 backup_s.pb2=
s->pb2;
3178 backup_s.tex_pb=
s->tex_pb;
3185 s->mv[0][0][0] =
s->p_mv_table[xy][0];
3186 s->mv[0][0][1] =
s->p_mv_table[xy][1];
3188 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3195 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3196 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3197 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3200 &dmin, &next_block, 0, 0);
3209 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3216 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3217 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3220 &dmin, &next_block, 0, 0);
3226 s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3227 s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3229 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3235 s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3236 s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3238 &dmin, &next_block,
s->mv[1][0][0],
s->mv[1][0][1]);
3244 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3245 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3246 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3247 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3249 &dmin, &next_block, 0, 0);
3256 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3257 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3258 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3261 &dmin, &next_block, 0, 0);
3268 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3269 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3270 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3273 &dmin, &next_block, 0, 0);
3279 for(dir=0; dir<2; dir++){
3281 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3282 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3283 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3287 &dmin, &next_block, 0, 0);
3296 &dmin, &next_block, 0, 0);
3297 if(
s->h263_pred ||
s->h263_aic){
3299 s->mbintra_table[mb_x + mb_y*
s->mb_stride]=1;
3307 const int last_qp= backup_s.qscale;
3311 static const int dquant_tab[4]={-1,1,-2,2};
3312 int storecoefs =
s->mb_intra &&
s->dc_val[0];
3320 s->mv[0][0][0] = best_s.
mv[0][0][0];
3321 s->mv[0][0][1] = best_s.
mv[0][0][1];
3322 s->mv[1][0][0] = best_s.
mv[1][0][0];
3323 s->mv[1][0][1] = best_s.
mv[1][0][1];
3326 for(; qpi<4; qpi++){
3327 int dquant= dquant_tab[qpi];
3328 qp= last_qp + dquant;
3329 if(qp < s->avctx->qmin || qp >
s->avctx->qmax)
3331 backup_s.dquant= dquant;
3334 dc[
i]=
s->dc_val[0][
s->block_index[
i] ];
3335 memcpy(ac[
i],
s->ac_val[0][
s->block_index[
i]],
sizeof(int16_t)*16);
3340 &dmin, &next_block,
s->mv[mvdir][0][0],
s->mv[mvdir][0][1]);
3344 s->dc_val[0][
s->block_index[
i] ]=
dc[
i];
3345 memcpy(
s->ac_val[0][
s->block_index[
i]], ac[
i],
sizeof(int16_t)*16);
3353 int mx=
s->b_direct_mv_table[xy][0];
3354 int my=
s->b_direct_mv_table[xy][1];
3356 backup_s.dquant = 0;
3361 &dmin, &next_block, mx, my);
3364 backup_s.dquant = 0;
3369 &dmin, &next_block, 0, 0);
3374 coded |=
s->block_last_index[
i];
3377 memcpy(
s->mv, best_s.
mv,
sizeof(
s->mv));
3399 &dmin, &next_block, mx, my);
3404 s->current_picture.qscale_table[xy] = best_s.
qscale;
3410 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3413 if(
s->data_partitioning){
3416 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3417 s->pb2= backup_s.pb2;
3421 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3422 s->tex_pb= backup_s.tex_pb;
3431 s->hdsp.put_pixels_tab[0][0](
s->dest[0],
s->sc.rd_scratchpad ,
s->linesize ,16);
3432 s->hdsp.put_pixels_tab[1][0](
s->dest[1],
s->sc.rd_scratchpad + 16*
s->linesize ,
s->uvlinesize, 8);
3433 s->hdsp.put_pixels_tab[1][0](
s->dest[2],
s->sc.rd_scratchpad + 16*
s->linesize + 8,
s->uvlinesize, 8);
3439 int motion_x = 0, motion_y = 0;
3447 motion_x=
s->mv[0][0][0] = 0;
3448 motion_y=
s->mv[0][0][1] = 0;
3453 motion_x=
s->mv[0][0][0] =
s->p_mv_table[xy][0];
3454 motion_y=
s->mv[0][0][1] =
s->p_mv_table[xy][1];
3461 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3462 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3463 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3471 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3472 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3479 motion_x=
s->b_direct_mv_table[xy][0];
3480 motion_y=
s->b_direct_mv_table[xy][1];
3494 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3495 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3496 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3497 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3502 motion_x=
s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3503 motion_y=
s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3508 motion_x=
s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3509 motion_y=
s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3516 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3517 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3518 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3526 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3527 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3528 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3535 for(dir=0; dir<2; dir++){
3537 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3538 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3539 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3550 s->last_mv_dir =
s->mv_dir;
3561 s->p_mv_table[xy][0]=0;
3562 s->p_mv_table[xy][1]=0;
3569 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
3570 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
3572 s->current_picture.encoding_error[0] +=
sse(
3573 s,
s->new_picture.f->data[0] +
s->mb_x*16 +
s->mb_y*
s->linesize*16,
3574 s->dest[0],
w,
h,
s->linesize);
3575 s->current_picture.encoding_error[1] +=
sse(
3576 s,
s->new_picture.f->data[1] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3577 s->dest[1],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3578 s->current_picture.encoding_error[2] +=
sse(
3579 s,
s->new_picture.f->data[2] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3580 s->dest[2],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3586 ff_dlog(
s->avctx,
"MB %d %d bits\n",
3597 #if FF_API_RTP_CALLBACK
3600 if (
s->avctx->rtp_callback) {
3601 int number_mb = (mb_y -
s->resync_mb_y)*
s->mb_width -
s->resync_mb_x;
3605 s->avctx->rtp_callback(
s->avctx,
s->ptr_lastgob, pdif, number_mb);
3613 #define MERGE(field) dst->field += src->field; src->field=0
3623 MERGE(dct_count[0]);
3624 MERGE(dct_count[1]);
3633 MERGE(er.error_count);
3634 MERGE(padding_bug_score);
3635 MERGE(current_picture.encoding_error[0]);
3636 MERGE(current_picture.encoding_error[1]);
3637 MERGE(current_picture.encoding_error[2]);
3640 for(
i=0;
i<64;
i++){
3641 MERGE(dct_error_sum[0][
i]);
3642 MERGE(dct_error_sum[1][
i]);
3653 if (
s->next_lambda){
3654 s->current_picture_ptr->f->quality =
3655 s->current_picture.f->quality =
s->next_lambda;
3656 if(!dry_run)
s->next_lambda= 0;
3657 }
else if (!
s->fixed_qscale) {
3659 s->current_picture_ptr->f->quality =
3660 s->current_picture.f->quality = quality;
3661 if (
s->current_picture.f->quality < 0)
3665 if(
s->adaptive_quant){
3666 switch(
s->codec_id){
3681 s->lambda=
s->lambda_table[0];
3684 s->lambda =
s->current_picture.f->quality;
3692 s->time =
s->current_picture_ptr->f->pts *
s->avctx->time_base.num;
3695 s->pb_time=
s->pp_time - (
s->last_non_b_time -
s->time);
3698 s->pp_time=
s->time -
s->last_non_b_time;
3699 s->last_non_b_time=
s->time;
3708 int context_count =
s->slice_context_count;
3710 s->picture_number = picture_number;
3713 s->me.mb_var_sum_temp =
3714 s->me.mc_mb_var_sum_temp = 0;
3723 s->me.scene_change_score=0;
3728 if(
s->msmpeg4_version >= 3)
s->no_rounding=1;
3729 else s->no_rounding=0;
3732 s->no_rounding ^= 1;
3741 s->lambda=
s->last_lambda_for[
s->pict_type];
3743 s->lambda=
s->last_lambda_for[
s->last_non_b_pict_type];
3748 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
3749 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
3750 s->q_chroma_intra_matrix =
s->q_intra_matrix;
3751 s->q_chroma_intra_matrix16 =
s->q_intra_matrix16;
3755 for(
i=1;
i<context_count;
i++){
3766 s->lambda = (
s->lambda *
s->me_penalty_compensation + 128) >> 8;
3767 s->lambda2 = (
s->lambda2 * (
int64_t)
s->me_penalty_compensation + 128) >> 8;
3778 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3781 if(!
s->fixed_qscale){
3783 s->avctx->execute(
s->avctx,
mb_var_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3786 for(
i=1;
i<context_count;
i++){
3789 s->current_picture.mc_mb_var_sum=
s->current_picture_ptr->mc_mb_var_sum=
s->me.mc_mb_var_sum_temp;
3790 s->current_picture. mb_var_sum=
s->current_picture_ptr-> mb_var_sum=
s->me. mb_var_sum_temp;
3793 if (
s->me.scene_change_score >
s->scenechange_threshold &&
3796 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3798 if(
s->msmpeg4_version >= 3)
3800 ff_dlog(
s,
"Scene change detected, encoding as I Frame %"PRId64
" %"PRId64
"\n",
3801 s->current_picture.mb_var_sum,
s->current_picture.mc_mb_var_sum);
3844 for(dir=0; dir<2; dir++){
3850 s->b_field_mv_table[dir][
i][j], dir ?
s->b_code :
s->f_code,
type, 1);
3861 if (
s->qscale < 3 &&
s->max_qcoeff <= 128 &&
3870 if (
s->avctx->intra_matrix) {
3872 luma_matrix =
s->avctx->intra_matrix;
3874 if (
s->avctx->chroma_intra_matrix)
3875 chroma_matrix =
s->avctx->chroma_intra_matrix;
3879 int j =
s->idsp.idct_permutation[
i];
3881 s->chroma_intra_matrix[j] =
av_clip_uint8((chroma_matrix[
i] *
s->qscale) >> 3);
3884 s->y_dc_scale_table=
3886 s->chroma_intra_matrix[0] =
3889 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3891 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3895 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};
3896 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};
3903 s->y_dc_scale_table= y;
3904 s->c_dc_scale_table=
c;
3905 s->intra_matrix[0] = 13;
3906 s->chroma_intra_matrix[0] = 14;
3908 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3910 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3915 s->y_dc_scale_table=
3920 s->current_picture_ptr->f->key_frame =
3922 s->current_picture_ptr->f->pict_type =
3923 s->current_picture.f->pict_type =
s->pict_type;
3925 if (
s->current_picture.f->key_frame)
3926 s->picture_in_gop_number=0;
3928 s->mb_x =
s->mb_y = 0;
3930 switch(
s->out_format) {
3934 s->pred,
s->intra_matrix,
s->chroma_intra_matrix);
3973 s->header_bits=
bits -
s->last_bits;
3975 for(
i=1;
i<context_count;
i++){
3978 s->avctx->execute(
s->avctx,
encode_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3979 for(
i=1;
i<context_count;
i++){
3980 if (
s->pb.buf_end ==
s->thread_context[
i]->pb.buf)
3989 const int intra=
s->mb_intra;
3992 s->dct_count[intra]++;
3994 for(
i=0;
i<64;
i++){
3999 s->dct_error_sum[intra][
i] +=
level;
4000 level -=
s->dct_offset[intra][
i];
4003 s->dct_error_sum[intra][
i] -=
level;
4004 level +=
s->dct_offset[intra][
i];
4013 int16_t *
block,
int n,
4014 int qscale,
int *overflow){
4016 const uint16_t *matrix;
4018 const uint8_t *perm_scantable;
4020 unsigned int threshold1, threshold2;
4032 int coeff_count[64];
4033 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4034 const int esc_length=
s->ac_esc_length;
4042 if(
s->dct_error_sum)
4045 qadd= ((qscale-1)|1)*8;
4048 else mpeg2_qscale = qscale << 1;
4052 scantable=
s->intra_scantable.scantable;
4053 perm_scantable=
s->intra_scantable.permutated;
4070 qmat = n < 4 ?
s->q_intra_matrix[qscale] :
s->q_chroma_intra_matrix[qscale];
4071 matrix = n < 4 ?
s->intra_matrix :
s->chroma_intra_matrix;
4075 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4076 length =
s->intra_chroma_ac_vlc_length;
4077 last_length=
s->intra_chroma_ac_vlc_last_length;
4079 length =
s->intra_ac_vlc_length;
4080 last_length=
s->intra_ac_vlc_last_length;
4083 scantable=
s->inter_scantable.scantable;
4084 perm_scantable=
s->inter_scantable.permutated;
4087 qmat =
s->q_inter_matrix[qscale];
4088 matrix =
s->inter_matrix;
4089 length =
s->inter_ac_vlc_length;
4090 last_length=
s->inter_ac_vlc_last_length;
4095 threshold2= (threshold1<<1);
4097 for(
i=63;
i>=start_i;
i--) {
4098 const int j = scantable[
i];
4101 if(((
unsigned)(
level+threshold1))>threshold2){
4107 for(
i=start_i;
i<=last_non_zero;
i++) {
4108 const int j = scantable[
i];
4113 if(((
unsigned)(
level+threshold1))>threshold2){
4134 *overflow=
s->max_qcoeff <
max;
4136 if(last_non_zero < start_i){
4137 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4138 return last_non_zero;
4141 score_tab[start_i]= 0;
4142 survivor[0]= start_i;
4145 for(
i=start_i;
i<=last_non_zero;
i++){
4146 int level_index, j, zero_distortion;
4148 int best_score=256*256*256*120;
4152 zero_distortion= dct_coeff*dct_coeff;
4154 for(level_index=0; level_index < coeff_count[
i]; level_index++){
4163 unquant_coeff= alevel*qmul + qadd;
4165 j =
s->idsp.idct_permutation[scantable[
i]];
4166 unquant_coeff = alevel * matrix[j] * 8;
4168 j =
s->idsp.idct_permutation[scantable[
i]];
4170 unquant_coeff = (
int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4171 unquant_coeff = (unquant_coeff - 1) | 1;
4173 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int) matrix[j])) >> 5;
4174 unquant_coeff = (unquant_coeff - 1) | 1;
4179 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4181 if((
level&(~127)) == 0){
4182 for(j=survivor_count-1; j>=0; j--){
4183 int run=
i - survivor[j];
4185 score += score_tab[
i-
run];
4187 if(score < best_score){
4190 level_tab[
i+1]=
level-64;
4195 for(j=survivor_count-1; j>=0; j--){
4196 int run=
i - survivor[j];
4198 score += score_tab[
i-
run];
4199 if(score < last_score){
4202 last_level=
level-64;
4208 distortion += esc_length*lambda;
4209 for(j=survivor_count-1; j>=0; j--){
4210 int run=
i - survivor[j];
4211 int score= distortion + score_tab[
i-
run];
4213 if(score < best_score){
4216 level_tab[
i+1]=
level-64;
4221 for(j=survivor_count-1; j>=0; j--){
4222 int run=
i - survivor[j];
4223 int score= distortion + score_tab[
i-
run];
4224 if(score < last_score){
4227 last_level=
level-64;
4235 score_tab[
i+1]= best_score;
4238 if(last_non_zero <= 27){
4239 for(; survivor_count; survivor_count--){
4240 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4244 for(; survivor_count; survivor_count--){
4245 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4250 survivor[ survivor_count++ ]=
i+1;
4254 last_score= 256*256*256*120;
4255 for(
i= survivor[0];
i<=last_non_zero + 1;
i++){
4256 int score= score_tab[
i];
4258 score += lambda * 2;
4260 if(score < last_score){
4263 last_level= level_tab[
i];
4264 last_run= run_tab[
i];
4269 s->coded_score[n] = last_score;
4272 last_non_zero= last_i - 1;
4273 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4275 if(last_non_zero < start_i)
4276 return last_non_zero;
4278 if(last_non_zero == 0 && start_i == 0){
4280 int best_score=
dc *
dc;
4282 for(
i=0;
i<coeff_count[0];
i++){
4285 int unquant_coeff, score, distortion;
4288 unquant_coeff= (alevel*qmul + qadd)>>3;
4290 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int) matrix[0])) >> 5;
4291 unquant_coeff = (unquant_coeff - 1) | 1;
4293 unquant_coeff = (unquant_coeff + 4) >> 3;
4294 unquant_coeff<<= 3 + 3;
4296 distortion= (unquant_coeff -
dc) * (unquant_coeff -
dc);
4299 else score= distortion + esc_length*lambda;
4301 if(score < best_score){
4303 best_level=
level - 64;
4306 block[0]= best_level;
4307 s->coded_score[n] = best_score -
dc*
dc;
4308 if(best_level == 0)
return -1;
4309 else return last_non_zero;
4315 block[ perm_scantable[last_non_zero] ]= last_level;
4318 for(;
i>start_i;
i -= run_tab[
i] + 1){
4319 block[ perm_scantable[
i-1] ]= level_tab[
i];
4322 return last_non_zero;
4337 if(
i==0)
s*= sqrt(0.5);
4338 if(j==0)
s*= sqrt(0.5);
4352 const uint8_t *perm_scantable;
4358 int qmul, qadd, start_i, last_non_zero,
i,
dc;
4362 int rle_index,
run, q = 1, sum;
4364 if(
basis[0][0] == 0)
4370 scantable=
s->intra_scantable.scantable;
4371 perm_scantable=
s->intra_scantable.permutated;
4389 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
4390 length =
s->intra_chroma_ac_vlc_length;
4391 last_length=
s->intra_chroma_ac_vlc_last_length;
4393 length =
s->intra_ac_vlc_length;
4394 last_length=
s->intra_ac_vlc_last_length;
4397 scantable=
s->inter_scantable.scantable;
4398 perm_scantable=
s->inter_scantable.permutated;
4401 length =
s->inter_ac_vlc_length;
4402 last_length=
s->inter_ac_vlc_last_length;
4404 last_non_zero =
s->block_last_index[n];
4407 for(
i=0;
i<64;
i++){
4412 for(
i=0;
i<64;
i++){
4418 w= 15 + (48*qns*one +
w/2)/
w;
4431 for(
i=start_i;
i<=last_non_zero;
i++){
4432 int j= perm_scantable[
i];
4439 run_tab[rle_index++]=
run;
4449 int best_score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0], 0);
4452 int run2, best_unquant_change=0, analyze_gradient;
4453 analyze_gradient = last_non_zero > 2 ||
s->quantizer_noise_shaping >= 3;
4455 if(analyze_gradient){
4456 for(
i=0;
i<64;
i++){
4466 int change, old_coeff;
4472 for(change=-1; change<=1; change+=2){
4473 int new_level=
level + change;
4474 int score, new_coeff;
4476 new_coeff= q*new_level;
4477 if(new_coeff >= 2048 || new_coeff < 0)
4480 score =
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[0],
4481 new_coeff - old_coeff);
4482 if(score<best_score){
4485 best_change= change;
4486 best_unquant_change= new_coeff - old_coeff;
4493 run2= run_tab[rle_index++];
4497 for(
i=start_i;
i<64;
i++){
4498 int j= perm_scantable[
i];
4500 int change, old_coeff;
4502 if(
s->quantizer_noise_shaping < 3 &&
i > last_non_zero + 1)
4507 else old_coeff= qmul*
level + qadd;
4508 run2= run_tab[rle_index++];
4515 for(change=-1; change<=1; change+=2){
4516 int new_level=
level + change;
4517 int score, new_coeff, unquant_change;
4524 if(new_level<0) new_coeff= qmul*new_level - qadd;
4525 else new_coeff= qmul*new_level + qadd;
4526 if(new_coeff >= 2048 || new_coeff <= -2048)
4531 if(level < 63 && level > -63){
4532 if(
i < last_non_zero)
4542 if(analyze_gradient){
4543 int g= d1[ scantable[
i] ];
4544 if(
g && (
g^new_level) >= 0)
4548 if(
i < last_non_zero){
4549 int next_i=
i + run2 + 1;
4550 int next_level=
block[ perm_scantable[next_i] ] + 64;
4552 if(next_level&(~127))
4555 if(next_i < last_non_zero)
4575 if(
i < last_non_zero){
4576 int next_i=
i + run2 + 1;
4577 int next_level=
block[ perm_scantable[next_i] ] + 64;
4579 if(next_level&(~127))
4582 if(next_i < last_non_zero)
4601 unquant_change= new_coeff - old_coeff;
4602 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4604 score +=
s->mpvencdsp.try_8x8basis(rem,
weight,
basis[j],
4606 if(score<best_score){
4609 best_change= change;
4610 best_unquant_change= unquant_change;
4614 prev_level=
level + 64;
4615 if(prev_level&(~127))
4625 int j= perm_scantable[ best_coeff ];
4627 block[j] += best_change;
4629 if(best_coeff > last_non_zero){
4630 last_non_zero= best_coeff;
4633 for(; last_non_zero>=start_i; last_non_zero--){
4634 if(
block[perm_scantable[last_non_zero]])
4641 for(
i=start_i;
i<=last_non_zero;
i++){
4642 int j= perm_scantable[
i];
4646 run_tab[rle_index++]=
run;
4653 s->mpvencdsp.add_8x8basis(rem,
basis[j], best_unquant_change);
4659 return last_non_zero;
4674 const uint8_t *scantable,
int last)
4685 for (
i = 0;
i <= last;
i++) {
4686 const int j = scantable[
i];
4691 for (
i = 0;
i <= last;
i++) {
4692 const int j = scantable[
i];
4693 const int perm_j = permutation[j];
4699 int16_t *
block,
int n,
4700 int qscale,
int *overflow)
4702 int i, j,
level, last_non_zero, q, start_i;
4707 unsigned int threshold1, threshold2;
4711 if(
s->dct_error_sum)
4715 scantable=
s->intra_scantable.scantable;
4730 qmat = n < 4 ?
s->q_intra_matrix[qscale] :
s->q_chroma_intra_matrix[qscale];
4733 scantable=
s->inter_scantable.scantable;
4736 qmat =
s->q_inter_matrix[qscale];
4740 threshold2= (threshold1<<1);
4741 for(
i=63;
i>=start_i;
i--) {
4745 if(((
unsigned)(
level+threshold1))>threshold2){
4752 for(
i=start_i;
i<=last_non_zero;
i++) {
4758 if(((
unsigned)(
level+threshold1))>threshold2){
4771 *overflow=
s->max_qcoeff <
max;
4776 scantable, last_non_zero);
4778 return last_non_zero;
4781 #define OFFSET(x) offsetof(MpegEncContext, x)
4782 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4785 {
"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 },
4815 {
"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},
4849 .
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)