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"
43 #include "mpegvideodata.h"
46 #include "mjpegenc_common.h"
48 #include "mpegutils.h"
51 #include "pixblockdsp.h"
55 #include "aandcttab.h"
57 #include "mpeg4video.h"
59 #include "bytestream.h"
63 #define QUANT_BIAS_SHIFT 8
65 #define QMAT_SHIFT_MMX 16
68 static int encode_picture(MpegEncContext *s, int picture_number);
69 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
70 static int sse_mb(MpegEncContext *s);
71 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
72 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
74 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
75 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
77 const AVOption ff_mpv_generic_options[] = {
82 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
83 uint16_t (*qmat16)[2][64],
84 const uint16_t *quant_matrix,
85 int bias, int qmin, int qmax, int intra)
87 FDCTDSPContext *fdsp = &s->fdsp;
91 for (qscale = qmin; qscale <= qmax; qscale++) {
93 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
95 fdsp->fdct == ff_faandct ||
96 #endif /* CONFIG_FAANDCT */
97 fdsp->fdct == ff_jpeg_fdct_islow_10) {
98 for (i = 0; i < 64; i++) {
99 const int j = s->idsp.idct_permutation[i];
100 int64_t den = (int64_t) qscale * quant_matrix[j];
101 /* 16 <= qscale * quant_matrix[i] <= 7905
102 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
103 * 19952 <= x <= 249205026
104 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
105 * 3444240 >= (1 << 36) / (x) >= 275 */
107 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
109 } else if (fdsp->fdct == ff_fdct_ifast) {
110 for (i = 0; i < 64; i++) {
111 const int j = s->idsp.idct_permutation[i];
112 int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
113 /* 16 <= qscale * quant_matrix[i] <= 7905
114 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
115 * 19952 <= x <= 249205026
116 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
117 * 3444240 >= (1 << 36) / (x) >= 275 */
119 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
122 for (i = 0; i < 64; i++) {
123 const int j = s->idsp.idct_permutation[i];
124 int64_t den = (int64_t) qscale * quant_matrix[j];
125 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
126 * Assume x = qscale * quant_matrix[i]
128 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
129 * so 32768 >= (1 << 19) / (x) >= 67 */
130 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
131 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
132 // (qscale * quant_matrix[i]);
133 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
135 if (qmat16[qscale][0][i] == 0 ||
136 qmat16[qscale][0][i] == 128 * 256)
137 qmat16[qscale][0][i] = 128 * 256 - 1;
138 qmat16[qscale][1][i] =
139 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
140 qmat16[qscale][0][i]);
144 for (i = intra; i < 64; i++) {
146 if (fdsp->fdct == ff_fdct_ifast) {
147 max = (8191LL * ff_aanscales[i]) >> 14;
149 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
155 av_log(NULL, AV_LOG_INFO,
156 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
161 static inline void update_qscale(MpegEncContext *s)
163 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
164 (FF_LAMBDA_SHIFT + 7);
165 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
167 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
171 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
177 for (i = 0; i < 64; i++) {
178 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
185 * init s->current_picture.qscale_table from s->lambda_table
187 void ff_init_qscale_tab(MpegEncContext *s)
189 int8_t * const qscale_table = s->current_picture.qscale_table;
192 for (i = 0; i < s->mb_num; i++) {
193 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
194 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
195 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
200 static void update_duplicate_context_after_me(MpegEncContext *dst,
203 #define COPY(a) dst->a= src->a
205 COPY(current_picture);
211 COPY(picture_in_gop_number);
212 COPY(gop_picture_number);
213 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
214 COPY(progressive_frame); // FIXME don't set in encode_header
215 COPY(partitioned_frame); // FIXME don't set in encode_header
220 * Set the given MpegEncContext to defaults for encoding.
221 * the changed fields will not depend upon the prior state of the MpegEncContext.
223 static void mpv_encode_defaults(MpegEncContext *s)
226 ff_mpv_common_defaults(s);
228 for (i = -16; i < 16; i++) {
229 default_fcode_tab[i + MAX_MV] = 1;
231 s->me.mv_penalty = default_mv_penalty;
232 s->fcode_tab = default_fcode_tab;
234 s->input_picture_number = 0;
235 s->picture_in_gop_number = 0;
238 /* init video encoder */
239 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
241 MpegEncContext *s = avctx->priv_data;
242 int i, ret, format_supported;
244 mpv_encode_defaults(s);
246 switch (avctx->codec_id) {
247 case AV_CODEC_ID_MPEG2VIDEO:
248 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
249 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
250 av_log(avctx, AV_LOG_ERROR,
251 "only YUV420 and YUV422 are supported\n");
255 case AV_CODEC_ID_MJPEG:
256 format_supported = 0;
257 /* JPEG color space */
258 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
259 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
260 (avctx->color_range == AVCOL_RANGE_JPEG &&
261 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
262 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
263 format_supported = 1;
264 /* MPEG color space */
265 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
266 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
267 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
268 format_supported = 1;
270 if (!format_supported) {
271 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
276 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
277 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
282 switch (avctx->pix_fmt) {
283 case AV_PIX_FMT_YUVJ422P:
284 case AV_PIX_FMT_YUV422P:
285 s->chroma_format = CHROMA_422;
287 case AV_PIX_FMT_YUVJ420P:
288 case AV_PIX_FMT_YUV420P:
290 s->chroma_format = CHROMA_420;
294 s->bit_rate = avctx->bit_rate;
295 s->width = avctx->width;
296 s->height = avctx->height;
297 if (avctx->gop_size > 600 &&
298 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
299 av_log(avctx, AV_LOG_ERROR,
300 "Warning keyframe interval too large! reducing it ...\n");
301 avctx->gop_size = 600;
303 s->gop_size = avctx->gop_size;
305 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->avctx->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->avctx->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->avctx->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->avctx->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->avctx->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->avctx->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->avctx->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->avctx, &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 ff_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->avctx, s->picture, direct);
1003 pic = &s->picture[i];
1007 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1010 ret = ff_alloc_picture(s, pic, direct);
1015 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1016 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1017 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1020 int h_chroma_shift, v_chroma_shift;
1021 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1025 for (i = 0; i < 3; i++) {
1026 int src_stride = pic_arg->linesize[i];
1027 int dst_stride = i ? s->uvlinesize : s->linesize;
1028 int h_shift = i ? h_chroma_shift : 0;
1029 int v_shift = i ? v_chroma_shift : 0;
1030 int w = s->width >> h_shift;
1031 int h = s->height >> v_shift;
1032 uint8_t *src = pic_arg->data[i];
1033 uint8_t *dst = pic->f->data[i];
1035 if (!s->avctx->rc_buffer_size)
1036 dst += INPLACE_OFFSET;
1038 if (src_stride == dst_stride)
1039 memcpy(dst, src, src_stride * h);
1042 uint8_t *dst2 = dst;
1044 memcpy(dst2, src, w);
1049 if ((s->width & 15) || (s->height & 15)) {
1050 s->mpvencdsp.draw_edges(dst, dst_stride,
1059 ret = av_frame_copy_props(pic->f, pic_arg);
1063 pic->f->display_picture_number = display_picture_number;
1064 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1067 /* shift buffer entries */
1068 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1069 s->input_picture[i - 1] = s->input_picture[i];
1071 s->input_picture[encoding_delay] = (Picture*) pic;
1076 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1080 int64_t score64 = 0;
1082 for (plane = 0; plane < 3; plane++) {
1083 const int stride = p->f->linesize[plane];
1084 const int bw = plane ? 1 : 2;
1085 for (y = 0; y < s->mb_height * bw; y++) {
1086 for (x = 0; x < s->mb_width * bw; x++) {
1087 int off = p->shared ? 0 : 16;
1088 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1089 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1090 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1092 switch (s->avctx->frame_skip_exp) {
1093 case 0: score = FFMAX(score, v); break;
1094 case 1: score += FFABS(v); break;
1095 case 2: score += v * v; break;
1096 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1097 case 4: score64 += v * v * (int64_t)(v * v); break;
1106 if (score64 < s->avctx->frame_skip_threshold)
1108 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1113 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1115 AVPacket pkt = { 0 };
1116 int ret, got_output;
1118 av_init_packet(&pkt);
1119 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1124 av_free_packet(&pkt);
1128 static int estimate_best_b_count(MpegEncContext *s)
1130 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1131 AVCodecContext *c = avcodec_alloc_context3(NULL);
1132 const int scale = s->avctx->brd_scale;
1133 int i, j, out_size, p_lambda, b_lambda, lambda2;
1134 int64_t best_rd = INT64_MAX;
1135 int best_b_count = -1;
1138 return AVERROR(ENOMEM);
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->avctx->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->avctx->flags & CODEC_FLAG_CLOSED_GOP)
1347 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1351 if ((s->avctx->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->avctx, &s->new_picture);
1376 if ((ret = ff_mpeg_ref_picture(s->avctx, &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->avctx, s->picture, 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->avctx, &s->current_picture);
1411 if ((ret = ff_mpeg_ref_picture(s->avctx, &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->avctx, &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->avctx, &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->avctx, 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->avctx, &s->current_picture);
1505 if ((ret = ff_mpeg_ref_picture(s->avctx, &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->avctx, &s->last_picture);
1517 if (s->last_picture_ptr->f->buf[0] &&
1518 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1519 s->last_picture_ptr)) < 0)
1522 if (s->next_picture_ptr) {
1523 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1524 if (s->next_picture_ptr->f->buf[0] &&
1525 (ret = ff_mpeg_ref_picture(s->avctx, &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->avctx->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->avctx->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->sc.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->avctx->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->avctx->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->avctx->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->avctx->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->avctx->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->sc.rd_scratchpad;
2332 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2333 s->dest[2] = s->sc.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->avctx->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 = H263_GOB_HEIGHT(s->height);
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->avctx->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->sc.rd_scratchpad , s->linesize ,16);
2986 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2987 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.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->avctx->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 ff_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->avctx->flags & CODEC_FLAG_PASS2) {
3285 if (estimate_qp(s,1) < 0)
3287 ff_get_2pass_fcode(s);
3288 } else if (!(s->avctx->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 ff_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->avctx->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->avctx->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->avctx->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 &&
3400 s->pict_type == AV_PICTURE_TYPE_I &&
3401 !(s->avctx->flags & CODEC_FLAG_QSCALE))
3402 s->qscale= 3; //reduce clipping problems
3404 if (s->out_format == FMT_MJPEG) {
3405 /* for mjpeg, we do include qscale in the matrix */
3407 int j = s->idsp.idct_permutation[i];
3409 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3411 s->y_dc_scale_table=
3412 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3413 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3414 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3415 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3419 //FIXME var duplication
3420 s->current_picture_ptr->f->key_frame =
3421 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3422 s->current_picture_ptr->f->pict_type =
3423 s->current_picture.f->pict_type = s->pict_type;
3425 if (s->current_picture.f->key_frame)
3426 s->picture_in_gop_number=0;
3428 s->last_bits= put_bits_count(&s->pb);
3429 switch(s->out_format) {
3431 if (CONFIG_MJPEG_ENCODER)
3432 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3436 if (CONFIG_H261_ENCODER)
3437 ff_h261_encode_picture_header(s, picture_number);
3440 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3441 ff_wmv2_encode_picture_header(s, picture_number);
3442 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3443 ff_msmpeg4_encode_picture_header(s, picture_number);
3444 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3445 ff_mpeg4_encode_picture_header(s, picture_number);
3446 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3447 ret = ff_rv10_encode_picture_header(s, picture_number);
3451 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3452 ff_rv20_encode_picture_header(s, picture_number);
3453 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3454 ff_flv_encode_picture_header(s, picture_number);
3455 else if (CONFIG_H263_ENCODER)
3456 ff_h263_encode_picture_header(s, picture_number);
3459 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3460 ff_mpeg1_encode_picture_header(s, picture_number);
3465 bits= put_bits_count(&s->pb);
3466 s->header_bits= bits - s->last_bits;
3468 for(i=1; i<context_count; i++){
3469 update_duplicate_context_after_me(s->thread_context[i], s);
3471 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3472 for(i=1; i<context_count; i++){
3473 merge_context_after_encode(s, s->thread_context[i]);
3479 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3480 const int intra= s->mb_intra;
3483 s->dct_count[intra]++;
3485 for(i=0; i<64; i++){
3486 int level= block[i];
3490 s->dct_error_sum[intra][i] += level;
3491 level -= s->dct_offset[intra][i];
3492 if(level<0) level=0;
3494 s->dct_error_sum[intra][i] -= level;
3495 level += s->dct_offset[intra][i];
3496 if(level>0) level=0;
3503 static int dct_quantize_trellis_c(MpegEncContext *s,
3504 int16_t *block, int n,
3505 int qscale, int *overflow){
3507 const uint8_t *scantable= s->intra_scantable.scantable;
3508 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3510 unsigned int threshold1, threshold2;
3522 int coeff_count[64];
3523 int qmul, qadd, start_i, last_non_zero, i, dc;
3524 const int esc_length= s->ac_esc_length;
3526 uint8_t * last_length;
3527 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3529 s->fdsp.fdct(block);
3531 if(s->dct_error_sum)
3532 s->denoise_dct(s, block);
3534 qadd= ((qscale-1)|1)*8;
3545 /* For AIC we skip quant/dequant of INTRADC */
3550 /* note: block[0] is assumed to be positive */
3551 block[0] = (block[0] + (q >> 1)) / q;
3554 qmat = s->q_intra_matrix[qscale];
3555 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3556 bias= 1<<(QMAT_SHIFT-1);
3557 length = s->intra_ac_vlc_length;
3558 last_length= s->intra_ac_vlc_last_length;
3562 qmat = s->q_inter_matrix[qscale];
3563 length = s->inter_ac_vlc_length;
3564 last_length= s->inter_ac_vlc_last_length;
3568 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3569 threshold2= (threshold1<<1);
3571 for(i=63; i>=start_i; i--) {
3572 const int j = scantable[i];
3573 int level = block[j] * qmat[j];
3575 if(((unsigned)(level+threshold1))>threshold2){
3581 for(i=start_i; i<=last_non_zero; i++) {
3582 const int j = scantable[i];
3583 int level = block[j] * qmat[j];
3585 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3586 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3587 if(((unsigned)(level+threshold1))>threshold2){
3589 level= (bias + level)>>QMAT_SHIFT;
3591 coeff[1][i]= level-1;
3592 // coeff[2][k]= level-2;
3594 level= (bias - level)>>QMAT_SHIFT;
3595 coeff[0][i]= -level;
3596 coeff[1][i]= -level+1;
3597 // coeff[2][k]= -level+2;
3599 coeff_count[i]= FFMIN(level, 2);
3600 assert(coeff_count[i]);
3603 coeff[0][i]= (level>>31)|1;
3608 *overflow= s->max_qcoeff < max; //overflow might have happened
3610 if(last_non_zero < start_i){
3611 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3612 return last_non_zero;
3615 score_tab[start_i]= 0;
3616 survivor[0]= start_i;
3619 for(i=start_i; i<=last_non_zero; i++){
3620 int level_index, j, zero_distortion;
3621 int dct_coeff= FFABS(block[ scantable[i] ]);
3622 int best_score=256*256*256*120;
3624 if (s->fdsp.fdct == ff_fdct_ifast)
3625 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3626 zero_distortion= dct_coeff*dct_coeff;
3628 for(level_index=0; level_index < coeff_count[i]; level_index++){
3630 int level= coeff[level_index][i];
3631 const int alevel= FFABS(level);
3636 if(s->out_format == FMT_H263){
3637 unquant_coeff= alevel*qmul + qadd;
3639 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3641 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3642 unquant_coeff = (unquant_coeff - 1) | 1;
3644 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3645 unquant_coeff = (unquant_coeff - 1) | 1;
3650 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3652 if((level&(~127)) == 0){
3653 for(j=survivor_count-1; j>=0; j--){
3654 int run= i - survivor[j];
3655 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3656 score += score_tab[i-run];
3658 if(score < best_score){
3661 level_tab[i+1]= level-64;
3665 if(s->out_format == FMT_H263){
3666 for(j=survivor_count-1; j>=0; j--){
3667 int run= i - survivor[j];
3668 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3669 score += score_tab[i-run];
3670 if(score < last_score){
3673 last_level= level-64;
3679 distortion += esc_length*lambda;
3680 for(j=survivor_count-1; j>=0; j--){
3681 int run= i - survivor[j];
3682 int score= distortion + score_tab[i-run];
3684 if(score < best_score){
3687 level_tab[i+1]= level-64;
3691 if(s->out_format == FMT_H263){
3692 for(j=survivor_count-1; j>=0; j--){
3693 int run= i - survivor[j];
3694 int score= distortion + score_tab[i-run];
3695 if(score < last_score){
3698 last_level= level-64;
3706 score_tab[i+1]= best_score;
3708 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3709 if(last_non_zero <= 27){
3710 for(; survivor_count; survivor_count--){
3711 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3715 for(; survivor_count; survivor_count--){
3716 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3721 survivor[ survivor_count++ ]= i+1;
3724 if(s->out_format != FMT_H263){
3725 last_score= 256*256*256*120;
3726 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3727 int score= score_tab[i];
3728 if(i) score += lambda*2; //FIXME exacter?
3730 if(score < last_score){
3733 last_level= level_tab[i];
3734 last_run= run_tab[i];
3739 s->coded_score[n] = last_score;
3741 dc= FFABS(block[0]);
3742 last_non_zero= last_i - 1;
3743 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3745 if(last_non_zero < start_i)
3746 return last_non_zero;
3748 if(last_non_zero == 0 && start_i == 0){
3750 int best_score= dc * dc;
3752 for(i=0; i<coeff_count[0]; i++){
3753 int level= coeff[i][0];
3754 int alevel= FFABS(level);
3755 int unquant_coeff, score, distortion;
3757 if(s->out_format == FMT_H263){
3758 unquant_coeff= (alevel*qmul + qadd)>>3;
3760 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3761 unquant_coeff = (unquant_coeff - 1) | 1;
3763 unquant_coeff = (unquant_coeff + 4) >> 3;
3764 unquant_coeff<<= 3 + 3;
3766 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3768 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3769 else score= distortion + esc_length*lambda;
3771 if(score < best_score){
3773 best_level= level - 64;
3776 block[0]= best_level;
3777 s->coded_score[n] = best_score - dc*dc;
3778 if(best_level == 0) return -1;
3779 else return last_non_zero;
3785 block[ perm_scantable[last_non_zero] ]= last_level;
3788 for(; i>start_i; i -= run_tab[i] + 1){
3789 block[ perm_scantable[i-1] ]= level_tab[i];
3792 return last_non_zero;
3795 //#define REFINE_STATS 1
3796 static int16_t basis[64][64];
3798 static void build_basis(uint8_t *perm){
3805 double s= 0.25*(1<<BASIS_SHIFT);
3807 int perm_index= perm[index];
3808 if(i==0) s*= sqrt(0.5);
3809 if(j==0) s*= sqrt(0.5);
3810 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)));
3817 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3818 int16_t *block, int16_t *weight, int16_t *orig,
3821 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3822 const uint8_t *scantable= s->intra_scantable.scantable;
3823 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3824 // unsigned int threshold1, threshold2;
3829 int qmul, qadd, start_i, last_non_zero, i, dc;
3831 uint8_t * last_length;
3833 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3836 static int after_last=0;
3837 static int to_zero=0;
3838 static int from_zero=0;
3841 static int messed_sign=0;
3844 if(basis[0][0] == 0)
3845 build_basis(s->idsp.idct_permutation);
3856 /* For AIC we skip quant/dequant of INTRADC */
3860 q <<= RECON_SHIFT-3;
3861 /* note: block[0] is assumed to be positive */
3863 // block[0] = (block[0] + (q >> 1)) / q;
3865 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3866 // bias= 1<<(QMAT_SHIFT-1);
3867 length = s->intra_ac_vlc_length;
3868 last_length= s->intra_ac_vlc_last_length;
3872 length = s->inter_ac_vlc_length;
3873 last_length= s->inter_ac_vlc_last_length;
3875 last_non_zero = s->block_last_index[n];
3880 dc += (1<<(RECON_SHIFT-1));
3881 for(i=0; i<64; i++){
3882 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3885 STOP_TIMER("memset rem[]")}
3888 for(i=0; i<64; i++){
3893 w= FFABS(weight[i]) + qns*one;
3894 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3897 // w=weight[i] = (63*qns + (w/2)) / w;
3903 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3909 for(i=start_i; i<=last_non_zero; i++){
3910 int j= perm_scantable[i];
3911 const int level= block[j];
3915 if(level<0) coeff= qmul*level - qadd;
3916 else coeff= qmul*level + qadd;
3917 run_tab[rle_index++]=run;
3920 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
3926 if(last_non_zero>0){
3927 STOP_TIMER("init rem[]")
3934 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
3937 int run2, best_unquant_change=0, analyze_gradient;
3941 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3943 if(analyze_gradient){
3947 for(i=0; i<64; i++){
3950 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3953 STOP_TIMER("rem*w*w")}
3963 const int level= block[0];
3964 int change, old_coeff;
3966 assert(s->mb_intra);
3970 for(change=-1; change<=1; change+=2){
3971 int new_level= level + change;
3972 int score, new_coeff;
3974 new_coeff= q*new_level;
3975 if(new_coeff >= 2048 || new_coeff < 0)
3978 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
3979 new_coeff - old_coeff);
3980 if(score<best_score){
3983 best_change= change;
3984 best_unquant_change= new_coeff - old_coeff;
3991 run2= run_tab[rle_index++];
3995 for(i=start_i; i<64; i++){
3996 int j= perm_scantable[i];
3997 const int level= block[j];
3998 int change, old_coeff;
4000 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4004 if(level<0) old_coeff= qmul*level - qadd;
4005 else old_coeff= qmul*level + qadd;
4006 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4010 assert(run2>=0 || i >= last_non_zero );
4013 for(change=-1; change<=1; change+=2){
4014 int new_level= level + change;
4015 int score, new_coeff, unquant_change;
4018 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4022 if(new_level<0) new_coeff= qmul*new_level - qadd;
4023 else new_coeff= qmul*new_level + qadd;
4024 if(new_coeff >= 2048 || new_coeff <= -2048)
4026 //FIXME check for overflow
4029 if(level < 63 && level > -63){
4030 if(i < last_non_zero)
4031 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4032 - length[UNI_AC_ENC_INDEX(run, level+64)];
4034 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4035 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4038 assert(FFABS(new_level)==1);
4040 if(analyze_gradient){
4041 int g= d1[ scantable[i] ];
4042 if(g && (g^new_level) >= 0)
4046 if(i < last_non_zero){
4047 int next_i= i + run2 + 1;
4048 int next_level= block[ perm_scantable[next_i] ] + 64;
4050 if(next_level&(~127))
4053 if(next_i < last_non_zero)
4054 score += length[UNI_AC_ENC_INDEX(run, 65)]
4055 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4056 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4058 score += length[UNI_AC_ENC_INDEX(run, 65)]
4059 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4060 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4062 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4064 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4065 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4071 assert(FFABS(level)==1);
4073 if(i < last_non_zero){
4074 int next_i= i + run2 + 1;
4075 int next_level= block[ perm_scantable[next_i] ] + 64;
4077 if(next_level&(~127))
4080 if(next_i < last_non_zero)
4081 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4082 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4083 - length[UNI_AC_ENC_INDEX(run, 65)];
4085 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4086 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4087 - length[UNI_AC_ENC_INDEX(run, 65)];
4089 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4091 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4092 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4099 unquant_change= new_coeff - old_coeff;
4100 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4102 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4104 if(score<best_score){
4107 best_change= change;
4108 best_unquant_change= unquant_change;
4112 prev_level= level + 64;
4113 if(prev_level&(~127))
4122 STOP_TIMER("iterative step")}
4126 int j= perm_scantable[ best_coeff ];
4128 block[j] += best_change;
4130 if(best_coeff > last_non_zero){
4131 last_non_zero= best_coeff;
4139 if(block[j] - best_change){
4140 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4152 for(; last_non_zero>=start_i; last_non_zero--){
4153 if(block[perm_scantable[last_non_zero]])
4159 if(256*256*256*64 % count == 0){
4160 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);
4165 for(i=start_i; i<=last_non_zero; i++){
4166 int j= perm_scantable[i];
4167 const int level= block[j];
4170 run_tab[rle_index++]=run;
4177 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4183 if(last_non_zero>0){
4184 STOP_TIMER("iterative search")
4189 return last_non_zero;
4192 int ff_dct_quantize_c(MpegEncContext *s,
4193 int16_t *block, int n,
4194 int qscale, int *overflow)
4196 int i, j, level, last_non_zero, q, start_i;
4198 const uint8_t *scantable= s->intra_scantable.scantable;
4201 unsigned int threshold1, threshold2;
4203 s->fdsp.fdct(block);
4205 if(s->dct_error_sum)
4206 s->denoise_dct(s, block);
4216 /* For AIC we skip quant/dequant of INTRADC */
4219 /* note: block[0] is assumed to be positive */
4220 block[0] = (block[0] + (q >> 1)) / q;
4223 qmat = s->q_intra_matrix[qscale];
4224 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4228 qmat = s->q_inter_matrix[qscale];
4229 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4231 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4232 threshold2= (threshold1<<1);
4233 for(i=63;i>=start_i;i--) {
4235 level = block[j] * qmat[j];
4237 if(((unsigned)(level+threshold1))>threshold2){
4244 for(i=start_i; i<=last_non_zero; i++) {
4246 level = block[j] * qmat[j];
4248 // if( bias+level >= (1<<QMAT_SHIFT)
4249 // || bias-level >= (1<<QMAT_SHIFT)){
4250 if(((unsigned)(level+threshold1))>threshold2){
4252 level= (bias + level)>>QMAT_SHIFT;
4255 level= (bias - level)>>QMAT_SHIFT;
4263 *overflow= s->max_qcoeff < max; //overflow might have happened
4265 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4266 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4267 ff_block_permute(block, s->idsp.idct_permutation,
4268 scantable, last_non_zero);
4270 return last_non_zero;
4273 #define OFFSET(x) offsetof(MpegEncContext, x)
4274 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4275 static const AVOption h263_options[] = {
4276 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4277 { "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},
4278 { "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 },
4283 static const AVClass h263_class = {
4284 .class_name = "H.263 encoder",
4285 .item_name = av_default_item_name,
4286 .option = h263_options,
4287 .version = LIBAVUTIL_VERSION_INT,
4290 AVCodec ff_h263_encoder = {
4292 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4293 .type = AVMEDIA_TYPE_VIDEO,
4294 .id = AV_CODEC_ID_H263,
4295 .priv_data_size = sizeof(MpegEncContext),
4296 .init = ff_mpv_encode_init,
4297 .encode2 = ff_mpv_encode_picture,
4298 .close = ff_mpv_encode_end,
4299 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4300 .priv_class = &h263_class,
4303 static const AVOption h263p_options[] = {
4304 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4305 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4306 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4307 { "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},
4311 static const AVClass h263p_class = {
4312 .class_name = "H.263p encoder",
4313 .item_name = av_default_item_name,
4314 .option = h263p_options,
4315 .version = LIBAVUTIL_VERSION_INT,
4318 AVCodec ff_h263p_encoder = {
4320 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4321 .type = AVMEDIA_TYPE_VIDEO,
4322 .id = AV_CODEC_ID_H263P,
4323 .priv_data_size = sizeof(MpegEncContext),
4324 .init = ff_mpv_encode_init,
4325 .encode2 = ff_mpv_encode_picture,
4326 .close = ff_mpv_encode_end,
4327 .capabilities = CODEC_CAP_SLICE_THREADS,
4328 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4329 .priv_class = &h263p_class,
4332 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4334 AVCodec ff_msmpeg4v2_encoder = {
4335 .name = "msmpeg4v2",
4336 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4337 .type = AVMEDIA_TYPE_VIDEO,
4338 .id = AV_CODEC_ID_MSMPEG4V2,
4339 .priv_data_size = sizeof(MpegEncContext),
4340 .init = ff_mpv_encode_init,
4341 .encode2 = ff_mpv_encode_picture,
4342 .close = ff_mpv_encode_end,
4343 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4344 .priv_class = &msmpeg4v2_class,
4347 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4349 AVCodec ff_msmpeg4v3_encoder = {
4351 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4352 .type = AVMEDIA_TYPE_VIDEO,
4353 .id = AV_CODEC_ID_MSMPEG4V3,
4354 .priv_data_size = sizeof(MpegEncContext),
4355 .init = ff_mpv_encode_init,
4356 .encode2 = ff_mpv_encode_picture,
4357 .close = ff_mpv_encode_end,
4358 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4359 .priv_class = &msmpeg4v3_class,
4362 FF_MPV_GENERIC_CLASS(wmv1)
4364 AVCodec ff_wmv1_encoder = {
4366 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4367 .type = AVMEDIA_TYPE_VIDEO,
4368 .id = AV_CODEC_ID_WMV1,
4369 .priv_data_size = sizeof(MpegEncContext),
4370 .init = ff_mpv_encode_init,
4371 .encode2 = ff_mpv_encode_picture,
4372 .close = ff_mpv_encode_end,
4373 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4374 .priv_class = &wmv1_class,