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 if ((ret = ff_msmpeg4_encode_init(s)) < 0)
765 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
766 && s->out_format == FMT_MPEG1)
767 ff_mpeg1_encode_init(s);
770 for (i = 0; i < 64; i++) {
771 int j = s->idsp.idct_permutation[i];
772 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
774 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
775 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
776 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
778 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
781 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
782 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
784 if (s->avctx->intra_matrix)
785 s->intra_matrix[j] = s->avctx->intra_matrix[i];
786 if (s->avctx->inter_matrix)
787 s->inter_matrix[j] = s->avctx->inter_matrix[i];
790 /* precompute matrix */
791 /* for mjpeg, we do include qscale in the matrix */
792 if (s->out_format != FMT_MJPEG) {
793 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
794 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
796 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
797 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
801 if (ff_rate_control_init(s) < 0)
804 #if FF_API_ERROR_RATE
805 FF_DISABLE_DEPRECATION_WARNINGS
806 if (avctx->error_rate)
807 s->error_rate = avctx->error_rate;
808 FF_ENABLE_DEPRECATION_WARNINGS;
811 #if FF_API_NORMALIZE_AQP
812 FF_DISABLE_DEPRECATION_WARNINGS
813 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
814 s->mpv_flags |= FF_MPV_FLAG_NAQ;
815 FF_ENABLE_DEPRECATION_WARNINGS;
819 FF_DISABLE_DEPRECATION_WARNINGS
820 if (avctx->flags & CODEC_FLAG_MV0)
821 s->mpv_flags |= FF_MPV_FLAG_MV0;
822 FF_ENABLE_DEPRECATION_WARNINGS
826 FF_DISABLE_DEPRECATION_WARNINGS
827 if (avctx->rc_qsquish != 0.0)
828 s->rc_qsquish = avctx->rc_qsquish;
829 if (avctx->rc_qmod_amp != 0.0)
830 s->rc_qmod_amp = avctx->rc_qmod_amp;
831 if (avctx->rc_qmod_freq)
832 s->rc_qmod_freq = avctx->rc_qmod_freq;
833 if (avctx->rc_buffer_aggressivity != 1.0)
834 s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
835 if (avctx->rc_initial_cplx != 0.0)
836 s->rc_initial_cplx = avctx->rc_initial_cplx;
838 s->lmin = avctx->lmin;
840 s->lmax = avctx->lmax;
844 s->rc_eq = av_strdup(avctx->rc_eq);
846 return AVERROR(ENOMEM);
848 FF_ENABLE_DEPRECATION_WARNINGS
851 if (avctx->b_frame_strategy == 2) {
852 for (i = 0; i < s->max_b_frames + 2; i++) {
853 s->tmp_frames[i] = av_frame_alloc();
854 if (!s->tmp_frames[i])
855 return AVERROR(ENOMEM);
857 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
858 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
859 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
861 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
869 ff_mpv_encode_end(avctx);
870 return AVERROR_UNKNOWN;
873 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
875 MpegEncContext *s = avctx->priv_data;
878 ff_rate_control_uninit(s);
880 ff_mpv_common_end(s);
881 if (CONFIG_MJPEG_ENCODER &&
882 s->out_format == FMT_MJPEG)
883 ff_mjpeg_encode_close(s);
885 av_freep(&avctx->extradata);
887 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
888 av_frame_free(&s->tmp_frames[i]);
890 ff_free_picture_tables(&s->new_picture);
891 ff_mpeg_unref_picture(s, &s->new_picture);
893 av_freep(&s->avctx->stats_out);
894 av_freep(&s->ac_stats);
896 av_freep(&s->q_intra_matrix);
897 av_freep(&s->q_inter_matrix);
898 av_freep(&s->q_intra_matrix16);
899 av_freep(&s->q_inter_matrix16);
900 av_freep(&s->input_picture);
901 av_freep(&s->reordered_input_picture);
902 av_freep(&s->dct_offset);
907 static int get_sae(uint8_t *src, int ref, int stride)
912 for (y = 0; y < 16; y++) {
913 for (x = 0; x < 16; x++) {
914 acc += FFABS(src[x + y * stride] - ref);
921 static int get_intra_count(MpegEncContext *s, uint8_t *src,
922 uint8_t *ref, int stride)
930 for (y = 0; y < h; y += 16) {
931 for (x = 0; x < w; x += 16) {
932 int offset = x + y * stride;
933 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
935 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
936 int sae = get_sae(src + offset, mean, stride);
938 acc += sae + 500 < sad;
945 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
949 int i, display_picture_number = 0, ret;
950 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
951 (s->low_delay ? 0 : 1);
956 display_picture_number = s->input_picture_number++;
958 if (pts != AV_NOPTS_VALUE) {
959 if (s->user_specified_pts != AV_NOPTS_VALUE) {
961 int64_t last = s->user_specified_pts;
964 av_log(s->avctx, AV_LOG_ERROR,
965 "Error, Invalid timestamp=%"PRId64", "
966 "last=%"PRId64"\n", pts, s->user_specified_pts);
970 if (!s->low_delay && display_picture_number == 1)
971 s->dts_delta = time - last;
973 s->user_specified_pts = pts;
975 if (s->user_specified_pts != AV_NOPTS_VALUE) {
976 s->user_specified_pts =
977 pts = s->user_specified_pts + 1;
978 av_log(s->avctx, AV_LOG_INFO,
979 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
982 pts = display_picture_number;
988 if (!pic_arg->buf[0] ||
989 pic_arg->linesize[0] != s->linesize ||
990 pic_arg->linesize[1] != s->uvlinesize ||
991 pic_arg->linesize[2] != s->uvlinesize)
993 if ((s->width & 15) || (s->height & 15))
996 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
997 pic_arg->linesize[1], s->linesize, s->uvlinesize);
999 i = ff_find_unused_picture(s, direct);
1003 pic = &s->picture[i];
1007 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1009 if (ff_alloc_picture(s, pic, 1) < 0) {
1013 if (ff_alloc_picture(s, pic, 0) < 0) {
1017 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1018 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1019 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1022 int h_chroma_shift, v_chroma_shift;
1023 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1027 for (i = 0; i < 3; i++) {
1028 int src_stride = pic_arg->linesize[i];
1029 int dst_stride = i ? s->uvlinesize : s->linesize;
1030 int h_shift = i ? h_chroma_shift : 0;
1031 int v_shift = i ? v_chroma_shift : 0;
1032 int w = s->width >> h_shift;
1033 int h = s->height >> v_shift;
1034 uint8_t *src = pic_arg->data[i];
1035 uint8_t *dst = pic->f->data[i];
1037 if (!s->avctx->rc_buffer_size)
1038 dst += INPLACE_OFFSET;
1040 if (src_stride == dst_stride)
1041 memcpy(dst, src, src_stride * h);
1044 uint8_t *dst2 = dst;
1046 memcpy(dst2, src, w);
1051 if ((s->width & 15) || (s->height & 15)) {
1052 s->mpvencdsp.draw_edges(dst, dst_stride,
1061 ret = av_frame_copy_props(pic->f, pic_arg);
1065 pic->f->display_picture_number = display_picture_number;
1066 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1069 /* shift buffer entries */
1070 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1071 s->input_picture[i - 1] = s->input_picture[i];
1073 s->input_picture[encoding_delay] = (Picture*) pic;
1078 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1082 int64_t score64 = 0;
1084 for (plane = 0; plane < 3; plane++) {
1085 const int stride = p->f->linesize[plane];
1086 const int bw = plane ? 1 : 2;
1087 for (y = 0; y < s->mb_height * bw; y++) {
1088 for (x = 0; x < s->mb_width * bw; x++) {
1089 int off = p->shared ? 0 : 16;
1090 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1091 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1092 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1094 switch (s->avctx->frame_skip_exp) {
1095 case 0: score = FFMAX(score, v); break;
1096 case 1: score += FFABS(v); break;
1097 case 2: score += v * v; break;
1098 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1099 case 4: score64 += v * v * (int64_t)(v * v); break;
1108 if (score64 < s->avctx->frame_skip_threshold)
1110 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1115 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1117 AVPacket pkt = { 0 };
1118 int ret, got_output;
1120 av_init_packet(&pkt);
1121 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1126 av_free_packet(&pkt);
1130 static int estimate_best_b_count(MpegEncContext *s)
1132 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1133 AVCodecContext *c = avcodec_alloc_context3(NULL);
1134 const int scale = s->avctx->brd_scale;
1135 int i, j, out_size, p_lambda, b_lambda, lambda2;
1136 int64_t best_rd = INT64_MAX;
1137 int best_b_count = -1;
1139 assert(scale >= 0 && scale <= 3);
1142 //s->next_picture_ptr->quality;
1143 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1144 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1145 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1146 if (!b_lambda) // FIXME we should do this somewhere else
1147 b_lambda = p_lambda;
1148 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1151 c->width = s->width >> scale;
1152 c->height = s->height >> scale;
1153 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
1154 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1155 c->mb_decision = s->avctx->mb_decision;
1156 c->me_cmp = s->avctx->me_cmp;
1157 c->mb_cmp = s->avctx->mb_cmp;
1158 c->me_sub_cmp = s->avctx->me_sub_cmp;
1159 c->pix_fmt = AV_PIX_FMT_YUV420P;
1160 c->time_base = s->avctx->time_base;
1161 c->max_b_frames = s->max_b_frames;
1163 if (avcodec_open2(c, codec, NULL) < 0)
1166 for (i = 0; i < s->max_b_frames + 2; i++) {
1167 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1168 s->next_picture_ptr;
1170 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1171 pre_input = *pre_input_ptr;
1173 if (!pre_input.shared && i) {
1174 pre_input.f->data[0] += INPLACE_OFFSET;
1175 pre_input.f->data[1] += INPLACE_OFFSET;
1176 pre_input.f->data[2] += INPLACE_OFFSET;
1179 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1180 s->tmp_frames[i]->linesize[0],
1181 pre_input.f->data[0],
1182 pre_input.f->linesize[0],
1183 c->width, c->height);
1184 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1185 s->tmp_frames[i]->linesize[1],
1186 pre_input.f->data[1],
1187 pre_input.f->linesize[1],
1188 c->width >> 1, c->height >> 1);
1189 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1190 s->tmp_frames[i]->linesize[2],
1191 pre_input.f->data[2],
1192 pre_input.f->linesize[2],
1193 c->width >> 1, c->height >> 1);
1197 for (j = 0; j < s->max_b_frames + 1; j++) {
1200 if (!s->input_picture[j])
1203 c->error[0] = c->error[1] = c->error[2] = 0;
1205 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1206 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1208 out_size = encode_frame(c, s->tmp_frames[0]);
1210 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1212 for (i = 0; i < s->max_b_frames + 1; i++) {
1213 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1215 s->tmp_frames[i + 1]->pict_type = is_p ?
1216 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1217 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1219 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1221 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1224 /* get the delayed frames */
1226 out_size = encode_frame(c, NULL);
1227 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1230 rd += c->error[0] + c->error[1] + c->error[2];
1241 return best_b_count;
1244 static int select_input_picture(MpegEncContext *s)
1248 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1249 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1250 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1252 /* set next picture type & ordering */
1253 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1254 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1255 !s->next_picture_ptr || s->intra_only) {
1256 s->reordered_input_picture[0] = s->input_picture[0];
1257 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1258 s->reordered_input_picture[0]->f->coded_picture_number =
1259 s->coded_picture_number++;
1263 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1264 if (s->picture_in_gop_number < s->gop_size &&
1265 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1266 // FIXME check that te gop check above is +-1 correct
1267 av_frame_unref(s->input_picture[0]->f);
1270 ff_vbv_update(s, 0);
1276 if (s->flags & CODEC_FLAG_PASS2) {
1277 for (i = 0; i < s->max_b_frames + 1; i++) {
1278 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1280 if (pict_num >= s->rc_context.num_entries)
1282 if (!s->input_picture[i]) {
1283 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1287 s->input_picture[i]->f->pict_type =
1288 s->rc_context.entry[pict_num].new_pict_type;
1292 if (s->avctx->b_frame_strategy == 0) {
1293 b_frames = s->max_b_frames;
1294 while (b_frames && !s->input_picture[b_frames])
1296 } else if (s->avctx->b_frame_strategy == 1) {
1297 for (i = 1; i < s->max_b_frames + 1; i++) {
1298 if (s->input_picture[i] &&
1299 s->input_picture[i]->b_frame_score == 0) {
1300 s->input_picture[i]->b_frame_score =
1302 s->input_picture[i ]->f->data[0],
1303 s->input_picture[i - 1]->f->data[0],
1307 for (i = 0; i < s->max_b_frames + 1; i++) {
1308 if (!s->input_picture[i] ||
1309 s->input_picture[i]->b_frame_score - 1 >
1310 s->mb_num / s->avctx->b_sensitivity)
1314 b_frames = FFMAX(0, i - 1);
1317 for (i = 0; i < b_frames + 1; i++) {
1318 s->input_picture[i]->b_frame_score = 0;
1320 } else if (s->avctx->b_frame_strategy == 2) {
1321 b_frames = estimate_best_b_count(s);
1323 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1329 for (i = b_frames - 1; i >= 0; i--) {
1330 int type = s->input_picture[i]->f->pict_type;
1331 if (type && type != AV_PICTURE_TYPE_B)
1334 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1335 b_frames == s->max_b_frames) {
1336 av_log(s->avctx, AV_LOG_ERROR,
1337 "warning, too many b frames in a row\n");
1340 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1341 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1342 s->gop_size > s->picture_in_gop_number) {
1343 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1345 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1347 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1351 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1352 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1355 s->reordered_input_picture[0] = s->input_picture[b_frames];
1356 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1357 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1358 s->reordered_input_picture[0]->f->coded_picture_number =
1359 s->coded_picture_number++;
1360 for (i = 0; i < b_frames; i++) {
1361 s->reordered_input_picture[i + 1] = s->input_picture[i];
1362 s->reordered_input_picture[i + 1]->f->pict_type =
1364 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1365 s->coded_picture_number++;
1370 if (s->reordered_input_picture[0]) {
1371 s->reordered_input_picture[0]->reference =
1372 s->reordered_input_picture[0]->f->pict_type !=
1373 AV_PICTURE_TYPE_B ? 3 : 0;
1375 ff_mpeg_unref_picture(s, &s->new_picture);
1376 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1379 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1380 // input is a shared pix, so we can't modifiy it -> alloc a new
1381 // one & ensure that the shared one is reuseable
1384 int i = ff_find_unused_picture(s, 0);
1387 pic = &s->picture[i];
1389 pic->reference = s->reordered_input_picture[0]->reference;
1390 if (ff_alloc_picture(s, pic, 0) < 0) {
1394 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1398 /* mark us unused / free shared pic */
1399 av_frame_unref(s->reordered_input_picture[0]->f);
1400 s->reordered_input_picture[0]->shared = 0;
1402 s->current_picture_ptr = pic;
1404 // input is not a shared pix -> reuse buffer for current_pix
1405 s->current_picture_ptr = s->reordered_input_picture[0];
1406 for (i = 0; i < 4; i++) {
1407 s->new_picture.f->data[i] += INPLACE_OFFSET;
1410 ff_mpeg_unref_picture(s, &s->current_picture);
1411 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1412 s->current_picture_ptr)) < 0)
1415 s->picture_number = s->new_picture.f->display_picture_number;
1417 ff_mpeg_unref_picture(s, &s->new_picture);
1422 static void frame_end(MpegEncContext *s)
1426 if (s->unrestricted_mv &&
1427 s->current_picture.reference &&
1429 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1430 int hshift = desc->log2_chroma_w;
1431 int vshift = desc->log2_chroma_h;
1432 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1433 s->h_edge_pos, s->v_edge_pos,
1434 EDGE_WIDTH, EDGE_WIDTH,
1435 EDGE_TOP | EDGE_BOTTOM);
1436 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1437 s->h_edge_pos >> hshift,
1438 s->v_edge_pos >> vshift,
1439 EDGE_WIDTH >> hshift,
1440 EDGE_WIDTH >> vshift,
1441 EDGE_TOP | EDGE_BOTTOM);
1442 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1443 s->h_edge_pos >> hshift,
1444 s->v_edge_pos >> vshift,
1445 EDGE_WIDTH >> hshift,
1446 EDGE_WIDTH >> vshift,
1447 EDGE_TOP | EDGE_BOTTOM);
1452 s->last_pict_type = s->pict_type;
1453 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1454 if (s->pict_type!= AV_PICTURE_TYPE_B)
1455 s->last_non_b_pict_type = s->pict_type;
1458 /* release non-reference frames */
1459 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1460 if (!s->picture[i].reference)
1461 ff_mpeg_unref_picture(s, &s->picture[i]);
1465 s->avctx->coded_frame = s->current_picture_ptr->f;
1469 static void update_noise_reduction(MpegEncContext *s)
1473 for (intra = 0; intra < 2; intra++) {
1474 if (s->dct_count[intra] > (1 << 16)) {
1475 for (i = 0; i < 64; i++) {
1476 s->dct_error_sum[intra][i] >>= 1;
1478 s->dct_count[intra] >>= 1;
1481 for (i = 0; i < 64; i++) {
1482 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1483 s->dct_count[intra] +
1484 s->dct_error_sum[intra][i] / 2) /
1485 (s->dct_error_sum[intra][i] + 1);
1490 static int frame_start(MpegEncContext *s)
1494 /* mark & release old frames */
1495 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1496 s->last_picture_ptr != s->next_picture_ptr &&
1497 s->last_picture_ptr->f->buf[0]) {
1498 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1501 s->current_picture_ptr->f->pict_type = s->pict_type;
1502 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1504 ff_mpeg_unref_picture(s, &s->current_picture);
1505 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1506 s->current_picture_ptr)) < 0)
1509 if (s->pict_type != AV_PICTURE_TYPE_B) {
1510 s->last_picture_ptr = s->next_picture_ptr;
1512 s->next_picture_ptr = s->current_picture_ptr;
1515 if (s->last_picture_ptr) {
1516 ff_mpeg_unref_picture(s, &s->last_picture);
1517 if (s->last_picture_ptr->f->buf[0] &&
1518 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1519 s->last_picture_ptr)) < 0)
1522 if (s->next_picture_ptr) {
1523 ff_mpeg_unref_picture(s, &s->next_picture);
1524 if (s->next_picture_ptr->f->buf[0] &&
1525 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1526 s->next_picture_ptr)) < 0)
1530 if (s->picture_structure!= PICT_FRAME) {
1532 for (i = 0; i < 4; i++) {
1533 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1534 s->current_picture.f->data[i] +=
1535 s->current_picture.f->linesize[i];
1537 s->current_picture.f->linesize[i] *= 2;
1538 s->last_picture.f->linesize[i] *= 2;
1539 s->next_picture.f->linesize[i] *= 2;
1543 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1544 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1545 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1546 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1547 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1548 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1550 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1551 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1554 if (s->dct_error_sum) {
1555 assert(s->avctx->noise_reduction && s->encoding);
1556 update_noise_reduction(s);
1562 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1563 const AVFrame *pic_arg, int *got_packet)
1565 MpegEncContext *s = avctx->priv_data;
1566 int i, stuffing_count, ret;
1567 int context_count = s->slice_context_count;
1569 s->picture_in_gop_number++;
1571 if (load_input_picture(s, pic_arg) < 0)
1574 if (select_input_picture(s) < 0) {
1579 if (s->new_picture.f->data[0]) {
1581 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1584 s->mb_info_ptr = av_packet_new_side_data(pkt,
1585 AV_PKT_DATA_H263_MB_INFO,
1586 s->mb_width*s->mb_height*12);
1587 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1590 for (i = 0; i < context_count; i++) {
1591 int start_y = s->thread_context[i]->start_mb_y;
1592 int end_y = s->thread_context[i]-> end_mb_y;
1593 int h = s->mb_height;
1594 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1595 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1597 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1600 s->pict_type = s->new_picture.f->pict_type;
1602 ret = frame_start(s);
1606 if (encode_picture(s, s->picture_number) < 0)
1609 avctx->header_bits = s->header_bits;
1610 avctx->mv_bits = s->mv_bits;
1611 avctx->misc_bits = s->misc_bits;
1612 avctx->i_tex_bits = s->i_tex_bits;
1613 avctx->p_tex_bits = s->p_tex_bits;
1614 avctx->i_count = s->i_count;
1615 // FIXME f/b_count in avctx
1616 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1617 avctx->skip_count = s->skip_count;
1621 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1622 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1624 if (avctx->rc_buffer_size) {
1625 RateControlContext *rcc = &s->rc_context;
1626 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1628 if (put_bits_count(&s->pb) > max_size &&
1629 s->lambda < s->lmax) {
1630 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1631 (s->qscale + 1) / s->qscale);
1632 if (s->adaptive_quant) {
1634 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1635 s->lambda_table[i] =
1636 FFMAX(s->lambda_table[i] + 1,
1637 s->lambda_table[i] * (s->qscale + 1) /
1640 s->mb_skipped = 0; // done in frame_start()
1641 // done in encode_picture() so we must undo it
1642 if (s->pict_type == AV_PICTURE_TYPE_P) {
1643 if (s->flipflop_rounding ||
1644 s->codec_id == AV_CODEC_ID_H263P ||
1645 s->codec_id == AV_CODEC_ID_MPEG4)
1646 s->no_rounding ^= 1;
1648 if (s->pict_type != AV_PICTURE_TYPE_B) {
1649 s->time_base = s->last_time_base;
1650 s->last_non_b_time = s->time - s->pp_time;
1652 for (i = 0; i < context_count; i++) {
1653 PutBitContext *pb = &s->thread_context[i]->pb;
1654 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1659 assert(s->avctx->rc_max_rate);
1662 if (s->flags & CODEC_FLAG_PASS1)
1663 ff_write_pass1_stats(s);
1665 for (i = 0; i < 4; i++) {
1666 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1667 avctx->error[i] += s->current_picture_ptr->f->error[i];
1670 if (s->flags & CODEC_FLAG_PASS1)
1671 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1672 avctx->i_tex_bits + avctx->p_tex_bits ==
1673 put_bits_count(&s->pb));
1674 flush_put_bits(&s->pb);
1675 s->frame_bits = put_bits_count(&s->pb);
1677 stuffing_count = ff_vbv_update(s, s->frame_bits);
1678 if (stuffing_count) {
1679 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1680 stuffing_count + 50) {
1681 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1685 switch (s->codec_id) {
1686 case AV_CODEC_ID_MPEG1VIDEO:
1687 case AV_CODEC_ID_MPEG2VIDEO:
1688 while (stuffing_count--) {
1689 put_bits(&s->pb, 8, 0);
1692 case AV_CODEC_ID_MPEG4:
1693 put_bits(&s->pb, 16, 0);
1694 put_bits(&s->pb, 16, 0x1C3);
1695 stuffing_count -= 4;
1696 while (stuffing_count--) {
1697 put_bits(&s->pb, 8, 0xFF);
1701 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1703 flush_put_bits(&s->pb);
1704 s->frame_bits = put_bits_count(&s->pb);
1707 /* update mpeg1/2 vbv_delay for CBR */
1708 if (s->avctx->rc_max_rate &&
1709 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1710 s->out_format == FMT_MPEG1 &&
1711 90000LL * (avctx->rc_buffer_size - 1) <=
1712 s->avctx->rc_max_rate * 0xFFFFLL) {
1713 int vbv_delay, min_delay;
1714 double inbits = s->avctx->rc_max_rate *
1715 av_q2d(s->avctx->time_base);
1716 int minbits = s->frame_bits - 8 *
1717 (s->vbv_delay_ptr - s->pb.buf - 1);
1718 double bits = s->rc_context.buffer_index + minbits - inbits;
1721 av_log(s->avctx, AV_LOG_ERROR,
1722 "Internal error, negative bits\n");
1724 assert(s->repeat_first_field == 0);
1726 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1727 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1728 s->avctx->rc_max_rate;
1730 vbv_delay = FFMAX(vbv_delay, min_delay);
1732 assert(vbv_delay < 0xFFFF);
1734 s->vbv_delay_ptr[0] &= 0xF8;
1735 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1736 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1737 s->vbv_delay_ptr[2] &= 0x07;
1738 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1739 avctx->vbv_delay = vbv_delay * 300;
1741 s->total_bits += s->frame_bits;
1742 avctx->frame_bits = s->frame_bits;
1744 pkt->pts = s->current_picture.f->pts;
1745 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1746 if (!s->current_picture.f->coded_picture_number)
1747 pkt->dts = pkt->pts - s->dts_delta;
1749 pkt->dts = s->reordered_pts;
1750 s->reordered_pts = pkt->pts;
1752 pkt->dts = pkt->pts;
1753 if (s->current_picture.f->key_frame)
1754 pkt->flags |= AV_PKT_FLAG_KEY;
1756 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1760 assert((s->frame_bits & 7) == 0);
1762 pkt->size = s->frame_bits / 8;
1763 *got_packet = !!pkt->size;
1767 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1768 int n, int threshold)
1770 static const char tab[64] = {
1771 3, 2, 2, 1, 1, 1, 1, 1,
1772 1, 1, 1, 1, 1, 1, 1, 1,
1773 1, 1, 1, 1, 1, 1, 1, 1,
1774 0, 0, 0, 0, 0, 0, 0, 0,
1775 0, 0, 0, 0, 0, 0, 0, 0,
1776 0, 0, 0, 0, 0, 0, 0, 0,
1777 0, 0, 0, 0, 0, 0, 0, 0,
1778 0, 0, 0, 0, 0, 0, 0, 0
1783 int16_t *block = s->block[n];
1784 const int last_index = s->block_last_index[n];
1787 if (threshold < 0) {
1789 threshold = -threshold;
1793 /* Are all we could set to zero already zero? */
1794 if (last_index <= skip_dc - 1)
1797 for (i = 0; i <= last_index; i++) {
1798 const int j = s->intra_scantable.permutated[i];
1799 const int level = FFABS(block[j]);
1801 if (skip_dc && i == 0)
1805 } else if (level > 1) {
1811 if (score >= threshold)
1813 for (i = skip_dc; i <= last_index; i++) {
1814 const int j = s->intra_scantable.permutated[i];
1818 s->block_last_index[n] = 0;
1820 s->block_last_index[n] = -1;
1823 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1827 const int maxlevel = s->max_qcoeff;
1828 const int minlevel = s->min_qcoeff;
1832 i = 1; // skip clipping of intra dc
1836 for (; i <= last_index; i++) {
1837 const int j = s->intra_scantable.permutated[i];
1838 int level = block[j];
1840 if (level > maxlevel) {
1843 } else if (level < minlevel) {
1851 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1852 av_log(s->avctx, AV_LOG_INFO,
1853 "warning, clipping %d dct coefficients to %d..%d\n",
1854 overflow, minlevel, maxlevel);
1857 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1861 for (y = 0; y < 8; y++) {
1862 for (x = 0; x < 8; x++) {
1868 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1869 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1870 int v = ptr[x2 + y2 * stride];
1876 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1881 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1882 int motion_x, int motion_y,
1883 int mb_block_height,
1886 int16_t weight[8][64];
1887 int16_t orig[8][64];
1888 const int mb_x = s->mb_x;
1889 const int mb_y = s->mb_y;
1892 int dct_offset = s->linesize * 8; // default for progressive frames
1893 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1894 ptrdiff_t wrap_y, wrap_c;
1896 for (i = 0; i < mb_block_count; i++)
1897 skip_dct[i] = s->skipdct;
1899 if (s->adaptive_quant) {
1900 const int last_qp = s->qscale;
1901 const int mb_xy = mb_x + mb_y * s->mb_stride;
1903 s->lambda = s->lambda_table[mb_xy];
1906 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1907 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1908 s->dquant = s->qscale - last_qp;
1910 if (s->out_format == FMT_H263) {
1911 s->dquant = av_clip(s->dquant, -2, 2);
1913 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1915 if (s->pict_type == AV_PICTURE_TYPE_B) {
1916 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1919 if (s->mv_type == MV_TYPE_8X8)
1925 ff_set_qscale(s, last_qp + s->dquant);
1926 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1927 ff_set_qscale(s, s->qscale + s->dquant);
1929 wrap_y = s->linesize;
1930 wrap_c = s->uvlinesize;
1931 ptr_y = s->new_picture.f->data[0] +
1932 (mb_y * 16 * wrap_y) + mb_x * 16;
1933 ptr_cb = s->new_picture.f->data[1] +
1934 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1935 ptr_cr = s->new_picture.f->data[2] +
1936 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1938 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1939 uint8_t *ebuf = s->edge_emu_buffer + 32;
1940 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1942 16, 16, mb_x * 16, mb_y * 16,
1943 s->width, s->height);
1945 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1947 8, mb_block_height, mb_x * 8, mb_y * 8,
1948 s->width >> 1, s->height >> 1);
1949 ptr_cb = ebuf + 18 * wrap_y;
1950 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1952 8, mb_block_height, mb_x * 8, mb_y * 8,
1953 s->width >> 1, s->height >> 1);
1954 ptr_cr = ebuf + 18 * wrap_y + 8;
1958 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1959 int progressive_score, interlaced_score;
1961 s->interlaced_dct = 0;
1962 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1963 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1964 NULL, wrap_y, 8) - 400;
1966 if (progressive_score > 0) {
1967 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1968 NULL, wrap_y * 2, 8) +
1969 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
1970 NULL, wrap_y * 2, 8);
1971 if (progressive_score > interlaced_score) {
1972 s->interlaced_dct = 1;
1974 dct_offset = wrap_y;
1976 if (s->chroma_format == CHROMA_422)
1982 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
1983 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
1984 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
1985 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
1987 if (s->flags & CODEC_FLAG_GRAY) {
1991 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1992 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1993 if (!s->chroma_y_shift) { /* 422 */
1994 s->pdsp.get_pixels(s->block[6],
1995 ptr_cb + (dct_offset >> 1), wrap_c);
1996 s->pdsp.get_pixels(s->block[7],
1997 ptr_cr + (dct_offset >> 1), wrap_c);
2001 op_pixels_func (*op_pix)[4];
2002 qpel_mc_func (*op_qpix)[16];
2003 uint8_t *dest_y, *dest_cb, *dest_cr;
2005 dest_y = s->dest[0];
2006 dest_cb = s->dest[1];
2007 dest_cr = s->dest[2];
2009 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2010 op_pix = s->hdsp.put_pixels_tab;
2011 op_qpix = s->qdsp.put_qpel_pixels_tab;
2013 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2014 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2017 if (s->mv_dir & MV_DIR_FORWARD) {
2018 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2019 s->last_picture.f->data,
2021 op_pix = s->hdsp.avg_pixels_tab;
2022 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2024 if (s->mv_dir & MV_DIR_BACKWARD) {
2025 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2026 s->next_picture.f->data,
2030 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
2031 int progressive_score, interlaced_score;
2033 s->interlaced_dct = 0;
2034 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2035 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2039 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2040 progressive_score -= 400;
2042 if (progressive_score > 0) {
2043 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2045 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2049 if (progressive_score > interlaced_score) {
2050 s->interlaced_dct = 1;
2052 dct_offset = wrap_y;
2054 if (s->chroma_format == CHROMA_422)
2060 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2061 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2062 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2063 dest_y + dct_offset, wrap_y);
2064 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2065 dest_y + dct_offset + 8, wrap_y);
2067 if (s->flags & CODEC_FLAG_GRAY) {
2071 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2072 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2073 if (!s->chroma_y_shift) { /* 422 */
2074 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2075 dest_cb + (dct_offset >> 1), wrap_c);
2076 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2077 dest_cr + (dct_offset >> 1), wrap_c);
2080 /* pre quantization */
2081 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2082 2 * s->qscale * s->qscale) {
2084 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2086 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2088 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2089 wrap_y, 8) < 20 * s->qscale)
2091 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2092 wrap_y, 8) < 20 * s->qscale)
2094 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2096 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2098 if (!s->chroma_y_shift) { /* 422 */
2099 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2100 dest_cb + (dct_offset >> 1),
2101 wrap_c, 8) < 20 * s->qscale)
2103 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2104 dest_cr + (dct_offset >> 1),
2105 wrap_c, 8) < 20 * s->qscale)
2111 if (s->quantizer_noise_shaping) {
2113 get_visual_weight(weight[0], ptr_y , wrap_y);
2115 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2117 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2119 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2121 get_visual_weight(weight[4], ptr_cb , wrap_c);
2123 get_visual_weight(weight[5], ptr_cr , wrap_c);
2124 if (!s->chroma_y_shift) { /* 422 */
2126 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2129 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2132 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2135 /* DCT & quantize */
2136 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2138 for (i = 0; i < mb_block_count; i++) {
2141 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2142 // FIXME we could decide to change to quantizer instead of
2144 // JS: I don't think that would be a good idea it could lower
2145 // quality instead of improve it. Just INTRADC clipping
2146 // deserves changes in quantizer
2148 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2150 s->block_last_index[i] = -1;
2152 if (s->quantizer_noise_shaping) {
2153 for (i = 0; i < mb_block_count; i++) {
2155 s->block_last_index[i] =
2156 dct_quantize_refine(s, s->block[i], weight[i],
2157 orig[i], i, s->qscale);
2162 if (s->luma_elim_threshold && !s->mb_intra)
2163 for (i = 0; i < 4; i++)
2164 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2165 if (s->chroma_elim_threshold && !s->mb_intra)
2166 for (i = 4; i < mb_block_count; i++)
2167 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2169 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2170 for (i = 0; i < mb_block_count; i++) {
2171 if (s->block_last_index[i] == -1)
2172 s->coded_score[i] = INT_MAX / 256;
2177 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2178 s->block_last_index[4] =
2179 s->block_last_index[5] = 0;
2181 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2184 // non c quantize code returns incorrect block_last_index FIXME
2185 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2186 for (i = 0; i < mb_block_count; i++) {
2188 if (s->block_last_index[i] > 0) {
2189 for (j = 63; j > 0; j--) {
2190 if (s->block[i][s->intra_scantable.permutated[j]])
2193 s->block_last_index[i] = j;
2198 /* huffman encode */
2199 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2200 case AV_CODEC_ID_MPEG1VIDEO:
2201 case AV_CODEC_ID_MPEG2VIDEO:
2202 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2203 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2205 case AV_CODEC_ID_MPEG4:
2206 if (CONFIG_MPEG4_ENCODER)
2207 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2209 case AV_CODEC_ID_MSMPEG4V2:
2210 case AV_CODEC_ID_MSMPEG4V3:
2211 case AV_CODEC_ID_WMV1:
2212 if (CONFIG_MSMPEG4_ENCODER)
2213 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2215 case AV_CODEC_ID_WMV2:
2216 if (CONFIG_WMV2_ENCODER)
2217 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2219 case AV_CODEC_ID_H261:
2220 if (CONFIG_H261_ENCODER)
2221 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2223 case AV_CODEC_ID_H263:
2224 case AV_CODEC_ID_H263P:
2225 case AV_CODEC_ID_FLV1:
2226 case AV_CODEC_ID_RV10:
2227 case AV_CODEC_ID_RV20:
2228 if (CONFIG_H263_ENCODER)
2229 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2231 case AV_CODEC_ID_MJPEG:
2232 if (CONFIG_MJPEG_ENCODER)
2233 ff_mjpeg_encode_mb(s, s->block);
2240 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2242 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2243 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2246 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2249 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2252 d->mb_skip_run= s->mb_skip_run;
2254 d->last_dc[i] = s->last_dc[i];
2257 d->mv_bits= s->mv_bits;
2258 d->i_tex_bits= s->i_tex_bits;
2259 d->p_tex_bits= s->p_tex_bits;
2260 d->i_count= s->i_count;
2261 d->f_count= s->f_count;
2262 d->b_count= s->b_count;
2263 d->skip_count= s->skip_count;
2264 d->misc_bits= s->misc_bits;
2268 d->qscale= s->qscale;
2269 d->dquant= s->dquant;
2271 d->esc3_level_length= s->esc3_level_length;
2274 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2277 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2278 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2281 d->mb_skip_run= s->mb_skip_run;
2283 d->last_dc[i] = s->last_dc[i];
2286 d->mv_bits= s->mv_bits;
2287 d->i_tex_bits= s->i_tex_bits;
2288 d->p_tex_bits= s->p_tex_bits;
2289 d->i_count= s->i_count;
2290 d->f_count= s->f_count;
2291 d->b_count= s->b_count;
2292 d->skip_count= s->skip_count;
2293 d->misc_bits= s->misc_bits;
2295 d->mb_intra= s->mb_intra;
2296 d->mb_skipped= s->mb_skipped;
2297 d->mv_type= s->mv_type;
2298 d->mv_dir= s->mv_dir;
2300 if(s->data_partitioning){
2302 d->tex_pb= s->tex_pb;
2306 d->block_last_index[i]= s->block_last_index[i];
2307 d->interlaced_dct= s->interlaced_dct;
2308 d->qscale= s->qscale;
2310 d->esc3_level_length= s->esc3_level_length;
2313 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2314 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2315 int *dmin, int *next_block, int motion_x, int motion_y)
2318 uint8_t *dest_backup[3];
2320 copy_context_before_encode(s, backup, type);
2322 s->block= s->blocks[*next_block];
2323 s->pb= pb[*next_block];
2324 if(s->data_partitioning){
2325 s->pb2 = pb2 [*next_block];
2326 s->tex_pb= tex_pb[*next_block];
2330 memcpy(dest_backup, s->dest, sizeof(s->dest));
2331 s->dest[0] = s->rd_scratchpad;
2332 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2333 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2334 assert(s->linesize >= 32); //FIXME
2337 encode_mb(s, motion_x, motion_y);
2339 score= put_bits_count(&s->pb);
2340 if(s->data_partitioning){
2341 score+= put_bits_count(&s->pb2);
2342 score+= put_bits_count(&s->tex_pb);
2345 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2346 ff_mpv_decode_mb(s, s->block);
2348 score *= s->lambda2;
2349 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2353 memcpy(s->dest, dest_backup, sizeof(s->dest));
2360 copy_context_after_encode(best, s, type);
2364 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2365 uint32_t *sq = ff_square_tab + 256;
2370 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2371 else if(w==8 && h==8)
2372 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2376 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2385 static int sse_mb(MpegEncContext *s){
2389 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2390 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2393 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2394 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) +
2395 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) +
2396 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);
2398 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) +
2399 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) +
2400 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);
2403 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)
2404 +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)
2405 +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);
2408 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2409 MpegEncContext *s= *(void**)arg;
2413 s->me.dia_size= s->avctx->pre_dia_size;
2414 s->first_slice_line=1;
2415 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2416 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2417 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2419 s->first_slice_line=0;
2427 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2428 MpegEncContext *s= *(void**)arg;
2430 s->me.dia_size= s->avctx->dia_size;
2431 s->first_slice_line=1;
2432 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2433 s->mb_x=0; //for block init below
2434 ff_init_block_index(s);
2435 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2436 s->block_index[0]+=2;
2437 s->block_index[1]+=2;
2438 s->block_index[2]+=2;
2439 s->block_index[3]+=2;
2441 /* compute motion vector & mb_type and store in context */
2442 if(s->pict_type==AV_PICTURE_TYPE_B)
2443 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2445 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2447 s->first_slice_line=0;
2452 static int mb_var_thread(AVCodecContext *c, void *arg){
2453 MpegEncContext *s= *(void**)arg;
2456 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2457 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2460 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2462 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2464 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2465 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2467 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2468 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2469 s->me.mb_var_sum_temp += varc;
2475 static void write_slice_end(MpegEncContext *s){
2476 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2477 if(s->partitioned_frame){
2478 ff_mpeg4_merge_partitions(s);
2481 ff_mpeg4_stuffing(&s->pb);
2482 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2483 ff_mjpeg_encode_stuffing(&s->pb);
2486 avpriv_align_put_bits(&s->pb);
2487 flush_put_bits(&s->pb);
2489 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2490 s->misc_bits+= get_bits_diff(s);
2493 static void write_mb_info(MpegEncContext *s)
2495 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2496 int offset = put_bits_count(&s->pb);
2497 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2498 int gobn = s->mb_y / s->gob_index;
2500 if (CONFIG_H263_ENCODER)
2501 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2502 bytestream_put_le32(&ptr, offset);
2503 bytestream_put_byte(&ptr, s->qscale);
2504 bytestream_put_byte(&ptr, gobn);
2505 bytestream_put_le16(&ptr, mba);
2506 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2507 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2508 /* 4MV not implemented */
2509 bytestream_put_byte(&ptr, 0); /* hmv2 */
2510 bytestream_put_byte(&ptr, 0); /* vmv2 */
2513 static void update_mb_info(MpegEncContext *s, int startcode)
2517 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2518 s->mb_info_size += 12;
2519 s->prev_mb_info = s->last_mb_info;
2522 s->prev_mb_info = put_bits_count(&s->pb)/8;
2523 /* This might have incremented mb_info_size above, and we return without
2524 * actually writing any info into that slot yet. But in that case,
2525 * this will be called again at the start of the after writing the
2526 * start code, actually writing the mb info. */
2530 s->last_mb_info = put_bits_count(&s->pb)/8;
2531 if (!s->mb_info_size)
2532 s->mb_info_size += 12;
2536 static int encode_thread(AVCodecContext *c, void *arg){
2537 MpegEncContext *s= *(void**)arg;
2538 int mb_x, mb_y, pdif = 0;
2539 int chr_h= 16>>s->chroma_y_shift;
2541 MpegEncContext best_s = { 0 }, backup_s;
2542 uint8_t bit_buf[2][MAX_MB_BYTES];
2543 uint8_t bit_buf2[2][MAX_MB_BYTES];
2544 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2545 PutBitContext pb[2], pb2[2], tex_pb[2];
2548 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2549 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2550 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2553 s->last_bits= put_bits_count(&s->pb);
2564 /* init last dc values */
2565 /* note: quant matrix value (8) is implied here */
2566 s->last_dc[i] = 128 << s->intra_dc_precision;
2568 s->current_picture.f->error[i] = 0;
2571 memset(s->last_mv, 0, sizeof(s->last_mv));
2575 switch(s->codec_id){
2576 case AV_CODEC_ID_H263:
2577 case AV_CODEC_ID_H263P:
2578 case AV_CODEC_ID_FLV1:
2579 if (CONFIG_H263_ENCODER)
2580 s->gob_index = ff_h263_get_gob_height(s);
2582 case AV_CODEC_ID_MPEG4:
2583 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2584 ff_mpeg4_init_partitions(s);
2590 s->first_slice_line = 1;
2591 s->ptr_lastgob = s->pb.buf;
2592 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2596 ff_set_qscale(s, s->qscale);
2597 ff_init_block_index(s);
2599 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2600 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2601 int mb_type= s->mb_type[xy];
2606 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2607 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2610 if(s->data_partitioning){
2611 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2612 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2613 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2619 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2620 ff_update_block_index(s);
2622 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2623 ff_h261_reorder_mb_index(s);
2624 xy= s->mb_y*s->mb_stride + s->mb_x;
2625 mb_type= s->mb_type[xy];
2628 /* write gob / video packet header */
2630 int current_packet_size, is_gob_start;
2632 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2634 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2636 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2638 switch(s->codec_id){
2639 case AV_CODEC_ID_H263:
2640 case AV_CODEC_ID_H263P:
2641 if(!s->h263_slice_structured)
2642 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2644 case AV_CODEC_ID_MPEG2VIDEO:
2645 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2646 case AV_CODEC_ID_MPEG1VIDEO:
2647 if(s->mb_skip_run) is_gob_start=0;
2652 if(s->start_mb_y != mb_y || mb_x!=0){
2655 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2656 ff_mpeg4_init_partitions(s);
2660 assert((put_bits_count(&s->pb)&7) == 0);
2661 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2663 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2664 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2665 int d = 100 / s->error_rate;
2667 current_packet_size=0;
2668 s->pb.buf_ptr= s->ptr_lastgob;
2669 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2673 if (s->avctx->rtp_callback){
2674 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2675 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2677 update_mb_info(s, 1);
2679 switch(s->codec_id){
2680 case AV_CODEC_ID_MPEG4:
2681 if (CONFIG_MPEG4_ENCODER) {
2682 ff_mpeg4_encode_video_packet_header(s);
2683 ff_mpeg4_clean_buffers(s);
2686 case AV_CODEC_ID_MPEG1VIDEO:
2687 case AV_CODEC_ID_MPEG2VIDEO:
2688 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2689 ff_mpeg1_encode_slice_header(s);
2690 ff_mpeg1_clean_buffers(s);
2693 case AV_CODEC_ID_H263:
2694 case AV_CODEC_ID_H263P:
2695 if (CONFIG_H263_ENCODER)
2696 ff_h263_encode_gob_header(s, mb_y);
2700 if(s->flags&CODEC_FLAG_PASS1){
2701 int bits= put_bits_count(&s->pb);
2702 s->misc_bits+= bits - s->last_bits;
2706 s->ptr_lastgob += current_packet_size;
2707 s->first_slice_line=1;
2708 s->resync_mb_x=mb_x;
2709 s->resync_mb_y=mb_y;
2713 if( (s->resync_mb_x == s->mb_x)
2714 && s->resync_mb_y+1 == s->mb_y){
2715 s->first_slice_line=0;
2719 s->dquant=0; //only for QP_RD
2721 update_mb_info(s, 0);
2723 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
2725 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2727 copy_context_before_encode(&backup_s, s, -1);
2729 best_s.data_partitioning= s->data_partitioning;
2730 best_s.partitioned_frame= s->partitioned_frame;
2731 if(s->data_partitioning){
2732 backup_s.pb2= s->pb2;
2733 backup_s.tex_pb= s->tex_pb;
2736 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2737 s->mv_dir = MV_DIR_FORWARD;
2738 s->mv_type = MV_TYPE_16X16;
2740 s->mv[0][0][0] = s->p_mv_table[xy][0];
2741 s->mv[0][0][1] = s->p_mv_table[xy][1];
2742 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2743 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2745 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2746 s->mv_dir = MV_DIR_FORWARD;
2747 s->mv_type = MV_TYPE_FIELD;
2750 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2751 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2752 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2754 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2755 &dmin, &next_block, 0, 0);
2757 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2758 s->mv_dir = MV_DIR_FORWARD;
2759 s->mv_type = MV_TYPE_16X16;
2763 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2764 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2766 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2767 s->mv_dir = MV_DIR_FORWARD;
2768 s->mv_type = MV_TYPE_8X8;
2771 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2772 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2774 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2775 &dmin, &next_block, 0, 0);
2777 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2778 s->mv_dir = MV_DIR_FORWARD;
2779 s->mv_type = MV_TYPE_16X16;
2781 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2782 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2783 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2784 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2786 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2787 s->mv_dir = MV_DIR_BACKWARD;
2788 s->mv_type = MV_TYPE_16X16;
2790 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2791 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2792 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2793 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2795 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2796 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2797 s->mv_type = MV_TYPE_16X16;
2799 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2800 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2801 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2802 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2803 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2804 &dmin, &next_block, 0, 0);
2806 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2807 s->mv_dir = MV_DIR_FORWARD;
2808 s->mv_type = MV_TYPE_FIELD;
2811 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2812 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2813 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2815 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2816 &dmin, &next_block, 0, 0);
2818 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2819 s->mv_dir = MV_DIR_BACKWARD;
2820 s->mv_type = MV_TYPE_FIELD;
2823 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2824 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2825 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2827 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2828 &dmin, &next_block, 0, 0);
2830 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2831 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2832 s->mv_type = MV_TYPE_FIELD;
2834 for(dir=0; dir<2; dir++){
2836 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2837 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2838 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2841 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2842 &dmin, &next_block, 0, 0);
2844 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2846 s->mv_type = MV_TYPE_16X16;
2850 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2851 &dmin, &next_block, 0, 0);
2852 if(s->h263_pred || s->h263_aic){
2854 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2856 ff_clean_intra_table_entries(s); //old mode?
2860 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2861 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2862 const int last_qp= backup_s.qscale;
2865 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2866 static const int dquant_tab[4]={-1,1,-2,2};
2868 assert(backup_s.dquant == 0);
2871 s->mv_dir= best_s.mv_dir;
2872 s->mv_type = MV_TYPE_16X16;
2873 s->mb_intra= best_s.mb_intra;
2874 s->mv[0][0][0] = best_s.mv[0][0][0];
2875 s->mv[0][0][1] = best_s.mv[0][0][1];
2876 s->mv[1][0][0] = best_s.mv[1][0][0];
2877 s->mv[1][0][1] = best_s.mv[1][0][1];
2879 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2880 for(; qpi<4; qpi++){
2881 int dquant= dquant_tab[qpi];
2882 qp= last_qp + dquant;
2883 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2885 backup_s.dquant= dquant;
2886 if(s->mb_intra && s->dc_val[0]){
2888 dc[i]= s->dc_val[0][ s->block_index[i] ];
2889 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2893 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2894 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2895 if(best_s.qscale != qp){
2896 if(s->mb_intra && s->dc_val[0]){
2898 s->dc_val[0][ s->block_index[i] ]= dc[i];
2899 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2906 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2907 int mx= s->b_direct_mv_table[xy][0];
2908 int my= s->b_direct_mv_table[xy][1];
2910 backup_s.dquant = 0;
2911 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2913 ff_mpeg4_set_direct_mv(s, mx, my);
2914 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2915 &dmin, &next_block, mx, my);
2917 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2918 backup_s.dquant = 0;
2919 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2921 ff_mpeg4_set_direct_mv(s, 0, 0);
2922 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2923 &dmin, &next_block, 0, 0);
2925 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2928 coded |= s->block_last_index[i];
2931 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2932 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2933 mx=my=0; //FIXME find the one we actually used
2934 ff_mpeg4_set_direct_mv(s, mx, my);
2935 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2943 s->mv_dir= best_s.mv_dir;
2944 s->mv_type = best_s.mv_type;
2946 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2947 s->mv[0][0][1] = best_s.mv[0][0][1];
2948 s->mv[1][0][0] = best_s.mv[1][0][0];
2949 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2952 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2953 &dmin, &next_block, mx, my);
2958 s->current_picture.qscale_table[xy] = best_s.qscale;
2960 copy_context_after_encode(s, &best_s, -1);
2962 pb_bits_count= put_bits_count(&s->pb);
2963 flush_put_bits(&s->pb);
2964 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2967 if(s->data_partitioning){
2968 pb2_bits_count= put_bits_count(&s->pb2);
2969 flush_put_bits(&s->pb2);
2970 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2971 s->pb2= backup_s.pb2;
2973 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2974 flush_put_bits(&s->tex_pb);
2975 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2976 s->tex_pb= backup_s.tex_pb;
2978 s->last_bits= put_bits_count(&s->pb);
2980 if (CONFIG_H263_ENCODER &&
2981 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2982 ff_h263_update_motion_val(s);
2984 if(next_block==0){ //FIXME 16 vs linesize16
2985 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2986 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2987 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2990 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2991 ff_mpv_decode_mb(s, s->block);
2993 int motion_x = 0, motion_y = 0;
2994 s->mv_type=MV_TYPE_16X16;
2995 // only one MB-Type possible
2998 case CANDIDATE_MB_TYPE_INTRA:
3001 motion_x= s->mv[0][0][0] = 0;
3002 motion_y= s->mv[0][0][1] = 0;
3004 case CANDIDATE_MB_TYPE_INTER:
3005 s->mv_dir = MV_DIR_FORWARD;
3007 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3008 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3010 case CANDIDATE_MB_TYPE_INTER_I:
3011 s->mv_dir = MV_DIR_FORWARD;
3012 s->mv_type = MV_TYPE_FIELD;
3015 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3016 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3017 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3020 case CANDIDATE_MB_TYPE_INTER4V:
3021 s->mv_dir = MV_DIR_FORWARD;
3022 s->mv_type = MV_TYPE_8X8;
3025 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3026 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3029 case CANDIDATE_MB_TYPE_DIRECT:
3030 if (CONFIG_MPEG4_ENCODER) {
3031 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3033 motion_x=s->b_direct_mv_table[xy][0];
3034 motion_y=s->b_direct_mv_table[xy][1];
3035 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3038 case CANDIDATE_MB_TYPE_DIRECT0:
3039 if (CONFIG_MPEG4_ENCODER) {
3040 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3042 ff_mpeg4_set_direct_mv(s, 0, 0);
3045 case CANDIDATE_MB_TYPE_BIDIR:
3046 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3048 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3049 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3050 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3051 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3053 case CANDIDATE_MB_TYPE_BACKWARD:
3054 s->mv_dir = MV_DIR_BACKWARD;
3056 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3057 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3059 case CANDIDATE_MB_TYPE_FORWARD:
3060 s->mv_dir = MV_DIR_FORWARD;
3062 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3063 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3065 case CANDIDATE_MB_TYPE_FORWARD_I:
3066 s->mv_dir = MV_DIR_FORWARD;
3067 s->mv_type = MV_TYPE_FIELD;
3070 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3071 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3072 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3075 case CANDIDATE_MB_TYPE_BACKWARD_I:
3076 s->mv_dir = MV_DIR_BACKWARD;
3077 s->mv_type = MV_TYPE_FIELD;
3080 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3081 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3082 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3085 case CANDIDATE_MB_TYPE_BIDIR_I:
3086 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3087 s->mv_type = MV_TYPE_FIELD;
3089 for(dir=0; dir<2; dir++){
3091 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3092 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3093 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3098 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3101 encode_mb(s, motion_x, motion_y);
3103 // RAL: Update last macroblock type
3104 s->last_mv_dir = s->mv_dir;
3106 if (CONFIG_H263_ENCODER &&
3107 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3108 ff_h263_update_motion_val(s);
3110 ff_mpv_decode_mb(s, s->block);
3113 /* clean the MV table in IPS frames for direct mode in B frames */
3114 if(s->mb_intra /* && I,P,S_TYPE */){
3115 s->p_mv_table[xy][0]=0;
3116 s->p_mv_table[xy][1]=0;
3119 if(s->flags&CODEC_FLAG_PSNR){
3123 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3124 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3126 s->current_picture.f->error[0] += sse(
3127 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3128 s->dest[0], w, h, s->linesize);
3129 s->current_picture.f->error[1] += sse(
3130 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3131 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3132 s->current_picture.f->error[2] += sse(
3133 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3134 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3137 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3138 ff_h263_loop_filter(s);
3140 av_dlog(s->avctx, "MB %d %d bits\n",
3141 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3145 //not beautiful here but we must write it before flushing so it has to be here
3146 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3147 ff_msmpeg4_encode_ext_header(s);
3151 /* Send the last GOB if RTP */
3152 if (s->avctx->rtp_callback) {
3153 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3154 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3155 /* Call the RTP callback to send the last GOB */
3157 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3163 #define MERGE(field) dst->field += src->field; src->field=0
3164 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3165 MERGE(me.scene_change_score);
3166 MERGE(me.mc_mb_var_sum_temp);
3167 MERGE(me.mb_var_sum_temp);
3170 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3173 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3174 MERGE(dct_count[1]);
3183 MERGE(er.error_count);
3184 MERGE(padding_bug_score);
3185 MERGE(current_picture.f->error[0]);
3186 MERGE(current_picture.f->error[1]);
3187 MERGE(current_picture.f->error[2]);
3189 if(dst->avctx->noise_reduction){
3190 for(i=0; i<64; i++){
3191 MERGE(dct_error_sum[0][i]);
3192 MERGE(dct_error_sum[1][i]);
3196 assert(put_bits_count(&src->pb) % 8 ==0);
3197 assert(put_bits_count(&dst->pb) % 8 ==0);
3198 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3199 flush_put_bits(&dst->pb);
3202 static int estimate_qp(MpegEncContext *s, int dry_run){
3203 if (s->next_lambda){
3204 s->current_picture_ptr->f->quality =
3205 s->current_picture.f->quality = s->next_lambda;
3206 if(!dry_run) s->next_lambda= 0;
3207 } else if (!s->fixed_qscale) {
3208 s->current_picture_ptr->f->quality =
3209 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3210 if (s->current_picture.f->quality < 0)
3214 if(s->adaptive_quant){
3215 switch(s->codec_id){
3216 case AV_CODEC_ID_MPEG4:
3217 if (CONFIG_MPEG4_ENCODER)
3218 ff_clean_mpeg4_qscales(s);
3220 case AV_CODEC_ID_H263:
3221 case AV_CODEC_ID_H263P:
3222 case AV_CODEC_ID_FLV1:
3223 if (CONFIG_H263_ENCODER)
3224 ff_clean_h263_qscales(s);
3227 ff_init_qscale_tab(s);
3230 s->lambda= s->lambda_table[0];
3233 s->lambda = s->current_picture.f->quality;
3238 /* must be called before writing the header */
3239 static void set_frame_distances(MpegEncContext * s){
3240 assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3241 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3243 if(s->pict_type==AV_PICTURE_TYPE_B){
3244 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3245 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3247 s->pp_time= s->time - s->last_non_b_time;
3248 s->last_non_b_time= s->time;
3249 assert(s->picture_number==0 || s->pp_time > 0);
3253 static int encode_picture(MpegEncContext *s, int picture_number)
3257 int context_count = s->slice_context_count;
3259 s->picture_number = picture_number;
3261 /* Reset the average MB variance */
3262 s->me.mb_var_sum_temp =
3263 s->me.mc_mb_var_sum_temp = 0;
3265 /* we need to initialize some time vars before we can encode b-frames */
3266 // RAL: Condition added for MPEG1VIDEO
3267 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3268 set_frame_distances(s);
3269 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3270 ff_set_mpeg4_time(s);
3272 s->me.scene_change_score=0;
3274 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3276 if(s->pict_type==AV_PICTURE_TYPE_I){
3277 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3278 else s->no_rounding=0;
3279 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3280 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3281 s->no_rounding ^= 1;
3284 if(s->flags & CODEC_FLAG_PASS2){
3285 if (estimate_qp(s,1) < 0)
3287 ff_get_2pass_fcode(s);
3288 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3289 if(s->pict_type==AV_PICTURE_TYPE_B)
3290 s->lambda= s->last_lambda_for[s->pict_type];
3292 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3296 s->mb_intra=0; //for the rate distortion & bit compare functions
3297 for(i=1; i<context_count; i++){
3298 ret = ff_update_duplicate_context(s->thread_context[i], s);
3306 /* Estimate motion for every MB */
3307 if(s->pict_type != AV_PICTURE_TYPE_I){
3308 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3309 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3310 if (s->pict_type != AV_PICTURE_TYPE_B) {
3311 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3312 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3316 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3317 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3319 for(i=0; i<s->mb_stride*s->mb_height; i++)
3320 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3322 if(!s->fixed_qscale){
3323 /* finding spatial complexity for I-frame rate control */
3324 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3327 for(i=1; i<context_count; i++){
3328 merge_context_after_me(s, s->thread_context[i]);
3330 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3331 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3334 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3335 s->pict_type= AV_PICTURE_TYPE_I;
3336 for(i=0; i<s->mb_stride*s->mb_height; i++)
3337 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3338 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3339 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3343 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3344 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3346 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3348 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3349 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3350 s->f_code= FFMAX3(s->f_code, a, b);
3353 ff_fix_long_p_mvs(s);
3354 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3355 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3359 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3360 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3365 if(s->pict_type==AV_PICTURE_TYPE_B){
3368 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3369 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3370 s->f_code = FFMAX(a, b);
3372 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3373 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3374 s->b_code = FFMAX(a, b);
3376 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3377 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3378 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3379 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3380 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3382 for(dir=0; dir<2; dir++){
3385 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3386 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3387 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3388 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3396 if (estimate_qp(s, 0) < 0)
3399 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3400 s->qscale= 3; //reduce clipping problems
3402 if (s->out_format == FMT_MJPEG) {
3403 /* for mjpeg, we do include qscale in the matrix */
3405 int j = s->idsp.idct_permutation[i];
3407 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3409 s->y_dc_scale_table=
3410 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3411 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3412 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3413 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3417 //FIXME var duplication
3418 s->current_picture_ptr->f->key_frame =
3419 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3420 s->current_picture_ptr->f->pict_type =
3421 s->current_picture.f->pict_type = s->pict_type;
3423 if (s->current_picture.f->key_frame)
3424 s->picture_in_gop_number=0;
3426 s->last_bits= put_bits_count(&s->pb);
3427 switch(s->out_format) {
3429 if (CONFIG_MJPEG_ENCODER)
3430 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3434 if (CONFIG_H261_ENCODER)
3435 ff_h261_encode_picture_header(s, picture_number);
3438 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3439 ff_wmv2_encode_picture_header(s, picture_number);
3440 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3441 ff_msmpeg4_encode_picture_header(s, picture_number);
3442 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3443 ff_mpeg4_encode_picture_header(s, picture_number);
3444 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3445 ret = ff_rv10_encode_picture_header(s, picture_number);
3449 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3450 ff_rv20_encode_picture_header(s, picture_number);
3451 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3452 ff_flv_encode_picture_header(s, picture_number);
3453 else if (CONFIG_H263_ENCODER)
3454 ff_h263_encode_picture_header(s, picture_number);
3457 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3458 ff_mpeg1_encode_picture_header(s, picture_number);
3463 bits= put_bits_count(&s->pb);
3464 s->header_bits= bits - s->last_bits;
3466 for(i=1; i<context_count; i++){
3467 update_duplicate_context_after_me(s->thread_context[i], s);
3469 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3470 for(i=1; i<context_count; i++){
3471 merge_context_after_encode(s, s->thread_context[i]);
3477 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3478 const int intra= s->mb_intra;
3481 s->dct_count[intra]++;
3483 for(i=0; i<64; i++){
3484 int level= block[i];
3488 s->dct_error_sum[intra][i] += level;
3489 level -= s->dct_offset[intra][i];
3490 if(level<0) level=0;
3492 s->dct_error_sum[intra][i] -= level;
3493 level += s->dct_offset[intra][i];
3494 if(level>0) level=0;
3501 static int dct_quantize_trellis_c(MpegEncContext *s,
3502 int16_t *block, int n,
3503 int qscale, int *overflow){
3505 const uint8_t *scantable= s->intra_scantable.scantable;
3506 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3508 unsigned int threshold1, threshold2;
3520 int coeff_count[64];
3521 int qmul, qadd, start_i, last_non_zero, i, dc;
3522 const int esc_length= s->ac_esc_length;
3524 uint8_t * last_length;
3525 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3527 s->fdsp.fdct(block);
3529 if(s->dct_error_sum)
3530 s->denoise_dct(s, block);
3532 qadd= ((qscale-1)|1)*8;
3543 /* For AIC we skip quant/dequant of INTRADC */
3548 /* note: block[0] is assumed to be positive */
3549 block[0] = (block[0] + (q >> 1)) / q;
3552 qmat = s->q_intra_matrix[qscale];
3553 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3554 bias= 1<<(QMAT_SHIFT-1);
3555 length = s->intra_ac_vlc_length;
3556 last_length= s->intra_ac_vlc_last_length;
3560 qmat = s->q_inter_matrix[qscale];
3561 length = s->inter_ac_vlc_length;
3562 last_length= s->inter_ac_vlc_last_length;
3566 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3567 threshold2= (threshold1<<1);
3569 for(i=63; i>=start_i; i--) {
3570 const int j = scantable[i];
3571 int level = block[j] * qmat[j];
3573 if(((unsigned)(level+threshold1))>threshold2){
3579 for(i=start_i; i<=last_non_zero; i++) {
3580 const int j = scantable[i];
3581 int level = block[j] * qmat[j];
3583 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3584 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3585 if(((unsigned)(level+threshold1))>threshold2){
3587 level= (bias + level)>>QMAT_SHIFT;
3589 coeff[1][i]= level-1;
3590 // coeff[2][k]= level-2;
3592 level= (bias - level)>>QMAT_SHIFT;
3593 coeff[0][i]= -level;
3594 coeff[1][i]= -level+1;
3595 // coeff[2][k]= -level+2;
3597 coeff_count[i]= FFMIN(level, 2);
3598 assert(coeff_count[i]);
3601 coeff[0][i]= (level>>31)|1;
3606 *overflow= s->max_qcoeff < max; //overflow might have happened
3608 if(last_non_zero < start_i){
3609 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3610 return last_non_zero;
3613 score_tab[start_i]= 0;
3614 survivor[0]= start_i;
3617 for(i=start_i; i<=last_non_zero; i++){
3618 int level_index, j, zero_distortion;
3619 int dct_coeff= FFABS(block[ scantable[i] ]);
3620 int best_score=256*256*256*120;
3622 if (s->fdsp.fdct == ff_fdct_ifast)
3623 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3624 zero_distortion= dct_coeff*dct_coeff;
3626 for(level_index=0; level_index < coeff_count[i]; level_index++){
3628 int level= coeff[level_index][i];
3629 const int alevel= FFABS(level);
3634 if(s->out_format == FMT_H263){
3635 unquant_coeff= alevel*qmul + qadd;
3637 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3639 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3640 unquant_coeff = (unquant_coeff - 1) | 1;
3642 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3643 unquant_coeff = (unquant_coeff - 1) | 1;
3648 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3650 if((level&(~127)) == 0){
3651 for(j=survivor_count-1; j>=0; j--){
3652 int run= i - survivor[j];
3653 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3654 score += score_tab[i-run];
3656 if(score < best_score){
3659 level_tab[i+1]= level-64;
3663 if(s->out_format == FMT_H263){
3664 for(j=survivor_count-1; j>=0; j--){
3665 int run= i - survivor[j];
3666 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3667 score += score_tab[i-run];
3668 if(score < last_score){
3671 last_level= level-64;
3677 distortion += esc_length*lambda;
3678 for(j=survivor_count-1; j>=0; j--){
3679 int run= i - survivor[j];
3680 int score= distortion + score_tab[i-run];
3682 if(score < best_score){
3685 level_tab[i+1]= level-64;
3689 if(s->out_format == FMT_H263){
3690 for(j=survivor_count-1; j>=0; j--){
3691 int run= i - survivor[j];
3692 int score= distortion + score_tab[i-run];
3693 if(score < last_score){
3696 last_level= level-64;
3704 score_tab[i+1]= best_score;
3706 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3707 if(last_non_zero <= 27){
3708 for(; survivor_count; survivor_count--){
3709 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3713 for(; survivor_count; survivor_count--){
3714 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3719 survivor[ survivor_count++ ]= i+1;
3722 if(s->out_format != FMT_H263){
3723 last_score= 256*256*256*120;
3724 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3725 int score= score_tab[i];
3726 if(i) score += lambda*2; //FIXME exacter?
3728 if(score < last_score){
3731 last_level= level_tab[i];
3732 last_run= run_tab[i];
3737 s->coded_score[n] = last_score;
3739 dc= FFABS(block[0]);
3740 last_non_zero= last_i - 1;
3741 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3743 if(last_non_zero < start_i)
3744 return last_non_zero;
3746 if(last_non_zero == 0 && start_i == 0){
3748 int best_score= dc * dc;
3750 for(i=0; i<coeff_count[0]; i++){
3751 int level= coeff[i][0];
3752 int alevel= FFABS(level);
3753 int unquant_coeff, score, distortion;
3755 if(s->out_format == FMT_H263){
3756 unquant_coeff= (alevel*qmul + qadd)>>3;
3758 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3759 unquant_coeff = (unquant_coeff - 1) | 1;
3761 unquant_coeff = (unquant_coeff + 4) >> 3;
3762 unquant_coeff<<= 3 + 3;
3764 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3766 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3767 else score= distortion + esc_length*lambda;
3769 if(score < best_score){
3771 best_level= level - 64;
3774 block[0]= best_level;
3775 s->coded_score[n] = best_score - dc*dc;
3776 if(best_level == 0) return -1;
3777 else return last_non_zero;
3783 block[ perm_scantable[last_non_zero] ]= last_level;
3786 for(; i>start_i; i -= run_tab[i] + 1){
3787 block[ perm_scantable[i-1] ]= level_tab[i];
3790 return last_non_zero;
3793 //#define REFINE_STATS 1
3794 static int16_t basis[64][64];
3796 static void build_basis(uint8_t *perm){
3803 double s= 0.25*(1<<BASIS_SHIFT);
3805 int perm_index= perm[index];
3806 if(i==0) s*= sqrt(0.5);
3807 if(j==0) s*= sqrt(0.5);
3808 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)));
3815 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3816 int16_t *block, int16_t *weight, int16_t *orig,
3819 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3820 const uint8_t *scantable= s->intra_scantable.scantable;
3821 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3822 // unsigned int threshold1, threshold2;
3827 int qmul, qadd, start_i, last_non_zero, i, dc;
3829 uint8_t * last_length;
3831 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3834 static int after_last=0;
3835 static int to_zero=0;
3836 static int from_zero=0;
3839 static int messed_sign=0;
3842 if(basis[0][0] == 0)
3843 build_basis(s->idsp.idct_permutation);
3854 /* For AIC we skip quant/dequant of INTRADC */
3858 q <<= RECON_SHIFT-3;
3859 /* note: block[0] is assumed to be positive */
3861 // block[0] = (block[0] + (q >> 1)) / q;
3863 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3864 // bias= 1<<(QMAT_SHIFT-1);
3865 length = s->intra_ac_vlc_length;
3866 last_length= s->intra_ac_vlc_last_length;
3870 length = s->inter_ac_vlc_length;
3871 last_length= s->inter_ac_vlc_last_length;
3873 last_non_zero = s->block_last_index[n];
3878 dc += (1<<(RECON_SHIFT-1));
3879 for(i=0; i<64; i++){
3880 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3883 STOP_TIMER("memset rem[]")}
3886 for(i=0; i<64; i++){
3891 w= FFABS(weight[i]) + qns*one;
3892 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3895 // w=weight[i] = (63*qns + (w/2)) / w;
3901 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3907 for(i=start_i; i<=last_non_zero; i++){
3908 int j= perm_scantable[i];
3909 const int level= block[j];
3913 if(level<0) coeff= qmul*level - qadd;
3914 else coeff= qmul*level + qadd;
3915 run_tab[rle_index++]=run;
3918 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
3924 if(last_non_zero>0){
3925 STOP_TIMER("init rem[]")
3932 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
3935 int run2, best_unquant_change=0, analyze_gradient;
3939 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3941 if(analyze_gradient){
3945 for(i=0; i<64; i++){
3948 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3951 STOP_TIMER("rem*w*w")}
3961 const int level= block[0];
3962 int change, old_coeff;
3964 assert(s->mb_intra);
3968 for(change=-1; change<=1; change+=2){
3969 int new_level= level + change;
3970 int score, new_coeff;
3972 new_coeff= q*new_level;
3973 if(new_coeff >= 2048 || new_coeff < 0)
3976 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
3977 new_coeff - old_coeff);
3978 if(score<best_score){
3981 best_change= change;
3982 best_unquant_change= new_coeff - old_coeff;
3989 run2= run_tab[rle_index++];
3993 for(i=start_i; i<64; i++){
3994 int j= perm_scantable[i];
3995 const int level= block[j];
3996 int change, old_coeff;
3998 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4002 if(level<0) old_coeff= qmul*level - qadd;
4003 else old_coeff= qmul*level + qadd;
4004 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4008 assert(run2>=0 || i >= last_non_zero );
4011 for(change=-1; change<=1; change+=2){
4012 int new_level= level + change;
4013 int score, new_coeff, unquant_change;
4016 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4020 if(new_level<0) new_coeff= qmul*new_level - qadd;
4021 else new_coeff= qmul*new_level + qadd;
4022 if(new_coeff >= 2048 || new_coeff <= -2048)
4024 //FIXME check for overflow
4027 if(level < 63 && level > -63){
4028 if(i < last_non_zero)
4029 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4030 - length[UNI_AC_ENC_INDEX(run, level+64)];
4032 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4033 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4036 assert(FFABS(new_level)==1);
4038 if(analyze_gradient){
4039 int g= d1[ scantable[i] ];
4040 if(g && (g^new_level) >= 0)
4044 if(i < last_non_zero){
4045 int next_i= i + run2 + 1;
4046 int next_level= block[ perm_scantable[next_i] ] + 64;
4048 if(next_level&(~127))
4051 if(next_i < last_non_zero)
4052 score += length[UNI_AC_ENC_INDEX(run, 65)]
4053 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4054 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4056 score += length[UNI_AC_ENC_INDEX(run, 65)]
4057 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4058 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4060 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4062 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4063 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4069 assert(FFABS(level)==1);
4071 if(i < last_non_zero){
4072 int next_i= i + run2 + 1;
4073 int next_level= block[ perm_scantable[next_i] ] + 64;
4075 if(next_level&(~127))
4078 if(next_i < last_non_zero)
4079 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4080 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4081 - length[UNI_AC_ENC_INDEX(run, 65)];
4083 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4084 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4085 - length[UNI_AC_ENC_INDEX(run, 65)];
4087 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4089 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4090 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4097 unquant_change= new_coeff - old_coeff;
4098 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4100 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4102 if(score<best_score){
4105 best_change= change;
4106 best_unquant_change= unquant_change;
4110 prev_level= level + 64;
4111 if(prev_level&(~127))
4120 STOP_TIMER("iterative step")}
4124 int j= perm_scantable[ best_coeff ];
4126 block[j] += best_change;
4128 if(best_coeff > last_non_zero){
4129 last_non_zero= best_coeff;
4137 if(block[j] - best_change){
4138 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4150 for(; last_non_zero>=start_i; last_non_zero--){
4151 if(block[perm_scantable[last_non_zero]])
4157 if(256*256*256*64 % count == 0){
4158 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);
4163 for(i=start_i; i<=last_non_zero; i++){
4164 int j= perm_scantable[i];
4165 const int level= block[j];
4168 run_tab[rle_index++]=run;
4175 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4181 if(last_non_zero>0){
4182 STOP_TIMER("iterative search")
4187 return last_non_zero;
4190 int ff_dct_quantize_c(MpegEncContext *s,
4191 int16_t *block, int n,
4192 int qscale, int *overflow)
4194 int i, j, level, last_non_zero, q, start_i;
4196 const uint8_t *scantable= s->intra_scantable.scantable;
4199 unsigned int threshold1, threshold2;
4201 s->fdsp.fdct(block);
4203 if(s->dct_error_sum)
4204 s->denoise_dct(s, block);
4214 /* For AIC we skip quant/dequant of INTRADC */
4217 /* note: block[0] is assumed to be positive */
4218 block[0] = (block[0] + (q >> 1)) / q;
4221 qmat = s->q_intra_matrix[qscale];
4222 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4226 qmat = s->q_inter_matrix[qscale];
4227 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4229 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4230 threshold2= (threshold1<<1);
4231 for(i=63;i>=start_i;i--) {
4233 level = block[j] * qmat[j];
4235 if(((unsigned)(level+threshold1))>threshold2){
4242 for(i=start_i; i<=last_non_zero; i++) {
4244 level = block[j] * qmat[j];
4246 // if( bias+level >= (1<<QMAT_SHIFT)
4247 // || bias-level >= (1<<QMAT_SHIFT)){
4248 if(((unsigned)(level+threshold1))>threshold2){
4250 level= (bias + level)>>QMAT_SHIFT;
4253 level= (bias - level)>>QMAT_SHIFT;
4261 *overflow= s->max_qcoeff < max; //overflow might have happened
4263 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4264 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4265 ff_block_permute(block, s->idsp.idct_permutation,
4266 scantable, last_non_zero);
4268 return last_non_zero;
4271 #define OFFSET(x) offsetof(MpegEncContext, x)
4272 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4273 static const AVOption h263_options[] = {
4274 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4275 { "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},
4276 { "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 },
4281 static const AVClass h263_class = {
4282 .class_name = "H.263 encoder",
4283 .item_name = av_default_item_name,
4284 .option = h263_options,
4285 .version = LIBAVUTIL_VERSION_INT,
4288 AVCodec ff_h263_encoder = {
4290 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4291 .type = AVMEDIA_TYPE_VIDEO,
4292 .id = AV_CODEC_ID_H263,
4293 .priv_data_size = sizeof(MpegEncContext),
4294 .init = ff_mpv_encode_init,
4295 .encode2 = ff_mpv_encode_picture,
4296 .close = ff_mpv_encode_end,
4297 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4298 .priv_class = &h263_class,
4301 static const AVOption h263p_options[] = {
4302 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4303 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4304 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4305 { "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},
4309 static const AVClass h263p_class = {
4310 .class_name = "H.263p encoder",
4311 .item_name = av_default_item_name,
4312 .option = h263p_options,
4313 .version = LIBAVUTIL_VERSION_INT,
4316 AVCodec ff_h263p_encoder = {
4318 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4319 .type = AVMEDIA_TYPE_VIDEO,
4320 .id = AV_CODEC_ID_H263P,
4321 .priv_data_size = sizeof(MpegEncContext),
4322 .init = ff_mpv_encode_init,
4323 .encode2 = ff_mpv_encode_picture,
4324 .close = ff_mpv_encode_end,
4325 .capabilities = CODEC_CAP_SLICE_THREADS,
4326 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4327 .priv_class = &h263p_class,
4330 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4332 AVCodec ff_msmpeg4v2_encoder = {
4333 .name = "msmpeg4v2",
4334 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4335 .type = AVMEDIA_TYPE_VIDEO,
4336 .id = AV_CODEC_ID_MSMPEG4V2,
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 = &msmpeg4v2_class,
4345 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4347 AVCodec ff_msmpeg4v3_encoder = {
4349 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4350 .type = AVMEDIA_TYPE_VIDEO,
4351 .id = AV_CODEC_ID_MSMPEG4V3,
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 = &msmpeg4v3_class,
4360 FF_MPV_GENERIC_CLASS(wmv1)
4362 AVCodec ff_wmv1_encoder = {
4364 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4365 .type = AVMEDIA_TYPE_VIDEO,
4366 .id = AV_CODEC_ID_WMV1,
4367 .priv_data_size = sizeof(MpegEncContext),
4368 .init = ff_mpv_encode_init,
4369 .encode2 = ff_mpv_encode_picture,
4370 .close = ff_mpv_encode_end,
4371 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4372 .priv_class = &wmv1_class,