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 Libav.
10 * Libav 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 * Libav 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 Libav; 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!).
32 #include "libavutil/internal.h"
33 #include "libavutil/intmath.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/timer.h"
42 #include "mpegvideo.h"
45 #include "mjpegenc_common.h"
47 #include "mpegutils.h"
50 #include "pixblockdsp.h"
54 #include "aandcttab.h"
56 #include "mpeg4video.h"
58 #include "bytestream.h"
61 #define QUANT_BIAS_SHIFT 8
63 #define QMAT_SHIFT_MMX 16
66 static int encode_picture(MpegEncContext *s, int picture_number);
67 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
68 static int sse_mb(MpegEncContext *s);
69 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
70 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
72 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
73 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
75 const AVOption ff_mpv_generic_options[] = {
80 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
81 uint16_t (*qmat16)[2][64],
82 const uint16_t *quant_matrix,
83 int bias, int qmin, int qmax, int intra)
85 FDCTDSPContext *fdsp = &s->fdsp;
89 for (qscale = qmin; qscale <= qmax; qscale++) {
91 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
93 fdsp->fdct == ff_faandct ||
94 #endif /* CONFIG_FAANDCT */
95 fdsp->fdct == ff_jpeg_fdct_islow_10) {
96 for (i = 0; i < 64; i++) {
97 const int j = s->idsp.idct_permutation[i];
98 /* 16 <= qscale * quant_matrix[i] <= 7905
99 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
100 * 19952 <= x <= 249205026
101 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
102 * 3444240 >= (1 << 36) / (x) >= 275 */
104 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
105 (qscale * quant_matrix[j]));
107 } else if (fdsp->fdct == ff_fdct_ifast) {
108 for (i = 0; i < 64; i++) {
109 const int j = s->idsp.idct_permutation[i];
110 /* 16 <= qscale * quant_matrix[i] <= 7905
111 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
112 * 19952 <= x <= 249205026
113 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
114 * 3444240 >= (1 << 36) / (x) >= 275 */
116 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
117 (ff_aanscales[i] * qscale *
121 for (i = 0; i < 64; i++) {
122 const int j = s->idsp.idct_permutation[i];
123 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
124 * Assume x = qscale * quant_matrix[i]
126 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
127 * so 32768 >= (1 << 19) / (x) >= 67 */
128 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
129 (qscale * quant_matrix[j]));
130 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
131 // (qscale * quant_matrix[i]);
132 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
133 (qscale * quant_matrix[j]);
135 if (qmat16[qscale][0][i] == 0 ||
136 qmat16[qscale][0][i] == 128 * 256)
137 qmat16[qscale][0][i] = 128 * 256 - 1;
138 qmat16[qscale][1][i] =
139 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
140 qmat16[qscale][0][i]);
144 for (i = intra; i < 64; i++) {
146 if (fdsp->fdct == ff_fdct_ifast) {
147 max = (8191LL * ff_aanscales[i]) >> 14;
149 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
155 av_log(NULL, AV_LOG_INFO,
156 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
161 static inline void update_qscale(MpegEncContext *s)
163 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
164 (FF_LAMBDA_SHIFT + 7);
165 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
167 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
171 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
177 for (i = 0; i < 64; i++) {
178 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
185 * init s->current_picture.qscale_table from s->lambda_table
187 void ff_init_qscale_tab(MpegEncContext *s)
189 int8_t * const qscale_table = s->current_picture.qscale_table;
192 for (i = 0; i < s->mb_num; i++) {
193 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
194 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
195 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
200 static void update_duplicate_context_after_me(MpegEncContext *dst,
203 #define COPY(a) dst->a= src->a
205 COPY(current_picture);
211 COPY(picture_in_gop_number);
212 COPY(gop_picture_number);
213 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
214 COPY(progressive_frame); // FIXME don't set in encode_header
215 COPY(partitioned_frame); // FIXME don't set in encode_header
220 * Set the given MpegEncContext to defaults for encoding.
221 * the changed fields will not depend upon the prior state of the MpegEncContext.
223 static void mpv_encode_defaults(MpegEncContext *s)
226 ff_mpv_common_defaults(s);
228 for (i = -16; i < 16; i++) {
229 default_fcode_tab[i + MAX_MV] = 1;
231 s->me.mv_penalty = default_mv_penalty;
232 s->fcode_tab = default_fcode_tab;
234 s->input_picture_number = 0;
235 s->picture_in_gop_number = 0;
238 /* init video encoder */
239 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
241 MpegEncContext *s = avctx->priv_data;
242 int i, ret, format_supported;
244 mpv_encode_defaults(s);
246 switch (avctx->codec_id) {
247 case AV_CODEC_ID_MPEG2VIDEO:
248 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
249 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
250 av_log(avctx, AV_LOG_ERROR,
251 "only YUV420 and YUV422 are supported\n");
255 case AV_CODEC_ID_MJPEG:
256 format_supported = 0;
257 /* JPEG color space */
258 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
259 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
260 (avctx->color_range == AVCOL_RANGE_JPEG &&
261 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
262 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
263 format_supported = 1;
264 /* MPEG color space */
265 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
266 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
267 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
268 format_supported = 1;
270 if (!format_supported) {
271 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
276 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
277 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
282 switch (avctx->pix_fmt) {
283 case AV_PIX_FMT_YUVJ422P:
284 case AV_PIX_FMT_YUV422P:
285 s->chroma_format = CHROMA_422;
287 case AV_PIX_FMT_YUVJ420P:
288 case AV_PIX_FMT_YUV420P:
290 s->chroma_format = CHROMA_420;
294 s->bit_rate = avctx->bit_rate;
295 s->width = avctx->width;
296 s->height = avctx->height;
297 if (avctx->gop_size > 600 &&
298 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
299 av_log(avctx, AV_LOG_ERROR,
300 "Warning keyframe interval too large! reducing it ...\n");
301 avctx->gop_size = 600;
303 s->gop_size = avctx->gop_size;
305 s->flags = avctx->flags;
306 s->flags2 = avctx->flags2;
307 if (avctx->max_b_frames > MAX_B_FRAMES) {
308 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
309 "is %d.\n", MAX_B_FRAMES);
311 s->max_b_frames = avctx->max_b_frames;
312 s->codec_id = avctx->codec->id;
313 s->strict_std_compliance = avctx->strict_std_compliance;
314 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
315 s->mpeg_quant = avctx->mpeg_quant;
316 s->rtp_mode = !!avctx->rtp_payload_size;
317 s->intra_dc_precision = avctx->intra_dc_precision;
318 s->user_specified_pts = AV_NOPTS_VALUE;
320 if (s->gop_size <= 1) {
327 s->me_method = avctx->me_method;
330 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
333 FF_DISABLE_DEPRECATION_WARNINGS
334 if (avctx->border_masking != 0.0)
335 s->border_masking = avctx->border_masking;
336 FF_ENABLE_DEPRECATION_WARNINGS
339 s->adaptive_quant = (s->avctx->lumi_masking ||
340 s->avctx->dark_masking ||
341 s->avctx->temporal_cplx_masking ||
342 s->avctx->spatial_cplx_masking ||
343 s->avctx->p_masking ||
345 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
348 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
350 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
351 av_log(avctx, AV_LOG_ERROR,
352 "a vbv buffer size is needed, "
353 "for encoding with a maximum bitrate\n");
357 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
358 av_log(avctx, AV_LOG_INFO,
359 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
362 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
363 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
367 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
368 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
372 if (avctx->rc_max_rate &&
373 avctx->rc_max_rate == avctx->bit_rate &&
374 avctx->rc_max_rate != avctx->rc_min_rate) {
375 av_log(avctx, AV_LOG_INFO,
376 "impossible bitrate constraints, this will fail\n");
379 if (avctx->rc_buffer_size &&
380 avctx->bit_rate * (int64_t)avctx->time_base.num >
381 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
382 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
386 if (!s->fixed_qscale &&
387 avctx->bit_rate * av_q2d(avctx->time_base) >
388 avctx->bit_rate_tolerance) {
389 av_log(avctx, AV_LOG_ERROR,
390 "bitrate tolerance too small for bitrate\n");
394 if (s->avctx->rc_max_rate &&
395 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
396 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
397 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
398 90000LL * (avctx->rc_buffer_size - 1) >
399 s->avctx->rc_max_rate * 0xFFFFLL) {
400 av_log(avctx, AV_LOG_INFO,
401 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
402 "specified vbv buffer is too large for the given bitrate!\n");
405 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
406 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
407 s->codec_id != AV_CODEC_ID_FLV1) {
408 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
412 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
413 av_log(avctx, AV_LOG_ERROR,
414 "OBMC is only supported with simple mb decision\n");
418 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
419 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
423 if (s->max_b_frames &&
424 s->codec_id != AV_CODEC_ID_MPEG4 &&
425 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
426 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
427 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
431 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
432 s->codec_id == AV_CODEC_ID_H263 ||
433 s->codec_id == AV_CODEC_ID_H263P) &&
434 (avctx->sample_aspect_ratio.num > 255 ||
435 avctx->sample_aspect_ratio.den > 255)) {
436 av_log(avctx, AV_LOG_ERROR,
437 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
438 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
442 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
443 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
444 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
448 // FIXME mpeg2 uses that too
449 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
450 av_log(avctx, AV_LOG_ERROR,
451 "mpeg2 style quantization not supported by codec\n");
455 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
456 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
460 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
461 s->avctx->mb_decision != FF_MB_DECISION_RD) {
462 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
466 if (s->avctx->scenechange_threshold < 1000000000 &&
467 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
468 av_log(avctx, AV_LOG_ERROR,
469 "closed gop with scene change detection are not supported yet, "
470 "set threshold to 1000000000\n");
474 if (s->flags & CODEC_FLAG_LOW_DELAY) {
475 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
476 av_log(avctx, AV_LOG_ERROR,
477 "low delay forcing is only available for mpeg2\n");
480 if (s->max_b_frames != 0) {
481 av_log(avctx, AV_LOG_ERROR,
482 "b frames cannot be used with low delay\n");
487 if (s->q_scale_type == 1) {
488 if (avctx->qmax > 12) {
489 av_log(avctx, AV_LOG_ERROR,
490 "non linear quant only supports qmax <= 12 currently\n");
495 if (s->avctx->thread_count > 1 &&
496 s->codec_id != AV_CODEC_ID_MPEG4 &&
497 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
498 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
499 (s->codec_id != AV_CODEC_ID_H263P)) {
500 av_log(avctx, AV_LOG_ERROR,
501 "multi threaded encoding not supported by codec\n");
505 if (s->avctx->thread_count < 1) {
506 av_log(avctx, AV_LOG_ERROR,
507 "automatic thread number detection not supported by codec,"
512 if (s->avctx->thread_count > 1)
515 if (!avctx->time_base.den || !avctx->time_base.num) {
516 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
520 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
521 av_log(avctx, AV_LOG_INFO,
522 "notice: b_frame_strategy only affects the first pass\n");
523 avctx->b_frame_strategy = 0;
526 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
528 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
529 avctx->time_base.den /= i;
530 avctx->time_base.num /= i;
534 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
535 s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
536 // (a + x * 3 / 8) / x
537 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
538 s->inter_quant_bias = 0;
540 s->intra_quant_bias = 0;
542 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
545 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
546 s->intra_quant_bias = avctx->intra_quant_bias;
547 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
548 s->inter_quant_bias = avctx->inter_quant_bias;
550 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
551 s->avctx->time_base.den > (1 << 16) - 1) {
552 av_log(avctx, AV_LOG_ERROR,
553 "timebase %d/%d not supported by MPEG 4 standard, "
554 "the maximum admitted value for the timebase denominator "
555 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
559 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
561 switch (avctx->codec->id) {
562 case AV_CODEC_ID_MPEG1VIDEO:
563 s->out_format = FMT_MPEG1;
564 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
565 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
567 case AV_CODEC_ID_MPEG2VIDEO:
568 s->out_format = FMT_MPEG1;
569 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
570 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
573 case AV_CODEC_ID_MJPEG:
574 s->out_format = FMT_MJPEG;
575 s->intra_only = 1; /* force intra only for jpeg */
576 if (!CONFIG_MJPEG_ENCODER ||
577 ff_mjpeg_encode_init(s) < 0)
582 case AV_CODEC_ID_H261:
583 if (!CONFIG_H261_ENCODER)
585 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
586 av_log(avctx, AV_LOG_ERROR,
587 "The specified picture size of %dx%d is not valid for the "
588 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
589 s->width, s->height);
592 s->out_format = FMT_H261;
596 case AV_CODEC_ID_H263:
597 if (!CONFIG_H263_ENCODER)
599 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
600 s->width, s->height) == 8) {
601 av_log(avctx, AV_LOG_INFO,
602 "The specified picture size of %dx%d is not valid for "
603 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
604 "352x288, 704x576, and 1408x1152."
605 "Try H.263+.\n", s->width, s->height);
608 s->out_format = FMT_H263;
612 case AV_CODEC_ID_H263P:
613 s->out_format = FMT_H263;
616 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
617 s->modified_quant = s->h263_aic;
618 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
619 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
622 /* These are just to be sure */
626 case AV_CODEC_ID_FLV1:
627 s->out_format = FMT_H263;
628 s->h263_flv = 2; /* format = 1; 11-bit codes */
629 s->unrestricted_mv = 1;
630 s->rtp_mode = 0; /* don't allow GOB */
634 case AV_CODEC_ID_RV10:
635 s->out_format = FMT_H263;
639 case AV_CODEC_ID_RV20:
640 s->out_format = FMT_H263;
643 s->modified_quant = 1;
647 s->unrestricted_mv = 0;
649 case AV_CODEC_ID_MPEG4:
650 s->out_format = FMT_H263;
652 s->unrestricted_mv = 1;
653 s->low_delay = s->max_b_frames ? 0 : 1;
654 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
656 case AV_CODEC_ID_MSMPEG4V2:
657 s->out_format = FMT_H263;
659 s->unrestricted_mv = 1;
660 s->msmpeg4_version = 2;
664 case AV_CODEC_ID_MSMPEG4V3:
665 s->out_format = FMT_H263;
667 s->unrestricted_mv = 1;
668 s->msmpeg4_version = 3;
669 s->flipflop_rounding = 1;
673 case AV_CODEC_ID_WMV1:
674 s->out_format = FMT_H263;
676 s->unrestricted_mv = 1;
677 s->msmpeg4_version = 4;
678 s->flipflop_rounding = 1;
682 case AV_CODEC_ID_WMV2:
683 s->out_format = FMT_H263;
685 s->unrestricted_mv = 1;
686 s->msmpeg4_version = 5;
687 s->flipflop_rounding = 1;
695 avctx->has_b_frames = !s->low_delay;
699 s->progressive_frame =
700 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
701 CODEC_FLAG_INTERLACED_ME) ||
706 if (ff_mpv_common_init(s) < 0)
710 ff_mpv_encode_init_x86(s);
712 ff_fdctdsp_init(&s->fdsp, avctx);
713 ff_me_cmp_init(&s->mecc, avctx);
714 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
715 ff_pixblockdsp_init(&s->pdsp, avctx);
716 ff_qpeldsp_init(&s->qdsp);
718 s->avctx->coded_frame = s->current_picture.f;
720 if (s->msmpeg4_version) {
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
722 2 * 2 * (MAX_LEVEL + 1) *
723 (MAX_RUN + 1) * 2 * sizeof(int), fail);
725 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
728 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
729 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
730 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
731 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
732 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
733 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
734 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
736 if (s->avctx->noise_reduction) {
737 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
738 2 * 64 * sizeof(uint16_t), fail);
741 if (CONFIG_H263_ENCODER)
742 ff_h263dsp_init(&s->h263dsp);
743 if (!s->dct_quantize)
744 s->dct_quantize = ff_dct_quantize_c;
746 s->denoise_dct = denoise_dct_c;
747 s->fast_dct_quantize = s->dct_quantize;
749 s->dct_quantize = dct_quantize_trellis_c;
751 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
752 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
754 s->quant_precision = 5;
756 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
757 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->avctx->frame_skip_cmp);
759 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
760 ff_h261_encode_init(s);
761 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
762 ff_h263_encode_init(s);
763 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
764 ff_msmpeg4_encode_init(s);
765 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
766 && s->out_format == FMT_MPEG1)
767 ff_mpeg1_encode_init(s);
770 for (i = 0; i < 64; i++) {
771 int j = s->idsp.idct_permutation[i];
772 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
774 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
775 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
776 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
778 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
781 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
782 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
784 if (s->avctx->intra_matrix)
785 s->intra_matrix[j] = s->avctx->intra_matrix[i];
786 if (s->avctx->inter_matrix)
787 s->inter_matrix[j] = s->avctx->inter_matrix[i];
790 /* precompute matrix */
791 /* for mjpeg, we do include qscale in the matrix */
792 if (s->out_format != FMT_MJPEG) {
793 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
794 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
796 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
797 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
801 if (ff_rate_control_init(s) < 0)
804 #if FF_API_ERROR_RATE
805 FF_DISABLE_DEPRECATION_WARNINGS
806 if (avctx->error_rate)
807 s->error_rate = avctx->error_rate;
808 FF_ENABLE_DEPRECATION_WARNINGS;
811 #if FF_API_NORMALIZE_AQP
812 FF_DISABLE_DEPRECATION_WARNINGS
813 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
814 s->mpv_flags |= FF_MPV_FLAG_NAQ;
815 FF_ENABLE_DEPRECATION_WARNINGS;
819 FF_DISABLE_DEPRECATION_WARNINGS
820 if (avctx->flags & CODEC_FLAG_MV0)
821 s->mpv_flags |= FF_MPV_FLAG_MV0;
822 FF_ENABLE_DEPRECATION_WARNINGS
826 FF_DISABLE_DEPRECATION_WARNINGS
827 if (avctx->rc_qsquish != 0.0)
828 s->rc_qsquish = avctx->rc_qsquish;
829 if (avctx->rc_qmod_amp != 0.0)
830 s->rc_qmod_amp = avctx->rc_qmod_amp;
831 if (avctx->rc_qmod_freq)
832 s->rc_qmod_freq = avctx->rc_qmod_freq;
833 if (avctx->rc_buffer_aggressivity != 1.0)
834 s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
835 if (avctx->rc_initial_cplx != 0.0)
836 s->rc_initial_cplx = avctx->rc_initial_cplx;
838 s->lmin = avctx->lmin;
840 s->lmax = avctx->lmax;
844 s->rc_eq = av_strdup(avctx->rc_eq);
846 return AVERROR(ENOMEM);
848 FF_ENABLE_DEPRECATION_WARNINGS
851 if (avctx->b_frame_strategy == 2) {
852 for (i = 0; i < s->max_b_frames + 2; i++) {
853 s->tmp_frames[i] = av_frame_alloc();
854 if (!s->tmp_frames[i])
855 return AVERROR(ENOMEM);
857 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
858 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
859 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
861 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
869 ff_mpv_encode_end(avctx);
870 return AVERROR_UNKNOWN;
873 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
875 MpegEncContext *s = avctx->priv_data;
878 ff_rate_control_uninit(s);
880 ff_mpv_common_end(s);
881 if (CONFIG_MJPEG_ENCODER &&
882 s->out_format == FMT_MJPEG)
883 ff_mjpeg_encode_close(s);
885 av_freep(&avctx->extradata);
887 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
888 av_frame_free(&s->tmp_frames[i]);
890 ff_free_picture_tables(&s->new_picture);
891 ff_mpeg_unref_picture(s, &s->new_picture);
893 av_freep(&s->avctx->stats_out);
894 av_freep(&s->ac_stats);
896 av_freep(&s->q_intra_matrix);
897 av_freep(&s->q_inter_matrix);
898 av_freep(&s->q_intra_matrix16);
899 av_freep(&s->q_inter_matrix16);
900 av_freep(&s->input_picture);
901 av_freep(&s->reordered_input_picture);
902 av_freep(&s->dct_offset);
907 static int get_sae(uint8_t *src, int ref, int stride)
912 for (y = 0; y < 16; y++) {
913 for (x = 0; x < 16; x++) {
914 acc += FFABS(src[x + y * stride] - ref);
921 static int get_intra_count(MpegEncContext *s, uint8_t *src,
922 uint8_t *ref, int stride)
930 for (y = 0; y < h; y += 16) {
931 for (x = 0; x < w; x += 16) {
932 int offset = x + y * stride;
933 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
935 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
936 int sae = get_sae(src + offset, mean, stride);
938 acc += sae + 500 < sad;
945 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
949 int i, display_picture_number = 0, ret;
950 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
951 (s->low_delay ? 0 : 1);
956 display_picture_number = s->input_picture_number++;
958 if (pts != AV_NOPTS_VALUE) {
959 if (s->user_specified_pts != AV_NOPTS_VALUE) {
961 int64_t last = s->user_specified_pts;
964 av_log(s->avctx, AV_LOG_ERROR,
965 "Error, Invalid timestamp=%"PRId64", "
966 "last=%"PRId64"\n", pts, s->user_specified_pts);
970 if (!s->low_delay && display_picture_number == 1)
971 s->dts_delta = time - last;
973 s->user_specified_pts = pts;
975 if (s->user_specified_pts != AV_NOPTS_VALUE) {
976 s->user_specified_pts =
977 pts = s->user_specified_pts + 1;
978 av_log(s->avctx, AV_LOG_INFO,
979 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
982 pts = display_picture_number;
988 if (!pic_arg->buf[0] ||
989 pic_arg->linesize[0] != s->linesize ||
990 pic_arg->linesize[1] != s->uvlinesize ||
991 pic_arg->linesize[2] != s->uvlinesize)
994 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
995 pic_arg->linesize[1], s->linesize, s->uvlinesize);
997 i = ff_find_unused_picture(s, direct);
1001 pic = &s->picture[i];
1005 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1007 if (ff_alloc_picture(s, pic, 1) < 0) {
1011 if (ff_alloc_picture(s, pic, 0) < 0) {
1015 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1016 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1017 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1020 int h_chroma_shift, v_chroma_shift;
1021 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1025 for (i = 0; i < 3; i++) {
1026 int src_stride = pic_arg->linesize[i];
1027 int dst_stride = i ? s->uvlinesize : s->linesize;
1028 int h_shift = i ? h_chroma_shift : 0;
1029 int v_shift = i ? v_chroma_shift : 0;
1030 int w = s->width >> h_shift;
1031 int h = s->height >> v_shift;
1032 uint8_t *src = pic_arg->data[i];
1033 uint8_t *dst = pic->f->data[i];
1035 if (!s->avctx->rc_buffer_size)
1036 dst += INPLACE_OFFSET;
1038 if (src_stride == dst_stride)
1039 memcpy(dst, src, src_stride * h);
1042 memcpy(dst, src, w);
1050 ret = av_frame_copy_props(pic->f, pic_arg);
1054 pic->f->display_picture_number = display_picture_number;
1055 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1058 /* shift buffer entries */
1059 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1060 s->input_picture[i - 1] = s->input_picture[i];
1062 s->input_picture[encoding_delay] = (Picture*) pic;
1067 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1071 int64_t score64 = 0;
1073 for (plane = 0; plane < 3; plane++) {
1074 const int stride = p->f->linesize[plane];
1075 const int bw = plane ? 1 : 2;
1076 for (y = 0; y < s->mb_height * bw; y++) {
1077 for (x = 0; x < s->mb_width * bw; x++) {
1078 int off = p->shared ? 0 : 16;
1079 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1080 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1081 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1083 switch (s->avctx->frame_skip_exp) {
1084 case 0: score = FFMAX(score, v); break;
1085 case 1: score += FFABS(v); break;
1086 case 2: score += v * v; break;
1087 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1088 case 4: score64 += v * v * (int64_t)(v * v); break;
1097 if (score64 < s->avctx->frame_skip_threshold)
1099 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1104 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1106 AVPacket pkt = { 0 };
1107 int ret, got_output;
1109 av_init_packet(&pkt);
1110 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1115 av_free_packet(&pkt);
1119 static int estimate_best_b_count(MpegEncContext *s)
1121 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1122 AVCodecContext *c = avcodec_alloc_context3(NULL);
1123 const int scale = s->avctx->brd_scale;
1124 int i, j, out_size, p_lambda, b_lambda, lambda2;
1125 int64_t best_rd = INT64_MAX;
1126 int best_b_count = -1;
1128 assert(scale >= 0 && scale <= 3);
1131 //s->next_picture_ptr->quality;
1132 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1133 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1134 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1135 if (!b_lambda) // FIXME we should do this somewhere else
1136 b_lambda = p_lambda;
1137 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1140 c->width = s->width >> scale;
1141 c->height = s->height >> scale;
1142 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
1143 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1144 c->mb_decision = s->avctx->mb_decision;
1145 c->me_cmp = s->avctx->me_cmp;
1146 c->mb_cmp = s->avctx->mb_cmp;
1147 c->me_sub_cmp = s->avctx->me_sub_cmp;
1148 c->pix_fmt = AV_PIX_FMT_YUV420P;
1149 c->time_base = s->avctx->time_base;
1150 c->max_b_frames = s->max_b_frames;
1152 if (avcodec_open2(c, codec, NULL) < 0)
1155 for (i = 0; i < s->max_b_frames + 2; i++) {
1156 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1157 s->next_picture_ptr;
1159 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1160 pre_input = *pre_input_ptr;
1162 if (!pre_input.shared && i) {
1163 pre_input.f->data[0] += INPLACE_OFFSET;
1164 pre_input.f->data[1] += INPLACE_OFFSET;
1165 pre_input.f->data[2] += INPLACE_OFFSET;
1168 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1169 s->tmp_frames[i]->linesize[0],
1170 pre_input.f->data[0],
1171 pre_input.f->linesize[0],
1172 c->width, c->height);
1173 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1174 s->tmp_frames[i]->linesize[1],
1175 pre_input.f->data[1],
1176 pre_input.f->linesize[1],
1177 c->width >> 1, c->height >> 1);
1178 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1179 s->tmp_frames[i]->linesize[2],
1180 pre_input.f->data[2],
1181 pre_input.f->linesize[2],
1182 c->width >> 1, c->height >> 1);
1186 for (j = 0; j < s->max_b_frames + 1; j++) {
1189 if (!s->input_picture[j])
1192 c->error[0] = c->error[1] = c->error[2] = 0;
1194 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1195 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1197 out_size = encode_frame(c, s->tmp_frames[0]);
1199 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1201 for (i = 0; i < s->max_b_frames + 1; i++) {
1202 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1204 s->tmp_frames[i + 1]->pict_type = is_p ?
1205 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1206 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1208 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1210 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1213 /* get the delayed frames */
1215 out_size = encode_frame(c, NULL);
1216 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1219 rd += c->error[0] + c->error[1] + c->error[2];
1230 return best_b_count;
1233 static int select_input_picture(MpegEncContext *s)
1237 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1238 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1239 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1241 /* set next picture type & ordering */
1242 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1243 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1244 !s->next_picture_ptr || s->intra_only) {
1245 s->reordered_input_picture[0] = s->input_picture[0];
1246 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1247 s->reordered_input_picture[0]->f->coded_picture_number =
1248 s->coded_picture_number++;
1252 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1253 if (s->picture_in_gop_number < s->gop_size &&
1254 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1255 // FIXME check that te gop check above is +-1 correct
1256 av_frame_unref(s->input_picture[0]->f);
1259 ff_vbv_update(s, 0);
1265 if (s->flags & CODEC_FLAG_PASS2) {
1266 for (i = 0; i < s->max_b_frames + 1; i++) {
1267 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1269 if (pict_num >= s->rc_context.num_entries)
1271 if (!s->input_picture[i]) {
1272 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1276 s->input_picture[i]->f->pict_type =
1277 s->rc_context.entry[pict_num].new_pict_type;
1281 if (s->avctx->b_frame_strategy == 0) {
1282 b_frames = s->max_b_frames;
1283 while (b_frames && !s->input_picture[b_frames])
1285 } else if (s->avctx->b_frame_strategy == 1) {
1286 for (i = 1; i < s->max_b_frames + 1; i++) {
1287 if (s->input_picture[i] &&
1288 s->input_picture[i]->b_frame_score == 0) {
1289 s->input_picture[i]->b_frame_score =
1291 s->input_picture[i ]->f->data[0],
1292 s->input_picture[i - 1]->f->data[0],
1296 for (i = 0; i < s->max_b_frames + 1; i++) {
1297 if (!s->input_picture[i] ||
1298 s->input_picture[i]->b_frame_score - 1 >
1299 s->mb_num / s->avctx->b_sensitivity)
1303 b_frames = FFMAX(0, i - 1);
1306 for (i = 0; i < b_frames + 1; i++) {
1307 s->input_picture[i]->b_frame_score = 0;
1309 } else if (s->avctx->b_frame_strategy == 2) {
1310 b_frames = estimate_best_b_count(s);
1312 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1318 for (i = b_frames - 1; i >= 0; i--) {
1319 int type = s->input_picture[i]->f->pict_type;
1320 if (type && type != AV_PICTURE_TYPE_B)
1323 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1324 b_frames == s->max_b_frames) {
1325 av_log(s->avctx, AV_LOG_ERROR,
1326 "warning, too many b frames in a row\n");
1329 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1330 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1331 s->gop_size > s->picture_in_gop_number) {
1332 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1334 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1336 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1340 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1341 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1344 s->reordered_input_picture[0] = s->input_picture[b_frames];
1345 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1346 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1347 s->reordered_input_picture[0]->f->coded_picture_number =
1348 s->coded_picture_number++;
1349 for (i = 0; i < b_frames; i++) {
1350 s->reordered_input_picture[i + 1] = s->input_picture[i];
1351 s->reordered_input_picture[i + 1]->f->pict_type =
1353 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1354 s->coded_picture_number++;
1359 if (s->reordered_input_picture[0]) {
1360 s->reordered_input_picture[0]->reference =
1361 s->reordered_input_picture[0]->f->pict_type !=
1362 AV_PICTURE_TYPE_B ? 3 : 0;
1364 ff_mpeg_unref_picture(s, &s->new_picture);
1365 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1368 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1369 // input is a shared pix, so we can't modifiy it -> alloc a new
1370 // one & ensure that the shared one is reuseable
1373 int i = ff_find_unused_picture(s, 0);
1376 pic = &s->picture[i];
1378 pic->reference = s->reordered_input_picture[0]->reference;
1379 if (ff_alloc_picture(s, pic, 0) < 0) {
1383 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1387 /* mark us unused / free shared pic */
1388 av_frame_unref(s->reordered_input_picture[0]->f);
1389 s->reordered_input_picture[0]->shared = 0;
1391 s->current_picture_ptr = pic;
1393 // input is not a shared pix -> reuse buffer for current_pix
1394 s->current_picture_ptr = s->reordered_input_picture[0];
1395 for (i = 0; i < 4; i++) {
1396 s->new_picture.f->data[i] += INPLACE_OFFSET;
1399 ff_mpeg_unref_picture(s, &s->current_picture);
1400 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1401 s->current_picture_ptr)) < 0)
1404 s->picture_number = s->new_picture.f->display_picture_number;
1406 ff_mpeg_unref_picture(s, &s->new_picture);
1411 static void frame_end(MpegEncContext *s)
1415 if (s->unrestricted_mv &&
1416 s->current_picture.reference &&
1418 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1419 int hshift = desc->log2_chroma_w;
1420 int vshift = desc->log2_chroma_h;
1421 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1422 s->h_edge_pos, s->v_edge_pos,
1423 EDGE_WIDTH, EDGE_WIDTH,
1424 EDGE_TOP | EDGE_BOTTOM);
1425 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1426 s->h_edge_pos >> hshift,
1427 s->v_edge_pos >> vshift,
1428 EDGE_WIDTH >> hshift,
1429 EDGE_WIDTH >> vshift,
1430 EDGE_TOP | EDGE_BOTTOM);
1431 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1432 s->h_edge_pos >> hshift,
1433 s->v_edge_pos >> vshift,
1434 EDGE_WIDTH >> hshift,
1435 EDGE_WIDTH >> vshift,
1436 EDGE_TOP | EDGE_BOTTOM);
1441 s->last_pict_type = s->pict_type;
1442 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1443 if (s->pict_type!= AV_PICTURE_TYPE_B)
1444 s->last_non_b_pict_type = s->pict_type;
1447 /* release non-reference frames */
1448 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1449 if (!s->picture[i].reference)
1450 ff_mpeg_unref_picture(s, &s->picture[i]);
1454 s->avctx->coded_frame = s->current_picture_ptr->f;
1458 static void update_noise_reduction(MpegEncContext *s)
1462 for (intra = 0; intra < 2; intra++) {
1463 if (s->dct_count[intra] > (1 << 16)) {
1464 for (i = 0; i < 64; i++) {
1465 s->dct_error_sum[intra][i] >>= 1;
1467 s->dct_count[intra] >>= 1;
1470 for (i = 0; i < 64; i++) {
1471 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1472 s->dct_count[intra] +
1473 s->dct_error_sum[intra][i] / 2) /
1474 (s->dct_error_sum[intra][i] + 1);
1479 static int frame_start(MpegEncContext *s)
1483 /* mark & release old frames */
1484 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1485 s->last_picture_ptr != s->next_picture_ptr &&
1486 s->last_picture_ptr->f->buf[0]) {
1487 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1490 s->current_picture_ptr->f->pict_type = s->pict_type;
1491 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1493 ff_mpeg_unref_picture(s, &s->current_picture);
1494 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1495 s->current_picture_ptr)) < 0)
1498 if (s->pict_type != AV_PICTURE_TYPE_B) {
1499 s->last_picture_ptr = s->next_picture_ptr;
1501 s->next_picture_ptr = s->current_picture_ptr;
1504 if (s->last_picture_ptr) {
1505 ff_mpeg_unref_picture(s, &s->last_picture);
1506 if (s->last_picture_ptr->f->buf[0] &&
1507 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1508 s->last_picture_ptr)) < 0)
1511 if (s->next_picture_ptr) {
1512 ff_mpeg_unref_picture(s, &s->next_picture);
1513 if (s->next_picture_ptr->f->buf[0] &&
1514 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1515 s->next_picture_ptr)) < 0)
1519 if (s->picture_structure!= PICT_FRAME) {
1521 for (i = 0; i < 4; i++) {
1522 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1523 s->current_picture.f->data[i] +=
1524 s->current_picture.f->linesize[i];
1526 s->current_picture.f->linesize[i] *= 2;
1527 s->last_picture.f->linesize[i] *= 2;
1528 s->next_picture.f->linesize[i] *= 2;
1532 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1533 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1534 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1535 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1536 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1537 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1539 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1540 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1543 if (s->dct_error_sum) {
1544 assert(s->avctx->noise_reduction && s->encoding);
1545 update_noise_reduction(s);
1551 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1552 const AVFrame *pic_arg, int *got_packet)
1554 MpegEncContext *s = avctx->priv_data;
1555 int i, stuffing_count, ret;
1556 int context_count = s->slice_context_count;
1558 s->picture_in_gop_number++;
1560 if (load_input_picture(s, pic_arg) < 0)
1563 if (select_input_picture(s) < 0) {
1568 if (s->new_picture.f->data[0]) {
1570 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1573 s->mb_info_ptr = av_packet_new_side_data(pkt,
1574 AV_PKT_DATA_H263_MB_INFO,
1575 s->mb_width*s->mb_height*12);
1576 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1579 for (i = 0; i < context_count; i++) {
1580 int start_y = s->thread_context[i]->start_mb_y;
1581 int end_y = s->thread_context[i]-> end_mb_y;
1582 int h = s->mb_height;
1583 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1584 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1586 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1589 s->pict_type = s->new_picture.f->pict_type;
1591 ret = frame_start(s);
1595 if (encode_picture(s, s->picture_number) < 0)
1598 avctx->header_bits = s->header_bits;
1599 avctx->mv_bits = s->mv_bits;
1600 avctx->misc_bits = s->misc_bits;
1601 avctx->i_tex_bits = s->i_tex_bits;
1602 avctx->p_tex_bits = s->p_tex_bits;
1603 avctx->i_count = s->i_count;
1604 // FIXME f/b_count in avctx
1605 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1606 avctx->skip_count = s->skip_count;
1610 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1611 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1613 if (avctx->rc_buffer_size) {
1614 RateControlContext *rcc = &s->rc_context;
1615 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1617 if (put_bits_count(&s->pb) > max_size &&
1618 s->lambda < s->lmax) {
1619 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1620 (s->qscale + 1) / s->qscale);
1621 if (s->adaptive_quant) {
1623 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1624 s->lambda_table[i] =
1625 FFMAX(s->lambda_table[i] + 1,
1626 s->lambda_table[i] * (s->qscale + 1) /
1629 s->mb_skipped = 0; // done in frame_start()
1630 // done in encode_picture() so we must undo it
1631 if (s->pict_type == AV_PICTURE_TYPE_P) {
1632 if (s->flipflop_rounding ||
1633 s->codec_id == AV_CODEC_ID_H263P ||
1634 s->codec_id == AV_CODEC_ID_MPEG4)
1635 s->no_rounding ^= 1;
1637 if (s->pict_type != AV_PICTURE_TYPE_B) {
1638 s->time_base = s->last_time_base;
1639 s->last_non_b_time = s->time - s->pp_time;
1641 for (i = 0; i < context_count; i++) {
1642 PutBitContext *pb = &s->thread_context[i]->pb;
1643 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1648 assert(s->avctx->rc_max_rate);
1651 if (s->flags & CODEC_FLAG_PASS1)
1652 ff_write_pass1_stats(s);
1654 for (i = 0; i < 4; i++) {
1655 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1656 avctx->error[i] += s->current_picture_ptr->f->error[i];
1659 if (s->flags & CODEC_FLAG_PASS1)
1660 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1661 avctx->i_tex_bits + avctx->p_tex_bits ==
1662 put_bits_count(&s->pb));
1663 flush_put_bits(&s->pb);
1664 s->frame_bits = put_bits_count(&s->pb);
1666 stuffing_count = ff_vbv_update(s, s->frame_bits);
1667 if (stuffing_count) {
1668 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1669 stuffing_count + 50) {
1670 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1674 switch (s->codec_id) {
1675 case AV_CODEC_ID_MPEG1VIDEO:
1676 case AV_CODEC_ID_MPEG2VIDEO:
1677 while (stuffing_count--) {
1678 put_bits(&s->pb, 8, 0);
1681 case AV_CODEC_ID_MPEG4:
1682 put_bits(&s->pb, 16, 0);
1683 put_bits(&s->pb, 16, 0x1C3);
1684 stuffing_count -= 4;
1685 while (stuffing_count--) {
1686 put_bits(&s->pb, 8, 0xFF);
1690 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1692 flush_put_bits(&s->pb);
1693 s->frame_bits = put_bits_count(&s->pb);
1696 /* update mpeg1/2 vbv_delay for CBR */
1697 if (s->avctx->rc_max_rate &&
1698 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1699 s->out_format == FMT_MPEG1 &&
1700 90000LL * (avctx->rc_buffer_size - 1) <=
1701 s->avctx->rc_max_rate * 0xFFFFLL) {
1702 int vbv_delay, min_delay;
1703 double inbits = s->avctx->rc_max_rate *
1704 av_q2d(s->avctx->time_base);
1705 int minbits = s->frame_bits - 8 *
1706 (s->vbv_delay_ptr - s->pb.buf - 1);
1707 double bits = s->rc_context.buffer_index + minbits - inbits;
1710 av_log(s->avctx, AV_LOG_ERROR,
1711 "Internal error, negative bits\n");
1713 assert(s->repeat_first_field == 0);
1715 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1716 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1717 s->avctx->rc_max_rate;
1719 vbv_delay = FFMAX(vbv_delay, min_delay);
1721 assert(vbv_delay < 0xFFFF);
1723 s->vbv_delay_ptr[0] &= 0xF8;
1724 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1725 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1726 s->vbv_delay_ptr[2] &= 0x07;
1727 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1728 avctx->vbv_delay = vbv_delay * 300;
1730 s->total_bits += s->frame_bits;
1731 avctx->frame_bits = s->frame_bits;
1733 pkt->pts = s->current_picture.f->pts;
1734 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1735 if (!s->current_picture.f->coded_picture_number)
1736 pkt->dts = pkt->pts - s->dts_delta;
1738 pkt->dts = s->reordered_pts;
1739 s->reordered_pts = pkt->pts;
1741 pkt->dts = pkt->pts;
1742 if (s->current_picture.f->key_frame)
1743 pkt->flags |= AV_PKT_FLAG_KEY;
1745 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1749 assert((s->frame_bits & 7) == 0);
1751 pkt->size = s->frame_bits / 8;
1752 *got_packet = !!pkt->size;
1756 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1757 int n, int threshold)
1759 static const char tab[64] = {
1760 3, 2, 2, 1, 1, 1, 1, 1,
1761 1, 1, 1, 1, 1, 1, 1, 1,
1762 1, 1, 1, 1, 1, 1, 1, 1,
1763 0, 0, 0, 0, 0, 0, 0, 0,
1764 0, 0, 0, 0, 0, 0, 0, 0,
1765 0, 0, 0, 0, 0, 0, 0, 0,
1766 0, 0, 0, 0, 0, 0, 0, 0,
1767 0, 0, 0, 0, 0, 0, 0, 0
1772 int16_t *block = s->block[n];
1773 const int last_index = s->block_last_index[n];
1776 if (threshold < 0) {
1778 threshold = -threshold;
1782 /* Are all we could set to zero already zero? */
1783 if (last_index <= skip_dc - 1)
1786 for (i = 0; i <= last_index; i++) {
1787 const int j = s->intra_scantable.permutated[i];
1788 const int level = FFABS(block[j]);
1790 if (skip_dc && i == 0)
1794 } else if (level > 1) {
1800 if (score >= threshold)
1802 for (i = skip_dc; i <= last_index; i++) {
1803 const int j = s->intra_scantable.permutated[i];
1807 s->block_last_index[n] = 0;
1809 s->block_last_index[n] = -1;
1812 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1816 const int maxlevel = s->max_qcoeff;
1817 const int minlevel = s->min_qcoeff;
1821 i = 1; // skip clipping of intra dc
1825 for (; i <= last_index; i++) {
1826 const int j = s->intra_scantable.permutated[i];
1827 int level = block[j];
1829 if (level > maxlevel) {
1832 } else if (level < minlevel) {
1840 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1841 av_log(s->avctx, AV_LOG_INFO,
1842 "warning, clipping %d dct coefficients to %d..%d\n",
1843 overflow, minlevel, maxlevel);
1846 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1850 for (y = 0; y < 8; y++) {
1851 for (x = 0; x < 8; x++) {
1857 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1858 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1859 int v = ptr[x2 + y2 * stride];
1865 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1870 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1871 int motion_x, int motion_y,
1872 int mb_block_height,
1875 int16_t weight[8][64];
1876 int16_t orig[8][64];
1877 const int mb_x = s->mb_x;
1878 const int mb_y = s->mb_y;
1881 int dct_offset = s->linesize * 8; // default for progressive frames
1882 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1883 ptrdiff_t wrap_y, wrap_c;
1885 for (i = 0; i < mb_block_count; i++)
1886 skip_dct[i] = s->skipdct;
1888 if (s->adaptive_quant) {
1889 const int last_qp = s->qscale;
1890 const int mb_xy = mb_x + mb_y * s->mb_stride;
1892 s->lambda = s->lambda_table[mb_xy];
1895 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1896 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1897 s->dquant = s->qscale - last_qp;
1899 if (s->out_format == FMT_H263) {
1900 s->dquant = av_clip(s->dquant, -2, 2);
1902 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1904 if (s->pict_type == AV_PICTURE_TYPE_B) {
1905 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1908 if (s->mv_type == MV_TYPE_8X8)
1914 ff_set_qscale(s, last_qp + s->dquant);
1915 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1916 ff_set_qscale(s, s->qscale + s->dquant);
1918 wrap_y = s->linesize;
1919 wrap_c = s->uvlinesize;
1920 ptr_y = s->new_picture.f->data[0] +
1921 (mb_y * 16 * wrap_y) + mb_x * 16;
1922 ptr_cb = s->new_picture.f->data[1] +
1923 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1924 ptr_cr = s->new_picture.f->data[2] +
1925 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1927 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1928 uint8_t *ebuf = s->edge_emu_buffer + 32;
1929 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1931 16, 16, mb_x * 16, mb_y * 16,
1932 s->width, s->height);
1934 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1936 8, mb_block_height, mb_x * 8, mb_y * 8,
1937 s->width >> 1, s->height >> 1);
1938 ptr_cb = ebuf + 18 * wrap_y;
1939 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1941 8, mb_block_height, mb_x * 8, mb_y * 8,
1942 s->width >> 1, s->height >> 1);
1943 ptr_cr = ebuf + 18 * wrap_y + 8;
1947 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1948 int progressive_score, interlaced_score;
1950 s->interlaced_dct = 0;
1951 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1952 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1953 NULL, wrap_y, 8) - 400;
1955 if (progressive_score > 0) {
1956 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1957 NULL, wrap_y * 2, 8) +
1958 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
1959 NULL, wrap_y * 2, 8);
1960 if (progressive_score > interlaced_score) {
1961 s->interlaced_dct = 1;
1963 dct_offset = wrap_y;
1965 if (s->chroma_format == CHROMA_422)
1971 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
1972 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
1973 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
1974 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
1976 if (s->flags & CODEC_FLAG_GRAY) {
1980 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1981 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1982 if (!s->chroma_y_shift) { /* 422 */
1983 s->pdsp.get_pixels(s->block[6],
1984 ptr_cb + (dct_offset >> 1), wrap_c);
1985 s->pdsp.get_pixels(s->block[7],
1986 ptr_cr + (dct_offset >> 1), wrap_c);
1990 op_pixels_func (*op_pix)[4];
1991 qpel_mc_func (*op_qpix)[16];
1992 uint8_t *dest_y, *dest_cb, *dest_cr;
1994 dest_y = s->dest[0];
1995 dest_cb = s->dest[1];
1996 dest_cr = s->dest[2];
1998 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1999 op_pix = s->hdsp.put_pixels_tab;
2000 op_qpix = s->qdsp.put_qpel_pixels_tab;
2002 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2003 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2006 if (s->mv_dir & MV_DIR_FORWARD) {
2007 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2008 s->last_picture.f->data,
2010 op_pix = s->hdsp.avg_pixels_tab;
2011 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2013 if (s->mv_dir & MV_DIR_BACKWARD) {
2014 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2015 s->next_picture.f->data,
2019 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
2020 int progressive_score, interlaced_score;
2022 s->interlaced_dct = 0;
2023 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2024 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2028 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2029 progressive_score -= 400;
2031 if (progressive_score > 0) {
2032 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2034 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2038 if (progressive_score > interlaced_score) {
2039 s->interlaced_dct = 1;
2041 dct_offset = wrap_y;
2043 if (s->chroma_format == CHROMA_422)
2049 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2050 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2051 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2052 dest_y + dct_offset, wrap_y);
2053 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2054 dest_y + dct_offset + 8, wrap_y);
2056 if (s->flags & CODEC_FLAG_GRAY) {
2060 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2061 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2062 if (!s->chroma_y_shift) { /* 422 */
2063 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2064 dest_cb + (dct_offset >> 1), wrap_c);
2065 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2066 dest_cr + (dct_offset >> 1), wrap_c);
2069 /* pre quantization */
2070 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2071 2 * s->qscale * s->qscale) {
2073 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2075 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2077 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2078 wrap_y, 8) < 20 * s->qscale)
2080 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2081 wrap_y, 8) < 20 * s->qscale)
2083 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2085 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2087 if (!s->chroma_y_shift) { /* 422 */
2088 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2089 dest_cb + (dct_offset >> 1),
2090 wrap_c, 8) < 20 * s->qscale)
2092 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2093 dest_cr + (dct_offset >> 1),
2094 wrap_c, 8) < 20 * s->qscale)
2100 if (s->quantizer_noise_shaping) {
2102 get_visual_weight(weight[0], ptr_y , wrap_y);
2104 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2106 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2108 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2110 get_visual_weight(weight[4], ptr_cb , wrap_c);
2112 get_visual_weight(weight[5], ptr_cr , wrap_c);
2113 if (!s->chroma_y_shift) { /* 422 */
2115 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2118 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2121 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2124 /* DCT & quantize */
2125 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2127 for (i = 0; i < mb_block_count; i++) {
2130 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2131 // FIXME we could decide to change to quantizer instead of
2133 // JS: I don't think that would be a good idea it could lower
2134 // quality instead of improve it. Just INTRADC clipping
2135 // deserves changes in quantizer
2137 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2139 s->block_last_index[i] = -1;
2141 if (s->quantizer_noise_shaping) {
2142 for (i = 0; i < mb_block_count; i++) {
2144 s->block_last_index[i] =
2145 dct_quantize_refine(s, s->block[i], weight[i],
2146 orig[i], i, s->qscale);
2151 if (s->luma_elim_threshold && !s->mb_intra)
2152 for (i = 0; i < 4; i++)
2153 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2154 if (s->chroma_elim_threshold && !s->mb_intra)
2155 for (i = 4; i < mb_block_count; i++)
2156 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2158 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2159 for (i = 0; i < mb_block_count; i++) {
2160 if (s->block_last_index[i] == -1)
2161 s->coded_score[i] = INT_MAX / 256;
2166 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2167 s->block_last_index[4] =
2168 s->block_last_index[5] = 0;
2170 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2173 // non c quantize code returns incorrect block_last_index FIXME
2174 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2175 for (i = 0; i < mb_block_count; i++) {
2177 if (s->block_last_index[i] > 0) {
2178 for (j = 63; j > 0; j--) {
2179 if (s->block[i][s->intra_scantable.permutated[j]])
2182 s->block_last_index[i] = j;
2187 /* huffman encode */
2188 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2189 case AV_CODEC_ID_MPEG1VIDEO:
2190 case AV_CODEC_ID_MPEG2VIDEO:
2191 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2192 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2194 case AV_CODEC_ID_MPEG4:
2195 if (CONFIG_MPEG4_ENCODER)
2196 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2198 case AV_CODEC_ID_MSMPEG4V2:
2199 case AV_CODEC_ID_MSMPEG4V3:
2200 case AV_CODEC_ID_WMV1:
2201 if (CONFIG_MSMPEG4_ENCODER)
2202 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2204 case AV_CODEC_ID_WMV2:
2205 if (CONFIG_WMV2_ENCODER)
2206 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2208 case AV_CODEC_ID_H261:
2209 if (CONFIG_H261_ENCODER)
2210 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2212 case AV_CODEC_ID_H263:
2213 case AV_CODEC_ID_H263P:
2214 case AV_CODEC_ID_FLV1:
2215 case AV_CODEC_ID_RV10:
2216 case AV_CODEC_ID_RV20:
2217 if (CONFIG_H263_ENCODER)
2218 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2220 case AV_CODEC_ID_MJPEG:
2221 if (CONFIG_MJPEG_ENCODER)
2222 ff_mjpeg_encode_mb(s, s->block);
2229 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2231 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2232 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2235 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2238 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2241 d->mb_skip_run= s->mb_skip_run;
2243 d->last_dc[i] = s->last_dc[i];
2246 d->mv_bits= s->mv_bits;
2247 d->i_tex_bits= s->i_tex_bits;
2248 d->p_tex_bits= s->p_tex_bits;
2249 d->i_count= s->i_count;
2250 d->f_count= s->f_count;
2251 d->b_count= s->b_count;
2252 d->skip_count= s->skip_count;
2253 d->misc_bits= s->misc_bits;
2257 d->qscale= s->qscale;
2258 d->dquant= s->dquant;
2260 d->esc3_level_length= s->esc3_level_length;
2263 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2266 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2267 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2270 d->mb_skip_run= s->mb_skip_run;
2272 d->last_dc[i] = s->last_dc[i];
2275 d->mv_bits= s->mv_bits;
2276 d->i_tex_bits= s->i_tex_bits;
2277 d->p_tex_bits= s->p_tex_bits;
2278 d->i_count= s->i_count;
2279 d->f_count= s->f_count;
2280 d->b_count= s->b_count;
2281 d->skip_count= s->skip_count;
2282 d->misc_bits= s->misc_bits;
2284 d->mb_intra= s->mb_intra;
2285 d->mb_skipped= s->mb_skipped;
2286 d->mv_type= s->mv_type;
2287 d->mv_dir= s->mv_dir;
2289 if(s->data_partitioning){
2291 d->tex_pb= s->tex_pb;
2295 d->block_last_index[i]= s->block_last_index[i];
2296 d->interlaced_dct= s->interlaced_dct;
2297 d->qscale= s->qscale;
2299 d->esc3_level_length= s->esc3_level_length;
2302 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2303 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2304 int *dmin, int *next_block, int motion_x, int motion_y)
2307 uint8_t *dest_backup[3];
2309 copy_context_before_encode(s, backup, type);
2311 s->block= s->blocks[*next_block];
2312 s->pb= pb[*next_block];
2313 if(s->data_partitioning){
2314 s->pb2 = pb2 [*next_block];
2315 s->tex_pb= tex_pb[*next_block];
2319 memcpy(dest_backup, s->dest, sizeof(s->dest));
2320 s->dest[0] = s->rd_scratchpad;
2321 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2322 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2323 assert(s->linesize >= 32); //FIXME
2326 encode_mb(s, motion_x, motion_y);
2328 score= put_bits_count(&s->pb);
2329 if(s->data_partitioning){
2330 score+= put_bits_count(&s->pb2);
2331 score+= put_bits_count(&s->tex_pb);
2334 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2335 ff_mpv_decode_mb(s, s->block);
2337 score *= s->lambda2;
2338 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2342 memcpy(s->dest, dest_backup, sizeof(s->dest));
2349 copy_context_after_encode(best, s, type);
2353 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2354 uint32_t *sq = ff_square_tab + 256;
2359 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2360 else if(w==8 && h==8)
2361 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2365 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2374 static int sse_mb(MpegEncContext *s){
2378 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2379 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2382 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2383 return s->mecc.nsse[0](s, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16, s->dest[0], s->linesize, 16) +
2384 s->mecc.nsse[1](s, s->new_picture.f->data[1] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[1], s->uvlinesize, 8) +
2385 s->mecc.nsse[1](s, s->new_picture.f->data[2] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[2], s->uvlinesize, 8);
2387 return s->mecc.sse[0](NULL, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize * 16, s->dest[0], s->linesize, 16) +
2388 s->mecc.sse[1](NULL, s->new_picture.f->data[1] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[1], s->uvlinesize, 8) +
2389 s->mecc.sse[1](NULL, s->new_picture.f->data[2] + s->mb_x * 8 + s->mb_y * s->uvlinesize * 8, s->dest[2], s->uvlinesize, 8);
2392 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)
2393 +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)
2394 +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);
2397 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2398 MpegEncContext *s= *(void**)arg;
2402 s->me.dia_size= s->avctx->pre_dia_size;
2403 s->first_slice_line=1;
2404 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2405 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2406 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2408 s->first_slice_line=0;
2416 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2417 MpegEncContext *s= *(void**)arg;
2419 s->me.dia_size= s->avctx->dia_size;
2420 s->first_slice_line=1;
2421 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2422 s->mb_x=0; //for block init below
2423 ff_init_block_index(s);
2424 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2425 s->block_index[0]+=2;
2426 s->block_index[1]+=2;
2427 s->block_index[2]+=2;
2428 s->block_index[3]+=2;
2430 /* compute motion vector & mb_type and store in context */
2431 if(s->pict_type==AV_PICTURE_TYPE_B)
2432 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2434 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2436 s->first_slice_line=0;
2441 static int mb_var_thread(AVCodecContext *c, void *arg){
2442 MpegEncContext *s= *(void**)arg;
2445 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2446 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2449 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2451 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2453 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2454 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2456 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2457 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2458 s->me.mb_var_sum_temp += varc;
2464 static void write_slice_end(MpegEncContext *s){
2465 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2466 if(s->partitioned_frame){
2467 ff_mpeg4_merge_partitions(s);
2470 ff_mpeg4_stuffing(&s->pb);
2471 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2472 ff_mjpeg_encode_stuffing(&s->pb);
2475 avpriv_align_put_bits(&s->pb);
2476 flush_put_bits(&s->pb);
2478 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2479 s->misc_bits+= get_bits_diff(s);
2482 static void write_mb_info(MpegEncContext *s)
2484 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2485 int offset = put_bits_count(&s->pb);
2486 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2487 int gobn = s->mb_y / s->gob_index;
2489 if (CONFIG_H263_ENCODER)
2490 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2491 bytestream_put_le32(&ptr, offset);
2492 bytestream_put_byte(&ptr, s->qscale);
2493 bytestream_put_byte(&ptr, gobn);
2494 bytestream_put_le16(&ptr, mba);
2495 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2496 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2497 /* 4MV not implemented */
2498 bytestream_put_byte(&ptr, 0); /* hmv2 */
2499 bytestream_put_byte(&ptr, 0); /* vmv2 */
2502 static void update_mb_info(MpegEncContext *s, int startcode)
2506 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2507 s->mb_info_size += 12;
2508 s->prev_mb_info = s->last_mb_info;
2511 s->prev_mb_info = put_bits_count(&s->pb)/8;
2512 /* This might have incremented mb_info_size above, and we return without
2513 * actually writing any info into that slot yet. But in that case,
2514 * this will be called again at the start of the after writing the
2515 * start code, actually writing the mb info. */
2519 s->last_mb_info = put_bits_count(&s->pb)/8;
2520 if (!s->mb_info_size)
2521 s->mb_info_size += 12;
2525 static int encode_thread(AVCodecContext *c, void *arg){
2526 MpegEncContext *s= *(void**)arg;
2527 int mb_x, mb_y, pdif = 0;
2528 int chr_h= 16>>s->chroma_y_shift;
2530 MpegEncContext best_s, backup_s;
2531 uint8_t bit_buf[2][MAX_MB_BYTES];
2532 uint8_t bit_buf2[2][MAX_MB_BYTES];
2533 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2534 PutBitContext pb[2], pb2[2], tex_pb[2];
2537 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2538 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2539 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2542 s->last_bits= put_bits_count(&s->pb);
2553 /* init last dc values */
2554 /* note: quant matrix value (8) is implied here */
2555 s->last_dc[i] = 128 << s->intra_dc_precision;
2557 s->current_picture.f->error[i] = 0;
2560 memset(s->last_mv, 0, sizeof(s->last_mv));
2564 switch(s->codec_id){
2565 case AV_CODEC_ID_H263:
2566 case AV_CODEC_ID_H263P:
2567 case AV_CODEC_ID_FLV1:
2568 if (CONFIG_H263_ENCODER)
2569 s->gob_index = ff_h263_get_gob_height(s);
2571 case AV_CODEC_ID_MPEG4:
2572 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2573 ff_mpeg4_init_partitions(s);
2579 s->first_slice_line = 1;
2580 s->ptr_lastgob = s->pb.buf;
2581 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2585 ff_set_qscale(s, s->qscale);
2586 ff_init_block_index(s);
2588 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2589 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2590 int mb_type= s->mb_type[xy];
2595 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2596 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2599 if(s->data_partitioning){
2600 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2601 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2602 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2608 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2609 ff_update_block_index(s);
2611 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2612 ff_h261_reorder_mb_index(s);
2613 xy= s->mb_y*s->mb_stride + s->mb_x;
2614 mb_type= s->mb_type[xy];
2617 /* write gob / video packet header */
2619 int current_packet_size, is_gob_start;
2621 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2623 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2625 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2627 switch(s->codec_id){
2628 case AV_CODEC_ID_H263:
2629 case AV_CODEC_ID_H263P:
2630 if(!s->h263_slice_structured)
2631 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2633 case AV_CODEC_ID_MPEG2VIDEO:
2634 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2635 case AV_CODEC_ID_MPEG1VIDEO:
2636 if(s->mb_skip_run) is_gob_start=0;
2641 if(s->start_mb_y != mb_y || mb_x!=0){
2644 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2645 ff_mpeg4_init_partitions(s);
2649 assert((put_bits_count(&s->pb)&7) == 0);
2650 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2652 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2653 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2654 int d = 100 / s->error_rate;
2656 current_packet_size=0;
2657 s->pb.buf_ptr= s->ptr_lastgob;
2658 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2662 if (s->avctx->rtp_callback){
2663 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2664 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2666 update_mb_info(s, 1);
2668 switch(s->codec_id){
2669 case AV_CODEC_ID_MPEG4:
2670 if (CONFIG_MPEG4_ENCODER) {
2671 ff_mpeg4_encode_video_packet_header(s);
2672 ff_mpeg4_clean_buffers(s);
2675 case AV_CODEC_ID_MPEG1VIDEO:
2676 case AV_CODEC_ID_MPEG2VIDEO:
2677 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2678 ff_mpeg1_encode_slice_header(s);
2679 ff_mpeg1_clean_buffers(s);
2682 case AV_CODEC_ID_H263:
2683 case AV_CODEC_ID_H263P:
2684 if (CONFIG_H263_ENCODER)
2685 ff_h263_encode_gob_header(s, mb_y);
2689 if(s->flags&CODEC_FLAG_PASS1){
2690 int bits= put_bits_count(&s->pb);
2691 s->misc_bits+= bits - s->last_bits;
2695 s->ptr_lastgob += current_packet_size;
2696 s->first_slice_line=1;
2697 s->resync_mb_x=mb_x;
2698 s->resync_mb_y=mb_y;
2702 if( (s->resync_mb_x == s->mb_x)
2703 && s->resync_mb_y+1 == s->mb_y){
2704 s->first_slice_line=0;
2708 s->dquant=0; //only for QP_RD
2710 update_mb_info(s, 0);
2712 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
2714 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2716 copy_context_before_encode(&backup_s, s, -1);
2718 best_s.data_partitioning= s->data_partitioning;
2719 best_s.partitioned_frame= s->partitioned_frame;
2720 if(s->data_partitioning){
2721 backup_s.pb2= s->pb2;
2722 backup_s.tex_pb= s->tex_pb;
2725 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2726 s->mv_dir = MV_DIR_FORWARD;
2727 s->mv_type = MV_TYPE_16X16;
2729 s->mv[0][0][0] = s->p_mv_table[xy][0];
2730 s->mv[0][0][1] = s->p_mv_table[xy][1];
2731 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2732 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2734 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2735 s->mv_dir = MV_DIR_FORWARD;
2736 s->mv_type = MV_TYPE_FIELD;
2739 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2740 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2741 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2743 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2744 &dmin, &next_block, 0, 0);
2746 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2747 s->mv_dir = MV_DIR_FORWARD;
2748 s->mv_type = MV_TYPE_16X16;
2752 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2753 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2755 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2756 s->mv_dir = MV_DIR_FORWARD;
2757 s->mv_type = MV_TYPE_8X8;
2760 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2761 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2763 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2764 &dmin, &next_block, 0, 0);
2766 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2767 s->mv_dir = MV_DIR_FORWARD;
2768 s->mv_type = MV_TYPE_16X16;
2770 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2771 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2772 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2773 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2775 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2776 s->mv_dir = MV_DIR_BACKWARD;
2777 s->mv_type = MV_TYPE_16X16;
2779 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2780 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2781 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2782 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2784 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2785 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2786 s->mv_type = MV_TYPE_16X16;
2788 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2789 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2790 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2791 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2792 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2793 &dmin, &next_block, 0, 0);
2795 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2796 s->mv_dir = MV_DIR_FORWARD;
2797 s->mv_type = MV_TYPE_FIELD;
2800 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2801 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2802 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2804 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2805 &dmin, &next_block, 0, 0);
2807 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2808 s->mv_dir = MV_DIR_BACKWARD;
2809 s->mv_type = MV_TYPE_FIELD;
2812 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2813 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2814 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2816 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2817 &dmin, &next_block, 0, 0);
2819 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2820 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2821 s->mv_type = MV_TYPE_FIELD;
2823 for(dir=0; dir<2; dir++){
2825 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2826 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2827 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2830 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2831 &dmin, &next_block, 0, 0);
2833 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2835 s->mv_type = MV_TYPE_16X16;
2839 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2840 &dmin, &next_block, 0, 0);
2841 if(s->h263_pred || s->h263_aic){
2843 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2845 ff_clean_intra_table_entries(s); //old mode?
2849 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2850 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2851 const int last_qp= backup_s.qscale;
2854 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2855 static const int dquant_tab[4]={-1,1,-2,2};
2857 assert(backup_s.dquant == 0);
2860 s->mv_dir= best_s.mv_dir;
2861 s->mv_type = MV_TYPE_16X16;
2862 s->mb_intra= best_s.mb_intra;
2863 s->mv[0][0][0] = best_s.mv[0][0][0];
2864 s->mv[0][0][1] = best_s.mv[0][0][1];
2865 s->mv[1][0][0] = best_s.mv[1][0][0];
2866 s->mv[1][0][1] = best_s.mv[1][0][1];
2868 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2869 for(; qpi<4; qpi++){
2870 int dquant= dquant_tab[qpi];
2871 qp= last_qp + dquant;
2872 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2874 backup_s.dquant= dquant;
2875 if(s->mb_intra && s->dc_val[0]){
2877 dc[i]= s->dc_val[0][ s->block_index[i] ];
2878 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2882 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2883 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2884 if(best_s.qscale != qp){
2885 if(s->mb_intra && s->dc_val[0]){
2887 s->dc_val[0][ s->block_index[i] ]= dc[i];
2888 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2895 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2896 int mx= s->b_direct_mv_table[xy][0];
2897 int my= s->b_direct_mv_table[xy][1];
2899 backup_s.dquant = 0;
2900 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2902 ff_mpeg4_set_direct_mv(s, mx, my);
2903 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2904 &dmin, &next_block, mx, my);
2906 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2907 backup_s.dquant = 0;
2908 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2910 ff_mpeg4_set_direct_mv(s, 0, 0);
2911 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2912 &dmin, &next_block, 0, 0);
2914 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2917 coded |= s->block_last_index[i];
2920 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2921 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2922 mx=my=0; //FIXME find the one we actually used
2923 ff_mpeg4_set_direct_mv(s, mx, my);
2924 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2932 s->mv_dir= best_s.mv_dir;
2933 s->mv_type = best_s.mv_type;
2935 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2936 s->mv[0][0][1] = best_s.mv[0][0][1];
2937 s->mv[1][0][0] = best_s.mv[1][0][0];
2938 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2941 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2942 &dmin, &next_block, mx, my);
2947 s->current_picture.qscale_table[xy] = best_s.qscale;
2949 copy_context_after_encode(s, &best_s, -1);
2951 pb_bits_count= put_bits_count(&s->pb);
2952 flush_put_bits(&s->pb);
2953 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2956 if(s->data_partitioning){
2957 pb2_bits_count= put_bits_count(&s->pb2);
2958 flush_put_bits(&s->pb2);
2959 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2960 s->pb2= backup_s.pb2;
2962 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2963 flush_put_bits(&s->tex_pb);
2964 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2965 s->tex_pb= backup_s.tex_pb;
2967 s->last_bits= put_bits_count(&s->pb);
2969 if (CONFIG_H263_ENCODER &&
2970 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2971 ff_h263_update_motion_val(s);
2973 if(next_block==0){ //FIXME 16 vs linesize16
2974 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2975 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2976 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2979 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2980 ff_mpv_decode_mb(s, s->block);
2982 int motion_x = 0, motion_y = 0;
2983 s->mv_type=MV_TYPE_16X16;
2984 // only one MB-Type possible
2987 case CANDIDATE_MB_TYPE_INTRA:
2990 motion_x= s->mv[0][0][0] = 0;
2991 motion_y= s->mv[0][0][1] = 0;
2993 case CANDIDATE_MB_TYPE_INTER:
2994 s->mv_dir = MV_DIR_FORWARD;
2996 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2997 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2999 case CANDIDATE_MB_TYPE_INTER_I:
3000 s->mv_dir = MV_DIR_FORWARD;
3001 s->mv_type = MV_TYPE_FIELD;
3004 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3005 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3006 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3009 case CANDIDATE_MB_TYPE_INTER4V:
3010 s->mv_dir = MV_DIR_FORWARD;
3011 s->mv_type = MV_TYPE_8X8;
3014 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3015 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3018 case CANDIDATE_MB_TYPE_DIRECT:
3019 if (CONFIG_MPEG4_ENCODER) {
3020 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3022 motion_x=s->b_direct_mv_table[xy][0];
3023 motion_y=s->b_direct_mv_table[xy][1];
3024 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3027 case CANDIDATE_MB_TYPE_DIRECT0:
3028 if (CONFIG_MPEG4_ENCODER) {
3029 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3031 ff_mpeg4_set_direct_mv(s, 0, 0);
3034 case CANDIDATE_MB_TYPE_BIDIR:
3035 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3037 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3038 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3039 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3040 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3042 case CANDIDATE_MB_TYPE_BACKWARD:
3043 s->mv_dir = MV_DIR_BACKWARD;
3045 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3046 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3048 case CANDIDATE_MB_TYPE_FORWARD:
3049 s->mv_dir = MV_DIR_FORWARD;
3051 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3052 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3054 case CANDIDATE_MB_TYPE_FORWARD_I:
3055 s->mv_dir = MV_DIR_FORWARD;
3056 s->mv_type = MV_TYPE_FIELD;
3059 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3060 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3061 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3064 case CANDIDATE_MB_TYPE_BACKWARD_I:
3065 s->mv_dir = MV_DIR_BACKWARD;
3066 s->mv_type = MV_TYPE_FIELD;
3069 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3070 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3071 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3074 case CANDIDATE_MB_TYPE_BIDIR_I:
3075 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3076 s->mv_type = MV_TYPE_FIELD;
3078 for(dir=0; dir<2; dir++){
3080 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3081 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3082 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3087 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3090 encode_mb(s, motion_x, motion_y);
3092 // RAL: Update last macroblock type
3093 s->last_mv_dir = s->mv_dir;
3095 if (CONFIG_H263_ENCODER &&
3096 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3097 ff_h263_update_motion_val(s);
3099 ff_mpv_decode_mb(s, s->block);
3102 /* clean the MV table in IPS frames for direct mode in B frames */
3103 if(s->mb_intra /* && I,P,S_TYPE */){
3104 s->p_mv_table[xy][0]=0;
3105 s->p_mv_table[xy][1]=0;
3108 if(s->flags&CODEC_FLAG_PSNR){
3112 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3113 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3115 s->current_picture.f->error[0] += sse(
3116 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3117 s->dest[0], w, h, s->linesize);
3118 s->current_picture.f->error[1] += sse(
3119 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3120 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3121 s->current_picture.f->error[2] += sse(
3122 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3123 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3126 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3127 ff_h263_loop_filter(s);
3129 av_dlog(s->avctx, "MB %d %d bits\n",
3130 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3134 //not beautiful here but we must write it before flushing so it has to be here
3135 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3136 ff_msmpeg4_encode_ext_header(s);
3140 /* Send the last GOB if RTP */
3141 if (s->avctx->rtp_callback) {
3142 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3143 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3144 /* Call the RTP callback to send the last GOB */
3146 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3152 #define MERGE(field) dst->field += src->field; src->field=0
3153 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3154 MERGE(me.scene_change_score);
3155 MERGE(me.mc_mb_var_sum_temp);
3156 MERGE(me.mb_var_sum_temp);
3159 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3162 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3163 MERGE(dct_count[1]);
3172 MERGE(er.error_count);
3173 MERGE(padding_bug_score);
3174 MERGE(current_picture.f->error[0]);
3175 MERGE(current_picture.f->error[1]);
3176 MERGE(current_picture.f->error[2]);
3178 if(dst->avctx->noise_reduction){
3179 for(i=0; i<64; i++){
3180 MERGE(dct_error_sum[0][i]);
3181 MERGE(dct_error_sum[1][i]);
3185 assert(put_bits_count(&src->pb) % 8 ==0);
3186 assert(put_bits_count(&dst->pb) % 8 ==0);
3187 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3188 flush_put_bits(&dst->pb);
3191 static int estimate_qp(MpegEncContext *s, int dry_run){
3192 if (s->next_lambda){
3193 s->current_picture_ptr->f->quality =
3194 s->current_picture.f->quality = s->next_lambda;
3195 if(!dry_run) s->next_lambda= 0;
3196 } else if (!s->fixed_qscale) {
3197 s->current_picture_ptr->f->quality =
3198 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3199 if (s->current_picture.f->quality < 0)
3203 if(s->adaptive_quant){
3204 switch(s->codec_id){
3205 case AV_CODEC_ID_MPEG4:
3206 if (CONFIG_MPEG4_ENCODER)
3207 ff_clean_mpeg4_qscales(s);
3209 case AV_CODEC_ID_H263:
3210 case AV_CODEC_ID_H263P:
3211 case AV_CODEC_ID_FLV1:
3212 if (CONFIG_H263_ENCODER)
3213 ff_clean_h263_qscales(s);
3216 ff_init_qscale_tab(s);
3219 s->lambda= s->lambda_table[0];
3222 s->lambda = s->current_picture.f->quality;
3227 /* must be called before writing the header */
3228 static void set_frame_distances(MpegEncContext * s){
3229 assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3230 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3232 if(s->pict_type==AV_PICTURE_TYPE_B){
3233 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3234 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3236 s->pp_time= s->time - s->last_non_b_time;
3237 s->last_non_b_time= s->time;
3238 assert(s->picture_number==0 || s->pp_time > 0);
3242 static int encode_picture(MpegEncContext *s, int picture_number)
3246 int context_count = s->slice_context_count;
3248 s->picture_number = picture_number;
3250 /* Reset the average MB variance */
3251 s->me.mb_var_sum_temp =
3252 s->me.mc_mb_var_sum_temp = 0;
3254 /* we need to initialize some time vars before we can encode b-frames */
3255 // RAL: Condition added for MPEG1VIDEO
3256 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3257 set_frame_distances(s);
3258 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3259 ff_set_mpeg4_time(s);
3261 s->me.scene_change_score=0;
3263 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3265 if(s->pict_type==AV_PICTURE_TYPE_I){
3266 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3267 else s->no_rounding=0;
3268 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3269 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3270 s->no_rounding ^= 1;
3273 if(s->flags & CODEC_FLAG_PASS2){
3274 if (estimate_qp(s,1) < 0)
3276 ff_get_2pass_fcode(s);
3277 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3278 if(s->pict_type==AV_PICTURE_TYPE_B)
3279 s->lambda= s->last_lambda_for[s->pict_type];
3281 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3285 s->mb_intra=0; //for the rate distortion & bit compare functions
3286 for(i=1; i<context_count; i++){
3287 ret = ff_update_duplicate_context(s->thread_context[i], s);
3295 /* Estimate motion for every MB */
3296 if(s->pict_type != AV_PICTURE_TYPE_I){
3297 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3298 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3299 if (s->pict_type != AV_PICTURE_TYPE_B) {
3300 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3301 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3305 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3306 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3308 for(i=0; i<s->mb_stride*s->mb_height; i++)
3309 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3311 if(!s->fixed_qscale){
3312 /* finding spatial complexity for I-frame rate control */
3313 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
<