2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
42 #include "aandcttab.h"
44 #include "mpeg4video.h"
46 #include "bytestream.h"
53 static int encode_picture(MpegEncContext *s, int picture_number);
54 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
55 static int sse_mb(MpegEncContext *s);
56 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
57 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 /* enable all paranoid tests for rounding, overflows, etc... */
64 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
65 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
67 const AVOption ff_mpv_generic_options[] = {
72 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
73 uint16_t (*qmat16)[2][64],
74 const uint16_t *quant_matrix,
75 int bias, int qmin, int qmax, int intra)
80 for (qscale = qmin; qscale <= qmax; qscale++) {
82 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
83 dsp->fdct == ff_jpeg_fdct_islow_10 ||
84 dsp->fdct == ff_faandct) {
85 for (i = 0; i < 64; i++) {
86 const int j = dsp->idct_permutation[i];
87 /* 16 <= qscale * quant_matrix[i] <= 7905
88 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
89 * 19952 <= x <= 249205026
90 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
91 * 3444240 >= (1 << 36) / (x) >= 275 */
93 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
94 (qscale * quant_matrix[j]));
96 } else if (dsp->fdct == ff_fdct_ifast) {
97 for (i = 0; i < 64; i++) {
98 const int j = dsp->idct_permutation[i];
99 /* 16 <= qscale * quant_matrix[i] <= 7905
100 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101 * 19952 <= x <= 249205026
102 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103 * 3444240 >= (1 << 36) / (x) >= 275 */
105 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
106 (ff_aanscales[i] * qscale * quant_matrix[j]));
109 for (i = 0; i < 64; i++) {
110 const int j = dsp->idct_permutation[i];
111 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
112 * Assume x = qscale * quant_matrix[i]
114 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
115 * so 32768 >= (1 << 19) / (x) >= 67 */
116 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
117 (qscale * quant_matrix[j]));
118 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
119 // (qscale * quant_matrix[i]);
120 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
121 (qscale * quant_matrix[j]);
123 if (qmat16[qscale][0][i] == 0 ||
124 qmat16[qscale][0][i] == 128 * 256)
125 qmat16[qscale][0][i] = 128 * 256 - 1;
126 qmat16[qscale][1][i] =
127 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
128 qmat16[qscale][0][i]);
132 for (i = intra; i < 64; i++) {
134 if (dsp->fdct == ff_fdct_ifast) {
135 max = (8191LL * ff_aanscales[i]) >> 14;
137 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
143 av_log(NULL, AV_LOG_INFO,
144 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
149 static inline void update_qscale(MpegEncContext *s)
151 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
152 (FF_LAMBDA_SHIFT + 7);
153 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
155 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
159 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165 for (i = 0; i < 64; i++) {
166 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
173 * init s->current_picture.qscale_table from s->lambda_table
175 void ff_init_qscale_tab(MpegEncContext *s)
177 int8_t * const qscale_table = s->current_picture.f.qscale_table;
180 for (i = 0; i < s->mb_num; i++) {
181 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
182 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
183 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
188 static void copy_picture_attributes(MpegEncContext *s,
194 dst->pict_type = src->pict_type;
195 dst->quality = src->quality;
196 dst->coded_picture_number = src->coded_picture_number;
197 dst->display_picture_number = src->display_picture_number;
198 //dst->reference = src->reference;
200 dst->interlaced_frame = src->interlaced_frame;
201 dst->top_field_first = src->top_field_first;
203 if (s->avctx->me_threshold) {
204 if (!src->motion_val[0])
205 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
207 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
208 if (!src->ref_index[0])
209 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
210 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
211 av_log(s->avctx, AV_LOG_ERROR,
212 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
213 src->motion_subsample_log2, dst->motion_subsample_log2);
215 memcpy(dst->mb_type, src->mb_type,
216 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
218 for (i = 0; i < 2; i++) {
219 int stride = ((16 * s->mb_width ) >>
220 src->motion_subsample_log2) + 1;
221 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
223 if (src->motion_val[i] &&
224 src->motion_val[i] != dst->motion_val[i]) {
225 memcpy(dst->motion_val[i], src->motion_val[i],
226 2 * stride * height * sizeof(int16_t));
228 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
229 memcpy(dst->ref_index[i], src->ref_index[i],
230 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
236 static void update_duplicate_context_after_me(MpegEncContext *dst,
239 #define COPY(a) dst->a= src->a
241 COPY(current_picture);
247 COPY(picture_in_gop_number);
248 COPY(gop_picture_number);
249 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
250 COPY(progressive_frame); // FIXME don't set in encode_header
251 COPY(partitioned_frame); // FIXME don't set in encode_header
256 * Set the given MpegEncContext to defaults for encoding.
257 * the changed fields will not depend upon the prior state of the MpegEncContext.
259 static void MPV_encode_defaults(MpegEncContext *s)
262 ff_MPV_common_defaults(s);
264 for (i = -16; i < 16; i++) {
265 default_fcode_tab[i + MAX_MV] = 1;
267 s->me.mv_penalty = default_mv_penalty;
268 s->fcode_tab = default_fcode_tab;
271 /* init video encoder */
272 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
274 MpegEncContext *s = avctx->priv_data;
276 int chroma_h_shift, chroma_v_shift;
278 MPV_encode_defaults(s);
280 switch (avctx->codec_id) {
281 case CODEC_ID_MPEG2VIDEO:
282 if (avctx->pix_fmt != PIX_FMT_YUV420P &&
283 avctx->pix_fmt != PIX_FMT_YUV422P) {
284 av_log(avctx, AV_LOG_ERROR,
285 "only YUV420 and YUV422 are supported\n");
290 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
291 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
292 avctx->pix_fmt != PIX_FMT_YUVJ444P &&
293 avctx->pix_fmt != PIX_FMT_BGR0 &&
294 avctx->pix_fmt != PIX_FMT_BGRA &&
295 avctx->pix_fmt != PIX_FMT_BGR24 &&
296 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
297 avctx->pix_fmt != PIX_FMT_YUV422P &&
298 avctx->pix_fmt != PIX_FMT_YUV444P) ||
299 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
300 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
306 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
307 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
308 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
309 avctx->pix_fmt != PIX_FMT_YUV422P) ||
310 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
311 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
316 if (avctx->pix_fmt != PIX_FMT_YUV420P) {
317 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
322 switch (avctx->pix_fmt) {
323 case PIX_FMT_YUVJ422P:
324 case PIX_FMT_YUV422P:
325 s->chroma_format = CHROMA_422;
327 case PIX_FMT_YUVJ420P:
328 case PIX_FMT_YUV420P:
330 s->chroma_format = CHROMA_420;
334 s->bit_rate = avctx->bit_rate;
335 s->width = avctx->width;
336 s->height = avctx->height;
337 if (avctx->gop_size > 600 &&
338 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
339 av_log(avctx, AV_LOG_WARNING,
340 "keyframe interval too large!, reducing it from %d to %d\n",
341 avctx->gop_size, 600);
342 avctx->gop_size = 600;
344 s->gop_size = avctx->gop_size;
346 s->flags = avctx->flags;
347 s->flags2 = avctx->flags2;
348 s->max_b_frames = avctx->max_b_frames;
349 s->codec_id = avctx->codec->id;
350 #if FF_API_MPV_GLOBAL_OPTS
351 if (avctx->luma_elim_threshold)
352 s->luma_elim_threshold = avctx->luma_elim_threshold;
353 if (avctx->chroma_elim_threshold)
354 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
356 s->strict_std_compliance = avctx->strict_std_compliance;
357 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
358 s->mpeg_quant = avctx->mpeg_quant;
359 s->rtp_mode = !!avctx->rtp_payload_size;
360 s->intra_dc_precision = avctx->intra_dc_precision;
361 s->user_specified_pts = AV_NOPTS_VALUE;
363 if (s->gop_size <= 1) {
370 s->me_method = avctx->me_method;
373 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
375 #if FF_API_MPV_GLOBAL_OPTS
376 if (s->flags & CODEC_FLAG_QP_RD)
377 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
380 s->adaptive_quant = (s->avctx->lumi_masking ||
381 s->avctx->dark_masking ||
382 s->avctx->temporal_cplx_masking ||
383 s->avctx->spatial_cplx_masking ||
384 s->avctx->p_masking ||
385 s->avctx->border_masking ||
386 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
389 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
391 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
392 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
393 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
397 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
398 av_log(avctx, AV_LOG_INFO,
399 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
402 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
403 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
407 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
408 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
412 if (avctx->rc_max_rate &&
413 avctx->rc_max_rate == avctx->bit_rate &&
414 avctx->rc_max_rate != avctx->rc_min_rate) {
415 av_log(avctx, AV_LOG_INFO,
416 "impossible bitrate constraints, this will fail\n");
419 if (avctx->rc_buffer_size &&
420 avctx->bit_rate * (int64_t)avctx->time_base.num >
421 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
422 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
426 if (!s->fixed_qscale &&
427 avctx->bit_rate * av_q2d(avctx->time_base) >
428 avctx->bit_rate_tolerance) {
429 av_log(avctx, AV_LOG_ERROR,
430 "bitrate tolerance too small for bitrate\n");
434 if (s->avctx->rc_max_rate &&
435 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
436 (s->codec_id == CODEC_ID_MPEG1VIDEO ||
437 s->codec_id == CODEC_ID_MPEG2VIDEO) &&
438 90000LL * (avctx->rc_buffer_size - 1) >
439 s->avctx->rc_max_rate * 0xFFFFLL) {
440 av_log(avctx, AV_LOG_INFO,
441 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
442 "specified vbv buffer is too large for the given bitrate!\n");
445 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 &&
446 s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P &&
447 s->codec_id != CODEC_ID_FLV1) {
448 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
452 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
453 av_log(avctx, AV_LOG_ERROR,
454 "OBMC is only supported with simple mb decision\n");
458 if (s->quarter_sample && s->codec_id != CODEC_ID_MPEG4) {
459 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
463 if (s->max_b_frames &&
464 s->codec_id != CODEC_ID_MPEG4 &&
465 s->codec_id != CODEC_ID_MPEG1VIDEO &&
466 s->codec_id != CODEC_ID_MPEG2VIDEO) {
467 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
471 if ((s->codec_id == CODEC_ID_MPEG4 ||
472 s->codec_id == CODEC_ID_H263 ||
473 s->codec_id == CODEC_ID_H263P) &&
474 (avctx->sample_aspect_ratio.num > 255 ||
475 avctx->sample_aspect_ratio.den > 255)) {
476 av_log(avctx, AV_LOG_WARNING,
477 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
478 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
479 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
480 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
483 if ((s->codec_id == CODEC_ID_H263 ||
484 s->codec_id == CODEC_ID_H263P) &&
485 (avctx->width > 2048 ||
486 avctx->height > 1152 )) {
487 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
490 if ((s->codec_id == CODEC_ID_H263 ||
491 s->codec_id == CODEC_ID_H263P) &&
492 ((avctx->width &3) ||
493 (avctx->height&3) )) {
494 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
498 if (s->codec_id == CODEC_ID_MPEG1VIDEO &&
499 (avctx->width > 4095 ||
500 avctx->height > 4095 )) {
501 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
505 if (s->codec_id == CODEC_ID_MPEG2VIDEO &&
506 (avctx->width > 16383 ||
507 avctx->height > 16383 )) {
508 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
512 if ((s->codec_id == CODEC_ID_WMV1 ||
513 s->codec_id == CODEC_ID_WMV2) &&
515 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
519 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
520 s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO) {
521 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
525 // FIXME mpeg2 uses that too
526 if (s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4) {
527 av_log(avctx, AV_LOG_ERROR,
528 "mpeg2 style quantization not supported by codec\n");
532 #if FF_API_MPV_GLOBAL_OPTS
533 if (s->flags & CODEC_FLAG_CBP_RD)
534 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
537 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
538 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
542 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
543 s->avctx->mb_decision != FF_MB_DECISION_RD) {
544 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
548 if (s->avctx->scenechange_threshold < 1000000000 &&
549 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
550 av_log(avctx, AV_LOG_ERROR,
551 "closed gop with scene change detection are not supported yet, "
552 "set threshold to 1000000000\n");
556 if (s->flags & CODEC_FLAG_LOW_DELAY) {
557 if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
558 av_log(avctx, AV_LOG_ERROR,
559 "low delay forcing is only available for mpeg2\n");
562 if (s->max_b_frames != 0) {
563 av_log(avctx, AV_LOG_ERROR,
564 "b frames cannot be used with low delay\n");
569 if (s->q_scale_type == 1) {
570 if (avctx->qmax > 12) {
571 av_log(avctx, AV_LOG_ERROR,
572 "non linear quant only supports qmax <= 12 currently\n");
577 if (s->avctx->thread_count > 1 &&
578 s->codec_id != CODEC_ID_MPEG4 &&
579 s->codec_id != CODEC_ID_MPEG1VIDEO &&
580 s->codec_id != CODEC_ID_MPEG2VIDEO &&
581 (s->codec_id != CODEC_ID_H263P)) {
582 av_log(avctx, AV_LOG_ERROR,
583 "multi threaded encoding not supported by codec\n");
587 if (s->avctx->thread_count < 1) {
588 av_log(avctx, AV_LOG_ERROR,
589 "automatic thread number detection not supported by codec, "
594 if (s->avctx->thread_count > 1)
597 if (!avctx->time_base.den || !avctx->time_base.num) {
598 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
602 i = (INT_MAX / 2 + 128) >> 8;
603 if (avctx->me_threshold >= i) {
604 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
608 if (avctx->mb_threshold >= i) {
609 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
614 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
615 av_log(avctx, AV_LOG_INFO,
616 "notice: b_frame_strategy only affects the first pass\n");
617 avctx->b_frame_strategy = 0;
620 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
622 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
623 avctx->time_base.den /= i;
624 avctx->time_base.num /= i;
628 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id==CODEC_ID_AMV) {
629 // (a + x * 3 / 8) / x
630 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
631 s->inter_quant_bias = 0;
633 s->intra_quant_bias = 0;
635 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
638 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
639 s->intra_quant_bias = avctx->intra_quant_bias;
640 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
641 s->inter_quant_bias = avctx->inter_quant_bias;
643 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
645 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
648 if (avctx->codec_id == CODEC_ID_MPEG4 &&
649 s->avctx->time_base.den > (1 << 16) - 1) {
650 av_log(avctx, AV_LOG_ERROR,
651 "timebase %d/%d not supported by MPEG 4 standard, "
652 "the maximum admitted value for the timebase denominator "
653 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
657 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
659 #if FF_API_MPV_GLOBAL_OPTS
660 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
661 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
662 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
663 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
664 if (avctx->quantizer_noise_shaping)
665 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
668 switch (avctx->codec->id) {
669 case CODEC_ID_MPEG1VIDEO:
670 s->out_format = FMT_MPEG1;
671 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
672 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
674 case CODEC_ID_MPEG2VIDEO:
675 s->out_format = FMT_MPEG1;
676 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
677 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
683 s->out_format = FMT_MJPEG;
684 s->intra_only = 1; /* force intra only for jpeg */
685 if (avctx->codec->id == CODEC_ID_LJPEG &&
686 (avctx->pix_fmt == PIX_FMT_BGR0
687 || s->avctx->pix_fmt == PIX_FMT_BGRA
688 || s->avctx->pix_fmt == PIX_FMT_BGR24)) {
689 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
690 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
691 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
693 s->mjpeg_vsample[0] = 2;
694 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
695 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
696 s->mjpeg_hsample[0] = 2;
697 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
698 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
700 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
701 ff_mjpeg_encode_init(s) < 0)
707 if (!CONFIG_H261_ENCODER)
709 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
710 av_log(avctx, AV_LOG_ERROR,
711 "The specified picture size of %dx%d is not valid for the "
712 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
713 s->width, s->height);
716 s->out_format = FMT_H261;
721 if (!CONFIG_H263_ENCODER)
723 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
724 s->width, s->height) == 8) {
725 av_log(avctx, AV_LOG_ERROR,
726 "The specified picture size of %dx%d is not valid for "
727 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
728 "352x288, 704x576, and 1408x1152. "
729 "Try H.263+.\n", s->width, s->height);
732 s->out_format = FMT_H263;
737 s->out_format = FMT_H263;
740 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
741 s->modified_quant = s->h263_aic;
742 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
743 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
746 /* These are just to be sure */
751 s->out_format = FMT_H263;
752 s->h263_flv = 2; /* format = 1; 11-bit codes */
753 s->unrestricted_mv = 1;
754 s->rtp_mode = 0; /* don't allow GOB */
759 s->out_format = FMT_H263;
764 s->out_format = FMT_H263;
767 s->modified_quant = 1;
771 s->unrestricted_mv = 0;
774 s->out_format = FMT_H263;
776 s->unrestricted_mv = 1;
777 s->low_delay = s->max_b_frames ? 0 : 1;
778 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
780 case CODEC_ID_MSMPEG4V2:
781 s->out_format = FMT_H263;
783 s->unrestricted_mv = 1;
784 s->msmpeg4_version = 2;
788 case CODEC_ID_MSMPEG4V3:
789 s->out_format = FMT_H263;
791 s->unrestricted_mv = 1;
792 s->msmpeg4_version = 3;
793 s->flipflop_rounding = 1;
798 s->out_format = FMT_H263;
800 s->unrestricted_mv = 1;
801 s->msmpeg4_version = 4;
802 s->flipflop_rounding = 1;
807 s->out_format = FMT_H263;
809 s->unrestricted_mv = 1;
810 s->msmpeg4_version = 5;
811 s->flipflop_rounding = 1;
819 avctx->has_b_frames = !s->low_delay;
823 s->progressive_frame =
824 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
825 CODEC_FLAG_INTERLACED_ME) ||
829 if (ff_MPV_common_init(s) < 0)
832 if (!s->dct_quantize)
833 s->dct_quantize = ff_dct_quantize_c;
835 s->denoise_dct = denoise_dct_c;
836 s->fast_dct_quantize = s->dct_quantize;
838 s->dct_quantize = dct_quantize_trellis_c;
840 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
841 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
843 s->quant_precision = 5;
845 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
846 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
848 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
849 ff_h261_encode_init(s);
850 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
851 ff_h263_encode_init(s);
852 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
853 ff_msmpeg4_encode_init(s);
854 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
855 && s->out_format == FMT_MPEG1)
856 ff_mpeg1_encode_init(s);
859 for (i = 0; i < 64; i++) {
860 int j = s->dsp.idct_permutation[i];
861 if (CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4 &&
863 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
864 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
865 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
867 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
870 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
871 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
873 if (s->avctx->intra_matrix)
874 s->intra_matrix[j] = s->avctx->intra_matrix[i];
875 if (s->avctx->inter_matrix)
876 s->inter_matrix[j] = s->avctx->inter_matrix[i];
879 /* precompute matrix */
880 /* for mjpeg, we do include qscale in the matrix */
881 if (s->out_format != FMT_MJPEG) {
882 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
883 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
885 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
886 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
890 if (ff_rate_control_init(s) < 0)
896 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
898 MpegEncContext *s = avctx->priv_data;
900 ff_rate_control_uninit(s);
902 ff_MPV_common_end(s);
903 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
904 s->out_format == FMT_MJPEG)
905 ff_mjpeg_encode_close(s);
907 av_freep(&avctx->extradata);
912 static int get_sae(uint8_t *src, int ref, int stride)
917 for (y = 0; y < 16; y++) {
918 for (x = 0; x < 16; x++) {
919 acc += FFABS(src[x + y * stride] - ref);
926 static int get_intra_count(MpegEncContext *s, uint8_t *src,
927 uint8_t *ref, int stride)
935 for (y = 0; y < h; y += 16) {
936 for (x = 0; x < w; x += 16) {
937 int offset = x + y * stride;
938 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
940 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
941 int sae = get_sae(src + offset, mean, stride);
943 acc += sae + 500 < sad;
950 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
955 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
956 (s->low_delay ? 0 : 1);
961 pic_arg->display_picture_number = s->input_picture_number++;
963 if (pts != AV_NOPTS_VALUE) {
964 if (s->user_specified_pts != AV_NOPTS_VALUE) {
966 int64_t last = s->user_specified_pts;
969 av_log(s->avctx, AV_LOG_ERROR,
970 "Error, Invalid timestamp=%"PRId64", "
971 "last=%"PRId64"\n", pts, s->user_specified_pts);
975 if (!s->low_delay && pic_arg->display_picture_number == 1)
976 s->dts_delta = time - last;
978 s->user_specified_pts = pts;
980 if (s->user_specified_pts != AV_NOPTS_VALUE) {
981 s->user_specified_pts =
982 pts = s->user_specified_pts + 1;
983 av_log(s->avctx, AV_LOG_INFO,
984 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
987 pts = pic_arg->display_picture_number;
993 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
995 if (pic_arg->linesize[0] != s->linesize)
997 if (pic_arg->linesize[1] != s->uvlinesize)
999 if (pic_arg->linesize[2] != s->uvlinesize)
1002 //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
1003 // pic_arg->linesize[1], s->linesize, s->uvlinesize);
1006 i = ff_find_unused_picture(s, 1);
1010 pic = &s->picture[i].f;
1013 for (i = 0; i < 4; i++) {
1014 pic->data[i] = pic_arg->data[i];
1015 pic->linesize[i] = pic_arg->linesize[i];
1017 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1021 i = ff_find_unused_picture(s, 0);
1025 pic = &s->picture[i].f;
1028 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1032 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1033 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1034 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1037 int h_chroma_shift, v_chroma_shift;
1038 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1041 for (i = 0; i < 3; i++) {
1042 int src_stride = pic_arg->linesize[i];
1043 int dst_stride = i ? s->uvlinesize : s->linesize;
1044 int h_shift = i ? h_chroma_shift : 0;
1045 int v_shift = i ? v_chroma_shift : 0;
1046 int w = s->width >> h_shift;
1047 int h = s->height >> v_shift;
1048 uint8_t *src = pic_arg->data[i];
1049 uint8_t *dst = pic->data[i];
1051 if(s->codec_id == CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1052 h= ((s->height+15)/16*16)>>v_shift;
1055 if (!s->avctx->rc_buffer_size)
1056 dst += INPLACE_OFFSET;
1058 if (src_stride == dst_stride)
1059 memcpy(dst, src, src_stride * h);
1062 memcpy(dst, src, w);
1070 copy_picture_attributes(s, pic, pic_arg);
1071 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1074 /* shift buffer entries */
1075 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1076 s->input_picture[i - 1] = s->input_picture[i];
1078 s->input_picture[encoding_delay] = (Picture*) pic;
1083 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1087 int64_t score64 = 0;
1089 for (plane = 0; plane < 3; plane++) {
1090 const int stride = p->f.linesize[plane];
1091 const int bw = plane ? 1 : 2;
1092 for (y = 0; y < s->mb_height * bw; y++) {
1093 for (x = 0; x < s->mb_width * bw; x++) {
1094 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1095 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1096 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1097 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1099 switch (s->avctx->frame_skip_exp) {
1100 case 0: score = FFMAX(score, v); break;
1101 case 1: score += FFABS(v); break;
1102 case 2: score += v * v; break;
1103 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1104 case 4: score64 += v * v * (int64_t)(v * v); break;
1113 if (score64 < s->avctx->frame_skip_threshold)
1115 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1120 static int estimate_best_b_count(MpegEncContext *s)
1122 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1123 AVCodecContext *c = avcodec_alloc_context3(NULL);
1124 AVFrame input[FF_MAX_B_FRAMES + 2];
1125 const int scale = s->avctx->brd_scale;
1126 int i, j, out_size, p_lambda, b_lambda, lambda2;
1127 int outbuf_size = s->width * s->height; // FIXME
1128 uint8_t *outbuf = av_malloc(outbuf_size);
1129 int64_t best_rd = INT64_MAX;
1130 int best_b_count = -1;
1132 assert(scale >= 0 && scale <= 3);
1135 //s->next_picture_ptr->quality;
1136 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1137 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1138 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1139 if (!b_lambda) // FIXME we should do this somewhere else
1140 b_lambda = p_lambda;
1141 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1144 c->width = s->width >> scale;
1145 c->height = s->height >> scale;
1146 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1147 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1148 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1149 c->mb_decision = s->avctx->mb_decision;
1150 c->me_cmp = s->avctx->me_cmp;
1151 c->mb_cmp = s->avctx->mb_cmp;
1152 c->me_sub_cmp = s->avctx->me_sub_cmp;
1153 c->pix_fmt = PIX_FMT_YUV420P;
1154 c->time_base = s->avctx->time_base;
1155 c->max_b_frames = s->max_b_frames;
1157 if (avcodec_open2(c, codec, NULL) < 0)
1160 for (i = 0; i < s->max_b_frames + 2; i++) {
1161 int ysize = c->width * c->height;
1162 int csize = (c->width / 2) * (c->height / 2);
1163 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1164 s->next_picture_ptr;
1166 avcodec_get_frame_defaults(&input[i]);
1167 input[i].data[0] = av_malloc(ysize + 2 * csize);
1168 input[i].data[1] = input[i].data[0] + ysize;
1169 input[i].data[2] = input[i].data[1] + csize;
1170 input[i].linesize[0] = c->width;
1171 input[i].linesize[1] =
1172 input[i].linesize[2] = c->width / 2;
1174 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1175 pre_input = *pre_input_ptr;
1177 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1178 pre_input.f.data[0] += INPLACE_OFFSET;
1179 pre_input.f.data[1] += INPLACE_OFFSET;
1180 pre_input.f.data[2] += INPLACE_OFFSET;
1183 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1184 pre_input.f.data[0], pre_input.f.linesize[0],
1185 c->width, c->height);
1186 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1187 pre_input.f.data[1], pre_input.f.linesize[1],
1188 c->width >> 1, c->height >> 1);
1189 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1190 pre_input.f.data[2], pre_input.f.linesize[2],
1191 c->width >> 1, c->height >> 1);
1195 for (j = 0; j < s->max_b_frames + 1; j++) {
1198 if (!s->input_picture[j])
1201 c->error[0] = c->error[1] = c->error[2] = 0;
1203 input[0].pict_type = AV_PICTURE_TYPE_I;
1204 input[0].quality = 1 * FF_QP2LAMBDA;
1205 out_size = avcodec_encode_video(c, outbuf,
1206 outbuf_size, &input[0]);
1207 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1209 for (i = 0; i < s->max_b_frames + 1; i++) {
1210 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1212 input[i + 1].pict_type = is_p ?
1213 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1214 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1215 out_size = avcodec_encode_video(c, outbuf, outbuf_size,
1217 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1220 /* get the delayed frames */
1222 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
1223 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1226 rd += c->error[0] + c->error[1] + c->error[2];
1238 for (i = 0; i < s->max_b_frames + 2; i++) {
1239 av_freep(&input[i].data[0]);
1242 return best_b_count;
1245 static int select_input_picture(MpegEncContext *s)
1249 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1250 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1251 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1253 /* set next picture type & ordering */
1254 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1255 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1256 s->next_picture_ptr == NULL || s->intra_only) {
1257 s->reordered_input_picture[0] = s->input_picture[0];
1258 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1259 s->reordered_input_picture[0]->f.coded_picture_number =
1260 s->coded_picture_number++;
1264 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1265 if (s->picture_in_gop_number < s->gop_size &&
1266 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1267 // FIXME check that te gop check above is +-1 correct
1268 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1269 // s->input_picture[0]->f.data[0],
1270 // s->input_picture[0]->pts);
1272 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1273 for (i = 0; i < 4; i++)
1274 s->input_picture[0]->f.data[i] = NULL;
1275 s->input_picture[0]->f.type = 0;
1277 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1278 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1280 s->avctx->release_buffer(s->avctx,
1281 &s->input_picture[0]->f);
1285 ff_vbv_update(s, 0);
1291 if (s->flags & CODEC_FLAG_PASS2) {
1292 for (i = 0; i < s->max_b_frames + 1; i++) {
1293 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1295 if (pict_num >= s->rc_context.num_entries)
1297 if (!s->input_picture[i]) {
1298 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1302 s->input_picture[i]->f.pict_type =
1303 s->rc_context.entry[pict_num].new_pict_type;
1307 if (s->avctx->b_frame_strategy == 0) {
1308 b_frames = s->max_b_frames;
1309 while (b_frames && !s->input_picture[b_frames])
1311 } else if (s->avctx->b_frame_strategy == 1) {
1312 for (i = 1; i < s->max_b_frames + 1; i++) {
1313 if (s->input_picture[i] &&
1314 s->input_picture[i]->b_frame_score == 0) {
1315 s->input_picture[i]->b_frame_score =
1317 s->input_picture[i ]->f.data[0],
1318 s->input_picture[i - 1]->f.data[0],
1322 for (i = 0; i < s->max_b_frames + 1; i++) {
1323 if (s->input_picture[i] == NULL ||
1324 s->input_picture[i]->b_frame_score - 1 >
1325 s->mb_num / s->avctx->b_sensitivity)
1329 b_frames = FFMAX(0, i - 1);
1332 for (i = 0; i < b_frames + 1; i++) {
1333 s->input_picture[i]->b_frame_score = 0;
1335 } else if (s->avctx->b_frame_strategy == 2) {
1336 b_frames = estimate_best_b_count(s);
1338 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1343 //static int b_count = 0;
1344 //b_count += b_frames;
1345 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1347 for (i = b_frames - 1; i >= 0; i--) {
1348 int type = s->input_picture[i]->f.pict_type;
1349 if (type && type != AV_PICTURE_TYPE_B)
1352 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1353 b_frames == s->max_b_frames) {
1354 av_log(s->avctx, AV_LOG_ERROR,
1355 "warning, too many b frames in a row\n");
1358 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1359 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1360 s->gop_size > s->picture_in_gop_number) {
1361 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1363 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1365 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1369 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1370 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1373 s->reordered_input_picture[0] = s->input_picture[b_frames];
1374 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1375 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1376 s->reordered_input_picture[0]->f.coded_picture_number =
1377 s->coded_picture_number++;
1378 for (i = 0; i < b_frames; i++) {
1379 s->reordered_input_picture[i + 1] = s->input_picture[i];
1380 s->reordered_input_picture[i + 1]->f.pict_type =
1382 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1383 s->coded_picture_number++;
1388 if (s->reordered_input_picture[0]) {
1389 s->reordered_input_picture[0]->f.reference =
1390 s->reordered_input_picture[0]->f.pict_type !=
1391 AV_PICTURE_TYPE_B ? 3 : 0;
1393 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1395 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1396 s->avctx->rc_buffer_size) {
1397 // input is a shared pix, so we can't modifiy it -> alloc a new
1398 // one & ensure that the shared one is reuseable
1401 int i = ff_find_unused_picture(s, 0);
1404 pic = &s->picture[i];
1406 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1407 if (ff_alloc_picture(s, pic, 0) < 0) {
1411 /* mark us unused / free shared pic */
1412 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1413 s->avctx->release_buffer(s->avctx,
1414 &s->reordered_input_picture[0]->f);
1415 for (i = 0; i < 4; i++)
1416 s->reordered_input_picture[0]->f.data[i] = NULL;
1417 s->reordered_input_picture[0]->f.type = 0;
1419 copy_picture_attributes(s, &pic->f,
1420 &s->reordered_input_picture[0]->f);
1422 s->current_picture_ptr = pic;
1424 // input is not a shared pix -> reuse buffer for current_pix
1426 assert(s->reordered_input_picture[0]->f.type ==
1427 FF_BUFFER_TYPE_USER ||
1428 s->reordered_input_picture[0]->f.type ==
1429 FF_BUFFER_TYPE_INTERNAL);
1431 s->current_picture_ptr = s->reordered_input_picture[0];
1432 for (i = 0; i < 4; i++) {
1433 s->new_picture.f.data[i] += INPLACE_OFFSET;
1436 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1438 s->picture_number = s->new_picture.f.display_picture_number;
1439 //printf("dpn:%d\n", s->picture_number);
1441 memset(&s->new_picture, 0, sizeof(Picture));
1446 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1447 AVFrame *pic_arg, int *got_packet)
1449 MpegEncContext *s = avctx->priv_data;
1450 int i, stuffing_count, ret;
1451 int context_count = s->slice_context_count;
1453 s->picture_in_gop_number++;
1455 if (load_input_picture(s, pic_arg) < 0)
1458 if (select_input_picture(s) < 0) {
1463 if (s->new_picture.f.data[0]) {
1464 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1467 s->mb_info_ptr = av_packet_new_side_data(pkt,
1468 AV_PKT_DATA_H263_MB_INFO,
1469 s->mb_width*s->mb_height*12);
1470 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1473 for (i = 0; i < context_count; i++) {
1474 int start_y = s->thread_context[i]->start_mb_y;
1475 int end_y = s->thread_context[i]-> end_mb_y;
1476 int h = s->mb_height;
1477 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1478 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1480 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1483 s->pict_type = s->new_picture.f.pict_type;
1485 //printf("qs:%f %f %d\n", s->new_picture.quality,
1486 // s->current_picture.quality, s->qscale);
1487 ff_MPV_frame_start(s, avctx);
1489 if (encode_picture(s, s->picture_number) < 0)
1492 avctx->header_bits = s->header_bits;
1493 avctx->mv_bits = s->mv_bits;
1494 avctx->misc_bits = s->misc_bits;
1495 avctx->i_tex_bits = s->i_tex_bits;
1496 avctx->p_tex_bits = s->p_tex_bits;
1497 avctx->i_count = s->i_count;
1498 // FIXME f/b_count in avctx
1499 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1500 avctx->skip_count = s->skip_count;
1502 ff_MPV_frame_end(s);
1504 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1505 ff_mjpeg_encode_picture_trailer(s);
1507 if (avctx->rc_buffer_size) {
1508 RateControlContext *rcc = &s->rc_context;
1509 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1511 if (put_bits_count(&s->pb) > max_size &&
1512 s->lambda < s->avctx->lmax) {
1513 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1514 (s->qscale + 1) / s->qscale);
1515 if (s->adaptive_quant) {
1517 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1518 s->lambda_table[i] =
1519 FFMAX(s->lambda_table[i] + 1,
1520 s->lambda_table[i] * (s->qscale + 1) /
1523 s->mb_skipped = 0; // done in MPV_frame_start()
1524 // done in encode_picture() so we must undo it
1525 if (s->pict_type == AV_PICTURE_TYPE_P) {
1526 if (s->flipflop_rounding ||
1527 s->codec_id == CODEC_ID_H263P ||
1528 s->codec_id == CODEC_ID_MPEG4)
1529 s->no_rounding ^= 1;
1531 if (s->pict_type != AV_PICTURE_TYPE_B) {
1532 s->time_base = s->last_time_base;
1533 s->last_non_b_time = s->time - s->pp_time;
1535 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1536 for (i = 0; i < context_count; i++) {
1537 PutBitContext *pb = &s->thread_context[i]->pb;
1538 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1543 assert(s->avctx->rc_max_rate);
1546 if (s->flags & CODEC_FLAG_PASS1)
1547 ff_write_pass1_stats(s);
1549 for (i = 0; i < 4; i++) {
1550 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1551 avctx->error[i] += s->current_picture_ptr->f.error[i];
1554 if (s->flags & CODEC_FLAG_PASS1)
1555 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1556 avctx->i_tex_bits + avctx->p_tex_bits ==
1557 put_bits_count(&s->pb));
1558 flush_put_bits(&s->pb);
1559 s->frame_bits = put_bits_count(&s->pb);
1561 stuffing_count = ff_vbv_update(s, s->frame_bits);
1562 if (stuffing_count) {
1563 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1564 stuffing_count + 50) {
1565 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1569 switch (s->codec_id) {
1570 case CODEC_ID_MPEG1VIDEO:
1571 case CODEC_ID_MPEG2VIDEO:
1572 while (stuffing_count--) {
1573 put_bits(&s->pb, 8, 0);
1576 case CODEC_ID_MPEG4:
1577 put_bits(&s->pb, 16, 0);
1578 put_bits(&s->pb, 16, 0x1C3);
1579 stuffing_count -= 4;
1580 while (stuffing_count--) {
1581 put_bits(&s->pb, 8, 0xFF);
1585 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1587 flush_put_bits(&s->pb);
1588 s->frame_bits = put_bits_count(&s->pb);
1591 /* update mpeg1/2 vbv_delay for CBR */
1592 if (s->avctx->rc_max_rate &&
1593 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1594 s->out_format == FMT_MPEG1 &&
1595 90000LL * (avctx->rc_buffer_size - 1) <=
1596 s->avctx->rc_max_rate * 0xFFFFLL) {
1597 int vbv_delay, min_delay;
1598 double inbits = s->avctx->rc_max_rate *
1599 av_q2d(s->avctx->time_base);
1600 int minbits = s->frame_bits - 8 *
1601 (s->vbv_delay_ptr - s->pb.buf - 1);
1602 double bits = s->rc_context.buffer_index + minbits - inbits;
1605 av_log(s->avctx, AV_LOG_ERROR,
1606 "Internal error, negative bits\n");
1608 assert(s->repeat_first_field == 0);
1610 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1611 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1612 s->avctx->rc_max_rate;
1614 vbv_delay = FFMAX(vbv_delay, min_delay);
1616 assert(vbv_delay < 0xFFFF);
1618 s->vbv_delay_ptr[0] &= 0xF8;
1619 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1620 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1621 s->vbv_delay_ptr[2] &= 0x07;
1622 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1623 avctx->vbv_delay = vbv_delay * 300;
1625 s->total_bits += s->frame_bits;
1626 avctx->frame_bits = s->frame_bits;
1628 pkt->pts = s->current_picture.f.pts;
1629 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1630 if (!s->current_picture.f.coded_picture_number)
1631 pkt->dts = pkt->pts - s->dts_delta;
1633 pkt->dts = s->reordered_pts;
1634 s->reordered_pts = pkt->pts;
1636 pkt->dts = pkt->pts;
1637 if (s->current_picture.f.key_frame)
1638 pkt->flags |= AV_PKT_FLAG_KEY;
1640 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1642 assert((put_bits_ptr(&s->pb) == s->pb.buf));
1645 assert((s->frame_bits & 7) == 0);
1647 pkt->size = s->frame_bits / 8;
1648 *got_packet = !!pkt->size;
1652 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1653 int n, int threshold)
1655 static const char tab[64] = {
1656 3, 2, 2, 1, 1, 1, 1, 1,
1657 1, 1, 1, 1, 1, 1, 1, 1,
1658 1, 1, 1, 1, 1, 1, 1, 1,
1659 0, 0, 0, 0, 0, 0, 0, 0,
1660 0, 0, 0, 0, 0, 0, 0, 0,
1661 0, 0, 0, 0, 0, 0, 0, 0,
1662 0, 0, 0, 0, 0, 0, 0, 0,
1663 0, 0, 0, 0, 0, 0, 0, 0
1668 DCTELEM *block = s->block[n];
1669 const int last_index = s->block_last_index[n];
1672 if (threshold < 0) {
1674 threshold = -threshold;
1678 /* Are all we could set to zero already zero? */
1679 if (last_index <= skip_dc - 1)
1682 for (i = 0; i <= last_index; i++) {
1683 const int j = s->intra_scantable.permutated[i];
1684 const int level = FFABS(block[j]);
1686 if (skip_dc && i == 0)
1690 } else if (level > 1) {
1696 if (score >= threshold)
1698 for (i = skip_dc; i <= last_index; i++) {
1699 const int j = s->intra_scantable.permutated[i];
1703 s->block_last_index[n] = 0;
1705 s->block_last_index[n] = -1;
1708 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1712 const int maxlevel = s->max_qcoeff;
1713 const int minlevel = s->min_qcoeff;
1717 i = 1; // skip clipping of intra dc
1721 for (; i <= last_index; i++) {
1722 const int j = s->intra_scantable.permutated[i];
1723 int level = block[j];
1725 if (level > maxlevel) {
1728 } else if (level < minlevel) {
1736 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1737 av_log(s->avctx, AV_LOG_INFO,
1738 "warning, clipping %d dct coefficients to %d..%d\n",
1739 overflow, minlevel, maxlevel);
1742 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1746 for (y = 0; y < 8; y++) {
1747 for (x = 0; x < 8; x++) {
1753 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1754 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1755 int v = ptr[x2 + y2 * stride];
1761 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1766 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1767 int motion_x, int motion_y,
1768 int mb_block_height,
1771 int16_t weight[8][64];
1772 DCTELEM orig[8][64];
1773 const int mb_x = s->mb_x;
1774 const int mb_y = s->mb_y;
1777 int dct_offset = s->linesize * 8; // default for progressive frames
1778 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1781 for (i = 0; i < mb_block_count; i++)
1782 skip_dct[i] = s->skipdct;
1784 if (s->adaptive_quant) {
1785 const int last_qp = s->qscale;
1786 const int mb_xy = mb_x + mb_y * s->mb_stride;
1788 s->lambda = s->lambda_table[mb_xy];
1791 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1792 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1793 s->dquant = s->qscale - last_qp;
1795 if (s->out_format == FMT_H263) {
1796 s->dquant = av_clip(s->dquant, -2, 2);
1798 if (s->codec_id == CODEC_ID_MPEG4) {
1800 if (s->pict_type == AV_PICTURE_TYPE_B) {
1801 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1804 if (s->mv_type == MV_TYPE_8X8)
1810 ff_set_qscale(s, last_qp + s->dquant);
1811 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1812 ff_set_qscale(s, s->qscale + s->dquant);
1814 wrap_y = s->linesize;
1815 wrap_c = s->uvlinesize;
1816 ptr_y = s->new_picture.f.data[0] +
1817 (mb_y * 16 * wrap_y) + mb_x * 16;
1818 ptr_cb = s->new_picture.f.data[1] +
1819 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1820 ptr_cr = s->new_picture.f.data[2] +
1821 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1823 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != CODEC_ID_AMV){
1824 uint8_t *ebuf = s->edge_emu_buffer + 32;
1825 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1826 mb_y * 16, s->width, s->height);
1828 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1829 mb_block_height, mb_x * 8, mb_y * 8,
1830 (s->width+1) >> 1, (s->height+1) >> 1);
1831 ptr_cb = ebuf + 18 * wrap_y;
1832 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1833 mb_block_height, mb_x * 8, mb_y * 8,
1834 (s->width+1) >> 1, (s->height+1) >> 1);
1835 ptr_cr = ebuf + 18 * wrap_y + 8;
1839 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1840 int progressive_score, interlaced_score;
1842 s->interlaced_dct = 0;
1843 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1845 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1846 NULL, wrap_y, 8) - 400;
1848 if (progressive_score > 0) {
1849 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1850 NULL, wrap_y * 2, 8) +
1851 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1852 NULL, wrap_y * 2, 8);
1853 if (progressive_score > interlaced_score) {
1854 s->interlaced_dct = 1;
1856 dct_offset = wrap_y;
1858 if (s->chroma_format == CHROMA_422)
1864 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1865 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1866 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1867 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1869 if (s->flags & CODEC_FLAG_GRAY) {
1873 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1874 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1875 if (!s->chroma_y_shift) { /* 422 */
1876 s->dsp.get_pixels(s->block[6],
1877 ptr_cb + (dct_offset >> 1), wrap_c);
1878 s->dsp.get_pixels(s->block[7],
1879 ptr_cr + (dct_offset >> 1), wrap_c);
1883 op_pixels_func (*op_pix)[4];
1884 qpel_mc_func (*op_qpix)[16];
1885 uint8_t *dest_y, *dest_cb, *dest_cr;
1887 dest_y = s->dest[0];
1888 dest_cb = s->dest[1];
1889 dest_cr = s->dest[2];
1891 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1892 op_pix = s->dsp.put_pixels_tab;
1893 op_qpix = s->dsp.put_qpel_pixels_tab;
1895 op_pix = s->dsp.put_no_rnd_pixels_tab;
1896 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1899 if (s->mv_dir & MV_DIR_FORWARD) {
1900 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data,
1902 op_pix = s->dsp.avg_pixels_tab;
1903 op_qpix = s->dsp.avg_qpel_pixels_tab;
1905 if (s->mv_dir & MV_DIR_BACKWARD) {
1906 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data,
1910 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1911 int progressive_score, interlaced_score;
1913 s->interlaced_dct = 0;
1914 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1917 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1918 ptr_y + wrap_y * 8, wrap_y,
1921 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1922 progressive_score -= 400;
1924 if (progressive_score > 0) {
1925 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1928 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1932 if (progressive_score > interlaced_score) {
1933 s->interlaced_dct = 1;
1935 dct_offset = wrap_y;
1937 if (s->chroma_format == CHROMA_422)
1943 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1944 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1945 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1946 dest_y + dct_offset, wrap_y);
1947 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1948 dest_y + dct_offset + 8, wrap_y);
1950 if (s->flags & CODEC_FLAG_GRAY) {
1954 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1955 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1956 if (!s->chroma_y_shift) { /* 422 */
1957 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1958 dest_cb + (dct_offset >> 1), wrap_c);
1959 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1960 dest_cr + (dct_offset >> 1), wrap_c);
1963 /* pre quantization */
1964 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1965 2 * s->qscale * s->qscale) {
1967 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1968 wrap_y, 8) < 20 * s->qscale)
1970 if (s->dsp.sad[1](NULL, ptr_y + 8,
1971 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1973 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1974 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1976 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1977 dest_y + dct_offset + 8,
1978 wrap_y, 8) < 20 * s->qscale)
1980 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1981 wrap_c, 8) < 20 * s->qscale)
1983 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1984 wrap_c, 8) < 20 * s->qscale)
1986 if (!s->chroma_y_shift) { /* 422 */
1987 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1988 dest_cb + (dct_offset >> 1),
1989 wrap_c, 8) < 20 * s->qscale)
1991 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1992 dest_cr + (dct_offset >> 1),
1993 wrap_c, 8) < 20 * s->qscale)
1999 if (s->quantizer_noise_shaping) {
2001 get_visual_weight(weight[0], ptr_y , wrap_y);
2003 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2005 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2007 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2009 get_visual_weight(weight[4], ptr_cb , wrap_c);
2011 get_visual_weight(weight[5], ptr_cr , wrap_c);
2012 if (!s->chroma_y_shift) { /* 422 */
2014 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2017 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2020 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2023 /* DCT & quantize */
2024 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2026 for (i = 0; i < mb_block_count; i++) {
2029 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2030 // FIXME we could decide to change to quantizer instead of
2032 // JS: I don't think that would be a good idea it could lower
2033 // quality instead of improve it. Just INTRADC clipping
2034 // deserves changes in quantizer
2036 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2038 s->block_last_index[i] = -1;
2040 if (s->quantizer_noise_shaping) {
2041 for (i = 0; i < mb_block_count; i++) {
2043 s->block_last_index[i] =
2044 dct_quantize_refine(s, s->block[i], weight[i],
2045 orig[i], i, s->qscale);
2050 if (s->luma_elim_threshold && !s->mb_intra)
2051 for (i = 0; i < 4; i++)
2052 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2053 if (s->chroma_elim_threshold && !s->mb_intra)
2054 for (i = 4; i < mb_block_count; i++)
2055 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2057 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2058 for (i = 0; i < mb_block_count; i++) {
2059 if (s->block_last_index[i] == -1)
2060 s->coded_score[i] = INT_MAX / 256;
2065 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2066 s->block_last_index[4] =
2067 s->block_last_index[5] = 0;
2069 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2072 // non c quantize code returns incorrect block_last_index FIXME
2073 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2074 for (i = 0; i < mb_block_count; i++) {
2076 if (s->block_last_index[i] > 0) {
2077 for (j = 63; j > 0; j--) {
2078 if (s->block[i][s->intra_scantable.permutated[j]])
2081 s->block_last_index[i] = j;
2086 /* huffman encode */
2087 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2088 case CODEC_ID_MPEG1VIDEO:
2089 case CODEC_ID_MPEG2VIDEO:
2090 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2091 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2093 case CODEC_ID_MPEG4:
2094 if (CONFIG_MPEG4_ENCODER)
2095 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2097 case CODEC_ID_MSMPEG4V2:
2098 case CODEC_ID_MSMPEG4V3:
2100 if (CONFIG_MSMPEG4_ENCODER)
2101 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2104 if (CONFIG_WMV2_ENCODER)
2105 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2108 if (CONFIG_H261_ENCODER)
2109 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2112 case CODEC_ID_H263P:
2116 if (CONFIG_H263_ENCODER)
2117 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2119 case CODEC_ID_MJPEG:
2121 if (CONFIG_MJPEG_ENCODER)
2122 ff_mjpeg_encode_mb(s, s->block);
2129 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2131 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2132 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2135 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2138 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2141 d->mb_skip_run= s->mb_skip_run;
2143 d->last_dc[i] = s->last_dc[i];
2146 d->mv_bits= s->mv_bits;
2147 d->i_tex_bits= s->i_tex_bits;
2148 d->p_tex_bits= s->p_tex_bits;
2149 d->i_count= s->i_count;
2150 d->f_count= s->f_count;
2151 d->b_count= s->b_count;
2152 d->skip_count= s->skip_count;
2153 d->misc_bits= s->misc_bits;
2157 d->qscale= s->qscale;
2158 d->dquant= s->dquant;
2160 d->esc3_level_length= s->esc3_level_length;
2163 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2166 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2167 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2170 d->mb_skip_run= s->mb_skip_run;
2172 d->last_dc[i] = s->last_dc[i];
2175 d->mv_bits= s->mv_bits;
2176 d->i_tex_bits= s->i_tex_bits;
2177 d->p_tex_bits= s->p_tex_bits;
2178 d->i_count= s->i_count;
2179 d->f_count= s->f_count;
2180 d->b_count= s->b_count;
2181 d->skip_count= s->skip_count;
2182 d->misc_bits= s->misc_bits;
2184 d->mb_intra= s->mb_intra;
2185 d->mb_skipped= s->mb_skipped;
2186 d->mv_type= s->mv_type;
2187 d->mv_dir= s->mv_dir;
2189 if(s->data_partitioning){
2191 d->tex_pb= s->tex_pb;
2195 d->block_last_index[i]= s->block_last_index[i];
2196 d->interlaced_dct= s->interlaced_dct;
2197 d->qscale= s->qscale;
2199 d->esc3_level_length= s->esc3_level_length;
2202 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2203 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2204 int *dmin, int *next_block, int motion_x, int motion_y)
2207 uint8_t *dest_backup[3];
2209 copy_context_before_encode(s, backup, type);
2211 s->block= s->blocks[*next_block];
2212 s->pb= pb[*next_block];
2213 if(s->data_partitioning){
2214 s->pb2 = pb2 [*next_block];
2215 s->tex_pb= tex_pb[*next_block];
2219 memcpy(dest_backup, s->dest, sizeof(s->dest));
2220 s->dest[0] = s->rd_scratchpad;
2221 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2222 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2223 assert(s->linesize >= 32); //FIXME
2226 encode_mb(s, motion_x, motion_y);
2228 score= put_bits_count(&s->pb);
2229 if(s->data_partitioning){
2230 score+= put_bits_count(&s->pb2);
2231 score+= put_bits_count(&s->tex_pb);
2234 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2235 ff_MPV_decode_mb(s, s->block);
2237 score *= s->lambda2;
2238 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2242 memcpy(s->dest, dest_backup, sizeof(s->dest));
2249 copy_context_after_encode(best, s, type);
2253 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2254 uint32_t *sq = ff_squareTbl + 256;
2259 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2260 else if(w==8 && h==8)
2261 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2265 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2274 static int sse_mb(MpegEncContext *s){
2278 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2279 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2282 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2283 return s->dsp.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)
2284 +s->dsp.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)
2285 +s->dsp.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);
2287 return s->dsp.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)
2288 +s->dsp.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)
2289 +s->dsp.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);
2292 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)
2293 +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)
2294 +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);
2297 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2298 MpegEncContext *s= *(void**)arg;
2302 s->me.dia_size= s->avctx->pre_dia_size;
2303 s->first_slice_line=1;
2304 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2305 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2306 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2308 s->first_slice_line=0;
2316 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2317 MpegEncContext *s= *(void**)arg;
2319 ff_check_alignment();
2321 s->me.dia_size= s->avctx->dia_size;
2322 s->first_slice_line=1;
2323 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2324 s->mb_x=0; //for block init below
2325 ff_init_block_index(s);
2326 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2327 s->block_index[0]+=2;
2328 s->block_index[1]+=2;
2329 s->block_index[2]+=2;
2330 s->block_index[3]+=2;
2332 /* compute motion vector & mb_type and store in context */
2333 if(s->pict_type==AV_PICTURE_TYPE_B)
2334 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2336 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2338 s->first_slice_line=0;
2343 static int mb_var_thread(AVCodecContext *c, void *arg){
2344 MpegEncContext *s= *(void**)arg;
2347 ff_check_alignment();
2349 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2350 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2353 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2355 int sum = s->dsp.pix_sum(pix, s->linesize);
2357 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2359 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2360 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2361 s->me.mb_var_sum_temp += varc;
2367 static void write_slice_end(MpegEncContext *s){
2368 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
2369 if(s->partitioned_frame){
2370 ff_mpeg4_merge_partitions(s);
2373 ff_mpeg4_stuffing(&s->pb);
2374 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2375 ff_mjpeg_encode_stuffing(&s->pb);
2378 avpriv_align_put_bits(&s->pb);
2379 flush_put_bits(&s->pb);
2381 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2382 s->misc_bits+= get_bits_diff(s);
2385 static void write_mb_info(MpegEncContext *s)
2387 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2388 int offset = put_bits_count(&s->pb);
2389 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2390 int gobn = s->mb_y / s->gob_index;
2392 if (CONFIG_H263_ENCODER)
2393 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2394 bytestream_put_le32(&ptr, offset);
2395 bytestream_put_byte(&ptr, s->qscale);
2396 bytestream_put_byte(&ptr, gobn);
2397 bytestream_put_le16(&ptr, mba);
2398 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2399 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2400 /* 4MV not implemented */
2401 bytestream_put_byte(&ptr, 0); /* hmv2 */
2402 bytestream_put_byte(&ptr, 0); /* vmv2 */
2405 static void update_mb_info(MpegEncContext *s, int startcode)
2409 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2410 s->mb_info_size += 12;
2411 s->prev_mb_info = s->last_mb_info;
2414 s->prev_mb_info = put_bits_count(&s->pb)/8;
2415 /* This might have incremented mb_info_size above, and we return without
2416 * actually writing any info into that slot yet. But in that case,
2417 * this will be called again at the start of the after writing the
2418 * start code, actually writing the mb info. */
2422 s->last_mb_info = put_bits_count(&s->pb)/8;
2423 if (!s->mb_info_size)
2424 s->mb_info_size += 12;
2428 static int encode_thread(AVCodecContext *c, void *arg){
2429 MpegEncContext *s= *(void**)arg;
2430 int mb_x, mb_y, pdif = 0;
2431 int chr_h= 16>>s->chroma_y_shift;
2433 MpegEncContext best_s, backup_s;
2434 uint8_t bit_buf[2][MAX_MB_BYTES];
2435 uint8_t bit_buf2[2][MAX_MB_BYTES];
2436 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2437 PutBitContext pb[2], pb2[2], tex_pb[2];
2438 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2440 ff_check_alignment();
2443 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2444 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2445 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2448 s->last_bits= put_bits_count(&s->pb);
2459 /* init last dc values */
2460 /* note: quant matrix value (8) is implied here */
2461 s->last_dc[i] = 128 << s->intra_dc_precision;
2463 s->current_picture.f.error[i] = 0;
2465 if(s->codec_id==CODEC_ID_AMV){
2466 s->last_dc[0] = 128*8/13;
2467 s->last_dc[1] = 128*8/14;
2468 s->last_dc[2] = 128*8/14;
2471 memset(s->last_mv, 0, sizeof(s->last_mv));
2475 switch(s->codec_id){
2477 case CODEC_ID_H263P:
2479 if (CONFIG_H263_ENCODER)
2480 s->gob_index = ff_h263_get_gob_height(s);
2482 case CODEC_ID_MPEG4:
2483 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2484 ff_mpeg4_init_partitions(s);
2490 s->first_slice_line = 1;
2491 s->ptr_lastgob = s->pb.buf;
2492 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2493 // printf("row %d at %X\n", s->mb_y, (int)s);
2497 ff_set_qscale(s, s->qscale);
2498 ff_init_block_index(s);
2500 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2501 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2502 int mb_type= s->mb_type[xy];
2507 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2508 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2511 if(s->data_partitioning){
2512 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2513 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2514 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2520 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2521 ff_update_block_index(s);
2523 if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){
2524 ff_h261_reorder_mb_index(s);
2525 xy= s->mb_y*s->mb_stride + s->mb_x;
2526 mb_type= s->mb_type[xy];
2529 /* write gob / video packet header */
2531 int current_packet_size, is_gob_start;
2533 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2535 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2537 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2539 switch(s->codec_id){
2541 case CODEC_ID_H263P:
2542 if(!s->h263_slice_structured)
2543 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2545 case CODEC_ID_MPEG2VIDEO:
2546 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2547 case CODEC_ID_MPEG1VIDEO:
2548 if(s->mb_skip_run) is_gob_start=0;
2553 if(s->start_mb_y != mb_y || mb_x!=0){
2556 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
2557 ff_mpeg4_init_partitions(s);
2561 assert((put_bits_count(&s->pb)&7) == 0);
2562 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2564 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2565 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2566 int d= 100 / s->avctx->error_rate;
2568 current_packet_size=0;
2569 s->pb.buf_ptr= s->ptr_lastgob;
2570 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2574 if (s->avctx->rtp_callback){
2575 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2576 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2578 update_mb_info(s, 1);
2580 switch(s->codec_id){
2581 case CODEC_ID_MPEG4:
2582 if (CONFIG_MPEG4_ENCODER) {
2583 ff_mpeg4_encode_video_packet_header(s);
2584 ff_mpeg4_clean_buffers(s);
2587 case CODEC_ID_MPEG1VIDEO:
2588 case CODEC_ID_MPEG2VIDEO:
2589 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2590 ff_mpeg1_encode_slice_header(s);
2591 ff_mpeg1_clean_buffers(s);
2595 case CODEC_ID_H263P:
2596 if (CONFIG_H263_ENCODER)
2597 ff_h263_encode_gob_header(s, mb_y);
2601 if(s->flags&CODEC_FLAG_PASS1){
2602 int bits= put_bits_count(&s->pb);
2603 s->misc_bits+= bits - s->last_bits;
2607 s->ptr_lastgob += current_packet_size;
2608 s->first_slice_line=1;
2609 s->resync_mb_x=mb_x;
2610 s->resync_mb_y=mb_y;
2614 if( (s->resync_mb_x == s->mb_x)
2615 && s->resync_mb_y+1 == s->mb_y){
2616 s->first_slice_line=0;
2620 s->dquant=0; //only for QP_RD
2622 update_mb_info(s, 0);
2624 if (mb_type & (mb_type-1) || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) { // more than 1 MB type possible or FF_MPV_FLAG_QP_RD
2626 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2628 copy_context_before_encode(&backup_s, s, -1);
2630 best_s.data_partitioning= s->data_partitioning;
2631 best_s.partitioned_frame= s->partitioned_frame;
2632 if(s->data_partitioning){
2633 backup_s.pb2= s->pb2;
2634 backup_s.tex_pb= s->tex_pb;
2637 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2638 s->mv_dir = MV_DIR_FORWARD;
2639 s->mv_type = MV_TYPE_16X16;
2641 s->mv[0][0][0] = s->p_mv_table[xy][0];
2642 s->mv[0][0][1] = s->p_mv_table[xy][1];
2643 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2644 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2646 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2647 s->mv_dir = MV_DIR_FORWARD;
2648 s->mv_type = MV_TYPE_FIELD;
2651 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2652 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2653 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2655 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2656 &dmin, &next_block, 0, 0);
2658 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2659 s->mv_dir = MV_DIR_FORWARD;
2660 s->mv_type = MV_TYPE_16X16;
2664 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2665 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2667 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2668 s->mv_dir = MV_DIR_FORWARD;
2669 s->mv_type = MV_TYPE_8X8;
2672 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2673 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2675 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2676 &dmin, &next_block, 0, 0);
2678 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2679 s->mv_dir = MV_DIR_FORWARD;
2680 s->mv_type = MV_TYPE_16X16;
2682 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2683 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2684 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2685 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2687 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2688 s->mv_dir = MV_DIR_BACKWARD;
2689 s->mv_type = MV_TYPE_16X16;
2691 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2692 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2693 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2694 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2696 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2697 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2698 s->mv_type = MV_TYPE_16X16;
2700 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2701 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2702 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2703 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2704 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2705 &dmin, &next_block, 0, 0);
2707 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2708 s->mv_dir = MV_DIR_FORWARD;
2709 s->mv_type = MV_TYPE_FIELD;
2712 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2713 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2714 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2716 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2717 &dmin, &next_block, 0, 0);
2719 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2720 s->mv_dir = MV_DIR_BACKWARD;
2721 s->mv_type = MV_TYPE_FIELD;
2724 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2725 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2726 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2728 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2729 &dmin, &next_block, 0, 0);
2731 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2732 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2733 s->mv_type = MV_TYPE_FIELD;
2735 for(dir=0; dir<2; dir++){
2737 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2738 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2739 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2742 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2743 &dmin, &next_block, 0, 0);
2745 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2747 s->mv_type = MV_TYPE_16X16;
2751 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2752 &dmin, &next_block, 0, 0);
2753 if(s->h263_pred || s->h263_aic){
2755 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2757 ff_clean_intra_table_entries(s); //old mode?
2761 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2762 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2763 const int last_qp= backup_s.qscale;
2766 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2767 static const int dquant_tab[4]={-1,1,-2,2};
2769 assert(backup_s.dquant == 0);
2772 s->mv_dir= best_s.mv_dir;
2773 s->mv_type = MV_TYPE_16X16;
2774 s->mb_intra= best_s.mb_intra;
2775 s->mv[0][0][0] = best_s.mv[0][0][0];
2776 s->mv[0][0][1] = best_s.mv[0][0][1];
2777 s->mv[1][0][0] = best_s.mv[1][0][0];
2778 s->mv[1][0][1] = best_s.mv[1][0][1];
2780 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2781 for(; qpi<4; qpi++){
2782 int dquant= dquant_tab[qpi];
2783 qp= last_qp + dquant;
2784 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2786 backup_s.dquant= dquant;
2787 if(s->mb_intra && s->dc_val[0]){
2789 dc[i]= s->dc_val[0][ s->block_index[i] ];
2790 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2794 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2795 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2796 if(best_s.qscale != qp){
2797 if(s->mb_intra && s->dc_val[0]){
2799 s->dc_val[0][ s->block_index[i] ]= dc[i];
2800 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2807 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2808 int mx= s->b_direct_mv_table[xy][0];
2809 int my= s->b_direct_mv_table[xy][1];
2811 backup_s.dquant = 0;
2812 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2814 ff_mpeg4_set_direct_mv(s, mx, my);
2815 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2816 &dmin, &next_block, mx, my);
2818 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2819 backup_s.dquant = 0;
2820 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2822 ff_mpeg4_set_direct_mv(s, 0, 0);
2823 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2824 &dmin, &next_block, 0, 0);
2826 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2829 coded |= s->block_last_index[i];
2832 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2833 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2834 mx=my=0; //FIXME find the one we actually used
2835 ff_mpeg4_set_direct_mv(s, mx, my);
2836 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2844 s->mv_dir= best_s.mv_dir;
2845 s->mv_type = best_s.mv_type;
2847 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2848 s->mv[0][0][1] = best_s.mv[0][0][1];
2849 s->mv[1][0][0] = best_s.mv[1][0][0];
2850 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2853 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2854 &dmin, &next_block, mx, my);
2859 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2861 copy_context_after_encode(s, &best_s, -1);
2863 pb_bits_count= put_bits_count(&s->pb);
2864 flush_put_bits(&s->pb);
2865 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2868 if(s->data_partitioning){
2869 pb2_bits_count= put_bits_count(&s->pb2);
2870 flush_put_bits(&s->pb2);
2871 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2872 s->pb2= backup_s.pb2;
2874 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2875 flush_put_bits(&s->tex_pb);
2876 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2877 s->tex_pb= backup_s.tex_pb;
2879 s->last_bits= put_bits_count(&s->pb);
2881 if (CONFIG_H263_ENCODER &&
2882 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2883 ff_h263_update_motion_val(s);
2885 if(next_block==0){ //FIXME 16 vs linesize16
2886 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2887 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2888 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2891 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2892 ff_MPV_decode_mb(s, s->block);
2894 int motion_x = 0, motion_y = 0;
2895 s->mv_type=MV_TYPE_16X16;
2896 // only one MB-Type possible
2899 case CANDIDATE_MB_TYPE_INTRA:
2902 motion_x= s->mv[0][0][0] = 0;
2903 motion_y= s->mv[0][0][1] = 0;
2905 case CANDIDATE_MB_TYPE_INTER:
2906 s->mv_dir = MV_DIR_FORWARD;
2908 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2909 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2911 case CANDIDATE_MB_TYPE_INTER_I:
2912 s->mv_dir = MV_DIR_FORWARD;
2913 s->mv_type = MV_TYPE_FIELD;
2916 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2917 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2918 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2921 case CANDIDATE_MB_TYPE_INTER4V:
2922 s->mv_dir = MV_DIR_FORWARD;
2923 s->mv_type = MV_TYPE_8X8;
2926 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2927 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2930 case CANDIDATE_MB_TYPE_DIRECT:
2931 if (CONFIG_MPEG4_ENCODER) {
2932 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2934 motion_x=s->b_direct_mv_table[xy][0];
2935 motion_y=s->b_direct_mv_table[xy][1];
2936 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2939 case CANDIDATE_MB_TYPE_DIRECT0:
2940 if (CONFIG_MPEG4_ENCODER) {
2941 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2943 ff_mpeg4_set_direct_mv(s, 0, 0);
2946 case CANDIDATE_MB_TYPE_BIDIR:
2947 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2949 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2950 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2951 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2952 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2954 case CANDIDATE_MB_TYPE_BACKWARD:
2955 s->mv_dir = MV_DIR_BACKWARD;
2957 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2958 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2960 case CANDIDATE_MB_TYPE_FORWARD:
2961 s->mv_dir = MV_DIR_FORWARD;
2963 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2964 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2965 // printf(" %d %d ", motion_x, motion_y);
2967 case CANDIDATE_MB_TYPE_FORWARD_I:
2968 s->mv_dir = MV_DIR_FORWARD;
2969 s->mv_type = MV_TYPE_FIELD;
2972 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2973 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2974 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2977 case CANDIDATE_MB_TYPE_BACKWARD_I:
2978 s->mv_dir = MV_DIR_BACKWARD;
2979 s->mv_type = MV_TYPE_FIELD;
2982 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2983 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2984 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2987 case CANDIDATE_MB_TYPE_BIDIR_I:
2988 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2989 s->mv_type = MV_TYPE_FIELD;
2991 for(dir=0; dir<2; dir++){
2993 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2994 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2995 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3000 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3003 encode_mb(s, motion_x, motion_y);
3005 // RAL: Update last macroblock type
3006 s->last_mv_dir = s->mv_dir;
3008 if (CONFIG_H263_ENCODER &&
3009 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3010 ff_h263_update_motion_val(s);
3012 ff_MPV_decode_mb(s, s->block);
3015 /* clean the MV table in IPS frames for direct mode in B frames */
3016 if(s->mb_intra /* && I,P,S_TYPE */){
3017 s->p_mv_table[xy][0]=0;
3018 s->p_mv_table[xy][1]=0;
3021 if(s->flags&CODEC_FLAG_PSNR){
3025 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3026 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3028 s->current_picture.f.error[0] += sse(
3029 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3030 s->dest[0], w, h, s->linesize);
3031 s->current_picture.f.error[1] += sse(
3032 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3033 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3034 s->current_picture.f.error[2] += sse(
3035 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3036 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3039 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3040 ff_h263_loop_filter(s);
3042 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
3046 //not beautiful here but we must write it before flushing so it has to be here
3047 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3048 ff_msmpeg4_encode_ext_header(s);
3052 /* Send the last GOB if RTP */
3053 if (s->avctx->rtp_callback) {
3054 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3055 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3056 /* Call the RTP callback to send the last GOB */
3058 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3064 #define MERGE(field) dst->field += src->field; src->field=0
3065 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3066 MERGE(me.scene_change_score);
3067 MERGE(me.mc_mb_var_sum_temp);
3068 MERGE(me.mb_var_sum_temp);
3071 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3074 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3075 MERGE(dct_count[1]);
3085 MERGE(padding_bug_score);
3086 MERGE(current_picture.f.error[0]);
3087 MERGE(current_picture.f.error[1]);
3088 MERGE(current_picture.f.error[2]);
3090 if(dst->avctx->noise_reduction){
3091 for(i=0; i<64; i++){
3092 MERGE(dct_error_sum[0][i]);
3093 MERGE(dct_error_sum[1][i]);
3097 assert(put_bits_count(&src->pb) % 8 ==0);
3098 assert(put_bits_count(&dst->pb) % 8 ==0);
3099 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3100 flush_put_bits(&dst->pb);
3103 static int estimate_qp(MpegEncContext *s, int dry_run){
3104 if (s->next_lambda){
3105 s->current_picture_ptr->f.quality =
3106 s->current_picture.f.quality = s->next_lambda;
3107 if(!dry_run) s->next_lambda= 0;
3108 } else if (!s->fixed_qscale) {
3109 s->current_picture_ptr->f.quality =
3110 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3111 if (s->current_picture.f.quality < 0)
3115 if(s->adaptive_quant){
3116 switch(s->codec_id){
3117 case CODEC_ID_MPEG4:
3118 if (CONFIG_MPEG4_ENCODER)
3119 ff_clean_mpeg4_qscales(s);
3122 case CODEC_ID_H263P:
3124 if (CONFIG_H263_ENCODER)
3125 ff_clean_h263_qscales(s);
3128 ff_init_qscale_tab(s);
3131 s->lambda= s->lambda_table[0];
3134 s->lambda = s->current_picture.f.quality;
3135 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3140 /* must be called before writing the header */
3141 static void set_frame_distances(MpegEncContext * s){
3142 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3143 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3145 if(s->pict_type==AV_PICTURE_TYPE_B){
3146 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3147 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3149 s->pp_time= s->time - s->last_non_b_time;
3150 s->last_non_b_time= s->time;
3151 assert(s->picture_number==0 || s->pp_time > 0);
3155 static int encode_picture(MpegEncContext *s, int picture_number)
3159 int context_count = s->slice_context_count;
3161 s->picture_number = picture_number;
3163 /* Reset the average MB variance */
3164 s->me.mb_var_sum_temp =
3165 s->me.mc_mb_var_sum_temp = 0;
3167 /* we need to initialize some time vars before we can encode b-frames */
3168 // RAL: Condition added for MPEG1VIDEO
3169 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3170 set_frame_distances(s);
3171 if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
3172 ff_set_mpeg4_time(s);
3174 s->me.scene_change_score=0;
3176 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3178 if(s->pict_type==AV_PICTURE_TYPE_I){
3179 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3180 else s->no_rounding=0;
3181 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3182 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3183 s->no_rounding ^= 1;
3186 if(s->flags & CODEC_FLAG_PASS2){
3187 if (estimate_qp(s,1) < 0)
3189 ff_get_2pass_fcode(s);
3190 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3191 if(s->pict_type==AV_PICTURE_TYPE_B)
3192 s->lambda= s->last_lambda_for[s->pict_type];
3194 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3198 if(s->codec_id != CODEC_ID_AMV){
3199 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3200 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3201 s->q_chroma_intra_matrix = s->q_intra_matrix;
3202 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3205 s->mb_intra=0; //for the rate distortion & bit compare functions
3206 for(i=1; i<context_count; i++){
3207 ff_update_duplicate_context(s->thread_context[i], s);
3213 /* Estimate motion for every MB */
3214 if(s->pict_type != AV_PICTURE_TYPE_I){
3215 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3216 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3217 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3218 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3219 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3223 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3224 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3226 for(i=0; i<s->mb_stride*s->mb_height; i++)
3227 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3229 if(!s->fixed_qscale){
3230 /* finding spatial complexity for I-frame rate control */
3231 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3234 for(i=1; i<context_count; i++){
3235 merge_context_after_me(s, s->thread_context[i]);
3237 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3238 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3241 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3242 s->pict_type= AV_PICTURE_TYPE_I;
3243 for(i=0; i<s->mb_stride*s->mb_height; i++)
3244 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3245 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3249 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3250 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3252 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3254 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3255 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3256 s->f_code= FFMAX3(s->f_code, a, b);
3259 ff_fix_long_p_mvs(s);
3260 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3261 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3265 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3266 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3271 if(s->pict_type==AV_PICTURE_TYPE_B){
3274 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3275 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3276 s->f_code = FFMAX(a, b);
3278 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3279 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3280 s->b_code = FFMAX(a, b);
3282 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3283 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3284 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3285 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3286 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3288 for(dir=0; dir<2; dir++){
3291 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3292 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3293 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3294 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3302 if (estimate_qp(s, 0) < 0)
3305 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3306 s->qscale= 3; //reduce clipping problems
3308 if (s->out_format == FMT_MJPEG) {
3309 /* for mjpeg, we do include qscale in the matrix */
3311 int j= s->dsp.idct_permutation[i];
3313 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3315 s->y_dc_scale_table=
3316 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3317 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3318 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3319 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3322 if(s->codec_id == CODEC_ID_AMV){
3323 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};
3324 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};
3326 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3328 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3329 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3331 s->y_dc_scale_table= y;
3332 s->c_dc_scale_table= c;
3333 s->intra_matrix[0] = 13;
3334 s->chroma_intra_matrix[0] = 14;
3335 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3336 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3337 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3338 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3342 //FIXME var duplication
3343 s->current_picture_ptr->f.key_frame =
3344 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3345 s->current_picture_ptr->f.pict_type =
3346 s->current_picture.f.pict_type = s->pict_type;
3348 if (s->current_picture.f.key_frame)
3349 s->picture_in_gop_number=0;
3351 s->last_bits= put_bits_count(&s->pb);
3352 switch(s->out_format) {
3354 if (CONFIG_MJPEG_ENCODER)
3355 ff_mjpeg_encode_picture_header(s);
3358 if (CONFIG_H261_ENCODER)
3359 ff_h261_encode_picture_header(s, picture_number);
3362 if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2)
3363 ff_wmv2_encode_picture_header(s, picture_number);
3364 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3365 ff_msmpeg4_encode_picture_header(s, picture_number);
3366 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3367 ff_mpeg4_encode_picture_header(s, picture_number);
3368 else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
3369 ff_rv10_encode_picture_header(s, picture_number);
3370 else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
3371 ff_rv20_encode_picture_header(s, picture_number);
3372 else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
3373 ff_flv_encode_picture_header(s, picture_number);
3374 else if (CONFIG_H263_ENCODER)
3375 ff_h263_encode_picture_header(s, picture_number);
3378 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3379 ff_mpeg1_encode_picture_header(s, picture_number);
3386 bits= put_bits_count(&s->pb);
3387 s->header_bits= bits - s->last_bits;
3389 for(i=1; i<context_count; i++){
3390 update_duplicate_context_after_me(s->thread_context[i], s);
3392 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3393 for(i=1; i<context_count; i++){
3394 merge_context_after_encode(s, s->thread_context[i]);
3400 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3401 const int intra= s->mb_intra;
3404 s->dct_count[intra]++;
3406 for(i=0; i<64; i++){
3407 int level= block[i];
3411 s->dct_error_sum[intra][i] += level;
3412 level -= s->dct_offset[intra][i];
3413 if(level<0) level=0;
3415 s->dct_error_sum[intra][i] -= level;
3416 level += s->dct_offset[intra][i];
3417 if(level>0) level=0;
3424 static int dct_quantize_trellis_c(MpegEncContext *s,
3425 DCTELEM *block, int n,
3426 int qscale, int *overflow){
3428 const uint8_t *scantable= s->intra_scantable.scantable;
3429 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3431 unsigned int threshold1, threshold2;
3443 int coeff_count[64];
3444 int qmul, qadd, start_i, last_non_zero, i, dc;
3445 const int esc_length= s->ac_esc_length;
3447 uint8_t * last_length;
3448 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3450 s->dsp.fdct (block);
3452 if(s->dct_error_sum)
3453 s->denoise_dct(s, block);
3455 qadd= ((qscale-1)|1)*8;
3466 /* For AIC we skip quant/dequant of INTRADC */
3471 /* note: block[0] is assumed to be positive */
3472 block[0] = (block[0] + (q >> 1)) / q;
3475 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3476 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3477 bias= 1<<(QMAT_SHIFT-1);
3478 length = s->intra_ac_vlc_length;
3479 last_length= s->intra_ac_vlc_last_length;
3483 qmat = s->q_inter_matrix[qscale];
3484 length = s->inter_ac_vlc_length;
3485 last_length= s->inter_ac_vlc_last_length;
3489 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3490 threshold2= (threshold1<<1);
3492 for(i=63; i>=start_i; i--) {
3493 const int j = scantable[i];
3494 int level = block[j] * qmat[j];
3496 if(((unsigned)(level+threshold1))>threshold2){
3502 for(i=start_i; i<=last_non_zero; i++) {
3503 const int j = scantable[i];
3504 int level = block[j] * qmat[j];
3506 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3507 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3508 if(((unsigned)(level+threshold1))>threshold2){
3510 level= (bias + level)>>QMAT_SHIFT;
3512 coeff[1][i]= level-1;
3513 // coeff[2][k]= level-2;
3515 level= (bias - level)>>QMAT_SHIFT;
3516 coeff[0][i]= -level;
3517 coeff[1][i]= -level+1;
3518 // coeff[2][k]= -level+2;
3520 coeff_count[i]= FFMIN(level, 2);
3521 assert(coeff_count[i]);
3524 coeff[0][i]= (level>>31)|1;
3529 *overflow= s->max_qcoeff < max; //overflow might have happened
3531 if(last_non_zero < start_i){
3532 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3533 return last_non_zero;
3536 score_tab[start_i]= 0;
3537 survivor[0]= start_i;
3540 for(i=start_i; i<=last_non_zero; i++){
3541 int level_index, j, zero_distortion;
3542 int dct_coeff= FFABS(block[ scantable[i] ]);
3543 int best_score=256*256*256*120;
3545 if (s->dsp.fdct == ff_fdct_ifast)
3546 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3547 zero_distortion= dct_coeff*dct_coeff;
3549 for(level_index=0; level_index < coeff_count[i]; level_index++){
3551 int level= coeff[level_index][i];
3552 const int alevel= FFABS(level);
3557 if(s->out_format == FMT_H263){
3558 unquant_coeff= alevel*qmul + qadd;
3560 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3562 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3563 unquant_coeff = (unquant_coeff - 1) | 1;
3565 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3566 unquant_coeff = (unquant_coeff - 1) | 1;
3571 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3573 if((level&(~127)) == 0){
3574 for(j=survivor_count-1; j>=0; j--){
3575 int run= i - survivor[j];
3576 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3577 score += score_tab[i-run];
3579 if(score < best_score){
3582 level_tab[i+1]= level-64;
3586 if(s->out_format == FMT_H263){
3587 for(j=survivor_count-1; j>=0; j--){
3588 int run= i - survivor[j];
3589 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3590 score += score_tab[i-run];
3591 if(score < last_score){
3594 last_level= level-64;
3600 distortion += esc_length*lambda;
3601 for(j=survivor_count-1; j>=0; j--){
3602 int run= i - survivor[j];
3603 int score= distortion + score_tab[i-run];
3605 if(score < best_score){
3608 level_tab[i+1]= level-64;
3612 if(s->out_format == FMT_H263){
3613 for(j=survivor_count-1; j>=0; j--){
3614 int run= i - survivor[j];
3615 int score= distortion + score_tab[i-run];
3616 if(score < last_score){
3619 last_level= level-64;
3627 score_tab[i+1]= best_score;
3629 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3630 if(last_non_zero <= 27){
3631 for(; survivor_count; survivor_count--){
3632 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3636 for(; survivor_count; survivor_count--){
3637 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3642 survivor[ survivor_count++ ]= i+1;
3645 if(s->out_format != FMT_H263){
3646 last_score= 256*256*256*120;
3647 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3648 int score= score_tab[i];
3649 if(i) score += lambda*2; //FIXME exacter?
3651 if(score < last_score){
3654 last_level= level_tab[i];
3655 last_run= run_tab[i];
3660 s->coded_score[n] = last_score;
3662 dc= FFABS(block[0]);
3663 last_non_zero= last_i - 1;
3664 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3666 if(last_non_zero < start_i)
3667 return last_non_zero;
3669 if(last_non_zero == 0 && start_i == 0){
3671 int best_score= dc * dc;
3673 for(i=0; i<coeff_count[0]; i++){
3674 int level= coeff[i][0];
3675 int alevel= FFABS(level);
3676 int unquant_coeff, score, distortion;
3678 if(s->out_format == FMT_H263){
3679 unquant_coeff= (alevel*qmul + qadd)>>3;
3681 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3682 unquant_coeff = (unquant_coeff - 1) | 1;
3684 unquant_coeff = (unquant_coeff + 4) >> 3;
3685 unquant_coeff<<= 3 + 3;
3687 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3689 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3690 else score= distortion + esc_length*lambda;
3692 if(score < best_score){
3694 best_level= level - 64;
3697 block[0]= best_level;
3698 s->coded_score[n] = best_score - dc*dc;
3699 if(best_level == 0) return -1;
3700 else return last_non_zero;
3706 block[ perm_scantable[last_non_zero] ]= last_level;
3709 for(; i>start_i; i -= run_tab[i] + 1){
3710 block[ perm_scantable[i-1] ]= level_tab[i];
3713 return last_non_zero;
3716 //#define REFINE_STATS 1
3717 static int16_t basis[64][64];
3719 static void build_basis(uint8_t *perm){
3726 double s= 0.25*(1<<BASIS_SHIFT);
3728 int perm_index= perm[index];
3729 if(i==0) s*= sqrt(0.5);
3730 if(j==0) s*= sqrt(0.5);
3731 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
3738 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3739 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3742 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3743 const uint8_t *scantable= s->intra_scantable.scantable;
3744 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3745 // unsigned int threshold1, threshold2;
3750 int qmul, qadd, start_i, last_non_zero, i, dc;
3752 uint8_t * last_length;
3754 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3757 static int after_last=0;
3758 static int to_zero=0;
3759 static int from_zero=0;
3762 static int messed_sign=0;
3765 if(basis[0][0] == 0)
3766 build_basis(s->dsp.idct_permutation);
3777 /* For AIC we skip quant/dequant of INTRADC */
3781 q <<= RECON_SHIFT-3;
3782 /* note: block[0] is assumed to be positive */
3784 // block[0] = (block[0] + (q >> 1)) / q;
3786 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3787 // bias= 1<<(QMAT_SHIFT-1);
3788 length = s->intra_ac_vlc_length;
3789 last_length= s->intra_ac_vlc_last_length;
3793 length = s->inter_ac_vlc_length;
3794 last_length= s->inter_ac_vlc_last_length;
3796 last_non_zero = s->block_last_index[n];
3801 dc += (1<<(RECON_SHIFT-1));
3802 for(i=0; i<64; i++){
3803 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3806 STOP_TIMER("memset rem[]")}
3809 for(i=0; i<64; i++){
3814 w= FFABS(weight[i]) + qns*one;
3815 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3818 // w=weight[i] = (63*qns + (w/2)) / w;
3824 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3830 for(i=start_i; i<=last_non_zero; i++){
3831 int j= perm_scantable[i];
3832 const int level= block[j];
3836 if(level<0) coeff= qmul*level - qadd;
3837 else coeff= qmul*level + qadd;
3838 run_tab[rle_index++]=run;
3841 s->dsp.add_8x8basis(rem, basis[j], coeff);
3847 if(last_non_zero>0){
3848 STOP_TIMER("init rem[]")
3855 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3858 int run2, best_unquant_change=0, analyze_gradient;
3862 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3864 if(analyze_gradient){
3868 for(i=0; i<64; i++){
3871 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3874 STOP_TIMER("rem*w*w")}
3884 const int level= block[0];
3885 int change, old_coeff;
3887 assert(s->mb_intra);
3891 for(change=-1; change<=1; change+=2){
3892 int new_level= level + change;
3893 int score, new_coeff;
3895 new_coeff= q*new_level;
3896 if(new_coeff >= 2048 || new_coeff < 0)
3899 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3900 if(score<best_score){
3903 best_change= change;
3904 best_unquant_change= new_coeff - old_coeff;
3911 run2= run_tab[rle_index++];
3915 for(i=start_i; i<64; i++){
3916 int j= perm_scantable[i];
3917 const int level= block[j];
3918 int change, old_coeff;
3920 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3924 if(level<0) old_coeff= qmul*level - qadd;
3925 else old_coeff= qmul*level + qadd;
3926 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3930 assert(run2>=0 || i >= last_non_zero );
3933 for(change=-1; change<=1; change+=2){
3934 int new_level= level + change;
3935 int score, new_coeff, unquant_change;
3938 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3942 if(new_level<0) new_coeff= qmul*new_level - qadd;
3943 else new_coeff= qmul*new_level + qadd;
3944 if(new_coeff >= 2048 || new_coeff <= -2048)
3946 //FIXME check for overflow
3949 if(level < 63 && level > -63){
3950 if(i < last_non_zero)
3951 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3952 - length[UNI_AC_ENC_INDEX(run, level+64)];
3954 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3955 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3958 assert(FFABS(new_level)==1);
3960 if(analyze_gradient){
3961 int g= d1[ scantable[i] ];
3962 if(g && (g^new_level) >= 0)
3966 if(i < last_non_zero){
3967 int next_i= i + run2 + 1;
3968 int next_level= block[ perm_scantable[next_i] ] + 64;
3970 if(next_level&(~127))
3973 if(next_i < last_non_zero)
3974 score += length[UNI_AC_ENC_INDEX(run, 65)]
3975 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3976 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3978 score += length[UNI_AC_ENC_INDEX(run, 65)]
3979 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3980 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3982 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
3984 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3985 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3991 assert(FFABS(level)==1);
3993 if(i < last_non_zero){
3994 int next_i= i + run2 + 1;
3995 int next_level= block[ perm_scantable[next_i] ] + 64;
3997 if(next_level&(~127))
4000 if(next_i < last_non_zero)
4001 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4002 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4003 - length[UNI_AC_ENC_INDEX(run, 65)];
4005 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4006 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4007 - length[UNI_AC_ENC_INDEX(run, 65)];
4009 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4011 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4012 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4019 unquant_change= new_coeff - old_coeff;
4020 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4022 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4023 if(score<best_score){
4026 best_change= change;
4027 best_unquant_change= unquant_change;
4031 prev_level= level + 64;
4032 if(prev_level&(~127))
4041 STOP_TIMER("iterative step")}
4045 int j= perm_scantable[ best_coeff ];
4047 block[j] += best_change;
4049 if(best_coeff > last_non_zero){
4050 last_non_zero= best_coeff;
4058 if(block[j] - best_change){
4059 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4071 for(; last_non_zero>=start_i; last_non_zero--){
4072 if(block[perm_scantable[last_non_zero]])
4078 if(256*256*256*64 % count == 0){
4079 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4084 for(i=start_i; i<=last_non_zero; i++){
4085 int j= perm_scantable[i];
4086 const int level= block[j];
4089 run_tab[rle_index++]=run;
4096 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4102 if(last_non_zero>0){
4103 STOP_TIMER("iterative search")
4108 return last_non_zero;
4111 int ff_dct_quantize_c(MpegEncContext *s,
4112 DCTELEM *block, int n,
4113 int qscale, int *overflow)
4115 int i, j, level, last_non_zero, q, start_i;
4117 const uint8_t *scantable= s->intra_scantable.scantable;
4120 unsigned int threshold1, threshold2;
4122 s->dsp.fdct (block);
4124 if(s->dct_error_sum)
4125 s->denoise_dct(s, block);
4135 /* For AIC we skip quant/dequant of INTRADC */
4138 /* note: block[0] is assumed to be positive */
4139 block[0] = (block[0] + (q >> 1)) / q;
4142 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4143 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4147 qmat = s->q_inter_matrix[qscale];
4148 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4150 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4151 threshold2= (threshold1<<1);
4152 for(i=63;i>=start_i;i--) {
4154 level = block[j] * qmat[j];
4156 if(((unsigned)(level+threshold1))>threshold2){
4163 for(i=start_i; i<=last_non_zero; i++) {
4165 level = block[j] * qmat[j];
4167 // if( bias+level >= (1<<QMAT_SHIFT)
4168 // || bias-level >= (1<<QMAT_SHIFT)){
4169 if(((unsigned)(level+threshold1))>threshold2){
4171 level= (bias + level)>>QMAT_SHIFT;
4174 level= (bias - level)>>QMAT_SHIFT;
4182 *overflow= s->max_qcoeff < max; //overflow might have happened
4184 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4185 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4186 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4188 return last_non_zero;
4191 #define OFFSET(x) offsetof(MpegEncContext, x)
4192 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4193 static const AVOption h263_options[] = {
4194 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4195 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4196 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { 0 }, 0, INT_MAX, VE },
4201 static const AVClass h263_class = {
4202 .class_name = "H.263 encoder",
4203 .item_name = av_default_item_name,
4204 .option = h263_options,
4205 .version = LIBAVUTIL_VERSION_INT,
4208 AVCodec ff_h263_encoder = {
4210 .type = AVMEDIA_TYPE_VIDEO,
4211 .id = CODEC_ID_H263,
4212 .priv_data_size = sizeof(MpegEncContext),
4213 .init = ff_MPV_encode_init,
4214 .encode2 = ff_MPV_encode_picture,
4215 .close = ff_MPV_encode_end,
4216 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4217 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4218 .priv_class = &h263_class,
4221 static const AVOption h263p_options[] = {
4222 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4223 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4224 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4225 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4229 static const AVClass h263p_class = {
4230 .class_name = "H.263p encoder",
4231 .item_name = av_default_item_name,
4232 .option = h263p_options,
4233 .version = LIBAVUTIL_VERSION_INT,
4236 AVCodec ff_h263p_encoder = {
4238 .type = AVMEDIA_TYPE_VIDEO,
4239 .id = CODEC_ID_H263P,
4240 .priv_data_size = sizeof(MpegEncContext),
4241 .init = ff_MPV_encode_init,
4242 .encode2 = ff_MPV_encode_picture,
4243 .close = ff_MPV_encode_end,
4244 .capabilities = CODEC_CAP_SLICE_THREADS,
4245 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4246 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4247 .priv_class = &h263p_class,
4250 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4252 AVCodec ff_msmpeg4v2_encoder = {
4253 .name = "msmpeg4v2",
4254 .type = AVMEDIA_TYPE_VIDEO,
4255 .id = CODEC_ID_MSMPEG4V2,
4256 .priv_data_size = sizeof(MpegEncContext),
4257 .init = ff_MPV_encode_init,
4258 .encode2 = ff_MPV_encode_picture,
4259 .close = ff_MPV_encode_end,
4260 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4261 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4262 .priv_class = &msmpeg4v2_class,
4265 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4267 AVCodec ff_msmpeg4v3_encoder = {
4269 .type = AVMEDIA_TYPE_VIDEO,
4270 .id = CODEC_ID_MSMPEG4V3,
4271 .priv_data_size = sizeof(MpegEncContext),
4272 .init = ff_MPV_encode_init,
4273 .encode2 = ff_MPV_encode_picture,
4274 .close = ff_MPV_encode_end,
4275 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4276 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4277 .priv_class = &msmpeg4v3_class,
4280 FF_MPV_GENERIC_CLASS(wmv1)
4282 AVCodec ff_wmv1_encoder = {
4284 .type = AVMEDIA_TYPE_VIDEO,
4285 .id = CODEC_ID_WMV1,
4286 .priv_data_size = sizeof(MpegEncContext),
4287 .init = ff_MPV_encode_init,
4288 .encode2 = ff_MPV_encode_picture,
4289 .close = ff_MPV_encode_end,
4290 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4291 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4292 .priv_class = &wmv1_class,