34 #include "config_components.h"
81 #define QUANT_BIAS_SHIFT 8
83 #define QMAT_SHIFT_MMX 16
109 uint16_t (*
qmat16)[2][64],
110 const uint16_t *quant_matrix,
111 int bias,
int qmin,
int qmax,
int intra)
122 else qscale2 =
qscale << 1;
129 for (
i = 0;
i < 64;
i++) {
130 const int j =
s->idsp.idct_permutation[
i];
131 int64_t den = (int64_t) qscale2 * quant_matrix[j];
141 for (
i = 0;
i < 64;
i++) {
142 const int j =
s->idsp.idct_permutation[
i];
143 int64_t den =
ff_aanscales[
i] * (int64_t) qscale2 * quant_matrix[j];
153 for (
i = 0;
i < 64;
i++) {
154 const int j =
s->idsp.idct_permutation[
i];
155 int64_t den = (int64_t) qscale2 * quant_matrix[j];
175 for (
i = intra;
i < 64;
i++) {
187 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
194 if (
s->q_scale_type == 1 && 0) {
196 int bestdiff=INT_MAX;
204 if (
diff < bestdiff) {
213 s->qscale =
av_clip(
s->qscale,
s->avctx->qmin,
s->vbv_ignore_qmax ? 31 :
s->avctx->qmax);
226 for (
i = 0;
i < 64;
i++) {
238 int8_t *
const qscale_table =
s->current_picture.qscale_table;
241 for (
i = 0;
i <
s->mb_num;
i++) {
242 unsigned int lam =
s->lambda_table[
s->mb_index2xy[
i]];
244 qscale_table[
s->mb_index2xy[
i]] =
av_clip(qp,
s->avctx->qmin,
252 #define COPY(a) dst->a= src->a
268 for (
int i = -16;
i < 16;
i++)
287 s->input_picture_number = 0;
288 s->picture_in_gop_number = 0;
297 if (CONFIG_H263_ENCODER)
299 if (!
s->dct_quantize)
303 s->fast_dct_quantize =
s->dct_quantize;
304 if (
s->avctx->trellis)
316 int mb_array_size, mv_table_size;
344 "keyframe interval too large!, reducing it from %d to %d\n",
356 "max b frames must be 0 or positive for mpegvideo based encoders\n");
367 s->rtp_mode = !!
s->rtp_payload_size;
371 if (
s->intra_dc_precision < 0) {
372 s->intra_dc_precision += 8;
373 }
else if (
s->intra_dc_precision >= 8)
374 s->intra_dc_precision -= 8;
376 if (
s->intra_dc_precision < 0) {
378 "intra dc precision must be positive, note some applications use"
379 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
389 if (
s->gop_size <= 1) {
443 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
460 "impossible bitrate constraints, this will fail\n");
470 if (!
s->fixed_qscale &&
476 if (nbt <= INT_MAX) {
489 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
490 "specified vbv buffer is too large for the given bitrate!\n");
502 "OBMC is only supported with simple mb decision\n");
517 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
570 if (
s->scenechange_threshold < 1000000000 &&
573 "closed gop with scene change detection are not supported yet, "
574 "set threshold to 1000000000\n");
582 "low delay forcing is only available for mpeg2, "
583 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
586 if (
s->max_b_frames != 0) {
588 "B-frames cannot be used with low delay\n");
593 if (
s->q_scale_type == 1) {
596 "non linear quant only supports qmax <= 28 currently\n");
609 "notice: b_frame_strategy only affects the first pass\n");
610 s->b_frame_strategy = 0;
624 s->inter_quant_bias = 0;
626 s->intra_quant_bias = 0;
641 "timebase %d/%d not supported by MPEG 4 standard, "
642 "the maximum admitted value for the timebase denominator "
650 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
657 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
661 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
675 if (!CONFIG_SPEEDHQ_ENCODER)
683 if (!CONFIG_H261_ENCODER)
694 if (!CONFIG_H263_ENCODER)
697 s->width,
s->height) == 8) {
699 "The specified picture size of %dx%d is not valid for "
700 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
701 "352x288, 704x576, and 1408x1152. "
702 "Try H.263+.\n",
s->width,
s->height);
714 s->modified_quant =
s->h263_aic;
716 s->unrestricted_mv =
s->obmc ||
s->loop_filter ||
s->umvplus;
726 s->unrestricted_mv = 1;
740 s->modified_quant = 1;
744 s->unrestricted_mv = 0;
749 s->unrestricted_mv = 1;
750 s->low_delay =
s->max_b_frames ? 0 : 1;
751 avctx->
delay =
s->low_delay ? 0 : (
s->max_b_frames + 1);
756 s->unrestricted_mv = 1;
757 s->msmpeg4_version = 2;
764 s->unrestricted_mv = 1;
765 s->msmpeg4_version = 3;
766 s->flipflop_rounding = 1;
773 s->unrestricted_mv = 1;
774 s->msmpeg4_version = 4;
775 s->flipflop_rounding = 1;
782 s->unrestricted_mv = 1;
783 s->msmpeg4_version = 5;
784 s->flipflop_rounding = 1;
796 s->progressive_frame =
801 if (
s->lmin >
s->lmax) {
829 mv_table_size = (
s->mb_height + 2) *
s->mb_stride + 1;
837 s->p_mv_table =
s->p_mv_table_base +
s->mb_stride + 1;
838 s->b_forw_mv_table =
s->b_forw_mv_table_base +
s->mb_stride + 1;
839 s->b_back_mv_table =
s->b_back_mv_table_base +
s->mb_stride + 1;
840 s->b_bidir_forw_mv_table =
s->b_bidir_forw_mv_table_base +
s->mb_stride + 1;
841 s->b_bidir_back_mv_table =
s->b_bidir_back_mv_table_base +
s->mb_stride + 1;
842 s->b_direct_mv_table =
s->b_direct_mv_table_base +
s->mb_stride + 1;
845 mb_array_size =
s->mb_stride *
s->mb_height;
855 #define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
860 if (!(tmp1 =
ALLOCZ_ARRAYS(
s->b_field_mv_table_base, 8, mv_table_size)) ||
861 !(tmp2 =
ALLOCZ_ARRAYS(
s->b_field_select_table[0][0], 2 * 4, mv_table_size)) ||
865 s->p_field_select_table[1] =
s->p_field_select_table[0] + 2 * mv_table_size;
866 tmp1 +=
s->mb_stride + 1;
868 for (
int i = 0;
i < 2;
i++) {
869 for (
int j = 0; j < 2; j++) {
870 for (
int k = 0; k < 2; k++) {
871 s->b_field_mv_table[
i][j][k] = tmp1;
872 tmp1 += mv_table_size;
874 s->b_field_select_table[
i][j] = tmp2;
875 tmp2 += 2 * mv_table_size;
880 if (
s->noise_reduction) {
888 s->dct_unquantize_intra =
s->dct_unquantize_mpeg2_intra;
889 s->dct_unquantize_inter =
s->dct_unquantize_mpeg2_inter;
891 s->dct_unquantize_intra =
s->dct_unquantize_h263_intra;
892 s->dct_unquantize_inter =
s->dct_unquantize_h263_inter;
894 s->dct_unquantize_intra =
s->dct_unquantize_mpeg1_intra;
895 s->dct_unquantize_inter =
s->dct_unquantize_mpeg1_inter;
898 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) &&
s->modified_quant)
901 if (
s->slice_context_count > 1) {
905 s->h263_slice_structured = 1;
908 s->quant_precision = 5;
915 if (CONFIG_H263_ENCODER &&
s->out_format ==
FMT_H263) {
917 if (CONFIG_MSMPEG4ENC &&
s->msmpeg4_version)
922 for (
i = 0;
i < 64;
i++) {
923 int j =
s->idsp.idct_permutation[
i];
936 s->chroma_intra_matrix[j] =
960 if (
s->b_frame_strategy == 2) {
961 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
963 if (!
s->tmp_frames[
i])
967 s->tmp_frames[
i]->width =
s->width >>
s->brd_scale;
968 s->tmp_frames[
i]->height =
s->height >>
s->brd_scale;
1006 av_freep(&
s->b_bidir_forw_mv_table_base);
1007 av_freep(&
s->b_bidir_back_mv_table_base);
1010 av_freep(&
s->b_field_select_table[0][0]);
1019 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
1020 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
1021 s->q_chroma_intra_matrix=
NULL;
1022 s->q_chroma_intra_matrix16=
NULL;
1037 #define IS_ENCODER 1
1045 for (
int i = 0;
i < 6;
i++) {
1046 for (
int j = 0; j < 64; j++) {
1048 block[
i][
s->idsp.idct_permutation[j]]);
1062 for (y = 0; y < 16; y++) {
1063 for (x = 0; x < 16; x++) {
1078 h =
s->height & ~15;
1080 for (y = 0; y <
h; y += 16) {
1081 for (x = 0; x <
w; x += 16) {
1088 acc += sae + 500 < sad;
1097 s->chroma_x_shift,
s->chroma_y_shift,
s->out_format,
1098 s->mb_stride,
s->mb_width,
s->mb_height,
s->b8_stride,
1099 &
s->linesize, &
s->uvlinesize);
1106 int i, display_picture_number = 0,
ret;
1107 int encoding_delay =
s->max_b_frames ?
s->max_b_frames
1108 : (
s->low_delay ? 0 : 1);
1109 int flush_offset = 1;
1114 display_picture_number =
s->input_picture_number++;
1118 int64_t last =
s->user_specified_pts;
1122 "Invalid pts (%"PRId64
") <= last (%"PRId64
")\n",
1127 if (!
s->low_delay && display_picture_number == 1)
1128 s->dts_delta =
pts - last;
1130 s->user_specified_pts =
pts;
1133 s->user_specified_pts =
1134 pts =
s->user_specified_pts + 1;
1136 "Warning: AVFrame.pts=? trying to guess (%"PRId64
")\n",
1139 pts = display_picture_number;
1143 if (!pic_arg->
buf[0] ||
1145 pic_arg->
linesize[1] !=
s->uvlinesize ||
1148 if ((
s->width & 15) || (
s->height & 15))
1156 pic_arg->
linesize[1],
s->linesize,
s->uvlinesize);
1162 pic = &
s->picture[
i];
1179 int h_chroma_shift, v_chroma_shift;
1184 for (
i = 0;
i < 3;
i++) {
1186 int dst_stride =
i ?
s->uvlinesize :
s->linesize;
1187 int h_shift =
i ? h_chroma_shift : 0;
1188 int v_shift =
i ? v_chroma_shift : 0;
1189 int w =
s->width >> h_shift;
1190 int h =
s->height >> v_shift;
1191 const uint8_t *
src = pic_arg->
data[
i];
1192 uint8_t *dst = pic->
f->
data[
i];
1196 && !
s->progressive_sequence
1197 &&
FFALIGN(
s->height, 32) -
s->height > 16)
1200 if (!
s->avctx->rc_buffer_size)
1203 if (src_stride == dst_stride)
1204 memcpy(dst,
src, src_stride *
h);
1207 uint8_t *dst2 = dst;
1209 memcpy(dst2,
src,
w);
1214 if ((
s->width & 15) || (
s->height & (vpad-1))) {
1215 s->mpvencdsp.draw_edges(dst, dst_stride,
1234 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1235 if (
s->input_picture[flush_offset])
1238 if (flush_offset <= 1)
1241 encoding_delay = encoding_delay - flush_offset + 1;
1246 s->input_picture[
i - flush_offset] =
s->input_picture[
i];
1248 s->input_picture[encoding_delay] = pic;
1257 int64_t score64 = 0;
1259 for (plane = 0; plane < 3; plane++) {
1261 const int bw = plane ? 1 : 2;
1262 for (y = 0; y <
s->mb_height * bw; y++) {
1263 for (x = 0; x <
s->mb_width * bw; x++) {
1264 int off = p->
shared ? 0 : 16;
1265 const uint8_t *dptr = p->
f->
data[plane] + 8 * (x + y *
stride) + off;
1266 const uint8_t *rptr =
ref->f->data[plane] + 8 * (x + y *
stride);
1267 int v =
s->mecc.frame_skip_cmp[1](
s, dptr, rptr,
stride, 8);
1269 switch (
FFABS(
s->frame_skip_exp)) {
1270 case 0: score =
FFMAX(score, v);
break;
1271 case 1: score +=
FFABS(v);
break;
1272 case 2: score64 += v * (int64_t)v;
break;
1273 case 3: score64 +=
FFABS(v * (int64_t)v * v);
break;
1274 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);
break;
1283 if (
s->frame_skip_exp < 0)
1284 score64 = pow(score64 / (
double)(
s->mb_width *
s->mb_height),
1285 -1.0/
s->frame_skip_exp);
1289 if (score64 < ((
s->frame_skip_factor * (int64_t)
s->lambda) >> 8))
1318 const int scale =
s->brd_scale;
1322 int64_t best_rd = INT64_MAX;
1323 int best_b_count = -1;
1338 b_lambda = p_lambda;
1342 for (
i = 0;
i <
s->max_b_frames + 2;
i++) {
1343 const Picture *pre_input_ptr =
i ?
s->input_picture[
i - 1] :
1344 s->next_picture_ptr;
1346 if (pre_input_ptr) {
1347 const uint8_t *
data[4];
1350 if (!pre_input_ptr->
shared &&
i) {
1356 s->mpvencdsp.shrink[
scale](
s->tmp_frames[
i]->data[0],
1357 s->tmp_frames[
i]->linesize[0],
1361 s->mpvencdsp.shrink[
scale](
s->tmp_frames[
i]->data[1],
1362 s->tmp_frames[
i]->linesize[1],
1366 s->mpvencdsp.shrink[
scale](
s->tmp_frames[
i]->data[2],
1367 s->tmp_frames[
i]->linesize[2],
1374 for (j = 0; j <
s->max_b_frames + 1; j++) {
1378 if (!
s->input_picture[j])
1391 c->mb_decision =
s->avctx->mb_decision;
1392 c->me_cmp =
s->avctx->me_cmp;
1393 c->mb_cmp =
s->avctx->mb_cmp;
1394 c->me_sub_cmp =
s->avctx->me_sub_cmp;
1396 c->time_base =
s->avctx->time_base;
1397 c->max_b_frames =
s->max_b_frames;
1415 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1416 int is_p =
i % (j + 1) == j ||
i ==
s->max_b_frames;
1418 s->tmp_frames[
i + 1]->pict_type = is_p ?
1420 s->tmp_frames[
i + 1]->quality = is_p ? p_lambda : b_lambda;
1439 rd +=
c->error[0] +
c->error[1] +
c->error[2];
1457 return best_b_count;
1465 s->reordered_input_picture[
i - 1] =
s->reordered_input_picture[
i];
1469 if (!
s->reordered_input_picture[0] &&
s->input_picture[0]) {
1470 if (
s->frame_skip_threshold ||
s->frame_skip_factor) {
1471 if (
s->picture_in_gop_number <
s->gop_size &&
1472 s->next_picture_ptr &&
1484 !
s->next_picture_ptr ||
s->intra_only) {
1485 s->reordered_input_picture[0] =
s->input_picture[0];
1487 s->reordered_input_picture[0]->coded_picture_number =
1488 s->coded_picture_number++;
1493 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1494 int pict_num =
s->input_picture[0]->display_picture_number +
i;
1496 if (pict_num >=
s->rc_context.num_entries)
1498 if (!
s->input_picture[
i]) {
1503 s->input_picture[
i]->f->pict_type =
1504 s->rc_context.entry[pict_num].new_pict_type;
1508 if (
s->b_frame_strategy == 0) {
1509 b_frames =
s->max_b_frames;
1510 while (b_frames && !
s->input_picture[b_frames])
1512 }
else if (
s->b_frame_strategy == 1) {
1513 for (
i = 1;
i <
s->max_b_frames + 1;
i++) {
1514 if (
s->input_picture[
i] &&
1515 s->input_picture[
i]->b_frame_score == 0) {
1516 s->input_picture[
i]->b_frame_score =
1518 s->input_picture[
i ]->f->data[0],
1519 s->input_picture[
i - 1]->f->data[0],
1523 for (
i = 0;
i <
s->max_b_frames + 1;
i++) {
1524 if (!
s->input_picture[
i] ||
1525 s->input_picture[
i]->b_frame_score - 1 >
1526 s->mb_num /
s->b_sensitivity)
1530 b_frames =
FFMAX(0,
i - 1);
1533 for (
i = 0;
i < b_frames + 1;
i++) {
1534 s->input_picture[
i]->b_frame_score = 0;
1536 }
else if (
s->b_frame_strategy == 2) {
1544 for (
i = b_frames - 1;
i >= 0;
i--) {
1545 int type =
s->input_picture[
i]->f->pict_type;
1550 b_frames ==
s->max_b_frames) {
1552 "warning, too many B-frames in a row\n");
1555 if (
s->picture_in_gop_number + b_frames >=
s->gop_size) {
1557 s->gop_size >
s->picture_in_gop_number) {
1558 b_frames =
s->gop_size -
s->picture_in_gop_number - 1;
1570 s->reordered_input_picture[0] =
s->input_picture[b_frames];
1573 s->reordered_input_picture[0]->coded_picture_number =
1574 s->coded_picture_number++;
1575 for (
i = 0;
i < b_frames;
i++) {
1576 s->reordered_input_picture[
i + 1] =
s->input_picture[
i];
1577 s->reordered_input_picture[
i + 1]->f->pict_type =
1579 s->reordered_input_picture[
i + 1]->coded_picture_number =
1580 s->coded_picture_number++;
1587 if (
s->reordered_input_picture[0]) {
1588 s->reordered_input_picture[0]->reference =
1589 s->reordered_input_picture[0]->f->pict_type !=
1593 s->reordered_input_picture[0]->f)))
1596 if (
s->reordered_input_picture[0]->shared ||
s->avctx->rc_buffer_size) {
1604 pic = &
s->picture[
i];
1606 pic->
reference =
s->reordered_input_picture[0]->reference;
1619 s->reordered_input_picture[0]->shared = 0;
1621 s->current_picture_ptr = pic;
1624 s->current_picture_ptr =
s->reordered_input_picture[0];
1625 for (
i = 0;
i < 4;
i++) {
1626 if (
s->new_picture->data[
i])
1630 s->picture_number =
s->current_picture_ptr->display_picture_number;
1638 if (
s->unrestricted_mv &&
1639 s->current_picture.reference &&
1642 int hshift =
desc->log2_chroma_w;
1643 int vshift =
desc->log2_chroma_h;
1644 s->mpvencdsp.draw_edges(
s->current_picture.f->data[0],
1645 s->current_picture.f->linesize[0],
1646 s->h_edge_pos,
s->v_edge_pos,
1649 s->mpvencdsp.draw_edges(
s->current_picture.f->data[1],
1650 s->current_picture.f->linesize[1],
1651 s->h_edge_pos >> hshift,
1652 s->v_edge_pos >> vshift,
1656 s->mpvencdsp.draw_edges(
s->current_picture.f->data[2],
1657 s->current_picture.f->linesize[2],
1658 s->h_edge_pos >> hshift,
1659 s->v_edge_pos >> vshift,
1667 s->last_pict_type =
s->pict_type;
1668 s->last_lambda_for [
s->pict_type] =
s->current_picture_ptr->f->quality;
1670 s->last_non_b_pict_type =
s->pict_type;
1677 for (intra = 0; intra < 2; intra++) {
1678 if (
s->dct_count[intra] > (1 << 16)) {
1679 for (
i = 0;
i < 64;
i++) {
1680 s->dct_error_sum[intra][
i] >>= 1;
1682 s->dct_count[intra] >>= 1;
1685 for (
i = 0;
i < 64;
i++) {
1686 s->dct_offset[intra][
i] = (
s->noise_reduction *
1687 s->dct_count[intra] +
1688 s->dct_error_sum[intra][
i] / 2) /
1689 (
s->dct_error_sum[intra][
i] + 1);
1700 s->last_picture_ptr !=
s->next_picture_ptr &&
1701 s->last_picture_ptr->f->buf[0]) {
1705 s->current_picture_ptr->f->pict_type =
s->pict_type;
1713 s->current_picture_ptr)) < 0)
1717 s->last_picture_ptr =
s->next_picture_ptr;
1718 s->next_picture_ptr =
s->current_picture_ptr;
1721 if (
s->last_picture_ptr) {
1723 if (
s->last_picture_ptr->f->buf[0] &&
1725 s->last_picture_ptr)) < 0)
1728 if (
s->next_picture_ptr) {
1730 if (
s->next_picture_ptr->f->buf[0] &&
1732 s->next_picture_ptr)) < 0)
1738 for (
i = 0;
i < 4;
i++) {
1740 s->current_picture.f->data[
i] +=
1741 s->current_picture.f->linesize[
i];
1743 s->current_picture.f->linesize[
i] *= 2;
1744 s->last_picture.f->linesize[
i] *= 2;
1745 s->next_picture.f->linesize[
i] *= 2;
1749 if (
s->dct_error_sum) {
1758 const AVFrame *pic_arg,
int *got_packet)
1761 int i, stuffing_count,
ret;
1762 int context_count =
s->slice_context_count;
1764 s->vbv_ignore_qmax = 0;
1766 s->picture_in_gop_number++;
1776 if (
s->new_picture->data[0]) {
1777 int growing_buffer = context_count == 1 && !
s->data_partitioning;
1778 size_t pkt_size = 10000 +
s->mb_width *
s->mb_height *
1791 s->mb_width*
s->mb_height*12);
1792 s->prev_mb_info =
s->last_mb_info =
s->mb_info_size = 0;
1795 for (
i = 0;
i < context_count;
i++) {
1796 int start_y =
s->thread_context[
i]->start_mb_y;
1798 int h =
s->mb_height;
1799 uint8_t *start =
pkt->
data + (size_t)(((int64_t)
pkt->
size) * start_y /
h);
1800 uint8_t *end =
pkt->
data + (size_t)(((int64_t)
pkt->
size) * end_y /
h);
1805 s->pict_type =
s->new_picture->pict_type;
1812 if (growing_buffer) {
1822 if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) &&
s->out_format ==
FMT_MJPEG)
1832 s->lambda <
s->lmax) {
1833 s->next_lambda =
FFMAX(
s->lambda + min_step,
s->lambda *
1834 (
s->qscale + 1) /
s->qscale);
1835 if (
s->adaptive_quant) {
1837 for (
i = 0;
i <
s->mb_height *
s->mb_stride;
i++)
1838 s->lambda_table[
i] =
1839 FFMAX(
s->lambda_table[
i] + min_step,
1840 s->lambda_table[
i] * (
s->qscale + 1) /
1846 if (
s->flipflop_rounding ||
1849 s->no_rounding ^= 1;
1852 s->time_base =
s->last_time_base;
1853 s->last_non_b_time =
s->time -
s->pp_time;
1855 for (
i = 0;
i < context_count;
i++) {
1859 s->vbv_ignore_qmax = 1;
1870 for (
i = 0;
i < 4;
i++) {
1880 s->misc_bits +
s->i_tex_bits +
1886 s->stuffing_bits = 8*stuffing_count;
1887 if (stuffing_count) {
1893 switch (
s->codec_id) {
1896 while (stuffing_count--) {
1903 stuffing_count -= 4;
1904 while (stuffing_count--) {
1910 s->stuffing_bits = 0;
1928 int minbits =
s->frame_bits - 8 *
1929 (
s->vbv_delay_pos - 1);
1930 double bits =
s->rc_context.buffer_index + minbits - inbits;
1931 uint8_t *
const vbv_delay_ptr =
s->pb.buf +
s->vbv_delay_pos;
1935 "Internal error, negative bits\n");
1947 vbv_delay_ptr[0] &= 0xF8;
1950 vbv_delay_ptr[2] &= 0x07;
1959 (uint8_t*)props, props_size);
1965 s->total_bits +=
s->frame_bits;
1967 pkt->
pts =
s->current_picture.f->pts;
1970 if (!
s->current_picture.coded_picture_number)
1995 if (!
s->picture[
i].reference)
2007 int n,
int threshold)
2009 static const char tab[64] = {
2010 3, 2, 2, 1, 1, 1, 1, 1,
2011 1, 1, 1, 1, 1, 1, 1, 1,
2012 1, 1, 1, 1, 1, 1, 1, 1,
2013 0, 0, 0, 0, 0, 0, 0, 0,
2014 0, 0, 0, 0, 0, 0, 0, 0,
2015 0, 0, 0, 0, 0, 0, 0, 0,
2016 0, 0, 0, 0, 0, 0, 0, 0,
2017 0, 0, 0, 0, 0, 0, 0, 0
2022 int16_t *
block =
s->block[n];
2023 const int last_index =
s->block_last_index[n];
2026 if (threshold < 0) {
2028 threshold = -threshold;
2033 if (last_index <= skip_dc - 1)
2036 for (
i = 0;
i <= last_index;
i++) {
2037 const int j =
s->intra_scantable.permutated[
i];
2040 if (skip_dc &&
i == 0)
2044 }
else if (
level > 1) {
2050 if (score >= threshold)
2052 for (
i = skip_dc;
i <= last_index;
i++) {
2053 const int j =
s->intra_scantable.permutated[
i];
2057 s->block_last_index[n] = 0;
2059 s->block_last_index[n] = -1;
2066 const int maxlevel =
s->max_qcoeff;
2067 const int minlevel =
s->min_qcoeff;
2075 for (;
i <= last_index;
i++) {
2076 const int j =
s->intra_scantable.permutated[
i];
2079 if (
level > maxlevel) {
2082 }
else if (
level < minlevel) {
2092 "warning, clipping %d dct coefficients to %d..%d\n",
2100 for (y = 0; y < 8; y++) {
2101 for (x = 0; x < 8; x++) {
2107 for (y2 =
FFMAX(y - 1, 0); y2 <
FFMIN(8, y + 2); y2++) {
2108 for (x2=
FFMAX(x - 1, 0); x2 <
FFMIN(8, x + 2); x2++) {
2109 int v = ptr[x2 + y2 *
stride];
2121 int motion_x,
int motion_y,
2122 int mb_block_height,
2131 #define INTERLACED_DCT(s) ((chroma_format == CHROMA_420 || chroma_format == CHROMA_422) && \
2132 (s)->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
2134 int16_t orig[12][64];
2135 const int mb_x =
s->mb_x;
2136 const int mb_y =
s->mb_y;
2140 int uv_dct_offset =
s->uvlinesize * 8;
2141 const uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2142 ptrdiff_t wrap_y, wrap_c;
2144 for (
i = 0;
i < mb_block_count;
i++)
2145 skip_dct[
i] =
s->skipdct;
2147 if (
s->adaptive_quant) {
2148 const int last_qp =
s->qscale;
2149 const int mb_xy =
mb_x +
mb_y *
s->mb_stride;
2151 s->lambda =
s->lambda_table[mb_xy];
2155 s->qscale =
s->current_picture_ptr->qscale_table[mb_xy];
2156 s->dquant =
s->qscale - last_qp;
2177 wrap_y =
s->linesize;
2178 wrap_c =
s->uvlinesize;
2179 ptr_y =
s->new_picture->data[0] +
2181 ptr_cb =
s->new_picture->data[1] +
2182 (
mb_y * mb_block_height * wrap_c) +
mb_x * mb_block_width;
2183 ptr_cr =
s->new_picture->data[2] +
2184 (
mb_y * mb_block_height * wrap_c) +
mb_x * mb_block_width;
2187 uint8_t *ebuf =
s->sc.edge_emu_buffer + 38 * wrap_y;
2190 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2193 s->width,
s->height);
2195 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2197 mb_block_width, mb_block_height,
2198 mb_x * mb_block_width,
mb_y * mb_block_height,
2200 ptr_cb = ebuf + 16 * wrap_y;
2201 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2203 mb_block_width, mb_block_height,
2204 mb_x * mb_block_width,
mb_y * mb_block_height,
2206 ptr_cr = ebuf + 16 * wrap_y + 16;
2211 int progressive_score, interlaced_score;
2213 s->interlaced_dct = 0;
2214 progressive_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
NULL, wrap_y, 8) +
2215 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y * 8,
2216 NULL, wrap_y, 8) - 400;
2218 if (progressive_score > 0) {
2219 interlaced_score =
s->mecc.ildct_cmp[4](
s, ptr_y,
2220 NULL, wrap_y * 2, 8) +
2221 s->mecc.ildct_cmp[4](
s, ptr_y + wrap_y,
2222 NULL, wrap_y * 2, 8);
2223 if (progressive_score > interlaced_score) {
2224 s->interlaced_dct = 1;
2227 uv_dct_offset = wrap_c;
2236 s->pdsp.get_pixels(
s->block[0], ptr_y, wrap_y);
2237 s->pdsp.get_pixels(
s->block[1], ptr_y + 8, wrap_y);
2238 s->pdsp.get_pixels(
s->block[2], ptr_y +
dct_offset, wrap_y);
2239 s->pdsp.get_pixels(
s->block[3], ptr_y +
dct_offset + 8, wrap_y);
2245 s->pdsp.get_pixels(
s->block[4], ptr_cb, wrap_c);
2246 s->pdsp.get_pixels(
s->block[5], ptr_cr, wrap_c);
2248 s->pdsp.get_pixels(
s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2249 s->pdsp.get_pixels(
s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2251 s->pdsp.get_pixels(
s->block[ 6], ptr_cb + 8, wrap_c);
2252 s->pdsp.get_pixels(
s->block[ 7], ptr_cr + 8, wrap_c);
2253 s->pdsp.get_pixels(
s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2254 s->pdsp.get_pixels(
s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2255 s->pdsp.get_pixels(
s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2256 s->pdsp.get_pixels(
s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2262 uint8_t *dest_y, *dest_cb, *dest_cr;
2264 dest_y =
s->dest[0];
2265 dest_cb =
s->dest[1];
2266 dest_cr =
s->dest[2];
2269 op_pix =
s->hdsp.put_pixels_tab;
2270 op_qpix =
s->qdsp.put_qpel_pixels_tab;
2272 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
2273 op_qpix =
s->qdsp.put_no_rnd_qpel_pixels_tab;
2278 s->last_picture.f->data,
2280 op_pix =
s->hdsp.avg_pixels_tab;
2281 op_qpix =
s->qdsp.avg_qpel_pixels_tab;
2285 s->next_picture.f->data,
2290 int progressive_score, interlaced_score;
2292 s->interlaced_dct = 0;
2293 progressive_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y, wrap_y, 8) +
2294 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y * 8,
2299 progressive_score -= 400;
2301 if (progressive_score > 0) {
2302 interlaced_score =
s->mecc.ildct_cmp[0](
s, dest_y, ptr_y,
2304 s->mecc.ildct_cmp[0](
s, dest_y + wrap_y,
2308 if (progressive_score > interlaced_score) {
2309 s->interlaced_dct = 1;
2312 uv_dct_offset = wrap_c;
2320 s->pdsp.diff_pixels(
s->block[0], ptr_y, dest_y, wrap_y);
2321 s->pdsp.diff_pixels(
s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2324 s->pdsp.diff_pixels(
s->block[3], ptr_y +
dct_offset + 8,
2331 s->pdsp.diff_pixels(
s->block[4], ptr_cb, dest_cb, wrap_c);
2332 s->pdsp.diff_pixels(
s->block[5], ptr_cr, dest_cr, wrap_c);
2334 s->pdsp.diff_pixels(
s->block[6], ptr_cb + uv_dct_offset,
2335 dest_cb + uv_dct_offset, wrap_c);
2336 s->pdsp.diff_pixels(
s->block[7], ptr_cr + uv_dct_offset,
2337 dest_cr + uv_dct_offset, wrap_c);
2341 if (
s->mc_mb_var[
s->mb_stride *
mb_y +
mb_x] < 2 *
s->qscale *
s->qscale) {
2343 if (
s->mecc.sad[1](
NULL, ptr_y, dest_y, wrap_y, 8) < 20 *
s->qscale)
2345 if (
s->mecc.sad[1](
NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 *
s->qscale)
2348 wrap_y, 8) < 20 *
s->qscale)
2351 wrap_y, 8) < 20 *
s->qscale)
2353 if (
s->mecc.sad[1](
NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 *
s->qscale)
2355 if (
s->mecc.sad[1](
NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 *
s->qscale)
2358 if (
s->mecc.sad[1](
NULL, ptr_cb + uv_dct_offset,
2359 dest_cb + uv_dct_offset,
2360 wrap_c, 8) < 20 *
s->qscale)
2362 if (
s->mecc.sad[1](
NULL, ptr_cr + uv_dct_offset,
2363 dest_cr + uv_dct_offset,
2364 wrap_c, 8) < 20 *
s->qscale)
2370 if (
s->quantizer_noise_shaping) {
2391 memcpy(orig[0],
s->block[0],
sizeof(int16_t) * 64 * mb_block_count);
2397 for (
i = 0;
i < mb_block_count;
i++) {
2400 s->block_last_index[
i] =
s->dct_quantize(
s,
s->block[
i],
i,
s->qscale, &
overflow);
2409 s->block_last_index[
i] = -1;
2411 if (
s->quantizer_noise_shaping) {
2412 for (
i = 0;
i < mb_block_count;
i++) {
2414 s->block_last_index[
i] =
2416 orig[
i],
i,
s->qscale);
2421 if (
s->luma_elim_threshold && !
s->mb_intra)
2422 for (
i = 0;
i < 4;
i++)
2424 if (
s->chroma_elim_threshold && !
s->mb_intra)
2425 for (
i = 4;
i < mb_block_count;
i++)
2429 for (
i = 0;
i < mb_block_count;
i++) {
2430 if (
s->block_last_index[
i] == -1)
2431 s->coded_score[
i] = INT_MAX / 256;
2437 s->block_last_index[4] =
2438 s->block_last_index[5] = 0;
2440 s->block[5][0] = (1024 +
s->c_dc_scale / 2) /
s->c_dc_scale;
2442 for (
i=6;
i<12;
i++) {
2443 s->block_last_index[
i] = 0;
2444 s->block[
i][0] =
s->block[4][0];
2451 for (
i = 0;
i < mb_block_count;
i++) {
2453 if (
s->block_last_index[
i] > 0) {
2454 for (j = 63; j > 0; j--) {
2455 if (
s->block[
i][
s->intra_scantable.permutated[j]])
2458 s->block_last_index[
i] = j;
2464 switch(
s->codec_id){
2467 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2471 if (CONFIG_MPEG4_ENCODER)
2477 if (CONFIG_MSMPEG4ENC)
2481 if (CONFIG_WMV2_ENCODER)
2485 if (CONFIG_H261_ENCODER)
2493 if (CONFIG_H263_ENCODER)
2496 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
2503 if (CONFIG_SPEEDHQ_ENCODER)
2526 memcpy(
d->last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2529 d->mb_skip_run=
s->mb_skip_run;
2531 d->last_dc[
i] =
s->last_dc[
i];
2534 d->mv_bits=
s->mv_bits;
2535 d->i_tex_bits=
s->i_tex_bits;
2536 d->p_tex_bits=
s->p_tex_bits;
2537 d->i_count=
s->i_count;
2538 d->skip_count=
s->skip_count;
2539 d->misc_bits=
s->misc_bits;
2543 d->qscale=
s->qscale;
2544 d->dquant=
s->dquant;
2546 d->esc3_level_length=
s->esc3_level_length;
2554 memcpy(
d->mv,
s->mv, 2*4*2*
sizeof(
int));
2555 memcpy(
d->last_mv,
s->last_mv, 2*2*2*
sizeof(
int));
2558 d->mb_skip_run=
s->mb_skip_run;
2560 d->last_dc[
i] =
s->last_dc[
i];
2563 d->mv_bits=
s->mv_bits;
2564 d->i_tex_bits=
s->i_tex_bits;
2565 d->p_tex_bits=
s->p_tex_bits;
2566 d->i_count=
s->i_count;
2567 d->skip_count=
s->skip_count;
2568 d->misc_bits=
s->misc_bits;
2570 d->mb_intra=
s->mb_intra;
2571 d->mb_skipped=
s->mb_skipped;
2572 d->mv_type=
s->mv_type;
2573 d->mv_dir=
s->mv_dir;
2575 if(
s->data_partitioning){
2577 d->tex_pb=
s->tex_pb;
2581 d->block_last_index[
i]=
s->block_last_index[
i];
2582 d->interlaced_dct=
s->interlaced_dct;
2583 d->qscale=
s->qscale;
2585 d->esc3_level_length=
s->esc3_level_length;
2590 int *dmin,
int *next_block,
int motion_x,
int motion_y)
2593 uint8_t *dest_backup[3];
2597 s->block=
s->blocks[*next_block];
2598 s->pb=
pb[*next_block];
2599 if(
s->data_partitioning){
2600 s->pb2 =
pb2 [*next_block];
2601 s->tex_pb=
tex_pb[*next_block];
2605 memcpy(dest_backup,
s->dest,
sizeof(
s->dest));
2606 s->dest[0] =
s->sc.rd_scratchpad;
2607 s->dest[1] =
s->sc.rd_scratchpad + 16*
s->linesize;
2608 s->dest[2] =
s->sc.rd_scratchpad + 16*
s->linesize + 8;
2615 if(
s->data_partitioning){
2623 score *=
s->lambda2;
2628 memcpy(
s->dest, dest_backup,
sizeof(
s->dest));
2646 else if(
w==8 &&
h==8)
2663 int chroma_mb_w =
w >>
s->chroma_x_shift;
2664 int chroma_mb_h =
h >>
s->chroma_y_shift;
2666 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
2667 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
2671 return s->mecc.nsse[0](
s,
s->new_picture->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
2672 s->dest[0],
s->linesize, 16) +
2673 s->mecc.nsse[1](
s,
s->new_picture->data[1] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2674 s->dest[1],
s->uvlinesize, chroma_mb_h) +
2675 s->mecc.nsse[1](
s,
s->new_picture->data[2] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2676 s->dest[2],
s->uvlinesize, chroma_mb_h);
2678 return s->mecc.sse[0](
NULL,
s->new_picture->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
2679 s->dest[0],
s->linesize, 16) +
2680 s->mecc.sse[1](
NULL,
s->new_picture->data[1] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2681 s->dest[1],
s->uvlinesize, chroma_mb_h) +
2682 s->mecc.sse[1](
NULL,
s->new_picture->data[2] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2683 s->dest[2],
s->uvlinesize, chroma_mb_h);
2686 return sse(
s,
s->new_picture->data[0] +
s->mb_x * 16 +
s->mb_y *
s->linesize * 16,
2687 s->dest[0],
w,
h,
s->linesize) +
2688 sse(
s,
s->new_picture->data[1] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2689 s->dest[1],
w >>
s->chroma_x_shift,
h >>
s->chroma_y_shift,
s->uvlinesize) +
2690 sse(
s,
s->new_picture->data[2] +
s->mb_x * chroma_mb_w +
s->mb_y *
s->uvlinesize * chroma_mb_h,
2691 s->dest[2],
w >>
s->chroma_x_shift,
h >>
s->chroma_y_shift,
s->uvlinesize);
2699 s->me.dia_size=
s->avctx->pre_dia_size;
2700 s->first_slice_line=1;
2701 for(
s->mb_y=
s->end_mb_y-1;
s->mb_y >=
s->start_mb_y;
s->mb_y--) {
2702 for(
s->mb_x=
s->mb_width-1;
s->mb_x >=0 ;
s->mb_x--) {
2705 s->first_slice_line=0;
2716 s->me.dia_size=
s->avctx->dia_size;
2717 s->first_slice_line=1;
2718 for(
s->mb_y=
s->start_mb_y;
s->mb_y <
s->end_mb_y;
s->mb_y++) {
2721 for(
s->mb_x=0;
s->mb_x <
s->mb_width;
s->mb_x++) {
2722 s->block_index[0]+=2;
2723 s->block_index[1]+=2;
2724 s->block_index[2]+=2;
2725 s->block_index[3]+=2;
2733 s->first_slice_line=0;
2746 const uint8_t *pix =
s->new_picture->data[0] + (yy *
s->linesize) + xx;
2748 int sum =
s->mpvencdsp.pix_sum(pix,
s->linesize);
2750 varc = (
s->mpvencdsp.pix_norm1(pix,
s->linesize) -
2751 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2753 s->mb_var [
s->mb_stride *
mb_y +
mb_x] = varc;
2754 s->mb_mean[
s->mb_stride *
mb_y +
mb_x] = (sum+128)>>8;
2755 s->me.mb_var_sum_temp += varc;
2763 if(
s->partitioned_frame){
2768 }
else if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) &&
2771 }
else if (CONFIG_SPEEDHQ_ENCODER &&
s->out_format ==
FMT_SPEEDHQ) {
2783 uint8_t *ptr =
s->mb_info_ptr +
s->mb_info_size - 12;
2785 int mba =
s->mb_x +
s->mb_width * (
s->mb_y %
s->gob_index);
2786 int gobn =
s->mb_y /
s->gob_index;
2788 if (CONFIG_H263_ENCODER)
2790 bytestream_put_le32(&ptr,
offset);
2791 bytestream_put_byte(&ptr,
s->qscale);
2792 bytestream_put_byte(&ptr, gobn);
2793 bytestream_put_le16(&ptr, mba);
2794 bytestream_put_byte(&ptr, pred_x);
2795 bytestream_put_byte(&ptr, pred_y);
2797 bytestream_put_byte(&ptr, 0);
2798 bytestream_put_byte(&ptr, 0);
2806 s->mb_info_size += 12;
2807 s->prev_mb_info =
s->last_mb_info;
2819 if (!
s->mb_info_size)
2820 s->mb_info_size += 12;
2827 &&
s->slice_context_count == 1
2828 &&
s->pb.buf ==
s->avctx->internal->byte_buffer) {
2829 int lastgob_pos =
s->ptr_lastgob -
s->pb.buf;
2831 uint8_t *new_buffer =
NULL;
2832 int new_buffer_size = 0;
2834 if ((
s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2842 s->avctx->internal->byte_buffer_size + size_increase);
2846 memcpy(new_buffer,
s->avctx->internal->byte_buffer,
s->avctx->internal->byte_buffer_size);
2847 av_free(
s->avctx->internal->byte_buffer);
2848 s->avctx->internal->byte_buffer = new_buffer;
2849 s->avctx->internal->byte_buffer_size = new_buffer_size;
2851 s->ptr_lastgob =
s->pb.buf + lastgob_pos;
2861 int chr_h= 16>>
s->chroma_y_shift;
2886 s->last_dc[
i] = 128 <<
s->intra_dc_precision;
2888 s->encoding_error[
i] = 0;
2891 s->last_dc[0] = 128*8/13;
2892 s->last_dc[1] = 128*8/14;
2893 s->last_dc[2] = 128*8/14;
2896 memset(
s->last_mv, 0,
sizeof(
s->last_mv));
2900 switch(
s->codec_id){
2904 if (CONFIG_H263_ENCODER)
2908 if(CONFIG_MPEG4_ENCODER &&
s->partitioned_frame)
2915 s->first_slice_line = 1;
2916 s->ptr_lastgob =
s->pb.buf;
2917 for (mb_y_order =
s->start_mb_y; mb_y_order < s->
end_mb_y; mb_y_order++) {
2921 if (first_in_slice && mb_y_order !=
s->start_mb_y)
2923 s->last_dc[0] =
s->last_dc[1] =
s->last_dc[2] = 1024 <<
s->intra_dc_precision;
2939 int size_increase =
s->avctx->internal->byte_buffer_size/4
2947 if(
s->data_partitioning){
2961 xy=
s->mb_y*
s->mb_stride +
s->mb_x;
2967 int current_packet_size, is_gob_start;
2970 - (
s->ptr_lastgob -
s->pb.buf);
2972 is_gob_start =
s->rtp_payload_size &&
2973 current_packet_size >=
s->rtp_payload_size &&
2976 if(
s->start_mb_y ==
mb_y &&
mb_y > 0 &&
mb_x==0) is_gob_start=1;
2978 switch(
s->codec_id){
2981 if(!
s->h263_slice_structured)
2982 if(
s->mb_x ||
s->mb_y%
s->gob_index) is_gob_start=0;
2985 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
2987 if(
s->mb_skip_run) is_gob_start=0;
2990 if(
s->mb_x==0 &&
s->mb_y!=0) is_gob_start=1;
3006 if (
s->error_rate &&
s->resync_mb_x +
s->resync_mb_y > 0) {
3008 int d = 100 /
s->error_rate;
3010 current_packet_size=0;
3011 s->pb.buf_ptr=
s->ptr_lastgob;
3016 switch(
s->codec_id){
3018 if (CONFIG_MPEG4_ENCODER) {
3025 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3032 if (CONFIG_H263_ENCODER) {
3041 s->misc_bits+=
bits -
s->last_bits;
3045 s->ptr_lastgob += current_packet_size;
3046 s->first_slice_line=1;
3047 s->resync_mb_x=
mb_x;
3048 s->resync_mb_y=
mb_y;
3052 if( (
s->resync_mb_x ==
s->mb_x)
3053 &&
s->resync_mb_y+1 ==
s->mb_y){
3054 s->first_slice_line=0;
3064 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3070 if(
s->data_partitioning){
3071 backup_s.pb2=
s->pb2;
3072 backup_s.tex_pb=
s->tex_pb;
3079 s->mv[0][0][0] =
s->p_mv_table[xy][0];
3080 s->mv[0][0][1] =
s->p_mv_table[xy][1];
3082 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3089 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3090 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3091 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3094 &dmin, &next_block, 0, 0);
3103 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3110 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3111 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3114 &dmin, &next_block, 0, 0);
3120 s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3121 s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3123 &dmin, &next_block,
s->mv[0][0][0],
s->mv[0][0][1]);
3129 s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3130 s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3132 &dmin, &next_block,
s->mv[1][0][0],
s->mv[1][0][1]);
3138 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3139 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3140 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3141 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3143 &dmin, &next_block, 0, 0);
3150 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3151 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3152 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3155 &dmin, &next_block, 0, 0);
3162 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3163 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3164 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3167 &dmin, &next_block, 0, 0);
3173 for(dir=0; dir<2; dir++){
3175 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3176 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3177 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3181 &dmin, &next_block, 0, 0);
3190 &dmin, &next_block, 0, 0);
3191 if(
s->h263_pred ||
s->h263_aic){
3193 s->mbintra_table[
mb_x +
mb_y*
s->mb_stride]=1;
3201 const int last_qp= backup_s.qscale;
3205 static const int dquant_tab[4]={-1,1,-2,2};
3206 int storecoefs =
s->mb_intra &&
s->dc_val[0];
3214 s->mv[0][0][0] = best_s.
mv[0][0][0];
3215 s->mv[0][0][1] = best_s.
mv[0][0][1];
3216 s->mv[1][0][0] = best_s.
mv[1][0][0];
3217 s->mv[1][0][1] = best_s.
mv[1][0][1];
3220 for(; qpi<4; qpi++){
3221 int dquant= dquant_tab[qpi];
3223 if(qp < s->
avctx->
qmin || qp >
s->avctx->qmax)
3228 dc[
i]=
s->dc_val[0][
s->block_index[
i] ];
3229 memcpy(ac[
i],
s->ac_val[0][
s->block_index[
i]],
sizeof(int16_t)*16);
3234 &dmin, &next_block,
s->mv[mvdir][0][0],
s->mv[mvdir][0][1]);
3238 s->dc_val[0][
s->block_index[
i] ]=
dc[
i];
3239 memcpy(
s->ac_val[0][
s->block_index[
i]], ac[
i],
sizeof(int16_t)*16);
3247 int mx=
s->b_direct_mv_table[xy][0];
3248 int my=
s->b_direct_mv_table[xy][1];
3250 backup_s.dquant = 0;
3255 &dmin, &next_block, mx, my);
3258 backup_s.dquant = 0;
3263 &dmin, &next_block, 0, 0);
3268 coded |=
s->block_last_index[
i];
3271 memcpy(
s->mv, best_s.
mv,
sizeof(
s->mv));
3293 &dmin, &next_block, mx, my);
3298 s->current_picture.qscale_table[xy] = best_s.
qscale;
3304 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3307 if(
s->data_partitioning){
3310 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3311 s->pb2= backup_s.pb2;
3315 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3316 s->tex_pb= backup_s.tex_pb;
3320 if (CONFIG_H263_ENCODER &&
3325 s->hdsp.put_pixels_tab[0][0](
s->dest[0],
s->sc.rd_scratchpad ,
s->linesize ,16);
3326 s->hdsp.put_pixels_tab[1][0](
s->dest[1],
s->sc.rd_scratchpad + 16*
s->linesize ,
s->uvlinesize, 8);
3327 s->hdsp.put_pixels_tab[1][0](
s->dest[2],
s->sc.rd_scratchpad + 16*
s->linesize + 8,
s->uvlinesize, 8);
3333 int motion_x = 0, motion_y = 0;
3341 motion_x=
s->mv[0][0][0] = 0;
3342 motion_y=
s->mv[0][0][1] = 0;
3347 motion_x=
s->mv[0][0][0] =
s->p_mv_table[xy][0];
3348 motion_y=
s->mv[0][0][1] =
s->p_mv_table[xy][1];
3355 j=
s->field_select[0][
i] =
s->p_field_select_table[
i][xy];
3356 s->mv[0][
i][0] =
s->p_field_mv_table[
i][j][xy][0];
3357 s->mv[0][
i][1] =
s->p_field_mv_table[
i][j][xy][1];
3365 s->mv[0][
i][0] =
s->current_picture.motion_val[0][
s->block_index[
i]][0];
3366 s->mv[0][
i][1] =
s->current_picture.motion_val[0][
s->block_index[
i]][1];
3370 if (CONFIG_MPEG4_ENCODER) {
3373 motion_x=
s->b_direct_mv_table[xy][0];
3374 motion_y=
s->b_direct_mv_table[xy][1];
3379 if (CONFIG_MPEG4_ENCODER) {
3388 s->mv[0][0][0] =
s->b_bidir_forw_mv_table[xy][0];
3389 s->mv[0][0][1] =
s->b_bidir_forw_mv_table[xy][1];
3390 s->mv[1][0][0] =
s->b_bidir_back_mv_table[xy][0];
3391 s->mv[1][0][1] =
s->b_bidir_back_mv_table[xy][1];
3396 motion_x=
s->mv[1][0][0] =
s->b_back_mv_table[xy][0];
3397 motion_y=
s->mv[1][0][1] =
s->b_back_mv_table[xy][1];
3402 motion_x=
s->mv[0][0][0] =
s->b_forw_mv_table[xy][0];
3403 motion_y=
s->mv[0][0][1] =
s->b_forw_mv_table[xy][1];
3410 j=
s->field_select[0][
i] =
s->b_field_select_table[0][
i][xy];
3411 s->mv[0][
i][0] =
s->b_field_mv_table[0][
i][j][xy][0];
3412 s->mv[0][
i][1] =
s->b_field_mv_table[0][
i][j][xy][1];
3420 j=
s->field_select[1][
i] =
s->b_field_select_table[1][
i][xy];
3421 s->mv[1][
i][0] =
s->b_field_mv_table[1][
i][j][xy][0];
3422 s->mv[1][
i][1] =
s->b_field_mv_table[1][
i][j][xy][1];
3429 for(dir=0; dir<2; dir++){
3431 j=
s->field_select[dir][
i] =
s->b_field_select_table[dir][
i][xy];
3432 s->mv[dir][
i][0] =
s->b_field_mv_table[dir][
i][j][xy][0];
3433 s->mv[dir][
i][1] =
s->b_field_mv_table[dir][
i][j][xy][1];
3444 s->last_mv_dir =
s->mv_dir;
3446 if (CONFIG_H263_ENCODER &&
3455 s->p_mv_table[xy][0]=0;
3456 s->p_mv_table[xy][1]=0;
3463 if(
s->mb_x*16 + 16 >
s->width )
w=
s->width -
s->mb_x*16;
3464 if(
s->mb_y*16 + 16 >
s->height)
h=
s->height-
s->mb_y*16;
3466 s->encoding_error[0] +=
sse(
3467 s,
s->new_picture->data[0] +
s->mb_x*16 +
s->mb_y*
s->linesize*16,
3468 s->dest[0],
w,
h,
s->linesize);
3469 s->encoding_error[1] +=
sse(
3470 s,
s->new_picture->data[1] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3471 s->dest[1],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3472 s->encoding_error[2] +=
sse(
3473 s,
s->new_picture->data[2] +
s->mb_x*8 +
s->mb_y*
s->uvlinesize*chr_h,
3474 s->dest[2],
w>>1,
h>>
s->chroma_y_shift,
s->uvlinesize);
3477 if(CONFIG_H263_ENCODER &&
s->out_format ==
FMT_H263)
3480 ff_dlog(
s->avctx,
"MB %d %d bits\n",
3486 if (CONFIG_MSMPEG4ENC &&
s->msmpeg4_version &&
s->msmpeg4_version<4 &&
s->pict_type ==
AV_PICTURE_TYPE_I)
3494 #define MERGE(field) dst->field += src->field; src->field=0
3517 for(
i=0;
i<64;
i++){
3530 if (
s->next_lambda){
3531 s->current_picture_ptr->f->quality =
3532 s->current_picture.f->quality =
s->next_lambda;
3533 if(!dry_run)
s->next_lambda= 0;
3534 }
else if (!
s->fixed_qscale) {
3536 s->current_picture_ptr->f->quality =
3537 s->current_picture.f->quality =
quality;
3538 if (
s->current_picture.f->quality < 0)
3542 if(
s->adaptive_quant){
3543 switch(
s->codec_id){
3545 if (CONFIG_MPEG4_ENCODER)
3551 if (CONFIG_H263_ENCODER)
3558 s->lambda=
s->lambda_table[0];
3561 s->lambda =
s->current_picture.f->quality;
3569 s->time =
s->current_picture_ptr->f->pts *
s->avctx->time_base.num;
3572 s->pb_time=
s->pp_time - (
s->last_non_b_time -
s->time);
3575 s->pp_time=
s->time -
s->last_non_b_time;
3576 s->last_non_b_time=
s->time;
3585 int context_count =
s->slice_context_count;
3588 s->me.mb_var_sum_temp =
3589 s->me.mc_mb_var_sum_temp = 0;
3593 if (
s->out_format ==
FMT_MPEG1 || (
s->h263_pred && !
s->msmpeg4_version))
3598 s->me.scene_change_score=0;
3603 if(
s->msmpeg4_version >= 3)
s->no_rounding=1;
3604 else s->no_rounding=0;
3607 s->no_rounding ^= 1;
3616 s->lambda=
s->last_lambda_for[
s->pict_type];
3618 s->lambda=
s->last_lambda_for[
s->last_non_b_pict_type];
3623 if(
s->q_chroma_intra_matrix !=
s->q_intra_matrix )
av_freep(&
s->q_chroma_intra_matrix);
3624 if(
s->q_chroma_intra_matrix16 !=
s->q_intra_matrix16)
av_freep(&
s->q_chroma_intra_matrix16);
3625 s->q_chroma_intra_matrix =
s->q_intra_matrix;
3626 s->q_chroma_intra_matrix16 =
s->q_intra_matrix16;
3630 for(
i=1;
i<context_count;
i++){
3641 s->lambda = (
s->lambda *
s->me_penalty_compensation + 128) >> 8;
3642 s->lambda2 = (
s->lambda2 * (int64_t)
s->me_penalty_compensation + 128) >> 8;
3653 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3656 if(!
s->fixed_qscale){
3658 s->avctx->execute(
s->avctx,
mb_var_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3661 for(
i=1;
i<context_count;
i++){
3664 s->mc_mb_var_sum =
s->me.mc_mb_var_sum_temp;
3665 s->mb_var_sum =
s->me. mb_var_sum_temp;
3668 if (
s->me.scene_change_score >
s->scenechange_threshold &&
3671 for(
i=0;
i<
s->mb_stride*
s->mb_height;
i++)
3673 if(
s->msmpeg4_version >= 3)
3675 ff_dlog(
s,
"Scene change detected, encoding as I Frame %"PRId64
" %"PRId64
"\n",
3676 s->mb_var_sum,
s->mc_mb_var_sum);
3717 for(dir=0; dir<2; dir++){
3723 s->b_field_mv_table[dir][
i][j], dir ?
s->b_code :
s->f_code,
type, 1);
3734 if (
s->qscale < 3 &&
s->max_qcoeff <= 128 &&
3743 if (
s->avctx->intra_matrix) {
3745 luma_matrix =
s->avctx->intra_matrix;
3747 if (
s->avctx->chroma_intra_matrix)
3748 chroma_matrix =
s->avctx->chroma_intra_matrix;
3752 int j =
s->idsp.idct_permutation[
i];
3754 s->chroma_intra_matrix[j] =
av_clip_uint8((chroma_matrix[
i] *
s->qscale) >> 3);
3757 s->y_dc_scale_table=
3759 s->chroma_intra_matrix[0] =
3762 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3764 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3768 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};
3769 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};
3770 for (
int i = 1;
i < 64;
i++) {
3776 s->y_dc_scale_table = y;
3777 s->c_dc_scale_table =
c;
3778 s->intra_matrix[0] = 13;
3779 s->chroma_intra_matrix[0] = 14;
3781 s->intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3783 s->chroma_intra_matrix,
s->intra_quant_bias, 8, 8, 1);
3796 s->current_picture_ptr->f->pict_type =
3797 s->current_picture.f->pict_type =
s->pict_type;
3800 s->picture_in_gop_number=0;
3802 s->mb_x =
s->mb_y = 0;
3804 switch(
s->out_format) {
3805 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
3811 if (CONFIG_SPEEDHQ_ENCODER)
3815 if (CONFIG_H261_ENCODER)
3821 else if (CONFIG_MSMPEG4ENC &&
s->msmpeg4_version)
3823 else if (CONFIG_MPEG4_ENCODER &&
s->h263_pred) {
3836 else if (CONFIG_H263_ENCODER)
3840 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3847 s->header_bits=
bits -
s->last_bits;
3849 for(
i=1;
i<context_count;
i++){
3852 s->avctx->execute(
s->avctx,
encode_thread, &
s->thread_context[0],
NULL, context_count,
sizeof(
void*));
3853 for(
i=1;
i<context_count;
i++){
3854 if (
s->pb.buf_end ==
s->thread_context[
i]->pb.buf)
3863 const int intra=
s->mb_intra;
3866 s->dct_count[intra]++;
3868 for(
i=0;
i<64;
i++){
3873 s->dct_error_sum[intra][
i] +=
level;
3874 level -=
s->dct_offset[intra][
i];
3877 s->dct_error_sum[intra][
i] -=
level;
3878 level +=
s->dct_offset[intra][
i];
3887 int16_t *
block,
int n,
3891 const uint8_t *scantable;
3892 const uint8_t *perm_scantable;
3894 unsigned int threshold1, threshold2;
3906 int coeff_count[64];
3907 int qmul, qadd, start_i, last_non_zero,
i,
dc;
3908 const int esc_length=
s->ac_esc_length;
3910 uint8_t * last_length;
3916 if(
s->dct_error_sum)
3922 else mpeg2_qscale =
qscale << 1;
3926 scantable=
s->intra_scantable.scantable;
3927 perm_scantable=
s->intra_scantable.permutated;
3944 qmat = n < 4 ?
s->q_intra_matrix[
qscale] :
s->q_chroma_intra_matrix[
qscale];
3945 matrix = n < 4 ?
s->intra_matrix :
s->chroma_intra_matrix;
3949 if (n > 3 &&
s->intra_chroma_ac_vlc_length) {
3950 length =
s->intra_chroma_ac_vlc_length;
3951 last_length=
s->intra_chroma_ac_vlc_last_length;
3953 length =
s->intra_ac_vlc_length;
3954 last_length=
s->intra_ac_vlc_last_length;
3957 scantable=
s->inter_scantable.scantable;
3958 perm_scantable=
s->inter_scantable.permutated;
3961 qmat =
s->q_inter_matrix[
qscale];
3963 length =
s->inter_ac_vlc_length;
3964 last_length=
s->inter_ac_vlc_last_length;
3969 threshold2= (threshold1<<1);
3971 for(
i=63;
i>=start_i;
i--) {
3972 const int j = scantable[
i];
3975 if(((
unsigned)(
level+threshold1))>threshold2){
3981 for(
i=start_i;
i<=last_non_zero;
i++) {
3982 const int j = scantable[
i];
3987 if(((
unsigned)(
level+threshold1))>threshold2){
4010 if(last_non_zero < start_i){
4011 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4012 return last_non_zero;
4015 score_tab[start_i]= 0;
4016 survivor[0]= start_i;
4019 for(
i=start_i;
i<=last_non_zero;
i++){
4020 int level_index, j, zero_distortion;
4022 int best_score=256*256*256*120;
4026 zero_distortion= dct_coeff*dct_coeff;
4028 for(level_index=0; level_index < coeff_count[
i]; level_index++){
4037 unquant_coeff= alevel*qmul + qadd;
4039 j =
s->idsp.idct_permutation[scantable[
i]];
4040 unquant_coeff = alevel *
matrix[j] * 8;
4042 j =
s->idsp.idct_permutation[scantable[
i]];
4044 unquant_coeff = (
int)( alevel * mpeg2_qscale *
matrix[j]) >> 4;
4045 unquant_coeff = (unquant_coeff - 1) | 1;
4047 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int)
matrix[j])) >> 5;
4048 unquant_coeff = (unquant_coeff - 1) | 1;
4053 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4055 if((
level&(~127)) == 0){
4056 for(j=survivor_count-1; j>=0; j--){
4057 int run=
i - survivor[j];
4059 score += score_tab[
i-
run];
4061 if(score < best_score){
4064 level_tab[
i+1]=
level-64;
4069 for(j=survivor_count-1; j>=0; j--){
4070 int run=
i - survivor[j];
4072 score += score_tab[
i-
run];
4073 if(score < last_score){
4076 last_level=
level-64;
4082 distortion += esc_length*
lambda;
4083 for(j=survivor_count-1; j>=0; j--){
4084 int run=
i - survivor[j];
4085 int score= distortion + score_tab[
i-
run];
4087 if(score < best_score){
4090 level_tab[
i+1]=
level-64;
4095 for(j=survivor_count-1; j>=0; j--){
4096 int run=
i - survivor[j];
4097 int score= distortion + score_tab[
i-
run];
4098 if(score < last_score){
4101 last_level=
level-64;
4109 score_tab[
i+1]= best_score;
4112 if(last_non_zero <= 27){
4113 for(; survivor_count; survivor_count--){
4114 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4118 for(; survivor_count; survivor_count--){
4119 if(score_tab[ survivor[survivor_count-1] ] <= best_score +
lambda)
4124 survivor[ survivor_count++ ]=
i+1;
4128 last_score= 256*256*256*120;
4129 for(
i= survivor[0];
i<=last_non_zero + 1;
i++){
4130 int score= score_tab[
i];
4134 if(score < last_score){
4137 last_level= level_tab[
i];
4138 last_run= run_tab[
i];
4143 s->coded_score[n] = last_score;
4146 last_non_zero= last_i - 1;
4147 memset(
block + start_i, 0, (64-start_i)*
sizeof(int16_t));
4149 if(last_non_zero < start_i)
4150 return last_non_zero;
4152 if(last_non_zero == 0 && start_i == 0){
4154 int best_score=
dc *
dc;
4156 for(
i=0;
i<coeff_count[0];
i++){
4159 int unquant_coeff, score, distortion;
4162 unquant_coeff= (alevel*qmul + qadd)>>3;
4164 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((
int)
matrix[0])) >> 5;
4165 unquant_coeff = (unquant_coeff - 1) | 1;
4167 unquant_coeff = (unquant_coeff + 4) >> 3;
4168 unquant_coeff<<= 3 + 3;
4170 distortion= (unquant_coeff -
dc) * (unquant_coeff -
dc);
4173 else score= distortion + esc_length*
lambda;
4175 if(score < best_score){
4177 best_level=
level - 64;
4180 block[0]= best_level;
4181 s->coded_score[n] = best_score -
dc*
dc;
4182 if(best_level == 0)
return -1;
4183 else return last_non_zero;
4189 block[ perm_scantable[last_non_zero] ]= last_level;
4192 for(;
i>start_i;
i -= run_tab[
i] + 1){
4193 block[ perm_scantable[
i-1] ]= level_tab[
i];
4196 return last_non_zero;
4211 if(
i==0)
s*= sqrt(0.5);
4212 if(j==0)
s*= sqrt(0.5);
4225 const uint8_t *scantable;
4226 const uint8_t *perm_scantable;