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 int64_t den = (int64_t) qscale * quant_matrix[j];
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) / den);
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 int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
111 /* 16 <= qscale * quant_matrix[i] <= 7905
112 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
113 * 19952 <= x <= 249205026
114 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
115 * 3444240 >= (1 << 36) / (x) >= 275 */
117 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
120 for (i = 0; i < 64; i++) {
121 const int j = s->idsp.idct_permutation[i];
122 int64_t den = (int64_t) qscale * quant_matrix[j];
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) / den);
129 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
130 // (qscale * quant_matrix[i]);
131 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
133 if (qmat16[qscale][0][i] == 0 ||
134 qmat16[qscale][0][i] == 128 * 256)
135 qmat16[qscale][0][i] = 128 * 256 - 1;
136 qmat16[qscale][1][i] =
137 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
138 qmat16[qscale][0][i]);
142 for (i = intra; i < 64; i++) {
144 if (fdsp->fdct == ff_fdct_ifast) {
145 max = (8191LL * ff_aanscales[i]) >> 14;
147 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
153 av_log(NULL, AV_LOG_INFO,
154 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
159 static inline void update_qscale(MpegEncContext *s)
161 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
162 (FF_LAMBDA_SHIFT + 7);
163 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
165 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
169 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
175 for (i = 0; i < 64; i++) {
176 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
183 * init s->current_picture.qscale_table from s->lambda_table
185 void ff_init_qscale_tab(MpegEncContext *s)
187 int8_t * const qscale_table = s->current_picture.qscale_table;
190 for (i = 0; i < s->mb_num; i++) {
191 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
192 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
193 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
198 static void update_duplicate_context_after_me(MpegEncContext *dst,
201 #define COPY(a) dst->a= src->a
203 COPY(current_picture);
209 COPY(picture_in_gop_number);
210 COPY(gop_picture_number);
211 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
212 COPY(progressive_frame); // FIXME don't set in encode_header
213 COPY(partitioned_frame); // FIXME don't set in encode_header
218 * Set the given MpegEncContext to defaults for encoding.
219 * the changed fields will not depend upon the prior state of the MpegEncContext.
221 static void mpv_encode_defaults(MpegEncContext *s)
224 ff_mpv_common_defaults(s);
226 for (i = -16; i < 16; i++) {
227 default_fcode_tab[i + MAX_MV] = 1;
229 s->me.mv_penalty = default_mv_penalty;
230 s->fcode_tab = default_fcode_tab;
232 s->input_picture_number = 0;
233 s->picture_in_gop_number = 0;
236 /* init video encoder */
237 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
239 MpegEncContext *s = avctx->priv_data;
240 int i, ret, format_supported;
242 mpv_encode_defaults(s);
244 switch (avctx->codec_id) {
245 case AV_CODEC_ID_MPEG2VIDEO:
246 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
247 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
248 av_log(avctx, AV_LOG_ERROR,
249 "only YUV420 and YUV422 are supported\n");
253 case AV_CODEC_ID_MJPEG:
254 format_supported = 0;
255 /* JPEG color space */
256 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
257 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
258 (avctx->color_range == AVCOL_RANGE_JPEG &&
259 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
260 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
261 format_supported = 1;
262 /* MPEG color space */
263 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
264 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
265 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
266 format_supported = 1;
268 if (!format_supported) {
269 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
274 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
275 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
280 switch (avctx->pix_fmt) {
281 case AV_PIX_FMT_YUVJ422P:
282 case AV_PIX_FMT_YUV422P:
283 s->chroma_format = CHROMA_422;
285 case AV_PIX_FMT_YUVJ420P:
286 case AV_PIX_FMT_YUV420P:
288 s->chroma_format = CHROMA_420;
292 s->bit_rate = avctx->bit_rate;
293 s->width = avctx->width;
294 s->height = avctx->height;
295 if (avctx->gop_size > 600 &&
296 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
297 av_log(avctx, AV_LOG_ERROR,
298 "Warning keyframe interval too large! reducing it ...\n");
299 avctx->gop_size = 600;
301 s->gop_size = avctx->gop_size;
303 s->flags = avctx->flags;
304 s->flags2 = avctx->flags2;
305 if (avctx->max_b_frames > MAX_B_FRAMES) {
306 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
307 "is %d.\n", MAX_B_FRAMES);
309 s->max_b_frames = avctx->max_b_frames;
310 s->codec_id = avctx->codec->id;
311 s->strict_std_compliance = avctx->strict_std_compliance;
312 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
313 s->mpeg_quant = avctx->mpeg_quant;
314 s->rtp_mode = !!avctx->rtp_payload_size;
315 s->intra_dc_precision = avctx->intra_dc_precision;
316 s->user_specified_pts = AV_NOPTS_VALUE;
318 if (s->gop_size <= 1) {
325 s->me_method = avctx->me_method;
328 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
331 FF_DISABLE_DEPRECATION_WARNINGS
332 if (avctx->border_masking != 0.0)
333 s->border_masking = avctx->border_masking;
334 FF_ENABLE_DEPRECATION_WARNINGS
337 s->adaptive_quant = (s->avctx->lumi_masking ||
338 s->avctx->dark_masking ||
339 s->avctx->temporal_cplx_masking ||
340 s->avctx->spatial_cplx_masking ||
341 s->avctx->p_masking ||
343 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
346 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
348 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
349 av_log(avctx, AV_LOG_ERROR,
350 "a vbv buffer size is needed, "
351 "for encoding with a maximum bitrate\n");
355 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
356 av_log(avctx, AV_LOG_INFO,
357 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
360 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
361 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
365 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
366 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
370 if (avctx->rc_max_rate &&
371 avctx->rc_max_rate == avctx->bit_rate &&
372 avctx->rc_max_rate != avctx->rc_min_rate) {
373 av_log(avctx, AV_LOG_INFO,
374 "impossible bitrate constraints, this will fail\n");
377 if (avctx->rc_buffer_size &&
378 avctx->bit_rate * (int64_t)avctx->time_base.num >
379 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
380 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
384 if (!s->fixed_qscale &&
385 avctx->bit_rate * av_q2d(avctx->time_base) >
386 avctx->bit_rate_tolerance) {
387 av_log(avctx, AV_LOG_ERROR,
388 "bitrate tolerance too small for bitrate\n");
392 if (s->avctx->rc_max_rate &&
393 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
394 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
395 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
396 90000LL * (avctx->rc_buffer_size - 1) >
397 s->avctx->rc_max_rate * 0xFFFFLL) {
398 av_log(avctx, AV_LOG_INFO,
399 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
400 "specified vbv buffer is too large for the given bitrate!\n");
403 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
404 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
405 s->codec_id != AV_CODEC_ID_FLV1) {
406 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
410 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
411 av_log(avctx, AV_LOG_ERROR,
412 "OBMC is only supported with simple mb decision\n");
416 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
417 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
421 if (s->max_b_frames &&
422 s->codec_id != AV_CODEC_ID_MPEG4 &&
423 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
424 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
425 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
429 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
430 s->codec_id == AV_CODEC_ID_H263 ||
431 s->codec_id == AV_CODEC_ID_H263P) &&
432 (avctx->sample_aspect_ratio.num > 255 ||
433 avctx->sample_aspect_ratio.den > 255)) {
434 av_log(avctx, AV_LOG_ERROR,
435 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
436 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
440 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
441 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
442 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
446 // FIXME mpeg2 uses that too
447 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
448 av_log(avctx, AV_LOG_ERROR,
449 "mpeg2 style quantization not supported by codec\n");
453 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
454 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
458 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
459 s->avctx->mb_decision != FF_MB_DECISION_RD) {
460 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
464 if (s->avctx->scenechange_threshold < 1000000000 &&
465 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
466 av_log(avctx, AV_LOG_ERROR,
467 "closed gop with scene change detection are not supported yet, "
468 "set threshold to 1000000000\n");
472 if (s->flags & CODEC_FLAG_LOW_DELAY) {
473 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
474 av_log(avctx, AV_LOG_ERROR,
475 "low delay forcing is only available for mpeg2\n");
478 if (s->max_b_frames != 0) {
479 av_log(avctx, AV_LOG_ERROR,
480 "b frames cannot be used with low delay\n");
485 if (s->q_scale_type == 1) {
486 if (avctx->qmax > 12) {
487 av_log(avctx, AV_LOG_ERROR,
488 "non linear quant only supports qmax <= 12 currently\n");
493 if (s->avctx->thread_count > 1 &&
494 s->codec_id != AV_CODEC_ID_MPEG4 &&
495 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
496 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
497 (s->codec_id != AV_CODEC_ID_H263P)) {
498 av_log(avctx, AV_LOG_ERROR,
499 "multi threaded encoding not supported by codec\n");
503 if (s->avctx->thread_count < 1) {
504 av_log(avctx, AV_LOG_ERROR,
505 "automatic thread number detection not supported by codec,"
510 if (s->avctx->thread_count > 1)
513 if (!avctx->time_base.den || !avctx->time_base.num) {
514 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
518 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
519 av_log(avctx, AV_LOG_INFO,
520 "notice: b_frame_strategy only affects the first pass\n");
521 avctx->b_frame_strategy = 0;
524 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
526 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
527 avctx->time_base.den /= i;
528 avctx->time_base.num /= i;
532 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
533 s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
534 // (a + x * 3 / 8) / x
535 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
536 s->inter_quant_bias = 0;
538 s->intra_quant_bias = 0;
540 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
543 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
544 s->intra_quant_bias = avctx->intra_quant_bias;
545 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
546 s->inter_quant_bias = avctx->inter_quant_bias;
548 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
549 s->avctx->time_base.den > (1 << 16) - 1) {
550 av_log(avctx, AV_LOG_ERROR,
551 "timebase %d/%d not supported by MPEG 4 standard, "
552 "the maximum admitted value for the timebase denominator "
553 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
557 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
559 switch (avctx->codec->id) {
560 case AV_CODEC_ID_MPEG1VIDEO:
561 s->out_format = FMT_MPEG1;
562 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
563 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
565 case AV_CODEC_ID_MPEG2VIDEO:
566 s->out_format = FMT_MPEG1;
567 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
568 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
571 case AV_CODEC_ID_MJPEG:
572 s->out_format = FMT_MJPEG;
573 s->intra_only = 1; /* force intra only for jpeg */
574 if (!CONFIG_MJPEG_ENCODER ||
575 ff_mjpeg_encode_init(s) < 0)
580 case AV_CODEC_ID_H261:
581 if (!CONFIG_H261_ENCODER)
583 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
584 av_log(avctx, AV_LOG_ERROR,
585 "The specified picture size of %dx%d is not valid for the "
586 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
587 s->width, s->height);
590 s->out_format = FMT_H261;
593 s->rtp_mode = 0; /* Sliced encoding not supported */
595 case AV_CODEC_ID_H263:
596 if (!CONFIG_H263_ENCODER)
598 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
599 s->width, s->height) == 8) {
600 av_log(avctx, AV_LOG_INFO,
601 "The specified picture size of %dx%d is not valid for "
602 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
603 "352x288, 704x576, and 1408x1152."
604 "Try H.263+.\n", s->width, s->height);
607 s->out_format = FMT_H263;
611 case AV_CODEC_ID_H263P:
612 s->out_format = FMT_H263;
615 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
616 s->modified_quant = s->h263_aic;
617 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
618 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
621 /* These are just to be sure */
625 case AV_CODEC_ID_FLV1:
626 s->out_format = FMT_H263;
627 s->h263_flv = 2; /* format = 1; 11-bit codes */
628 s->unrestricted_mv = 1;
629 s->rtp_mode = 0; /* don't allow GOB */
633 case AV_CODEC_ID_RV10:
634 s->out_format = FMT_H263;
638 case AV_CODEC_ID_RV20:
639 s->out_format = FMT_H263;
642 s->modified_quant = 1;
646 s->unrestricted_mv = 0;
648 case AV_CODEC_ID_MPEG4:
649 s->out_format = FMT_H263;
651 s->unrestricted_mv = 1;
652 s->low_delay = s->max_b_frames ? 0 : 1;
653 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
655 case AV_CODEC_ID_MSMPEG4V2:
656 s->out_format = FMT_H263;
658 s->unrestricted_mv = 1;
659 s->msmpeg4_version = 2;
663 case AV_CODEC_ID_MSMPEG4V3:
664 s->out_format = FMT_H263;
666 s->unrestricted_mv = 1;
667 s->msmpeg4_version = 3;
668 s->flipflop_rounding = 1;
672 case AV_CODEC_ID_WMV1:
673 s->out_format = FMT_H263;
675 s->unrestricted_mv = 1;
676 s->msmpeg4_version = 4;
677 s->flipflop_rounding = 1;
681 case AV_CODEC_ID_WMV2:
682 s->out_format = FMT_H263;
684 s->unrestricted_mv = 1;
685 s->msmpeg4_version = 5;
686 s->flipflop_rounding = 1;
694 avctx->has_b_frames = !s->low_delay;
698 s->progressive_frame =
699 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
700 CODEC_FLAG_INTERLACED_ME) ||
705 if (ff_mpv_common_init(s) < 0)
709 ff_mpv_encode_init_x86(s);
711 ff_fdctdsp_init(&s->fdsp, avctx);
712 ff_me_cmp_init(&s->mecc, avctx);
713 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
714 ff_pixblockdsp_init(&s->pdsp, avctx);
715 ff_qpeldsp_init(&s->qdsp);
717 s->avctx->coded_frame = s->current_picture.f;
719 if (s->msmpeg4_version) {
720 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
721 2 * 2 * (MAX_LEVEL + 1) *
722 (MAX_RUN + 1) * 2 * sizeof(int), fail);
724 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
726 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
728 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
729 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
730 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
731 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
732 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
733 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
735 if (s->avctx->noise_reduction) {
736 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
737 2 * 64 * sizeof(uint16_t), fail);
740 if (CONFIG_H263_ENCODER)
741 ff_h263dsp_init(&s->h263dsp);
742 if (!s->dct_quantize)
743 s->dct_quantize = ff_dct_quantize_c;
745 s->denoise_dct = denoise_dct_c;
746 s->fast_dct_quantize = s->dct_quantize;
748 s->dct_quantize = dct_quantize_trellis_c;
750 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
751 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
753 s->quant_precision = 5;
755 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
756 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->avctx->frame_skip_cmp);
758 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
759 ff_h261_encode_init(s);
760 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
761 ff_h263_encode_init(s);
762 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
763 ff_msmpeg4_encode_init(s);
764 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
765 && s->out_format == FMT_MPEG1)
766 ff_mpeg1_encode_init(s);
769 for (i = 0; i < 64; i++) {
770 int j = s->idsp.idct_permutation[i];
771 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
773 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
774 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
775 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
777 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
780 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
781 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
783 if (s->avctx->intra_matrix)
784 s->intra_matrix[j] = s->avctx->intra_matrix[i];
785 if (s->avctx->inter_matrix)
786 s->inter_matrix[j] = s->avctx->inter_matrix[i];
789 /* precompute matrix */
790 /* for mjpeg, we do include qscale in the matrix */
791 if (s->out_format != FMT_MJPEG) {
792 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
793 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
795 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
796 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
800 if (ff_rate_control_init(s) < 0)
803 #if FF_API_ERROR_RATE
804 FF_DISABLE_DEPRECATION_WARNINGS
805 if (avctx->error_rate)
806 s->error_rate = avctx->error_rate;
807 FF_ENABLE_DEPRECATION_WARNINGS;
810 #if FF_API_NORMALIZE_AQP
811 FF_DISABLE_DEPRECATION_WARNINGS
812 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
813 s->mpv_flags |= FF_MPV_FLAG_NAQ;
814 FF_ENABLE_DEPRECATION_WARNINGS;
818 FF_DISABLE_DEPRECATION_WARNINGS
819 if (avctx->flags & CODEC_FLAG_MV0)
820 s->mpv_flags |= FF_MPV_FLAG_MV0;
821 FF_ENABLE_DEPRECATION_WARNINGS
825 FF_DISABLE_DEPRECATION_WARNINGS
826 if (avctx->rc_qsquish != 0.0)
827 s->rc_qsquish = avctx->rc_qsquish;
828 if (avctx->rc_qmod_amp != 0.0)
829 s->rc_qmod_amp = avctx->rc_qmod_amp;
830 if (avctx->rc_qmod_freq)
831 s->rc_qmod_freq = avctx->rc_qmod_freq;
832 if (avctx->rc_buffer_aggressivity != 1.0)
833 s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
834 if (avctx->rc_initial_cplx != 0.0)
835 s->rc_initial_cplx = avctx->rc_initial_cplx;
837 s->lmin = avctx->lmin;
839 s->lmax = avctx->lmax;
843 s->rc_eq = av_strdup(avctx->rc_eq);
845 return AVERROR(ENOMEM);
847 FF_ENABLE_DEPRECATION_WARNINGS
850 if (avctx->b_frame_strategy == 2) {
851 for (i = 0; i < s->max_b_frames + 2; i++) {
852 s->tmp_frames[i] = av_frame_alloc();
853 if (!s->tmp_frames[i])
854 return AVERROR(ENOMEM);
856 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
857 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
858 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
860 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
868 ff_mpv_encode_end(avctx);
869 return AVERROR_UNKNOWN;
872 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
874 MpegEncContext *s = avctx->priv_data;
877 ff_rate_control_uninit(s);
879 ff_mpv_common_end(s);
880 if (CONFIG_MJPEG_ENCODER &&
881 s->out_format == FMT_MJPEG)
882 ff_mjpeg_encode_close(s);
884 av_freep(&avctx->extradata);
886 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
887 av_frame_free(&s->tmp_frames[i]);
889 ff_free_picture_tables(&s->new_picture);
890 ff_mpeg_unref_picture(s, &s->new_picture);
892 av_freep(&s->avctx->stats_out);
893 av_freep(&s->ac_stats);
895 av_freep(&s->q_intra_matrix);
896 av_freep(&s->q_inter_matrix);
897 av_freep(&s->q_intra_matrix16);
898 av_freep(&s->q_inter_matrix16);
899 av_freep(&s->input_picture);
900 av_freep(&s->reordered_input_picture);
901 av_freep(&s->dct_offset);
906 static int get_sae(uint8_t *src, int ref, int stride)
911 for (y = 0; y < 16; y++) {
912 for (x = 0; x < 16; x++) {
913 acc += FFABS(src[x + y * stride] - ref);
920 static int get_intra_count(MpegEncContext *s, uint8_t *src,
921 uint8_t *ref, int stride)
929 for (y = 0; y < h; y += 16) {
930 for (x = 0; x < w; x += 16) {
931 int offset = x + y * stride;
932 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
934 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
935 int sae = get_sae(src + offset, mean, stride);
937 acc += sae + 500 < sad;
944 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
948 int i, display_picture_number = 0, ret;
949 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
950 (s->low_delay ? 0 : 1);
955 display_picture_number = s->input_picture_number++;
957 if (pts != AV_NOPTS_VALUE) {
958 if (s->user_specified_pts != AV_NOPTS_VALUE) {
960 int64_t last = s->user_specified_pts;
963 av_log(s->avctx, AV_LOG_ERROR,
964 "Error, Invalid timestamp=%"PRId64", "
965 "last=%"PRId64"\n", pts, s->user_specified_pts);
969 if (!s->low_delay && display_picture_number == 1)
970 s->dts_delta = time - last;
972 s->user_specified_pts = pts;
974 if (s->user_specified_pts != AV_NOPTS_VALUE) {
975 s->user_specified_pts =
976 pts = s->user_specified_pts + 1;
977 av_log(s->avctx, AV_LOG_INFO,
978 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
981 pts = display_picture_number;
987 if (!pic_arg->buf[0] ||
988 pic_arg->linesize[0] != s->linesize ||
989 pic_arg->linesize[1] != s->uvlinesize ||
990 pic_arg->linesize[2] != s->uvlinesize)
993 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
994 pic_arg->linesize[1], s->linesize, s->uvlinesize);
996 i = ff_find_unused_picture(s, direct);
1000 pic = &s->picture[i];
1004 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1006 if (ff_alloc_picture(s, pic, 1) < 0) {
1010 if (ff_alloc_picture(s, pic, 0) < 0) {
1014 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1015 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1016 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1019 int h_chroma_shift, v_chroma_shift;
1020 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1024 for (i = 0; i < 3; i++) {
1025 int src_stride = pic_arg->linesize[i];
1026 int dst_stride = i ? s->uvlinesize : s->linesize;
1027 int h_shift = i ? h_chroma_shift : 0;
1028 int v_shift = i ? v_chroma_shift : 0;
1029 int w = s->width >> h_shift;
1030 int h = s->height >> v_shift;
1031 uint8_t *src = pic_arg->data[i];
1032 uint8_t *dst = pic->f->data[i];
1034 if (!s->avctx->rc_buffer_size)
1035 dst += INPLACE_OFFSET;
1037 if (src_stride == dst_stride)
1038 memcpy(dst, src, src_stride * h);
1041 memcpy(dst, src, w);
1049 ret = av_frame_copy_props(pic->f, pic_arg);
1053 pic->f->display_picture_number = display_picture_number;
1054 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1057 /* shift buffer entries */
1058 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1059 s->input_picture[i - 1] = s->input_picture[i];
1061 s->input_picture[encoding_delay] = (Picture*) pic;
1066 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1070 int64_t score64 = 0;
1072 for (plane = 0; plane < 3; plane++) {
1073 const int stride = p->f->linesize[plane];
1074 const int bw = plane ? 1 : 2;
1075 for (y = 0; y < s->mb_height * bw; y++) {
1076 for (x = 0; x < s->mb_width * bw; x++) {
1077 int off = p->shared ? 0 : 16;
1078 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1079 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1080 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1082 switch (s->avctx->frame_skip_exp) {
1083 case 0: score = FFMAX(score, v); break;
1084 case 1: score += FFABS(v); break;
1085 case 2: score += v * v; break;
1086 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1087 case 4: score64 += v * v * (int64_t)(v * v); break;
1096 if (score64 < s->avctx->frame_skip_threshold)
1098 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1103 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1105 AVPacket pkt = { 0 };
1106 int ret, got_output;
1108 av_init_packet(&pkt);
1109 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1114 av_free_packet(&pkt);
1118 static int estimate_best_b_count(MpegEncContext *s)
1120 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1121 AVCodecContext *c = avcodec_alloc_context3(NULL);
1122 const int scale = s->avctx->brd_scale;
1123 int i, j, out_size, p_lambda, b_lambda, lambda2;
1124 int64_t best_rd = INT64_MAX;
1125 int best_b_count = -1;
1127 assert(scale >= 0 && scale <= 3);
1130 //s->next_picture_ptr->quality;
1131 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1132 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1133 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1134 if (!b_lambda) // FIXME we should do this somewhere else
1135 b_lambda = p_lambda;
1136 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1139 c->width = s->width >> scale;
1140 c->height = s->height >> scale;
1141 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
1142 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1143 c->mb_decision = s->avctx->mb_decision;
1144 c->me_cmp = s->avctx->me_cmp;
1145 c->mb_cmp = s->avctx->mb_cmp;
1146 c->me_sub_cmp = s->avctx->me_sub_cmp;
1147 c->pix_fmt = AV_PIX_FMT_YUV420P;
1148 c->time_base = s->avctx->time_base;
1149 c->max_b_frames = s->max_b_frames;
1151 if (avcodec_open2(c, codec, NULL) < 0)
1154 for (i = 0; i < s->max_b_frames + 2; i++) {
1155 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1156 s->next_picture_ptr;
1158 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1159 pre_input = *pre_input_ptr;
1161 if (!pre_input.shared && i) {
1162 pre_input.f->data[0] += INPLACE_OFFSET;
1163 pre_input.f->data[1] += INPLACE_OFFSET;
1164 pre_input.f->data[2] += INPLACE_OFFSET;
1167 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1168 s->tmp_frames[i]->linesize[0],
1169 pre_input.f->data[0],
1170 pre_input.f->linesize[0],
1171 c->width, c->height);
1172 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1173 s->tmp_frames[i]->linesize[1],
1174 pre_input.f->data[1],
1175 pre_input.f->linesize[1],
1176 c->width >> 1, c->height >> 1);
1177 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1178 s->tmp_frames[i]->linesize[2],
1179 pre_input.f->data[2],
1180 pre_input.f->linesize[2],
1181 c->width >> 1, c->height >> 1);
1185 for (j = 0; j < s->max_b_frames + 1; j++) {
1188 if (!s->input_picture[j])
1191 c->error[0] = c->error[1] = c->error[2] = 0;
1193 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1194 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1196 out_size = encode_frame(c, s->tmp_frames[0]);
1198 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1200 for (i = 0; i < s->max_b_frames + 1; i++) {
1201 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1203 s->tmp_frames[i + 1]->pict_type = is_p ?
1204 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1205 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1207 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1209 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1212 /* get the delayed frames */
1214 out_size = encode_frame(c, NULL);
1215 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1218 rd += c->error[0] + c->error[1] + c->error[2];
1229 return best_b_count;
1232 static int select_input_picture(MpegEncContext *s)
1236 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1237 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1238 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1240 /* set next picture type & ordering */
1241 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1242 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1243 !s->next_picture_ptr || s->intra_only) {
1244 s->reordered_input_picture[0] = s->input_picture[0];
1245 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1246 s->reordered_input_picture[0]->f->coded_picture_number =
1247 s->coded_picture_number++;
1251 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1252 if (s->picture_in_gop_number < s->gop_size &&
1253 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1254 // FIXME check that te gop check above is +-1 correct
1255 av_frame_unref(s->input_picture[0]->f);
1258 ff_vbv_update(s, 0);
1264 if (s->flags & CODEC_FLAG_PASS2) {
1265 for (i = 0; i < s->max_b_frames + 1; i++) {
1266 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1268 if (pict_num >= s->rc_context.num_entries)
1270 if (!s->input_picture[i]) {
1271 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1275 s->input_picture[i]->f->pict_type =
1276 s->rc_context.entry[pict_num].new_pict_type;
1280 if (s->avctx->b_frame_strategy == 0) {
1281 b_frames = s->max_b_frames;
1282 while (b_frames && !s->input_picture[b_frames])
1284 } else if (s->avctx->b_frame_strategy == 1) {
1285 for (i = 1; i < s->max_b_frames + 1; i++) {
1286 if (s->input_picture[i] &&
1287 s->input_picture[i]->b_frame_score == 0) {
1288 s->input_picture[i]->b_frame_score =
1290 s->input_picture[i ]->f->data[0],
1291 s->input_picture[i - 1]->f->data[0],
1295 for (i = 0; i < s->max_b_frames + 1; i++) {
1296 if (!s->input_picture[i] ||
1297 s->input_picture[i]->b_frame_score - 1 >
1298 s->mb_num / s->avctx->b_sensitivity)
1302 b_frames = FFMAX(0, i - 1);
1305 for (i = 0; i < b_frames + 1; i++) {
1306 s->input_picture[i]->b_frame_score = 0;
1308 } else if (s->avctx->b_frame_strategy == 2) {
1309 b_frames = estimate_best_b_count(s);
1311 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1317 for (i = b_frames - 1; i >= 0; i--) {
1318 int type = s->input_picture[i]->f->pict_type;
1319 if (type && type != AV_PICTURE_TYPE_B)
1322 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1323 b_frames == s->max_b_frames) {
1324 av_log(s->avctx, AV_LOG_ERROR,
1325 "warning, too many b frames in a row\n");
1328 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1329 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1330 s->gop_size > s->picture_in_gop_number) {
1331 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1333 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1335 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1339 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1340 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1343 s->reordered_input_picture[0] = s->input_picture[b_frames];
1344 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1345 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1346 s->reordered_input_picture[0]->f->coded_picture_number =
1347 s->coded_picture_number++;
1348 for (i = 0; i < b_frames; i++) {
1349 s->reordered_input_picture[i + 1] = s->input_picture[i];
1350 s->reordered_input_picture[i + 1]->f->pict_type =
1352 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1353 s->coded_picture_number++;
1358 if (s->reordered_input_picture[0]) {
1359 s->reordered_input_picture[0]->reference =
1360 s->reordered_input_picture[0]->f->pict_type !=
1361 AV_PICTURE_TYPE_B ? 3 : 0;
1363 ff_mpeg_unref_picture(s, &s->new_picture);
1364 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1367 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1368 // input is a shared pix, so we can't modifiy it -> alloc a new
1369 // one & ensure that the shared one is reuseable
1372 int i = ff_find_unused_picture(s, 0);
1375 pic = &s->picture[i];
1377 pic->reference = s->reordered_input_picture[0]->reference;
1378 if (ff_alloc_picture(s, pic, 0) < 0) {
1382 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1386 /* mark us unused / free shared pic */
1387 av_frame_unref(s->reordered_input_picture[0]->f);
1388 s->reordered_input_picture[0]->shared = 0;
1390 s->current_picture_ptr = pic;
1392 // input is not a shared pix -> reuse buffer for current_pix
1393 s->current_picture_ptr = s->reordered_input_picture[0];
1394 for (i = 0; i < 4; i++) {
1395 s->new_picture.f->data[i] += INPLACE_OFFSET;
1398 ff_mpeg_unref_picture(s, &s->current_picture);
1399 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1400 s->current_picture_ptr)) < 0)
1403 s->picture_number = s->new_picture.f->display_picture_number;
1405 ff_mpeg_unref_picture(s, &s->new_picture);
1410 static void frame_end(MpegEncContext *s)
1414 if (s->unrestricted_mv &&
1415 s->current_picture.reference &&
1417 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1418 int hshift = desc->log2_chroma_w;
1419 int vshift = desc->log2_chroma_h;
1420 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1421 s->h_edge_pos, s->v_edge_pos,
1422 EDGE_WIDTH, EDGE_WIDTH,
1423 EDGE_TOP | EDGE_BOTTOM);
1424 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1425 s->h_edge_pos >> hshift,
1426 s->v_edge_pos >> vshift,
1427 EDGE_WIDTH >> hshift,
1428 EDGE_WIDTH >> vshift,
1429 EDGE_TOP | EDGE_BOTTOM);
1430 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1431 s->h_edge_pos >> hshift,
1432 s->v_edge_pos >> vshift,
1433 EDGE_WIDTH >> hshift,
1434 EDGE_WIDTH >> vshift,
1435 EDGE_TOP | EDGE_BOTTOM);
1440 s->last_pict_type = s->pict_type;
1441 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1442 if (s->pict_type!= AV_PICTURE_TYPE_B)
1443 s->last_non_b_pict_type = s->pict_type;
1446 /* release non-reference frames */
1447 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1448 if (!s->picture[i].reference)
1449 ff_mpeg_unref_picture(s, &s->picture[i]);
1453 s->avctx->coded_frame = s->current_picture_ptr->f;
1457 static void update_noise_reduction(MpegEncContext *s)
1461 for (intra = 0; intra < 2; intra++) {
1462 if (s->dct_count[intra] > (1 << 16)) {
1463 for (i = 0; i < 64; i++) {
1464 s->dct_error_sum[intra][i] >>= 1;
1466 s->dct_count[intra] >>= 1;
1469 for (i = 0; i < 64; i++) {
1470 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1471 s->dct_count[intra] +
1472 s->dct_error_sum[intra][i] / 2) /
1473 (s->dct_error_sum[intra][i] + 1);
1478 static int frame_start(MpegEncContext *s)
1482 /* mark & release old frames */
1483 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1484 s->last_picture_ptr != s->next_picture_ptr &&
1485 s->last_picture_ptr->f->buf[0]) {
1486 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1489 s->current_picture_ptr->f->pict_type = s->pict_type;
1490 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1492 ff_mpeg_unref_picture(s, &s->current_picture);
1493 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1494 s->current_picture_ptr)) < 0)
1497 if (s->pict_type != AV_PICTURE_TYPE_B) {
1498 s->last_picture_ptr = s->next_picture_ptr;
1500 s->next_picture_ptr = s->current_picture_ptr;
1503 if (s->last_picture_ptr) {
1504 ff_mpeg_unref_picture(s, &s->last_picture);
1505 if (s->last_picture_ptr->f->buf[0] &&
1506 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1507 s->last_picture_ptr)) < 0)
1510 if (s->next_picture_ptr) {
1511 ff_mpeg_unref_picture(s, &s->next_picture);
1512 if (s->next_picture_ptr->f->buf[0] &&
1513 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1514 s->next_picture_ptr)) < 0)
1518 if (s->picture_structure!= PICT_FRAME) {
1520 for (i = 0; i < 4; i++) {
1521 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1522 s->current_picture.f->data[i] +=
1523 s->current_picture.f->linesize[i];
1525 s->current_picture.f->linesize[i] *= 2;
1526 s->last_picture.f->linesize[i] *= 2;
1527 s->next_picture.f->linesize[i] *= 2;
1531 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1532 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1533 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1534 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1535 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1536 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1538 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1539 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1542 if (s->dct_error_sum) {
1543 assert(s->avctx->noise_reduction && s->encoding);
1544 update_noise_reduction(s);
1550 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1551 const AVFrame *pic_arg, int *got_packet)
1553 MpegEncContext *s = avctx->priv_data;
1554 int i, stuffing_count, ret;
1555 int context_count = s->slice_context_count;
1557 s->picture_in_gop_number++;
1559 if (load_input_picture(s, pic_arg) < 0)
1562 if (select_input_picture(s) < 0) {
1567 if (s->new_picture.f->data[0]) {
1569 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1572 s->mb_info_ptr = av_packet_new_side_data(pkt,
1573 AV_PKT_DATA_H263_MB_INFO,
1574 s->mb_width*s->mb_height*12);
1575 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1578 for (i = 0; i < context_count; i++) {
1579 int start_y = s->thread_context[i]->start_mb_y;
1580 int end_y = s->thread_context[i]-> end_mb_y;
1581 int h = s->mb_height;
1582 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1583 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1585 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1588 s->pict_type = s->new_picture.f->pict_type;
1590 ret = frame_start(s);
1594 if (encode_picture(s, s->picture_number) < 0)
1597 avctx->header_bits = s->header_bits;
1598 avctx->mv_bits = s->mv_bits;
1599 avctx->misc_bits = s->misc_bits;
1600 avctx->i_tex_bits = s->i_tex_bits;
1601 avctx->p_tex_bits = s->p_tex_bits;
1602 avctx->i_count = s->i_count;
1603 // FIXME f/b_count in avctx
1604 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1605 avctx->skip_count = s->skip_count;
1609 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1610 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1612 if (avctx->rc_buffer_size) {
1613 RateControlContext *rcc = &s->rc_context;
1614 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1616 if (put_bits_count(&s->pb) > max_size &&
1617 s->lambda < s->lmax) {
1618 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1619 (s->qscale + 1) / s->qscale);
1620 if (s->adaptive_quant) {
1622 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1623 s->lambda_table[i] =
1624 FFMAX(s->lambda_table[i] + 1,
1625 s->lambda_table[i] * (s->qscale + 1) /
1628 s->mb_skipped = 0; // done in frame_start()
1629 // done in encode_picture() so we must undo it
1630 if (s->pict_type == AV_PICTURE_TYPE_P) {
1631 if (s->flipflop_rounding ||
1632 s->codec_id == AV_CODEC_ID_H263P ||
1633 s->codec_id == AV_CODEC_ID_MPEG4)
1634 s->no_rounding ^= 1;
1636 if (s->pict_type != AV_PICTURE_TYPE_B) {
1637 s->time_base = s->last_time_base;
1638 s->last_non_b_time = s->time - s->pp_time;
1640 for (i = 0; i < context_count; i++) {
1641 PutBitContext *pb = &s->thread_context[i]->pb;
1642 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1647 assert(s->avctx->rc_max_rate);
1650 if (s->flags & CODEC_FLAG_PASS1)
1651 ff_write_pass1_stats(s);
1653 for (i = 0; i < 4; i++) {
1654 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1655 avctx->error[i] += s->current_picture_ptr->f->error[i];
1658 if (s->flags & CODEC_FLAG_PASS1)
1659 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1660 avctx->i_tex_bits + avctx->p_tex_bits ==
1661 put_bits_count(&s->pb));
1662 flush_put_bits(&s->pb);
1663 s->frame_bits = put_bits_count(&s->pb);
1665 stuffing_count = ff_vbv_update(s, s->frame_bits);
1666 if (stuffing_count) {
1667 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1668 stuffing_count + 50) {
1669 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1673 switch (s->codec_id) {
1674 case AV_CODEC_ID_MPEG1VIDEO:
1675 case AV_CODEC_ID_MPEG2VIDEO:
1676 while (stuffing_count--) {
1677 put_bits(&s->pb, 8, 0);
1680 case AV_CODEC_ID_MPEG4:
1681 put_bits(&s->pb, 16, 0);
1682 put_bits(&s->pb, 16, 0x1C3);
1683 stuffing_count -= 4;
1684 while (stuffing_count--) {
1685 put_bits(&s->pb, 8, 0xFF);
1689 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1691 flush_put_bits(&s->pb);
1692 s->frame_bits = put_bits_count(&s->pb);
1695 /* update mpeg1/2 vbv_delay for CBR */
1696 if (s->avctx->rc_max_rate &&
1697 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1698 s->out_format == FMT_MPEG1 &&
1699 90000LL * (avctx->rc_buffer_size - 1) <=
1700 s->avctx->rc_max_rate * 0xFFFFLL) {
1701 int vbv_delay, min_delay;
1702 double inbits = s->avctx->rc_max_rate *
1703 av_q2d(s->avctx->time_base);
1704 int minbits = s->frame_bits - 8 *
1705 (s->vbv_delay_ptr - s->pb.buf - 1);
1706 double bits = s->rc_context.buffer_index + minbits - inbits;
1709 av_log(s->avctx, AV_LOG_ERROR,
1710 "Internal error, negative bits\n");
1712 assert(s->repeat_first_field == 0);
1714 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1715 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1716 s->avctx->rc_max_rate;
1718 vbv_delay = FFMAX(vbv_delay, min_delay);
1720 assert(vbv_delay < 0xFFFF);
1722 s->vbv_delay_ptr[0] &= 0xF8;
1723 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1724 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1725 s->vbv_delay_ptr[2] &= 0x07;
1726 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1727 avctx->vbv_delay = vbv_delay * 300;
1729 s->total_bits += s->frame_bits;
1730 avctx->frame_bits = s->frame_bits;
1732 pkt->pts = s->current_picture.f->pts;
1733 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1734 if (!s->current_picture.f->coded_picture_number)
1735 pkt->dts = pkt->pts - s->dts_delta;
1737 pkt->dts = s->reordered_pts;
1738 s->reordered_pts = pkt->pts;
1740 pkt->dts = pkt->pts;
1741 if (s->current_picture.f->key_frame)
1742 pkt->flags |= AV_PKT_FLAG_KEY;
1744 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1748 assert((s->frame_bits & 7) == 0);
1750 pkt->size = s->frame_bits / 8;
1751 *got_packet = !!pkt->size;
1755 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1756 int n, int threshold)
1758 static const char tab[64] = {
1759 3, 2, 2, 1, 1, 1, 1, 1,
1760 1, 1, 1, 1, 1, 1, 1, 1,
1761 1, 1, 1, 1, 1, 1, 1, 1,
1762 0, 0, 0, 0, 0, 0, 0, 0,
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
1771 int16_t *block = s->block[n];
1772 const int last_index = s->block_last_index[n];
1775 if (threshold < 0) {
1777 threshold = -threshold;
1781 /* Are all we could set to zero already zero? */
1782 if (last_index <= skip_dc - 1)
1785 for (i = 0; i <= last_index; i++) {
1786 const int j = s->intra_scantable.permutated[i];
1787 const int level = FFABS(block[j]);
1789 if (skip_dc && i == 0)
1793 } else if (level > 1) {
1799 if (score >= threshold)
1801 for (i = skip_dc; i <= last_index; i++) {
1802 const int j = s->intra_scantable.permutated[i];
1806 s->block_last_index[n] = 0;
1808 s->block_last_index[n] = -1;
1811 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1815 const int maxlevel = s->max_qcoeff;
1816 const int minlevel = s->min_qcoeff;
1820 i = 1; // skip clipping of intra dc
1824 for (; i <= last_index; i++) {
1825 const int j = s->intra_scantable.permutated[i];
1826 int level = block[j];
1828 if (level > maxlevel) {
1831 } else if (level < minlevel) {
1839 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1840 av_log(s->avctx, AV_LOG_INFO,
1841 "warning, clipping %d dct coefficients to %d..%d\n",
1842 overflow, minlevel, maxlevel);
1845 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1849 for (y = 0; y < 8; y++) {
1850 for (x = 0; x < 8; x++) {
1856 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1857 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1858 int v = ptr[x2 + y2 * stride];
1864 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1869 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1870 int motion_x, int motion_y,
1871 int mb_block_height,
1874 int16_t weight[8][64];
1875 int16_t orig[8][64];
1876 const int mb_x = s->mb_x;
1877 const int mb_y = s->mb_y;
1880 int dct_offset = s->linesize * 8; // default for progressive frames
1881 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1882 ptrdiff_t wrap_y, wrap_c;
1884 for (i = 0; i < mb_block_count; i++)
1885 skip_dct[i] = s->skipdct;
1887 if (s->adaptive_quant) {
1888 const int last_qp = s->qscale;
1889 const int mb_xy = mb_x + mb_y * s->mb_stride;
1891 s->lambda = s->lambda_table[mb_xy];
1894 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1895 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1896 s->dquant = s->qscale - last_qp;
1898 if (s->out_format == FMT_H263) {
1899 s->dquant = av_clip(s->dquant, -2, 2);
1901 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1903 if (s->pict_type == AV_PICTURE_TYPE_B) {
1904 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1907 if (s->mv_type == MV_TYPE_8X8)
1913 ff_set_qscale(s, last_qp + s->dquant);
1914 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1915 ff_set_qscale(s, s->qscale + s->dquant);
1917 wrap_y = s->linesize;
1918 wrap_c = s->uvlinesize;
1919 ptr_y = s->new_picture.f->data[0] +
1920 (mb_y * 16 * wrap_y) + mb_x * 16;
1921 ptr_cb = s->new_picture.f->data[1] +
1922 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1923 ptr_cr = s->new_picture.f->data[2] +
1924 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1926 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1927 uint8_t *ebuf = s->edge_emu_buffer + 32;
1928 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1930 16, 16, mb_x * 16, mb_y * 16,
1931 s->width, s->height);
1933 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1935 8, mb_block_height, mb_x * 8, mb_y * 8,
1936 s->width >> 1, s->height >> 1);
1937 ptr_cb = ebuf + 18 * wrap_y;
1938 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1940 8, mb_block_height, mb_x * 8, mb_y * 8,
1941 s->width >> 1, s->height >> 1);
1942 ptr_cr = ebuf + 18 * wrap_y + 8;
1946 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1947 int progressive_score, interlaced_score;
1949 s->interlaced_dct = 0;
1950 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1951 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1952 NULL, wrap_y, 8) - 400;
1954 if (progressive_score > 0) {
1955 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1956 NULL, wrap_y * 2, 8) +
1957 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
1958 NULL, wrap_y * 2, 8);
1959 if (progressive_score > interlaced_score) {
1960 s->interlaced_dct = 1;
1962 dct_offset = wrap_y;
1964 if (s->chroma_format == CHROMA_422)
1970 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
1971 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
1972 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
1973 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
1975 if (s->flags & CODEC_FLAG_GRAY) {
1979 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1980 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1981 if (!s->chroma_y_shift) { /* 422 */
1982 s->pdsp.get_pixels(s->block[6],
1983 ptr_cb + (dct_offset >> 1), wrap_c);
1984 s->pdsp.get_pixels(s->block[7],
1985 ptr_cr + (dct_offset >> 1), wrap_c);
1989 op_pixels_func (*op_pix)[4];
1990 qpel_mc_func (*op_qpix)[16];
1991 uint8_t *dest_y, *dest_cb, *dest_cr;
1993 dest_y = s->dest[0];
1994 dest_cb = s->dest[1];
1995 dest_cr = s->dest[2];
1997 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1998 op_pix = s->hdsp.put_pixels_tab;
1999 op_qpix = s->qdsp.put_qpel_pixels_tab;
2001 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2002 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2005 if (s->mv_dir & MV_DIR_FORWARD) {
2006 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2007 s->last_picture.f->data,
2009 op_pix = s->hdsp.avg_pixels_tab;
2010 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2012 if (s->mv_dir & MV_DIR_BACKWARD) {
2013 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2014 s->next_picture.f->data,
2018 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
2019 int progressive_score, interlaced_score;
2021 s->interlaced_dct = 0;
2022 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2023 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2027 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2028 progressive_score -= 400;
2030 if (progressive_score > 0) {
2031 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2033 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2037 if (progressive_score > interlaced_score) {
2038 s->interlaced_dct = 1;
2040 dct_offset = wrap_y;
2042 if (s->chroma_format == CHROMA_422)
2048 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2049 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2050 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2051 dest_y + dct_offset, wrap_y);
2052 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2053 dest_y + dct_offset + 8, wrap_y);
2055 if (s->flags & CODEC_FLAG_GRAY) {
2059 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2060 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2061 if (!s->chroma_y_shift) { /* 422 */
2062 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2063 dest_cb + (dct_offset >> 1), wrap_c);
2064 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2065 dest_cr + (dct_offset >> 1), wrap_c);
2068 /* pre quantization */
2069 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2070 2 * s->qscale * s->qscale) {
2072 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2074 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2076 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2077 wrap_y, 8) < 20 * s->qscale)
2079 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2080 wrap_y, 8) < 20 * s->qscale)
2082 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2084 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2086 if (!s->chroma_y_shift) { /* 422 */
2087 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2088 dest_cb + (dct_offset >> 1),
2089 wrap_c, 8) < 20 * s->qscale)
2091 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2092 dest_cr + (dct_offset >> 1),
2093 wrap_c, 8) < 20 * s->qscale)
2099 if (s->quantizer_noise_shaping) {
2101 get_visual_weight(weight[0], ptr_y , wrap_y);
2103 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2105 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2107 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2109 get_visual_weight(weight[4], ptr_cb , wrap_c);
2111 get_visual_weight(weight[5], ptr_cr , wrap_c);
2112 if (!s->chroma_y_shift) { /* 422 */
2114 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2117 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2120 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2123 /* DCT & quantize */
2124 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2126 for (i = 0; i < mb_block_count; i++) {
2129 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2130 // FIXME we could decide to change to quantizer instead of
2132 // JS: I don't think that would be a good idea it could lower
2133 // quality instead of improve it. Just INTRADC clipping
2134 // deserves changes in quantizer
2136 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2138 s->block_last_index[i] = -1;
2140 if (s->quantizer_noise_shaping) {
2141 for (i = 0; i < mb_block_count; i++) {
2143 s->block_last_index[i] =
2144 dct_quantize_refine(s, s->block[i], weight[i],
2145 orig[i], i, s->qscale);
2150 if (s->luma_elim_threshold && !s->mb_intra)
2151 for (i = 0; i < 4; i++)
2152 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2153 if (s->chroma_elim_threshold && !s->mb_intra)
2154 for (i = 4; i < mb_block_count; i++)
2155 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2157 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2158 for (i = 0; i < mb_block_count; i++) {
2159 if (s->block_last_index[i] == -1)
2160 s->coded_score[i] = INT_MAX / 256;
2165 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2166 s->block_last_index[4] =
2167 s->block_last_index[5] = 0;
2169 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2172 // non c quantize code returns incorrect block_last_index FIXME
2173 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2174 for (i = 0; i < mb_block_count; i++) {
2176 if (s->block_last_index[i] > 0) {
2177 for (j = 63; j > 0; j--) {
2178 if (s->block[i][s->intra_scantable.permutated[j]])
2181 s->block_last_index[i] = j;
2186 /* huffman encode */
2187 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2188 case AV_CODEC_ID_MPEG1VIDEO:
2189 case AV_CODEC_ID_MPEG2VIDEO:
2190 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2191 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2193 case AV_CODEC_ID_MPEG4:
2194 if (CONFIG_MPEG4_ENCODER)
2195 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2197 case AV_CODEC_ID_MSMPEG4V2:
2198 case AV_CODEC_ID_MSMPEG4V3:
2199 case AV_CODEC_ID_WMV1:
2200 if (CONFIG_MSMPEG4_ENCODER)
2201 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2203 case AV_CODEC_ID_WMV2:
2204 if (CONFIG_WMV2_ENCODER)
2205 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2207 case AV_CODEC_ID_H261:
2208 if (CONFIG_H261_ENCODER)
2209 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2211 case AV_CODEC_ID_H263:
2212 case AV_CODEC_ID_H263P:
2213 case AV_CODEC_ID_FLV1:
2214 case AV_CODEC_ID_RV10:
2215 case AV_CODEC_ID_RV20:
2216 if (CONFIG_H263_ENCODER)
2217 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2219 case AV_CODEC_ID_MJPEG:
2220 if (CONFIG_MJPEG_ENCODER)
2221 ff_mjpeg_encode_mb(s, s->block);
2228 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2230 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2231 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2234 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2237 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2240 d->mb_skip_run= s->mb_skip_run;
2242 d->last_dc[i] = s->last_dc[i];
2245 d->mv_bits= s->mv_bits;
2246 d->i_tex_bits= s->i_tex_bits;
2247 d->p_tex_bits= s->p_tex_bits;
2248 d->i_count= s->i_count;
2249 d->f_count= s->f_count;
2250 d->b_count= s->b_count;
2251 d->skip_count= s->skip_count;
2252 d->misc_bits= s->misc_bits;
2256 d->qscale= s->qscale;
2257 d->dquant= s->dquant;
2259 d->esc3_level_length= s->esc3_level_length;
2262 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2265 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2266 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2269 d->mb_skip_run= s->mb_skip_run;
2271 d->last_dc[i] = s->last_dc[i];
2274 d->mv_bits= s->mv_bits;
2275 d->i_tex_bits= s->i_tex_bits;
2276 d->p_tex_bits= s->p_tex_bits;
2277 d->i_count= s->i_count;
2278 d->f_count= s->f_count;
2279 d->b_count= s->b_count;
2280 d->skip_count= s->skip_count;
2281 d->misc_bits= s->misc_bits;
2283 d->mb_intra= s->mb_intra;
2284 d->mb_skipped= s->mb_skipped;
2285 d->mv_type= s->mv_type;
2286 d->mv_dir= s->mv_dir;
2288 if(s->data_partitioning){
2290 d->tex_pb= s->tex_pb;
2294 d->block_last_index[i]= s->block_last_index[i];
2295 d->interlaced_dct= s->interlaced_dct;
2296 d->qscale= s->qscale;
2298 d->esc3_level_length= s->esc3_level_length;
2301 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2302 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2303 int *dmin, int *next_block, int motion_x, int motion_y)
2306 uint8_t *dest_backup[3];
2308 copy_context_before_encode(s, backup, type);
2310 s->block= s->blocks[*next_block];
2311 s->pb= pb[*next_block];
2312 if(s->data_partitioning){
2313 s->pb2 = pb2 [*next_block];
2314 s->tex_pb= tex_pb[*next_block];
2318 memcpy(dest_backup, s->dest, sizeof(s->dest));
2319 s->dest[0] = s->rd_scratchpad;
2320 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2321 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2322 assert(s->linesize >= 32); //FIXME
2325 encode_mb(s, motion_x, motion_y);
2327 score= put_bits_count(&s->pb);
2328 if(s->data_partitioning){
2329 score+= put_bits_count(&s->pb2);
2330 score+= put_bits_count(&s->tex_pb);
2333 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2334 ff_mpv_decode_mb(s, s->block);
2336 score *= s->lambda2;
2337 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2341 memcpy(s->dest, dest_backup, sizeof(s->dest));
2348 copy_context_after_encode(best, s, type);
2352 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2353 uint32_t *sq = ff_square_tab + 256;
2358 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2359 else if(w==8 && h==8)
2360 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2364 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2373 static int sse_mb(MpegEncContext *s){
2377 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2378 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2381 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2382 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) +
2383 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) +
2384 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);
2386 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) +
2387 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) +
2388 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);
2391 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)
2392 +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)
2393 +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);
2396 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2397 MpegEncContext *s= *(void**)arg;
2401 s->me.dia_size= s->avctx->pre_dia_size;
2402 s->first_slice_line=1;
2403 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2404 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2405 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2407 s->first_slice_line=0;
2415 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2416 MpegEncContext *s= *(void**)arg;
2418 s->me.dia_size= s->avctx->dia_size;
2419 s->first_slice_line=1;
2420 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2421 s->mb_x=0; //for block init below
2422 ff_init_block_index(s);
2423 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2424 s->block_index[0]+=2;
2425 s->block_index[1]+=2;
2426 s->block_index[2]+=2;
2427 s->block_index[3]+=2;
2429 /* compute motion vector & mb_type and store in context */
2430 if(s->pict_type==AV_PICTURE_TYPE_B)
2431 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2433 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2435 s->first_slice_line=0;
2440 static int mb_var_thread(AVCodecContext *c, void *arg){
2441 MpegEncContext *s= *(void**)arg;
2444 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2445 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2448 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2450 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2452 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2453 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2455 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2456 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2457 s->me.mb_var_sum_temp += varc;
2463 static void write_slice_end(MpegEncContext *s){
2464 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2465 if(s->partitioned_frame){
2466 ff_mpeg4_merge_partitions(s);
2469 ff_mpeg4_stuffing(&s->pb);
2470 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2471 ff_mjpeg_encode_stuffing(&s->pb);
2474 avpriv_align_put_bits(&s->pb);
2475 flush_put_bits(&s->pb);
2477 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2478 s->misc_bits+= get_bits_diff(s);
2481 static void write_mb_info(MpegEncContext *s)
2483 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2484 int offset = put_bits_count(&s->pb);
2485 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2486 int gobn = s->mb_y / s->gob_index;
2488 if (CONFIG_H263_ENCODER)
2489 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2490 bytestream_put_le32(&ptr, offset);
2491 bytestream_put_byte(&ptr, s->qscale);
2492 bytestream_put_byte(&ptr, gobn);
2493 bytestream_put_le16(&ptr, mba);
2494 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2495 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2496 /* 4MV not implemented */
2497 bytestream_put_byte(&ptr, 0); /* hmv2 */
2498 bytestream_put_byte(&ptr, 0); /* vmv2 */
2501 static void update_mb_info(MpegEncContext *s, int startcode)
2505 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2506 s->mb_info_size += 12;
2507 s->prev_mb_info = s->last_mb_info;
2510 s->prev_mb_info = put_bits_count(&s->pb)/8;
2511 /* This might have incremented mb_info_size above, and we return without
2512 * actually writing any info into that slot yet. But in that case,
2513 * this will be called again at the start of the after writing the
2514 * start code, actually writing the mb info. */
2518 s->last_mb_info = put_bits_count(&s->pb)/8;
2519 if (!s->mb_info_size)
2520 s->mb_info_size += 12;
2524 static int encode_thread(AVCodecContext *c, void *arg){
2525 MpegEncContext *s= *(void**)arg;
2526 int mb_x, mb_y, pdif = 0;
2527 int chr_h= 16>>s->chroma_y_shift;
2529 MpegEncContext best_s, backup_s;
2530 uint8_t bit_buf[2][MAX_MB_BYTES];
2531 uint8_t bit_buf2[2][MAX_MB_BYTES];
2532 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2533 PutBitContext pb[2], pb2[2], tex_pb[2];
2536 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2537 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2538 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2541 s->last_bits= put_bits_count(&s->pb);
2552 /* init last dc values */
2553 /* note: quant matrix value (8) is implied here */
2554 s->last_dc[i] = 128 << s->intra_dc_precision;
2556 s->current_picture.f->error[i] = 0;
2559 memset(s->last_mv, 0, sizeof(s->last_mv));
2563 switch(s->codec_id){
2564 case AV_CODEC_ID_H263:
2565 case AV_CODEC_ID_H263P:
2566 case AV_CODEC_ID_FLV1:
2567 if (CONFIG_H263_ENCODER)
2568 s->gob_index = ff_h263_get_gob_height(s);
2570 case AV_CODEC_ID_MPEG4:
2571 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2572 ff_mpeg4_init_partitions(s);
2578 s->first_slice_line = 1;
2579 s->ptr_lastgob = s->pb.buf;
2580 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2584 ff_set_qscale(s, s->qscale);
2585 ff_init_block_index(s);
2587 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2588 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2589 int mb_type= s->mb_type[xy];
2594 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2595 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2598 if(s->data_partitioning){
2599 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2600 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2601 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2607 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2608 ff_update_block_index(s);
2610 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2611 ff_h261_reorder_mb_index(s);
2612 xy= s->mb_y*s->mb_stride + s->mb_x;
2613 mb_type= s->mb_type[xy];
2616 /* write gob / video packet header */
2618 int current_packet_size, is_gob_start;
2620 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2622 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2624 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2626 switch(s->codec_id){
2627 case AV_CODEC_ID_H263:
2628 case AV_CODEC_ID_H263P:
2629 if(!s->h263_slice_structured)
2630 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2632 case AV_CODEC_ID_MPEG2VIDEO:
2633 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2634 case AV_CODEC_ID_MPEG1VIDEO:
2635 if(s->mb_skip_run) is_gob_start=0;
2640 if(s->start_mb_y != mb_y || mb_x!=0){
2643 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2644 ff_mpeg4_init_partitions(s);
2648 assert((put_bits_count(&s->pb)&7) == 0);
2649 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2651 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2652 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2653 int d = 100 / s->error_rate;
2655 current_packet_size=0;
2656 s->pb.buf_ptr= s->ptr_lastgob;
2657 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2661 if (s->avctx->rtp_callback){
2662 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2663 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2665 update_mb_info(s, 1);
2667 switch(s->codec_id){
2668 case AV_CODEC_ID_MPEG4:
2669 if (CONFIG_MPEG4_ENCODER) {
2670 ff_mpeg4_encode_video_packet_header(s);
2671 ff_mpeg4_clean_buffers(s);
2674 case AV_CODEC_ID_MPEG1VIDEO:
2675 case AV_CODEC_ID_MPEG2VIDEO:
2676 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2677 ff_mpeg1_encode_slice_header(s);
2678 ff_mpeg1_clean_buffers(s);
2681 case AV_CODEC_ID_H263:
2682 case AV_CODEC_ID_H263P:
2683 if (CONFIG_H263_ENCODER)
2684 ff_h263_encode_gob_header(s, mb_y);
2688 if(s->flags&CODEC_FLAG_PASS1){
2689 int bits= put_bits_count(&s->pb);
2690 s->misc_bits+= bits - s->last_bits;
2694 s->ptr_lastgob += current_packet_size;
2695 s->first_slice_line=1;
2696 s->resync_mb_x=mb_x;
2697 s->resync_mb_y=mb_y;
2701 if( (s->resync_mb_x == s->mb_x)
2702 && s->resync_mb_y+1 == s->mb_y){
2703 s->first_slice_line=0;
2707 s->dquant=0; //only for QP_RD
2709 update_mb_info(s, 0);
2711 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
2713 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2715 copy_context_before_encode(&backup_s, s, -1);
2717 best_s.data_partitioning= s->data_partitioning;
2718 best_s.partitioned_frame= s->partitioned_frame;
2719 if(s->data_partitioning){
2720 backup_s.pb2= s->pb2;
2721 backup_s.tex_pb= s->tex_pb;
2724 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2725 s->mv_dir = MV_DIR_FORWARD;
2726 s->mv_type = MV_TYPE_16X16;
2728 s->mv[0][0][0] = s->p_mv_table[xy][0];
2729 s->mv[0][0][1] = s->p_mv_table[xy][1];
2730 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2731 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2733 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2734 s->mv_dir = MV_DIR_FORWARD;
2735 s->mv_type = MV_TYPE_FIELD;
2738 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2739 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2740 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2742 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2743 &dmin, &next_block, 0, 0);
2745 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2746 s->mv_dir = MV_DIR_FORWARD;
2747 s->mv_type = MV_TYPE_16X16;
2751 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2752 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2754 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2755 s->mv_dir = MV_DIR_FORWARD;
2756 s->mv_type = MV_TYPE_8X8;
2759 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2760 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2762 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2763 &dmin, &next_block, 0, 0);
2765 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2766 s->mv_dir = MV_DIR_FORWARD;
2767 s->mv_type = MV_TYPE_16X16;
2769 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2770 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2771 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2772 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2774 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2775 s->mv_dir = MV_DIR_BACKWARD;
2776 s->mv_type = MV_TYPE_16X16;
2778 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2779 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2780 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2781 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2783 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2784 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2785 s->mv_type = MV_TYPE_16X16;
2787 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2788 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2789 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2790 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2791 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2792 &dmin, &next_block, 0, 0);
2794 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2795 s->mv_dir = MV_DIR_FORWARD;
2796 s->mv_type = MV_TYPE_FIELD;
2799 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2800 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2801 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2803 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2804 &dmin, &next_block, 0, 0);
2806 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2807 s->mv_dir = MV_DIR_BACKWARD;
2808 s->mv_type = MV_TYPE_FIELD;
2811 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2812 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2813 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2815 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2816 &dmin, &next_block, 0, 0);
2818 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2819 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2820 s->mv_type = MV_TYPE_FIELD;
2822 for(dir=0; dir<2; dir++){
2824 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2825 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2826 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2829 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2830 &dmin, &next_block, 0, 0);
2832 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2834 s->mv_type = MV_TYPE_16X16;
2838 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2839 &dmin, &next_block, 0, 0);
2840 if(s->h263_pred || s->h263_aic){
2842 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2844 ff_clean_intra_table_entries(s); //old mode?
2848 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2849 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2850 const int last_qp= backup_s.qscale;
2853 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2854 static const int dquant_tab[4]={-1,1,-2,2};
2856 assert(backup_s.dquant == 0);
2859 s->mv_dir= best_s.mv_dir;
2860 s->mv_type = MV_TYPE_16X16;
2861 s->mb_intra= best_s.mb_intra;
2862 s->mv[0][0][0] = best_s.mv[0][0][0];
2863 s->mv[0][0][1] = best_s.mv[0][0][1];
2864 s->mv[1][0][0] = best_s.mv[1][0][0];
2865 s->mv[1][0][1] = best_s.mv[1][0][1];
2867 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2868 for(; qpi<4; qpi++){
2869 int dquant= dquant_tab[qpi];
2870 qp= last_qp + dquant;
2871 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2873 backup_s.dquant= dquant;
2874 if(s->mb_intra && s->dc_val[0]){
2876 dc[i]= s->dc_val[0][ s->block_index[i] ];
2877 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2881 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2882 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2883 if(best_s.qscale != qp){
2884 if(s->mb_intra && s->dc_val[0]){
2886 s->dc_val[0][ s->block_index[i] ]= dc[i];
2887 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2894 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2895 int mx= s->b_direct_mv_table[xy][0];
2896 int my= s->b_direct_mv_table[xy][1];
2898 backup_s.dquant = 0;
2899 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2901 ff_mpeg4_set_direct_mv(s, mx, my);
2902 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2903 &dmin, &next_block, mx, my);
2905 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2906 backup_s.dquant = 0;
2907 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2909 ff_mpeg4_set_direct_mv(s, 0, 0);
2910 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2911 &dmin, &next_block, 0, 0);
2913 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2916 coded |= s->block_last_index[i];
2919 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2920 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2921 mx=my=0; //FIXME find the one we actually used
2922 ff_mpeg4_set_direct_mv(s, mx, my);
2923 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2931 s->mv_dir= best_s.mv_dir;
2932 s->mv_type = best_s.mv_type;
2934 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2935 s->mv[0][0][1] = best_s.mv[0][0][1];
2936 s->mv[1][0][0] = best_s.mv[1][0][0];
2937 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2940 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2941 &dmin, &next_block, mx, my);
2946 s->current_picture.qscale_table[xy] = best_s.qscale;
2948 copy_context_after_encode(s, &best_s, -1);
2950 pb_bits_count= put_bits_count(&s->pb);
2951 flush_put_bits(&s->pb);
2952 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2955 if(s->data_partitioning){
2956 pb2_bits_count= put_bits_count(&s->pb2);
2957 flush_put_bits(&s->pb2);
2958 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2959 s->pb2= backup_s.pb2;
2961 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2962 flush_put_bits(&s->tex_pb);
2963 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2964 s->tex_pb= backup_s.tex_pb;
2966 s->last_bits= put_bits_count(&s->pb);
2968 if (CONFIG_H263_ENCODER &&
2969 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2970 ff_h263_update_motion_val(s);
2972 if(next_block==0){ //FIXME 16 vs linesize16
2973 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2974 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2975 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2978 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2979 ff_mpv_decode_mb(s, s->block);
2981 int motion_x = 0, motion_y = 0;
2982 s->mv_type=MV_TYPE_16X16;
2983 // only one MB-Type possible
2986 case CANDIDATE_MB_TYPE_INTRA:
2989 motion_x= s->mv[0][0][0] = 0;
2990 motion_y= s->mv[0][0][1] = 0;
2992 case CANDIDATE_MB_TYPE_INTER:
2993 s->mv_dir = MV_DIR_FORWARD;
2995 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2996 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2998 case CANDIDATE_MB_TYPE_INTER_I:
2999 s->mv_dir = MV_DIR_FORWARD;
3000 s->mv_type = MV_TYPE_FIELD;
3003 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3004 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3005 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3008 case CANDIDATE_MB_TYPE_INTER4V:
3009 s->mv_dir = MV_DIR_FORWARD;
3010 s->mv_type = MV_TYPE_8X8;
3013 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3014 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3017 case CANDIDATE_MB_TYPE_DIRECT:
3018 if (CONFIG_MPEG4_ENCODER) {
3019 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3021 motion_x=s->b_direct_mv_table[xy][0];
3022 motion_y=s->b_direct_mv_table[xy][1];
3023 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3026 case CANDIDATE_MB_TYPE_DIRECT0:
3027 if (CONFIG_MPEG4_ENCODER) {
3028 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3030 ff_mpeg4_set_direct_mv(s, 0, 0);
3033 case CANDIDATE_MB_TYPE_BIDIR:
3034 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3036 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3037 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3038 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3039 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3041 case CANDIDATE_MB_TYPE_BACKWARD:
3042 s->mv_dir = MV_DIR_BACKWARD;
3044 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3045 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3047 case CANDIDATE_MB_TYPE_FORWARD:
3048 s->mv_dir = MV_DIR_FORWARD;
3050 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3051 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3053 case CANDIDATE_MB_TYPE_FORWARD_I:
3054 s->mv_dir = MV_DIR_FORWARD;
3055 s->mv_type = MV_TYPE_FIELD;
3058 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3059 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3060 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3063 case CANDIDATE_MB_TYPE_BACKWARD_I:
3064 s->mv_dir = MV_DIR_BACKWARD;
3065 s->mv_type = MV_TYPE_FIELD;
3068 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3069 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3070 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3073 case CANDIDATE_MB_TYPE_BIDIR_I:
3074 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3075 s->mv_type = MV_TYPE_FIELD;
3077 for(dir=0; dir<2; dir++){
3079 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3080 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3081 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3086 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3089 encode_mb(s, motion_x, motion_y);
3091 // RAL: Update last macroblock type
3092 s->last_mv_dir = s->mv_dir;
3094 if (CONFIG_H263_ENCODER &&
3095 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3096 ff_h263_update_motion_val(s);
3098 ff_mpv_decode_mb(s, s->block);
3101 /* clean the MV table in IPS frames for direct mode in B frames */
3102 if(s->mb_intra /* && I,P,S_TYPE */){
3103 s->p_mv_table[xy][0]=0;
3104 s->p_mv_table[xy][1]=0;
3107 if(s->flags&CODEC_FLAG_PSNR){
3111 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3112 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3114 s->current_picture.f->error[0] += sse(
3115 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3116 s->dest[0], w, h, s->linesize);
3117 s->current_picture.f->error[1] += sse(
3118 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3119 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3120 s->current_picture.f->error[2] += sse(
3121 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3122 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3125 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3126 ff_h263_loop_filter(s);
3128 av_dlog(s->avctx, "MB %d %d bits\n",
3129 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3133 //not beautiful here but we must write it before flushing so it has to be here
3134 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3135 ff_msmpeg4_encode_ext_header(s);
3139 /* Send the last GOB if RTP */
3140 if (s->avctx->rtp_callback) {
3141 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3142 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3143 /* Call the RTP callback to send the last GOB */
3145 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3151 #define MERGE(field) dst->field += src->field; src->field=0
3152 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3153 MERGE(me.scene_change_score);
3154 MERGE(me.mc_mb_var_sum_temp);
3155 MERGE(me.mb_var_sum_temp);
3158 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3161 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3162 MERGE(dct_count[1]);
3171 MERGE(er.error_count);
3172 MERGE(padding_bug_score);
3173 MERGE(current_picture.f->error[0]);
3174 MERGE(current_picture.f->error[1]);
3175 MERGE(current_picture.f->error[2]);
3177 if(dst->avctx->noise_reduction){
3178 for(i=0; i<64; i++){
3179 MERGE(dct_error_sum[0][i]);
3180 MERGE(dct_error_sum[1][i]);
3184 assert(put_bits_count(&src->pb) % 8 ==0);
3185 assert(put_bits_count(&dst->pb) % 8 ==0);
3186 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3187 flush_put_bits(&dst->pb);
3190 static int estimate_qp(MpegEncContext *s, int dry_run){
3191 if (s->next_lambda){
3192 s->current_picture_ptr->f->quality =
3193 s->current_picture.f->quality = s->next_lambda;
3194 if(!dry_run) s->next_lambda= 0;
3195 } else if (!s->fixed_qscale) {
3196 s->current_picture_ptr->f->quality =
3197 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3198 if (s->current_picture.f->quality < 0)
3202 if(s->adaptive_quant){
3203 switch(s->codec_id){
3204 case AV_CODEC_ID_MPEG4:
3205 if (CONFIG_MPEG4_ENCODER)
3206 ff_clean_mpeg4_qscales(s);
3208 case AV_CODEC_ID_H263:
3209 case AV_CODEC_ID_H263P:
3210 case AV_CODEC_ID_FLV1:
3211 if (CONFIG_H263_ENCODER)
3212 ff_clean_h263_qscales(s);
3215 ff_init_qscale_tab(s);
3218 s->lambda= s->lambda_table[0];
3221 s->lambda = s->current_picture.f->quality;
3226 /* must be called before writing the header */
3227 static void set_frame_distances(MpegEncContext * s){
3228 assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3229 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3231 if(s->pict_type==AV_PICTURE_TYPE_B){
3232 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3233 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3235 s->pp_time= s->time - s->last_non_b_time;
3236 s->last_non_b_time= s->time;
3237 assert(s->picture_number==0 || s->pp_time > 0);
3241 static int encode_picture(MpegEncContext *s, int picture_number)
3245 int context_count = s->slice_context_count;
3247 s->picture_number = picture_number;
3249 /* Reset the average MB variance */
3250 s->me.mb_var_sum_temp =
3251 s->me.mc_mb_var_sum_temp = 0;
3253 /* we need to initialize some time vars before we can encode b-frames */
3254 // RAL: Condition added for MPEG1VIDEO
3255 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3256 set_frame_distances(s);
3257 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3258 ff_set_mpeg4_time(s);
3260 s->me.scene_change_score=0;
3262 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3264 if(s->pict_type==AV_PICTURE_TYPE_I){
3265 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3266 else s->no_rounding=0;
3267 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3268 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3269 s->no_rounding ^= 1;
3272 if(s->flags & CODEC_FLAG_PASS2){
3273 if (estimate_qp(s,1) < 0)
3275 ff_get_2pass_fcode(s);
3276 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3277 if(s->pict_type==AV_PICTURE_TYPE_B)
3278 s->lambda= s->last_lambda_for[s->pict_type];
3280 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3284 s->mb_intra=0; //for the rate distortion & bit compare functions
3285 for(i=1; i<context_count; i++){
3286 ret = ff_update_duplicate_context(s->thread_context[i], s);
3294 /* Estimate motion for every MB */
3295 if(s->pict_type != AV_PICTURE_TYPE_I){
3296 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3297 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3298 if (s->pict_type != AV_PICTURE_TYPE_B) {
3299 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3300 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3304 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3305 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3307 for(i=0; i<s->mb_stride*s->mb_height; i++)
3308 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3310 if(!s->fixed_qscale){
3311 /* finding spatial complexity for I-frame rate control */
3312 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3315 for(i=1; i<context_count; i++){
3316 merge_context_after_me(s, s->thread_context[i]);
3318 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3319 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3322 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3323 s->pict_type= AV_PICTURE_TYPE_I;
3324 for(i=0; i<s->mb_stride*s->mb_height; i++)
3325 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3326 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3327 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3331 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3332 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3334 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3336 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3337 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3338 s->f_code= FFMAX3(s->f_code, a, b);
3341 ff_fix_long_p_mvs(s);
3342 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3343 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3347 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3348 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3353 if(s->pict_type==AV_PICTURE_TYPE_B){
3356 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3357 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3358 s->f_code = FFMAX(a, b);
3360 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3361 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3362 s->b_code = FFMAX(a, b);
3364 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3365 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3366 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3367 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3368 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3370 for(dir=0; dir<2; dir++){
3373 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3374 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3375 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3376 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3384 if (estimate_qp(s, 0) < 0)
3387 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3388 s->qscale= 3; //reduce clipping problems
3390 if (s->out_format == FMT_MJPEG) {
3391 /* for mjpeg, we do include qscale in the matrix */
3393 int j = s->idsp.idct_permutation[i];
3395 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3397 s->y_dc_scale_table=
3398 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3399 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3400 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3401 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3405 //FIXME var duplication
3406 s->current_picture_ptr->f->key_frame =
3407 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3408 s->current_picture_ptr->f->pict_type =
3409 s->current_picture.f->pict_type = s->pict_type;
3411 if (s->current_picture.f->key_frame)
3412 s->picture_in_gop_number=0;
3414 s->last_bits= put_bits_count(&s->pb);
3415 switch(s->out_format) {
3417 if (CONFIG_MJPEG_ENCODER)
3418 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3422 if (CONFIG_H261_ENCODER)
3423 ff_h261_encode_picture_header(s, picture_number);
3426 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3427 ff_wmv2_encode_picture_header(s, picture_number);
3428 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3429 ff_msmpeg4_encode_picture_header(s, picture_number);
3430 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3431 ff_mpeg4_encode_picture_header(s, picture_number);
3432 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3433 ff_rv10_encode_picture_header(s, picture_number);
3434 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3435 ff_rv20_encode_picture_header(s, picture_number);
3436 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3437 ff_flv_encode_picture_header(s, picture_number);
3438 else if (CONFIG_H263_ENCODER)
3439 ff_h263_encode_picture_header(s, picture_number);
3442 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3443 ff_mpeg1_encode_picture_header(s, picture_number);
3448 bits= put_bits_count(&s->pb);
3449 s->header_bits= bits - s->last_bits;
3451 for(i=1; i<context_count; i++){
3452 update_duplicate_context_after_me(s->thread_context[i], s);
3454 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3455 for(i=1; i<context_count; i++){
3456 merge_context_after_encode(s, s->thread_context[i]);
3462 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3463 const int intra= s->mb_intra;
3466 s->dct_count[intra]++;
3468 for(i=0; i<64; i++){
3469 int level= block[i];
3473 s->dct_error_sum[intra][i] += level;
3474 level -= s->dct_offset[intra][i];
3475 if(level<0) level=0;
3477 s->dct_error_sum[intra][i] -= level;
3478 level += s->dct_offset[intra][i];
3479 if(level>0) level=0;
3486 static int dct_quantize_trellis_c(MpegEncContext *s,
3487 int16_t *block, int n,
3488 int qscale, int *overflow){
3490 const uint8_t *scantable= s->intra_scantable.scantable;
3491 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3493 unsigned int threshold1, threshold2;
3505 int coeff_count[64];
3506 int qmul, qadd, start_i, last_non_zero, i, dc;
3507 const int esc_length= s->ac_esc_length;
3509 uint8_t * last_length;
3510 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3512 s->fdsp.fdct(block);
3514 if(s->dct_error_sum)
3515 s->denoise_dct(s, block);
3517 qadd= ((qscale-1)|1)*8;
3528 /* For AIC we skip quant/dequant of INTRADC */
3533 /* note: block[0] is assumed to be positive */
3534 block[0] = (block[0] + (q >> 1)) / q;
3537 qmat = s->q_intra_matrix[qscale];
3538 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3539 bias= 1<<(QMAT_SHIFT-1);
3540 length = s->intra_ac_vlc_length;
3541 last_length= s->intra_ac_vlc_last_length;
3545 qmat = s->q_inter_matrix[qscale];
3546 length = s->inter_ac_vlc_length;
3547 last_length= s->inter_ac_vlc_last_length;
3551 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3552 threshold2= (threshold1<<1);
3554 for(i=63; i>=start_i; i--) {
3555 const int j = scantable[i];
3556 int level = block[j] * qmat[j];
3558 if(((unsigned)(level+threshold1))>threshold2){
3564 for(i=start_i; i<=last_non_zero; i++) {
3565 const int j = scantable[i];
3566 int level = block[j] * qmat[j];
3568 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3569 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3570 if(((unsigned)(level+threshold1))>threshold2){
3572 level= (bias + level)>>QMAT_SHIFT;
3574 coeff[1][i]= level-1;
3575 // coeff[2][k]= level-2;
3577 level= (bias - level)>>QMAT_SHIFT;
3578 coeff[0][i]= -level;
3579 coeff[1][i]= -level+1;
3580 // coeff[2][k]= -level+2;
3582 coeff_count[i]= FFMIN(level, 2);
3583 assert(coeff_count[i]);
3586 coeff[0][i]= (level>>31)|1;
3591 *overflow= s->max_qcoeff < max; //overflow might have happened
3593 if(last_non_zero < start_i){
3594 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3595 return last_non_zero;
3598 score_tab[start_i]= 0;
3599 survivor[0]= start_i;
3602 for(i=start_i; i<=last_non_zero; i++){
3603 int level_index, j, zero_distortion;
3604 int dct_coeff= FFABS(block[ scantable[i] ]);
3605 int best_score=256*256*256*120;
3607 if (s->fdsp.fdct == ff_fdct_ifast)
3608 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3609 zero_distortion= dct_coeff*dct_coeff;
3611 for(level_index=0; level_index < coeff_count[i]; level_index++){
3613 int level= coeff[level_index][i];
3614 const int alevel= FFABS(level);
3619 if(s->out_format == FMT_H263){
3620 unquant_coeff= alevel*qmul + qadd;
3622 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3624 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3625 unquant_coeff = (unquant_coeff - 1) | 1;
3627 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3628 unquant_coeff = (unquant_coeff - 1) | 1;
3633 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3635 if((level&(~127)) == 0){
3636 for(j=survivor_count-1; j>=0; j--){
3637 int run= i - survivor[j];
3638 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3639 score += score_tab[i-run];
3641 if(score < best_score){
3644 level_tab[i+1]= level-64;
3648 if(s->out_format == FMT_H263){
3649 for(j=survivor_count-1; j>=0; j--){
3650 int run= i - survivor[j];
3651 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3652 score += score_tab[i-run];
3653 if(score < last_score){
3656 last_level= level-64;
3662 distortion += esc_length*lambda;
3663 for(j=survivor_count-1; j>=0; j--){
3664 int run= i - survivor[j];
3665 int score= distortion + score_tab[i-run];
3667 if(score < best_score){
3670 level_tab[i+1]= level-64;
3674 if(s->out_format == FMT_H263){
3675 for(j=survivor_count-1; j>=0; j--){
3676 int run= i - survivor[j];
3677 int score= distortion + score_tab[i-run];
3678 if(score < last_score){
3681 last_level= level-64;
3689 score_tab[i+1]= best_score;
3691 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3692 if(last_non_zero <= 27){
3693 for(; survivor_count; survivor_count--){
3694 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3698 for(; survivor_count; survivor_count--){
3699 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3704 survivor[ survivor_count++ ]= i+1;
3707 if(s->out_format != FMT_H263){
3708 last_score= 256*256*256*120;
3709 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3710 int score= score_tab[i];
3711 if(i) score += lambda*2; //FIXME exacter?
3713 if(score < last_score){
3716 last_level= level_tab[i];
3717 last_run= run_tab[i];
3722 s->coded_score[n] = last_score;
3724 dc= FFABS(block[0]);
3725 last_non_zero= last_i - 1;
3726 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3728 if(last_non_zero < start_i)
3729 return last_non_zero;
3731 if(last_non_zero == 0 && start_i == 0){
3733 int best_score= dc * dc;
3735 for(i=0; i<coeff_count[0]; i++){
3736 int level= coeff[i][0];
3737 int alevel= FFABS(level);
3738 int unquant_coeff, score, distortion;
3740 if(s->out_format == FMT_H263){
3741 unquant_coeff= (alevel*qmul + qadd)>>3;
3743 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3744 unquant_coeff = (unquant_coeff - 1) | 1;
3746 unquant_coeff = (unquant_coeff + 4) >> 3;
3747 unquant_coeff<<= 3 + 3;
3749 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3751 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3752 else score= distortion + esc_length*lambda;
3754 if(score < best_score){
3756 best_level= level - 64;
3759 block[0]= best_level;
3760 s->coded_score[n] = best_score - dc*dc;
3761 if(best_level == 0) return -1;
3762 else return last_non_zero;
3768 block[ perm_scantable[last_non_zero] ]= last_level;
3771 for(; i>start_i; i -= run_tab[i] + 1){
3772 block[ perm_scantable[i-1] ]= level_tab[i];
3775 return last_non_zero;
3778 //#define REFINE_STATS 1
3779 static int16_t basis[64][64];
3781 static void build_basis(uint8_t *perm){
3788 double s= 0.25*(1<<BASIS_SHIFT);
3790 int perm_index= perm[index];
3791 if(i==0) s*= sqrt(0.5);
3792 if(j==0) s*= sqrt(0.5);
3793 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)));
3800 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3801 int16_t *block, int16_t *weight, int16_t *orig,
3804 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3805 const uint8_t *scantable= s->intra_scantable.scantable;
3806 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3807 // unsigned int threshold1, threshold2;
3812 int qmul, qadd, start_i, last_non_zero, i, dc;
3814 uint8_t * last_length;
3816 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3819 static int after_last=0;
3820 static int to_zero=0;
3821 static int from_zero=0;
3824 static int messed_sign=0;
3827 if(basis[0][0] == 0)
3828 build_basis(s->idsp.idct_permutation);
3839 /* For AIC we skip quant/dequant of INTRADC */
3843 q <<= RECON_SHIFT-3;
3844 /* note: block[0] is assumed to be positive */
3846 // block[0] = (block[0] + (q >> 1)) / q;
3848 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3849 // bias= 1<<(QMAT_SHIFT-1);
3850 length = s->intra_ac_vlc_length;
3851 last_length= s->intra_ac_vlc_last_length;
3855 length = s->inter_ac_vlc_length;
3856 last_length= s->inter_ac_vlc_last_length;
3858 last_non_zero = s->block_last_index[n];
3863 dc += (1<<(RECON_SHIFT-1));
3864 for(i=0; i<64; i++){
3865 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3868 STOP_TIMER("memset rem[]")}
3871 for(i=0; i<64; i++){
3876 w= FFABS(weight[i]) + qns*one;
3877 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3880 // w=weight[i] = (63*qns + (w/2)) / w;
3886 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3892 for(i=start_i; i<=last_non_zero; i++){
3893 int j= perm_scantable[i];
3894 const int level= block[j];
3898 if(level<0) coeff= qmul*level - qadd;
3899 else coeff= qmul*level + qadd;
3900 run_tab[rle_index++]=run;
3903 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
3909 if(last_non_zero>0){
3910 STOP_TIMER("init rem[]")
3917 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
3920 int run2, best_unquant_change=0, analyze_gradient;
3924 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3926 if(analyze_gradient){
3930 for(i=0; i<64; i++){
3933 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3936 STOP_TIMER("rem*w*w")}
3946 const int level= block[0];
3947 int change, old_coeff;
3949 assert(s->mb_intra);
3953 for(change=-1; change<=1; change+=2){
3954 int new_level= level + change;
3955 int score, new_coeff;
3957 new_coeff= q*new_level;
3958 if(new_coeff >= 2048 || new_coeff < 0)
3961 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
3962 new_coeff - old_coeff);
3963 if(score<best_score){
3966 best_change= change;
3967 best_unquant_change= new_coeff - old_coeff;
3974 run2= run_tab[rle_index++];
3978 for(i=start_i; i<64; i++){
3979 int j= perm_scantable[i];
3980 const int level= block[j];
3981 int change, old_coeff;
3983 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3987 if(level<0) old_coeff= qmul*level - qadd;
3988 else old_coeff= qmul*level + qadd;
3989 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3993 assert(run2>=0 || i >= last_non_zero );
3996 for(change=-1; change<=1; change+=2){
3997 int new_level= level + change;
3998 int score, new_coeff, unquant_change;
4001 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4005 if(new_level<0) new_coeff= qmul*new_level - qadd;
4006 else new_coeff= qmul*new_level + qadd;
4007 if(new_coeff >= 2048 || new_coeff <= -2048)
4009 //FIXME check for overflow
4012 if(level < 63 && level > -63){
4013 if(i < last_non_zero)
4014 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4015 - length[UNI_AC_ENC_INDEX(run, level+64)];
4017 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4018 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4021 assert(FFABS(new_level)==1);
4023 if(analyze_gradient){
4024 int g= d1[ scantable[i] ];
4025 if(g && (g^new_level) >= 0)
4029 if(i < last_non_zero){
4030 int next_i= i + run2 + 1;
4031 int next_level= block[ perm_scantable[next_i] ] + 64;
4033 if(next_level&(~127))
4036 if(next_i < last_non_zero)
4037 score += length[UNI_AC_ENC_INDEX(run, 65)]
4038 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4039 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4041 score += length[UNI_AC_ENC_INDEX(run, 65)]
4042 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4043 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4045 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4047 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4048 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4054 assert(FFABS(level)==1);
4056 if(i < last_non_zero){
4057 int next_i= i + run2 + 1;
4058 int next_level= block[ perm_scantable[next_i] ] + 64;
4060 if(next_level&(~127))
4063 if(next_i < last_non_zero)
4064 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4065 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4066 - length[UNI_AC_ENC_INDEX(run, 65)];
4068 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4069 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4070 - length[UNI_AC_ENC_INDEX(run, 65)];
4072 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4074 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4075 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4082 unquant_change= new_coeff - old_coeff;
4083 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4085 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4087 if(score<best_score){
4090 best_change= change;
4091 best_unquant_change= unquant_change;
4095 prev_level= level + 64;
4096 if(prev_level&(~127))
4105 STOP_TIMER("iterative step")}
4109 int j= perm_scantable[ best_coeff ];
4111 block[j] += best_change;
4113 if(best_coeff > last_non_zero){
4114 last_non_zero= best_coeff;
4122 if(block[j] - best_change){
4123 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4135 for(; last_non_zero>=start_i; last_non_zero--){
4136 if(block[perm_scantable[last_non_zero]])
4142 if(256*256*256*64 % count == 0){
4143 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);
4148 for(i=start_i; i<=last_non_zero; i++){
4149 int j= perm_scantable[i];
4150 const int level= block[j];
4153 run_tab[rle_index++]=run;
4160 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4166 if(last_non_zero>0){
4167 STOP_TIMER("iterative search")
4172 return last_non_zero;
4175 int ff_dct_quantize_c(MpegEncContext *s,
4176 int16_t *block, int n,
4177 int qscale, int *overflow)
4179 int i, j, level, last_non_zero, q, start_i;
4181 const uint8_t *scantable= s->intra_scantable.scantable;
4184 unsigned int threshold1, threshold2;
4186 s->fdsp.fdct(block);
4188 if(s->dct_error_sum)
4189 s->denoise_dct(s, block);
4199 /* For AIC we skip quant/dequant of INTRADC */
4202 /* note: block[0] is assumed to be positive */
4203 block[0] = (block[0] + (q >> 1)) / q;
4206 qmat = s->q_intra_matrix[qscale];
4207 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4211 qmat = s->q_inter_matrix[qscale];
4212 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4214 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4215 threshold2= (threshold1<<1);
4216 for(i=63;i>=start_i;i--) {
4218 level = block[j] * qmat[j];
4220 if(((unsigned)(level+threshold1))>threshold2){
4227 for(i=start_i; i<=last_non_zero; i++) {
4229 level = block[j] * qmat[j];
4231 // if( bias+level >= (1<<QMAT_SHIFT)
4232 // || bias-level >= (1<<QMAT_SHIFT)){
4233 if(((unsigned)(level+threshold1))>threshold2){
4235 level= (bias + level)>>QMAT_SHIFT;
4238 level= (bias - level)>>QMAT_SHIFT;
4246 *overflow= s->max_qcoeff < max; //overflow might have happened
4248 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4249 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4250 ff_block_permute(block, s->idsp.idct_permutation,
4251 scantable, last_non_zero);
4253 return last_non_zero;
4256 #define OFFSET(x) offsetof(MpegEncContext, x)
4257 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4258 static const AVOption h263_options[] = {
4259 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4260 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4261 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4266 static const AVClass h263_class = {
4267 .class_name = "H.263 encoder",
4268 .item_name = av_default_item_name,
4269 .option = h263_options,
4270 .version = LIBAVUTIL_VERSION_INT,
4273 AVCodec ff_h263_encoder = {
4275 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4276 .type = AVMEDIA_TYPE_VIDEO,
4277 .id = AV_CODEC_ID_H263,
4278 .priv_data_size = sizeof(MpegEncContext),
4279 .init = ff_mpv_encode_init,
4280 .encode2 = ff_mpv_encode_picture,
4281 .close = ff_mpv_encode_end,
4282 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4283 .priv_class = &h263_class,
4286 static const AVOption h263p_options[] = {
4287 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4288 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4289 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4290 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4294 static const AVClass h263p_class = {
4295 .class_name = "H.263p encoder",
4296 .item_name = av_default_item_name,
4297 .option = h263p_options,
4298 .version = LIBAVUTIL_VERSION_INT,
4301 AVCodec ff_h263p_encoder = {
4303 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4304 .type = AVMEDIA_TYPE_VIDEO,
4305 .id = AV_CODEC_ID_H263P,
4306 .priv_data_size = sizeof(MpegEncContext),
4307 .init = ff_mpv_encode_init,
4308 .encode2 = ff_mpv_encode_picture,
4309 .close = ff_mpv_encode_end,
4310 .capabilities = CODEC_CAP_SLICE_THREADS,
4311 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4312 .priv_class = &h263p_class,
4315 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4317 AVCodec ff_msmpeg4v2_encoder = {
4318 .name = "msmpeg4v2",
4319 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4320 .type = AVMEDIA_TYPE_VIDEO,
4321 .id = AV_CODEC_ID_MSMPEG4V2,
4322 .priv_data_size = sizeof(MpegEncContext),
4323 .init = ff_mpv_encode_init,
4324 .encode2 = ff_mpv_encode_picture,
4325 .close = ff_mpv_encode_end,
4326 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4327 .priv_class = &msmpeg4v2_class,
4330 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4332 AVCodec ff_msmpeg4v3_encoder = {
4334 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4335 .type = AVMEDIA_TYPE_VIDEO,
4336 .id = AV_CODEC_ID_MSMPEG4V3,
4337 .priv_data_size = sizeof(MpegEncContext),
4338 .init = ff_mpv_encode_init,
4339 .encode2 = ff_mpv_encode_picture,
4340 .close = ff_mpv_encode_end,
4341 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4342 .priv_class = &msmpeg4v3_class,
4345 FF_MPV_GENERIC_CLASS(wmv1)
4347 AVCodec ff_wmv1_encoder = {
4349 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4350 .type = AVMEDIA_TYPE_VIDEO,
4351 .id = AV_CODEC_ID_WMV1,
4352 .priv_data_size = sizeof(MpegEncContext),
4353 .init = ff_mpv_encode_init,
4354 .encode2 = ff_mpv_encode_picture,
4355 .close = ff_mpv_encode_end,
4356 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4357 .priv_class = &wmv1_class,