2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of Libav.
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "libavutil/internal.h"
33 #include "libavutil/intmath.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/timer.h"
42 #include "mpegvideo.h"
45 #include "mjpegenc_common.h"
47 #include "mpegutils.h"
50 #include "pixblockdsp.h"
54 #include "aandcttab.h"
56 #include "mpeg4video.h"
58 #include "bytestream.h"
61 #define QUANT_BIAS_SHIFT 8
63 #define QMAT_SHIFT_MMX 16
66 static int encode_picture(MpegEncContext *s, int picture_number);
67 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
68 static int sse_mb(MpegEncContext *s);
69 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
70 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
72 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
73 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
75 const AVOption ff_mpv_generic_options[] = {
80 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
81 uint16_t (*qmat16)[2][64],
82 const uint16_t *quant_matrix,
83 int bias, int qmin, int qmax, int intra)
85 FDCTDSPContext *fdsp = &s->fdsp;
89 for (qscale = qmin; qscale <= qmax; qscale++) {
91 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
93 fdsp->fdct == ff_faandct ||
94 #endif /* CONFIG_FAANDCT */
95 fdsp->fdct == ff_jpeg_fdct_islow_10) {
96 for (i = 0; i < 64; i++) {
97 const int j = s->idsp.idct_permutation[i];
98 int64_t den = (int64_t) qscale * quant_matrix[j];
99 /* 16 <= qscale * quant_matrix[i] <= 7905
100 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101 * 19952 <= x <= 249205026
102 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103 * 3444240 >= (1 << 36) / (x) >= 275 */
105 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
107 } else if (fdsp->fdct == ff_fdct_ifast) {
108 for (i = 0; i < 64; i++) {
109 const int j = s->idsp.idct_permutation[i];
110 int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
111 /* 16 <= qscale * quant_matrix[i] <= 7905
112 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
113 * 19952 <= x <= 249205026
114 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
115 * 3444240 >= (1 << 36) / (x) >= 275 */
117 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
120 for (i = 0; i < 64; i++) {
121 const int j = s->idsp.idct_permutation[i];
122 int64_t den = (int64_t) qscale * quant_matrix[j];
123 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
124 * Assume x = qscale * quant_matrix[i]
126 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
127 * so 32768 >= (1 << 19) / (x) >= 67 */
128 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
129 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
130 // (qscale * quant_matrix[i]);
131 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
133 if (qmat16[qscale][0][i] == 0 ||
134 qmat16[qscale][0][i] == 128 * 256)
135 qmat16[qscale][0][i] = 128 * 256 - 1;
136 qmat16[qscale][1][i] =
137 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
138 qmat16[qscale][0][i]);
142 for (i = intra; i < 64; i++) {
144 if (fdsp->fdct == ff_fdct_ifast) {
145 max = (8191LL * ff_aanscales[i]) >> 14;
147 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
153 av_log(NULL, AV_LOG_INFO,
154 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
159 static inline void update_qscale(MpegEncContext *s)
161 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
162 (FF_LAMBDA_SHIFT + 7);
163 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
165 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
169 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
175 for (i = 0; i < 64; i++) {
176 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
183 * init s->current_picture.qscale_table from s->lambda_table
185 void ff_init_qscale_tab(MpegEncContext *s)
187 int8_t * const qscale_table = s->current_picture.qscale_table;
190 for (i = 0; i < s->mb_num; i++) {
191 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
192 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
193 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
198 static void update_duplicate_context_after_me(MpegEncContext *dst,
201 #define COPY(a) dst->a= src->a
203 COPY(current_picture);
209 COPY(picture_in_gop_number);
210 COPY(gop_picture_number);
211 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
212 COPY(progressive_frame); // FIXME don't set in encode_header
213 COPY(partitioned_frame); // FIXME don't set in encode_header
218 * Set the given MpegEncContext to defaults for encoding.
219 * the changed fields will not depend upon the prior state of the MpegEncContext.
221 static void mpv_encode_defaults(MpegEncContext *s)
224 ff_mpv_common_defaults(s);
226 for (i = -16; i < 16; i++) {
227 default_fcode_tab[i + MAX_MV] = 1;
229 s->me.mv_penalty = default_mv_penalty;
230 s->fcode_tab = default_fcode_tab;
232 s->input_picture_number = 0;
233 s->picture_in_gop_number = 0;
236 /* init video encoder */
237 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
239 MpegEncContext *s = avctx->priv_data;
240 int i, ret, format_supported;
242 mpv_encode_defaults(s);
244 switch (avctx->codec_id) {
245 case AV_CODEC_ID_MPEG2VIDEO:
246 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
247 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
248 av_log(avctx, AV_LOG_ERROR,
249 "only YUV420 and YUV422 are supported\n");
253 case AV_CODEC_ID_MJPEG:
254 format_supported = 0;
255 /* JPEG color space */
256 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
257 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
258 (avctx->color_range == AVCOL_RANGE_JPEG &&
259 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
260 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
261 format_supported = 1;
262 /* MPEG color space */
263 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
264 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
265 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
266 format_supported = 1;
268 if (!format_supported) {
269 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
274 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
275 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
280 switch (avctx->pix_fmt) {
281 case AV_PIX_FMT_YUVJ422P:
282 case AV_PIX_FMT_YUV422P:
283 s->chroma_format = CHROMA_422;
285 case AV_PIX_FMT_YUVJ420P:
286 case AV_PIX_FMT_YUV420P:
288 s->chroma_format = CHROMA_420;
292 s->bit_rate = avctx->bit_rate;
293 s->width = avctx->width;
294 s->height = avctx->height;
295 if (avctx->gop_size > 600 &&
296 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
297 av_log(avctx, AV_LOG_ERROR,
298 "Warning keyframe interval too large! reducing it ...\n");
299 avctx->gop_size = 600;
301 s->gop_size = avctx->gop_size;
303 if (avctx->max_b_frames > MAX_B_FRAMES) {
304 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
305 "is %d.\n", MAX_B_FRAMES);
307 s->max_b_frames = avctx->max_b_frames;
308 s->codec_id = avctx->codec->id;
309 s->strict_std_compliance = avctx->strict_std_compliance;
310 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
311 s->mpeg_quant = avctx->mpeg_quant;
312 s->rtp_mode = !!avctx->rtp_payload_size;
313 s->intra_dc_precision = avctx->intra_dc_precision;
314 s->user_specified_pts = AV_NOPTS_VALUE;
316 if (s->gop_size <= 1) {
323 s->me_method = avctx->me_method;
326 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
329 FF_DISABLE_DEPRECATION_WARNINGS
330 if (avctx->border_masking != 0.0)
331 s->border_masking = avctx->border_masking;
332 FF_ENABLE_DEPRECATION_WARNINGS
335 s->adaptive_quant = (s->avctx->lumi_masking ||
336 s->avctx->dark_masking ||
337 s->avctx->temporal_cplx_masking ||
338 s->avctx->spatial_cplx_masking ||
339 s->avctx->p_masking ||
341 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
344 s->loop_filter = !!(s->avctx->flags & CODEC_FLAG_LOOP_FILTER);
346 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
347 av_log(avctx, AV_LOG_ERROR,
348 "a vbv buffer size is needed, "
349 "for encoding with a maximum bitrate\n");
353 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
354 av_log(avctx, AV_LOG_INFO,
355 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
358 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
359 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
363 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
364 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
368 if (avctx->rc_max_rate &&
369 avctx->rc_max_rate == avctx->bit_rate &&
370 avctx->rc_max_rate != avctx->rc_min_rate) {
371 av_log(avctx, AV_LOG_INFO,
372 "impossible bitrate constraints, this will fail\n");
375 if (avctx->rc_buffer_size &&
376 avctx->bit_rate * (int64_t)avctx->time_base.num >
377 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
378 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
382 if (!s->fixed_qscale &&
383 avctx->bit_rate * av_q2d(avctx->time_base) >
384 avctx->bit_rate_tolerance) {
385 av_log(avctx, AV_LOG_ERROR,
386 "bitrate tolerance too small for bitrate\n");
390 if (s->avctx->rc_max_rate &&
391 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
392 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
393 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
394 90000LL * (avctx->rc_buffer_size - 1) >
395 s->avctx->rc_max_rate * 0xFFFFLL) {
396 av_log(avctx, AV_LOG_INFO,
397 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
398 "specified vbv buffer is too large for the given bitrate!\n");
401 if ((s->avctx->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
402 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
403 s->codec_id != AV_CODEC_ID_FLV1) {
404 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
408 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
409 av_log(avctx, AV_LOG_ERROR,
410 "OBMC is only supported with simple mb decision\n");
414 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
415 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
419 if (s->max_b_frames &&
420 s->codec_id != AV_CODEC_ID_MPEG4 &&
421 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
422 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
423 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
427 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
428 s->codec_id == AV_CODEC_ID_H263 ||
429 s->codec_id == AV_CODEC_ID_H263P) &&
430 (avctx->sample_aspect_ratio.num > 255 ||
431 avctx->sample_aspect_ratio.den > 255)) {
432 av_log(avctx, AV_LOG_ERROR,
433 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
434 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
438 if ((s->avctx->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
439 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
440 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
444 // FIXME mpeg2 uses that too
445 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
446 av_log(avctx, AV_LOG_ERROR,
447 "mpeg2 style quantization not supported by codec\n");
451 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
452 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
456 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
457 s->avctx->mb_decision != FF_MB_DECISION_RD) {
458 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
462 if (s->avctx->scenechange_threshold < 1000000000 &&
463 (s->avctx->flags & CODEC_FLAG_CLOSED_GOP)) {
464 av_log(avctx, AV_LOG_ERROR,
465 "closed gop with scene change detection are not supported yet, "
466 "set threshold to 1000000000\n");
470 if (s->avctx->flags & CODEC_FLAG_LOW_DELAY) {
471 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
472 av_log(avctx, AV_LOG_ERROR,
473 "low delay forcing is only available for mpeg2\n");
476 if (s->max_b_frames != 0) {
477 av_log(avctx, AV_LOG_ERROR,
478 "b frames cannot be used with low delay\n");
483 if (s->q_scale_type == 1) {
484 if (avctx->qmax > 12) {
485 av_log(avctx, AV_LOG_ERROR,
486 "non linear quant only supports qmax <= 12 currently\n");
491 if (s->avctx->thread_count > 1 &&
492 s->codec_id != AV_CODEC_ID_MPEG4 &&
493 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
494 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
495 (s->codec_id != AV_CODEC_ID_H263P)) {
496 av_log(avctx, AV_LOG_ERROR,
497 "multi threaded encoding not supported by codec\n");
501 if (s->avctx->thread_count < 1) {
502 av_log(avctx, AV_LOG_ERROR,
503 "automatic thread number detection not supported by codec,"
508 if (s->avctx->thread_count > 1)
511 if (!avctx->time_base.den || !avctx->time_base.num) {
512 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
516 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
517 av_log(avctx, AV_LOG_INFO,
518 "notice: b_frame_strategy only affects the first pass\n");
519 avctx->b_frame_strategy = 0;
522 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
524 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
525 avctx->time_base.den /= i;
526 avctx->time_base.num /= i;
530 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
531 s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
532 // (a + x * 3 / 8) / x
533 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
534 s->inter_quant_bias = 0;
536 s->intra_quant_bias = 0;
538 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
541 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
542 s->intra_quant_bias = avctx->intra_quant_bias;
543 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
544 s->inter_quant_bias = avctx->inter_quant_bias;
546 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
547 s->avctx->time_base.den > (1 << 16) - 1) {
548 av_log(avctx, AV_LOG_ERROR,
549 "timebase %d/%d not supported by MPEG 4 standard, "
550 "the maximum admitted value for the timebase denominator "
551 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
555 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
557 switch (avctx->codec->id) {
558 case AV_CODEC_ID_MPEG1VIDEO:
559 s->out_format = FMT_MPEG1;
560 s->low_delay = !!(s->avctx->flags & CODEC_FLAG_LOW_DELAY);
561 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
563 case AV_CODEC_ID_MPEG2VIDEO:
564 s->out_format = FMT_MPEG1;
565 s->low_delay = !!(s->avctx->flags & CODEC_FLAG_LOW_DELAY);
566 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
569 case AV_CODEC_ID_MJPEG:
570 s->out_format = FMT_MJPEG;
571 s->intra_only = 1; /* force intra only for jpeg */
572 if (!CONFIG_MJPEG_ENCODER ||
573 ff_mjpeg_encode_init(s) < 0)
578 case AV_CODEC_ID_H261:
579 if (!CONFIG_H261_ENCODER)
581 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
582 av_log(avctx, AV_LOG_ERROR,
583 "The specified picture size of %dx%d is not valid for the "
584 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
585 s->width, s->height);
588 s->out_format = FMT_H261;
591 s->rtp_mode = 0; /* Sliced encoding not supported */
593 case AV_CODEC_ID_H263:
594 if (!CONFIG_H263_ENCODER)
596 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
597 s->width, s->height) == 8) {
598 av_log(avctx, AV_LOG_INFO,
599 "The specified picture size of %dx%d is not valid for "
600 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
601 "352x288, 704x576, and 1408x1152."
602 "Try H.263+.\n", s->width, s->height);
605 s->out_format = FMT_H263;
609 case AV_CODEC_ID_H263P:
610 s->out_format = FMT_H263;
613 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
614 s->modified_quant = s->h263_aic;
615 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
616 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
619 /* These are just to be sure */
623 case AV_CODEC_ID_FLV1:
624 s->out_format = FMT_H263;
625 s->h263_flv = 2; /* format = 1; 11-bit codes */
626 s->unrestricted_mv = 1;
627 s->rtp_mode = 0; /* don't allow GOB */
631 case AV_CODEC_ID_RV10:
632 s->out_format = FMT_H263;
636 case AV_CODEC_ID_RV20:
637 s->out_format = FMT_H263;
640 s->modified_quant = 1;
644 s->unrestricted_mv = 0;
646 case AV_CODEC_ID_MPEG4:
647 s->out_format = FMT_H263;
649 s->unrestricted_mv = 1;
650 s->low_delay = s->max_b_frames ? 0 : 1;
651 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
653 case AV_CODEC_ID_MSMPEG4V2:
654 s->out_format = FMT_H263;
656 s->unrestricted_mv = 1;
657 s->msmpeg4_version = 2;
661 case AV_CODEC_ID_MSMPEG4V3:
662 s->out_format = FMT_H263;
664 s->unrestricted_mv = 1;
665 s->msmpeg4_version = 3;
666 s->flipflop_rounding = 1;
670 case AV_CODEC_ID_WMV1:
671 s->out_format = FMT_H263;
673 s->unrestricted_mv = 1;
674 s->msmpeg4_version = 4;
675 s->flipflop_rounding = 1;
679 case AV_CODEC_ID_WMV2:
680 s->out_format = FMT_H263;
682 s->unrestricted_mv = 1;
683 s->msmpeg4_version = 5;
684 s->flipflop_rounding = 1;
692 avctx->has_b_frames = !s->low_delay;
696 s->progressive_frame =
697 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
698 CODEC_FLAG_INTERLACED_ME) ||
703 if (ff_mpv_common_init(s) < 0)
707 ff_mpv_encode_init_x86(s);
709 ff_fdctdsp_init(&s->fdsp, avctx);
710 ff_me_cmp_init(&s->mecc, avctx);
711 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
712 ff_pixblockdsp_init(&s->pdsp, avctx);
713 ff_qpeldsp_init(&s->qdsp);
715 s->avctx->coded_frame = s->current_picture.f;
717 if (s->msmpeg4_version) {
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
719 2 * 2 * (MAX_LEVEL + 1) *
720 (MAX_RUN + 1) * 2 * sizeof(int), fail);
722 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
724 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
725 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
726 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
728 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
729 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
730 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
731 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
733 if (s->avctx->noise_reduction) {
734 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
735 2 * 64 * sizeof(uint16_t), fail);
738 if (CONFIG_H263_ENCODER)
739 ff_h263dsp_init(&s->h263dsp);
740 if (!s->dct_quantize)
741 s->dct_quantize = ff_dct_quantize_c;
743 s->denoise_dct = denoise_dct_c;
744 s->fast_dct_quantize = s->dct_quantize;
746 s->dct_quantize = dct_quantize_trellis_c;
748 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
749 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
751 s->quant_precision = 5;
753 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
754 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->avctx->frame_skip_cmp);
756 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
757 ff_h261_encode_init(s);
758 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
759 ff_h263_encode_init(s);
760 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
761 if ((ret = ff_msmpeg4_encode_init(s)) < 0)
763 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
764 && s->out_format == FMT_MPEG1)
765 ff_mpeg1_encode_init(s);
768 for (i = 0; i < 64; i++) {
769 int j = s->idsp.idct_permutation[i];
770 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
772 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
773 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
774 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
776 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
779 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
780 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
782 if (s->avctx->intra_matrix)
783 s->intra_matrix[j] = s->avctx->intra_matrix[i];
784 if (s->avctx->inter_matrix)
785 s->inter_matrix[j] = s->avctx->inter_matrix[i];
788 /* precompute matrix */
789 /* for mjpeg, we do include qscale in the matrix */
790 if (s->out_format != FMT_MJPEG) {
791 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
792 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
794 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
795 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
799 if (ff_rate_control_init(s) < 0)
802 #if FF_API_ERROR_RATE
803 FF_DISABLE_DEPRECATION_WARNINGS
804 if (avctx->error_rate)
805 s->error_rate = avctx->error_rate;
806 FF_ENABLE_DEPRECATION_WARNINGS;
809 #if FF_API_NORMALIZE_AQP
810 FF_DISABLE_DEPRECATION_WARNINGS
811 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
812 s->mpv_flags |= FF_MPV_FLAG_NAQ;
813 FF_ENABLE_DEPRECATION_WARNINGS;
817 FF_DISABLE_DEPRECATION_WARNINGS
818 if (avctx->flags & CODEC_FLAG_MV0)
819 s->mpv_flags |= FF_MPV_FLAG_MV0;
820 FF_ENABLE_DEPRECATION_WARNINGS
824 FF_DISABLE_DEPRECATION_WARNINGS
825 if (avctx->rc_qsquish != 0.0)
826 s->rc_qsquish = avctx->rc_qsquish;
827 if (avctx->rc_qmod_amp != 0.0)
828 s->rc_qmod_amp = avctx->rc_qmod_amp;
829 if (avctx->rc_qmod_freq)
830 s->rc_qmod_freq = avctx->rc_qmod_freq;
831 if (avctx->rc_buffer_aggressivity != 1.0)
832 s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
833 if (avctx->rc_initial_cplx != 0.0)
834 s->rc_initial_cplx = avctx->rc_initial_cplx;
836 s->lmin = avctx->lmin;
838 s->lmax = avctx->lmax;
842 s->rc_eq = av_strdup(avctx->rc_eq);
844 return AVERROR(ENOMEM);
846 FF_ENABLE_DEPRECATION_WARNINGS
849 if (avctx->b_frame_strategy == 2) {
850 for (i = 0; i < s->max_b_frames + 2; i++) {
851 s->tmp_frames[i] = av_frame_alloc();
852 if (!s->tmp_frames[i])
853 return AVERROR(ENOMEM);
855 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
856 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
857 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
859 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
867 ff_mpv_encode_end(avctx);
868 return AVERROR_UNKNOWN;
871 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
873 MpegEncContext *s = avctx->priv_data;
876 ff_rate_control_uninit(s);
878 ff_mpv_common_end(s);
879 if (CONFIG_MJPEG_ENCODER &&
880 s->out_format == FMT_MJPEG)
881 ff_mjpeg_encode_close(s);
883 av_freep(&avctx->extradata);
885 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
886 av_frame_free(&s->tmp_frames[i]);
888 ff_free_picture_tables(&s->new_picture);
889 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
891 av_freep(&s->avctx->stats_out);
892 av_freep(&s->ac_stats);
894 av_freep(&s->q_intra_matrix);
895 av_freep(&s->q_inter_matrix);
896 av_freep(&s->q_intra_matrix16);
897 av_freep(&s->q_inter_matrix16);
898 av_freep(&s->input_picture);
899 av_freep(&s->reordered_input_picture);
900 av_freep(&s->dct_offset);
905 static int get_sae(uint8_t *src, int ref, int stride)
910 for (y = 0; y < 16; y++) {
911 for (x = 0; x < 16; x++) {
912 acc += FFABS(src[x + y * stride] - ref);
919 static int get_intra_count(MpegEncContext *s, uint8_t *src,
920 uint8_t *ref, int stride)
928 for (y = 0; y < h; y += 16) {
929 for (x = 0; x < w; x += 16) {
930 int offset = x + y * stride;
931 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
933 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
934 int sae = get_sae(src + offset, mean, stride);
936 acc += sae + 500 < sad;
943 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
947 int i, display_picture_number = 0, ret;
948 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
949 (s->low_delay ? 0 : 1);
954 display_picture_number = s->input_picture_number++;
956 if (pts != AV_NOPTS_VALUE) {
957 if (s->user_specified_pts != AV_NOPTS_VALUE) {
959 int64_t last = s->user_specified_pts;
962 av_log(s->avctx, AV_LOG_ERROR,
963 "Error, Invalid timestamp=%"PRId64", "
964 "last=%"PRId64"\n", pts, s->user_specified_pts);
968 if (!s->low_delay && display_picture_number == 1)
969 s->dts_delta = time - last;
971 s->user_specified_pts = pts;
973 if (s->user_specified_pts != AV_NOPTS_VALUE) {
974 s->user_specified_pts =
975 pts = s->user_specified_pts + 1;
976 av_log(s->avctx, AV_LOG_INFO,
977 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
980 pts = display_picture_number;
986 if (!pic_arg->buf[0] ||
987 pic_arg->linesize[0] != s->linesize ||
988 pic_arg->linesize[1] != s->uvlinesize ||
989 pic_arg->linesize[2] != s->uvlinesize)
991 if ((s->width & 15) || (s->height & 15))
994 ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
995 pic_arg->linesize[1], s->linesize, s->uvlinesize);
997 i = ff_find_unused_picture(s, direct);
1001 pic = &s->picture[i];
1005 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1008 ret = ff_alloc_picture(s, pic, direct);
1013 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1014 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1015 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1018 int h_chroma_shift, v_chroma_shift;
1019 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1023 for (i = 0; i < 3; i++) {
1024 int src_stride = pic_arg->linesize[i];
1025 int dst_stride = i ? s->uvlinesize : s->linesize;
1026 int h_shift = i ? h_chroma_shift : 0;
1027 int v_shift = i ? v_chroma_shift : 0;
1028 int w = s->width >> h_shift;
1029 int h = s->height >> v_shift;
1030 uint8_t *src = pic_arg->data[i];
1031 uint8_t *dst = pic->f->data[i];
1033 if (!s->avctx->rc_buffer_size)
1034 dst += INPLACE_OFFSET;
1036 if (src_stride == dst_stride)
1037 memcpy(dst, src, src_stride * h);
1040 uint8_t *dst2 = dst;
1042 memcpy(dst2, src, w);
1047 if ((s->width & 15) || (s->height & 15)) {
1048 s->mpvencdsp.draw_edges(dst, dst_stride,
1057 ret = av_frame_copy_props(pic->f, pic_arg);
1061 pic->f->display_picture_number = display_picture_number;
1062 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1065 /* shift buffer entries */
1066 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1067 s->input_picture[i - 1] = s->input_picture[i];
1069 s->input_picture[encoding_delay] = (Picture*) pic;
1074 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1078 int64_t score64 = 0;
1080 for (plane = 0; plane < 3; plane++) {
1081 const int stride = p->f->linesize[plane];
1082 const int bw = plane ? 1 : 2;
1083 for (y = 0; y < s->mb_height * bw; y++) {
1084 for (x = 0; x < s->mb_width * bw; x++) {
1085 int off = p->shared ? 0 : 16;
1086 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1087 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1088 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1090 switch (s->avctx->frame_skip_exp) {
1091 case 0: score = FFMAX(score, v); break;
1092 case 1: score += FFABS(v); break;
1093 case 2: score += v * v; break;
1094 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1095 case 4: score64 += v * v * (int64_t)(v * v); break;
1104 if (score64 < s->avctx->frame_skip_threshold)
1106 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1111 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1113 AVPacket pkt = { 0 };
1114 int ret, got_output;
1116 av_init_packet(&pkt);
1117 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1122 av_free_packet(&pkt);
1126 static int estimate_best_b_count(MpegEncContext *s)
1128 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1129 AVCodecContext *c = avcodec_alloc_context3(NULL);
1130 const int scale = s->avctx->brd_scale;
1131 int i, j, out_size, p_lambda, b_lambda, lambda2;
1132 int64_t best_rd = INT64_MAX;
1133 int best_b_count = -1;
1136 return AVERROR(ENOMEM);
1137 assert(scale >= 0 && scale <= 3);
1140 //s->next_picture_ptr->quality;
1141 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1142 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1143 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1144 if (!b_lambda) // FIXME we should do this somewhere else
1145 b_lambda = p_lambda;
1146 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1149 c->width = s->width >> scale;
1150 c->height = s->height >> scale;
1151 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
1152 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1153 c->mb_decision = s->avctx->mb_decision;
1154 c->me_cmp = s->avctx->me_cmp;
1155 c->mb_cmp = s->avctx->mb_cmp;
1156 c->me_sub_cmp = s->avctx->me_sub_cmp;
1157 c->pix_fmt = AV_PIX_FMT_YUV420P;
1158 c->time_base = s->avctx->time_base;
1159 c->max_b_frames = s->max_b_frames;
1161 if (avcodec_open2(c, codec, NULL) < 0)
1164 for (i = 0; i < s->max_b_frames + 2; i++) {
1165 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1166 s->next_picture_ptr;
1168 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1169 pre_input = *pre_input_ptr;
1171 if (!pre_input.shared && i) {
1172 pre_input.f->data[0] += INPLACE_OFFSET;
1173 pre_input.f->data[1] += INPLACE_OFFSET;
1174 pre_input.f->data[2] += INPLACE_OFFSET;
1177 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1178 s->tmp_frames[i]->linesize[0],
1179 pre_input.f->data[0],
1180 pre_input.f->linesize[0],
1181 c->width, c->height);
1182 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1183 s->tmp_frames[i]->linesize[1],
1184 pre_input.f->data[1],
1185 pre_input.f->linesize[1],
1186 c->width >> 1, c->height >> 1);
1187 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1188 s->tmp_frames[i]->linesize[2],
1189 pre_input.f->data[2],
1190 pre_input.f->linesize[2],
1191 c->width >> 1, c->height >> 1);
1195 for (j = 0; j < s->max_b_frames + 1; j++) {
1198 if (!s->input_picture[j])
1201 c->error[0] = c->error[1] = c->error[2] = 0;
1203 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1204 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1206 out_size = encode_frame(c, s->tmp_frames[0]);
1208 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1210 for (i = 0; i < s->max_b_frames + 1; i++) {
1211 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1213 s->tmp_frames[i + 1]->pict_type = is_p ?
1214 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1215 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1217 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1219 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1222 /* get the delayed frames */
1224 out_size = encode_frame(c, NULL);
1225 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1228 rd += c->error[0] + c->error[1] + c->error[2];
1239 return best_b_count;
1242 static int select_input_picture(MpegEncContext *s)
1246 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1247 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1248 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1250 /* set next picture type & ordering */
1251 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1252 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1253 !s->next_picture_ptr || s->intra_only) {
1254 s->reordered_input_picture[0] = s->input_picture[0];
1255 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1256 s->reordered_input_picture[0]->f->coded_picture_number =
1257 s->coded_picture_number++;
1261 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1262 if (s->picture_in_gop_number < s->gop_size &&
1263 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1264 // FIXME check that te gop check above is +-1 correct
1265 av_frame_unref(s->input_picture[0]->f);
1268 ff_vbv_update(s, 0);
1274 if (s->avctx->flags & CODEC_FLAG_PASS2) {
1275 for (i = 0; i < s->max_b_frames + 1; i++) {
1276 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1278 if (pict_num >= s->rc_context.num_entries)
1280 if (!s->input_picture[i]) {
1281 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1285 s->input_picture[i]->f->pict_type =
1286 s->rc_context.entry[pict_num].new_pict_type;
1290 if (s->avctx->b_frame_strategy == 0) {
1291 b_frames = s->max_b_frames;
1292 while (b_frames && !s->input_picture[b_frames])
1294 } else if (s->avctx->b_frame_strategy == 1) {
1295 for (i = 1; i < s->max_b_frames + 1; i++) {
1296 if (s->input_picture[i] &&
1297 s->input_picture[i]->b_frame_score == 0) {
1298 s->input_picture[i]->b_frame_score =
1300 s->input_picture[i ]->f->data[0],
1301 s->input_picture[i - 1]->f->data[0],
1305 for (i = 0; i < s->max_b_frames + 1; i++) {
1306 if (!s->input_picture[i] ||
1307 s->input_picture[i]->b_frame_score - 1 >
1308 s->mb_num / s->avctx->b_sensitivity)
1312 b_frames = FFMAX(0, i - 1);
1315 for (i = 0; i < b_frames + 1; i++) {
1316 s->input_picture[i]->b_frame_score = 0;
1318 } else if (s->avctx->b_frame_strategy == 2) {
1319 b_frames = estimate_best_b_count(s);
1321 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1327 for (i = b_frames - 1; i >= 0; i--) {
1328 int type = s->input_picture[i]->f->pict_type;
1329 if (type && type != AV_PICTURE_TYPE_B)
1332 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1333 b_frames == s->max_b_frames) {
1334 av_log(s->avctx, AV_LOG_ERROR,
1335 "warning, too many b frames in a row\n");
1338 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1339 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1340 s->gop_size > s->picture_in_gop_number) {
1341 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1343 if (s->avctx->flags & CODEC_FLAG_CLOSED_GOP)
1345 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1349 if ((s->avctx->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1350 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1353 s->reordered_input_picture[0] = s->input_picture[b_frames];
1354 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1355 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1356 s->reordered_input_picture[0]->f->coded_picture_number =
1357 s->coded_picture_number++;
1358 for (i = 0; i < b_frames; i++) {
1359 s->reordered_input_picture[i + 1] = s->input_picture[i];
1360 s->reordered_input_picture[i + 1]->f->pict_type =
1362 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1363 s->coded_picture_number++;
1368 if (s->reordered_input_picture[0]) {
1369 s->reordered_input_picture[0]->reference =
1370 s->reordered_input_picture[0]->f->pict_type !=
1371 AV_PICTURE_TYPE_B ? 3 : 0;
1373 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1374 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1377 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1378 // input is a shared pix, so we can't modifiy it -> alloc a new
1379 // one & ensure that the shared one is reuseable
1382 int i = ff_find_unused_picture(s, 0);
1385 pic = &s->picture[i];
1387 pic->reference = s->reordered_input_picture[0]->reference;
1388 if (ff_alloc_picture(s, pic, 0) < 0) {
1392 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1396 /* mark us unused / free shared pic */
1397 av_frame_unref(s->reordered_input_picture[0]->f);
1398 s->reordered_input_picture[0]->shared = 0;
1400 s->current_picture_ptr = pic;
1402 // input is not a shared pix -> reuse buffer for current_pix
1403 s->current_picture_ptr = s->reordered_input_picture[0];
1404 for (i = 0; i < 4; i++) {
1405 s->new_picture.f->data[i] += INPLACE_OFFSET;
1408 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1409 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1410 s->current_picture_ptr)) < 0)
1413 s->picture_number = s->new_picture.f->display_picture_number;
1415 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1420 static void frame_end(MpegEncContext *s)
1424 if (s->unrestricted_mv &&
1425 s->current_picture.reference &&
1427 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1428 int hshift = desc->log2_chroma_w;
1429 int vshift = desc->log2_chroma_h;
1430 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1431 s->h_edge_pos, s->v_edge_pos,
1432 EDGE_WIDTH, EDGE_WIDTH,
1433 EDGE_TOP | EDGE_BOTTOM);
1434 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1435 s->h_edge_pos >> hshift,
1436 s->v_edge_pos >> vshift,
1437 EDGE_WIDTH >> hshift,
1438 EDGE_WIDTH >> vshift,
1439 EDGE_TOP | EDGE_BOTTOM);
1440 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1441 s->h_edge_pos >> hshift,
1442 s->v_edge_pos >> vshift,
1443 EDGE_WIDTH >> hshift,
1444 EDGE_WIDTH >> vshift,
1445 EDGE_TOP | EDGE_BOTTOM);
1450 s->last_pict_type = s->pict_type;
1451 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1452 if (s->pict_type!= AV_PICTURE_TYPE_B)
1453 s->last_non_b_pict_type = s->pict_type;
1456 /* release non-reference frames */
1457 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1458 if (!s->picture[i].reference)
1459 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1463 s->avctx->coded_frame = s->current_picture_ptr->f;
1467 static void update_noise_reduction(MpegEncContext *s)
1471 for (intra = 0; intra < 2; intra++) {
1472 if (s->dct_count[intra] > (1 << 16)) {
1473 for (i = 0; i < 64; i++) {
1474 s->dct_error_sum[intra][i] >>= 1;
1476 s->dct_count[intra] >>= 1;
1479 for (i = 0; i < 64; i++) {
1480 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1481 s->dct_count[intra] +
1482 s->dct_error_sum[intra][i] / 2) /
1483 (s->dct_error_sum[intra][i] + 1);
1488 static int frame_start(MpegEncContext *s)
1492 /* mark & release old frames */
1493 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1494 s->last_picture_ptr != s->next_picture_ptr &&
1495 s->last_picture_ptr->f->buf[0]) {
1496 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1499 s->current_picture_ptr->f->pict_type = s->pict_type;
1500 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1502 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1503 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1504 s->current_picture_ptr)) < 0)
1507 if (s->pict_type != AV_PICTURE_TYPE_B) {
1508 s->last_picture_ptr = s->next_picture_ptr;
1510 s->next_picture_ptr = s->current_picture_ptr;
1513 if (s->last_picture_ptr) {
1514 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1515 if (s->last_picture_ptr->f->buf[0] &&
1516 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1517 s->last_picture_ptr)) < 0)
1520 if (s->next_picture_ptr) {
1521 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1522 if (s->next_picture_ptr->f->buf[0] &&
1523 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1524 s->next_picture_ptr)) < 0)
1528 if (s->picture_structure!= PICT_FRAME) {
1530 for (i = 0; i < 4; i++) {
1531 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1532 s->current_picture.f->data[i] +=
1533 s->current_picture.f->linesize[i];
1535 s->current_picture.f->linesize[i] *= 2;
1536 s->last_picture.f->linesize[i] *= 2;
1537 s->next_picture.f->linesize[i] *= 2;
1541 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1542 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1543 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1544 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1545 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1546 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1548 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1549 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1552 if (s->dct_error_sum) {
1553 assert(s->avctx->noise_reduction && s->encoding);
1554 update_noise_reduction(s);
1560 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1561 const AVFrame *pic_arg, int *got_packet)
1563 MpegEncContext *s = avctx->priv_data;
1564 int i, stuffing_count, ret;
1565 int context_count = s->slice_context_count;
1567 s->picture_in_gop_number++;
1569 if (load_input_picture(s, pic_arg) < 0)
1572 if (select_input_picture(s) < 0) {
1577 if (s->new_picture.f->data[0]) {
1579 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1582 s->mb_info_ptr = av_packet_new_side_data(pkt,
1583 AV_PKT_DATA_H263_MB_INFO,
1584 s->mb_width*s->mb_height*12);
1585 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1588 for (i = 0; i < context_count; i++) {
1589 int start_y = s->thread_context[i]->start_mb_y;
1590 int end_y = s->thread_context[i]-> end_mb_y;
1591 int h = s->mb_height;
1592 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1593 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1595 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1598 s->pict_type = s->new_picture.f->pict_type;
1600 ret = frame_start(s);
1604 if (encode_picture(s, s->picture_number) < 0)
1607 avctx->header_bits = s->header_bits;
1608 avctx->mv_bits = s->mv_bits;
1609 avctx->misc_bits = s->misc_bits;
1610 avctx->i_tex_bits = s->i_tex_bits;
1611 avctx->p_tex_bits = s->p_tex_bits;
1612 avctx->i_count = s->i_count;
1613 // FIXME f/b_count in avctx
1614 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1615 avctx->skip_count = s->skip_count;
1619 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1620 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1622 if (avctx->rc_buffer_size) {
1623 RateControlContext *rcc = &s->rc_context;
1624 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1626 if (put_bits_count(&s->pb) > max_size &&
1627 s->lambda < s->lmax) {
1628 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1629 (s->qscale + 1) / s->qscale);
1630 if (s->adaptive_quant) {
1632 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1633 s->lambda_table[i] =
1634 FFMAX(s->lambda_table[i] + 1,
1635 s->lambda_table[i] * (s->qscale + 1) /
1638 s->mb_skipped = 0; // done in frame_start()
1639 // done in encode_picture() so we must undo it
1640 if (s->pict_type == AV_PICTURE_TYPE_P) {
1641 if (s->flipflop_rounding ||
1642 s->codec_id == AV_CODEC_ID_H263P ||
1643 s->codec_id == AV_CODEC_ID_MPEG4)
1644 s->no_rounding ^= 1;
1646 if (s->pict_type != AV_PICTURE_TYPE_B) {
1647 s->time_base = s->last_time_base;
1648 s->last_non_b_time = s->time - s->pp_time;
1650 for (i = 0; i < context_count; i++) {
1651 PutBitContext *pb = &s->thread_context[i]->pb;
1652 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1657 assert(s->avctx->rc_max_rate);
1660 if (s->avctx->flags & CODEC_FLAG_PASS1)
1661 ff_write_pass1_stats(s);
1663 for (i = 0; i < 4; i++) {
1664 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1665 avctx->error[i] += s->current_picture_ptr->f->error[i];
1668 if (s->avctx->flags & CODEC_FLAG_PASS1)
1669 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1670 avctx->i_tex_bits + avctx->p_tex_bits ==
1671 put_bits_count(&s->pb));
1672 flush_put_bits(&s->pb);
1673 s->frame_bits = put_bits_count(&s->pb);
1675 stuffing_count = ff_vbv_update(s, s->frame_bits);
1676 if (stuffing_count) {
1677 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1678 stuffing_count + 50) {
1679 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1683 switch (s->codec_id) {
1684 case AV_CODEC_ID_MPEG1VIDEO:
1685 case AV_CODEC_ID_MPEG2VIDEO:
1686 while (stuffing_count--) {
1687 put_bits(&s->pb, 8, 0);
1690 case AV_CODEC_ID_MPEG4:
1691 put_bits(&s->pb, 16, 0);
1692 put_bits(&s->pb, 16, 0x1C3);
1693 stuffing_count -= 4;
1694 while (stuffing_count--) {
1695 put_bits(&s->pb, 8, 0xFF);
1699 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1701 flush_put_bits(&s->pb);
1702 s->frame_bits = put_bits_count(&s->pb);
1705 /* update mpeg1/2 vbv_delay for CBR */
1706 if (s->avctx->rc_max_rate &&
1707 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1708 s->out_format == FMT_MPEG1 &&
1709 90000LL * (avctx->rc_buffer_size - 1) <=
1710 s->avctx->rc_max_rate * 0xFFFFLL) {
1711 int vbv_delay, min_delay;
1712 double inbits = s->avctx->rc_max_rate *
1713 av_q2d(s->avctx->time_base);
1714 int minbits = s->frame_bits - 8 *
1715 (s->vbv_delay_ptr - s->pb.buf - 1);
1716 double bits = s->rc_context.buffer_index + minbits - inbits;
1719 av_log(s->avctx, AV_LOG_ERROR,
1720 "Internal error, negative bits\n");
1722 assert(s->repeat_first_field == 0);
1724 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1725 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1726 s->avctx->rc_max_rate;
1728 vbv_delay = FFMAX(vbv_delay, min_delay);
1730 assert(vbv_delay < 0xFFFF);
1732 s->vbv_delay_ptr[0] &= 0xF8;
1733 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1734 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1735 s->vbv_delay_ptr[2] &= 0x07;
1736 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1737 avctx->vbv_delay = vbv_delay * 300;
1739 s->total_bits += s->frame_bits;
1740 avctx->frame_bits = s->frame_bits;
1742 pkt->pts = s->current_picture.f->pts;
1743 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1744 if (!s->current_picture.f->coded_picture_number)
1745 pkt->dts = pkt->pts - s->dts_delta;
1747 pkt->dts = s->reordered_pts;
1748 s->reordered_pts = pkt->pts;
1750 pkt->dts = pkt->pts;
1751 if (s->current_picture.f->key_frame)
1752 pkt->flags |= AV_PKT_FLAG_KEY;
1754 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1758 assert((s->frame_bits & 7) == 0);
1760 pkt->size = s->frame_bits / 8;
1761 *got_packet = !!pkt->size;
1765 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1766 int n, int threshold)
1768 static const char tab[64] = {
1769 3, 2, 2, 1, 1, 1, 1, 1,
1770 1, 1, 1, 1, 1, 1, 1, 1,
1771 1, 1, 1, 1, 1, 1, 1, 1,
1772 0, 0, 0, 0, 0, 0, 0, 0,
1773 0, 0, 0, 0, 0, 0, 0, 0,
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
1781 int16_t *block = s->block[n];
1782 const int last_index = s->block_last_index[n];
1785 if (threshold < 0) {
1787 threshold = -threshold;
1791 /* Are all we could set to zero already zero? */
1792 if (last_index <= skip_dc - 1)
1795 for (i = 0; i <= last_index; i++) {
1796 const int j = s->intra_scantable.permutated[i];
1797 const int level = FFABS(block[j]);
1799 if (skip_dc && i == 0)
1803 } else if (level > 1) {
1809 if (score >= threshold)
1811 for (i = skip_dc; i <= last_index; i++) {
1812 const int j = s->intra_scantable.permutated[i];
1816 s->block_last_index[n] = 0;
1818 s->block_last_index[n] = -1;
1821 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1825 const int maxlevel = s->max_qcoeff;
1826 const int minlevel = s->min_qcoeff;
1830 i = 1; // skip clipping of intra dc
1834 for (; i <= last_index; i++) {
1835 const int j = s->intra_scantable.permutated[i];
1836 int level = block[j];
1838 if (level > maxlevel) {
1841 } else if (level < minlevel) {
1849 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1850 av_log(s->avctx, AV_LOG_INFO,
1851 "warning, clipping %d dct coefficients to %d..%d\n",
1852 overflow, minlevel, maxlevel);
1855 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1859 for (y = 0; y < 8; y++) {
1860 for (x = 0; x < 8; x++) {
1866 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1867 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1868 int v = ptr[x2 + y2 * stride];
1874 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1879 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1880 int motion_x, int motion_y,
1881 int mb_block_height,
1884 int16_t weight[8][64];
1885 int16_t orig[8][64];
1886 const int mb_x = s->mb_x;
1887 const int mb_y = s->mb_y;
1890 int dct_offset = s->linesize * 8; // default for progressive frames
1891 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1892 ptrdiff_t wrap_y, wrap_c;
1894 for (i = 0; i < mb_block_count; i++)
1895 skip_dct[i] = s->skipdct;
1897 if (s->adaptive_quant) {
1898 const int last_qp = s->qscale;
1899 const int mb_xy = mb_x + mb_y * s->mb_stride;
1901 s->lambda = s->lambda_table[mb_xy];
1904 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1905 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1906 s->dquant = s->qscale - last_qp;
1908 if (s->out_format == FMT_H263) {
1909 s->dquant = av_clip(s->dquant, -2, 2);
1911 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1913 if (s->pict_type == AV_PICTURE_TYPE_B) {
1914 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1917 if (s->mv_type == MV_TYPE_8X8)
1923 ff_set_qscale(s, last_qp + s->dquant);
1924 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1925 ff_set_qscale(s, s->qscale + s->dquant);
1927 wrap_y = s->linesize;
1928 wrap_c = s->uvlinesize;
1929 ptr_y = s->new_picture.f->data[0] +
1930 (mb_y * 16 * wrap_y) + mb_x * 16;
1931 ptr_cb = s->new_picture.f->data[1] +
1932 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1933 ptr_cr = s->new_picture.f->data[2] +
1934 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1936 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1937 uint8_t *ebuf = s->edge_emu_buffer + 32;
1938 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1940 16, 16, mb_x * 16, mb_y * 16,
1941 s->width, s->height);
1943 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1945 8, mb_block_height, mb_x * 8, mb_y * 8,
1946 s->width >> 1, s->height >> 1);
1947 ptr_cb = ebuf + 18 * wrap_y;
1948 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1950 8, mb_block_height, mb_x * 8, mb_y * 8,
1951 s->width >> 1, s->height >> 1);
1952 ptr_cr = ebuf + 18 * wrap_y + 8;
1956 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
1957 int progressive_score, interlaced_score;
1959 s->interlaced_dct = 0;
1960 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1961 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1962 NULL, wrap_y, 8) - 400;
1964 if (progressive_score > 0) {
1965 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1966 NULL, wrap_y * 2, 8) +
1967 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
1968 NULL, wrap_y * 2, 8);
1969 if (progressive_score > interlaced_score) {
1970 s->interlaced_dct = 1;
1972 dct_offset = wrap_y;
1974 if (s->chroma_format == CHROMA_422)
1980 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
1981 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
1982 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
1983 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
1985 if (s->avctx->flags & CODEC_FLAG_GRAY) {
1989 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1990 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1991 if (!s->chroma_y_shift) { /* 422 */
1992 s->pdsp.get_pixels(s->block[6],
1993 ptr_cb + (dct_offset >> 1), wrap_c);
1994 s->pdsp.get_pixels(s->block[7],
1995 ptr_cr + (dct_offset >> 1), wrap_c);
1999 op_pixels_func (*op_pix)[4];
2000 qpel_mc_func (*op_qpix)[16];
2001 uint8_t *dest_y, *dest_cb, *dest_cr;
2003 dest_y = s->dest[0];
2004 dest_cb = s->dest[1];
2005 dest_cr = s->dest[2];
2007 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2008 op_pix = s->hdsp.put_pixels_tab;
2009 op_qpix = s->qdsp.put_qpel_pixels_tab;
2011 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2012 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2015 if (s->mv_dir & MV_DIR_FORWARD) {
2016 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2017 s->last_picture.f->data,
2019 op_pix = s->hdsp.avg_pixels_tab;
2020 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2022 if (s->mv_dir & MV_DIR_BACKWARD) {
2023 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2024 s->next_picture.f->data,
2028 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
2029 int progressive_score, interlaced_score;
2031 s->interlaced_dct = 0;
2032 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2033 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2037 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2038 progressive_score -= 400;
2040 if (progressive_score > 0) {
2041 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2043 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2047 if (progressive_score > interlaced_score) {
2048 s->interlaced_dct = 1;
2050 dct_offset = wrap_y;
2052 if (s->chroma_format == CHROMA_422)
2058 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2059 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2060 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2061 dest_y + dct_offset, wrap_y);
2062 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2063 dest_y + dct_offset + 8, wrap_y);
2065 if (s->avctx->flags & CODEC_FLAG_GRAY) {
2069 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2070 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2071 if (!s->chroma_y_shift) { /* 422 */
2072 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2073 dest_cb + (dct_offset >> 1), wrap_c);
2074 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2075 dest_cr + (dct_offset >> 1), wrap_c);
2078 /* pre quantization */
2079 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2080 2 * s->qscale * s->qscale) {
2082 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2084 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2086 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2087 wrap_y, 8) < 20 * s->qscale)
2089 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2090 wrap_y, 8) < 20 * s->qscale)
2092 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2094 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2096 if (!s->chroma_y_shift) { /* 422 */
2097 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2098 dest_cb + (dct_offset >> 1),
2099 wrap_c, 8) < 20 * s->qscale)
2101 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2102 dest_cr + (dct_offset >> 1),
2103 wrap_c, 8) < 20 * s->qscale)
2109 if (s->quantizer_noise_shaping) {
2111 get_visual_weight(weight[0], ptr_y , wrap_y);
2113 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2115 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2117 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2119 get_visual_weight(weight[4], ptr_cb , wrap_c);
2121 get_visual_weight(weight[5], ptr_cr , wrap_c);
2122 if (!s->chroma_y_shift) { /* 422 */
2124 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2127 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2130 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2133 /* DCT & quantize */
2134 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2136 for (i = 0; i < mb_block_count; i++) {
2139 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2140 // FIXME we could decide to change to quantizer instead of
2142 // JS: I don't think that would be a good idea it could lower
2143 // quality instead of improve it. Just INTRADC clipping
2144 // deserves changes in quantizer
2146 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2148 s->block_last_index[i] = -1;
2150 if (s->quantizer_noise_shaping) {
2151 for (i = 0; i < mb_block_count; i++) {
2153 s->block_last_index[i] =
2154 dct_quantize_refine(s, s->block[i], weight[i],
2155 orig[i], i, s->qscale);
2160 if (s->luma_elim_threshold && !s->mb_intra)
2161 for (i = 0; i < 4; i++)
2162 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2163 if (s->chroma_elim_threshold && !s->mb_intra)
2164 for (i = 4; i < mb_block_count; i++)
2165 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2167 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2168 for (i = 0; i < mb_block_count; i++) {
2169 if (s->block_last_index[i] == -1)
2170 s->coded_score[i] = INT_MAX / 256;
2175 if ((s->avctx->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2176 s->block_last_index[4] =
2177 s->block_last_index[5] = 0;
2179 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2182 // non c quantize code returns incorrect block_last_index FIXME
2183 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2184 for (i = 0; i < mb_block_count; i++) {
2186 if (s->block_last_index[i] > 0) {
2187 for (j = 63; j > 0; j--) {
2188 if (s->block[i][s->intra_scantable.permutated[j]])
2191 s->block_last_index[i] = j;
2196 /* huffman encode */
2197 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2198 case AV_CODEC_ID_MPEG1VIDEO:
2199 case AV_CODEC_ID_MPEG2VIDEO:
2200 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2201 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2203 case AV_CODEC_ID_MPEG4:
2204 if (CONFIG_MPEG4_ENCODER)
2205 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2207 case AV_CODEC_ID_MSMPEG4V2:
2208 case AV_CODEC_ID_MSMPEG4V3:
2209 case AV_CODEC_ID_WMV1:
2210 if (CONFIG_MSMPEG4_ENCODER)
2211 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2213 case AV_CODEC_ID_WMV2:
2214 if (CONFIG_WMV2_ENCODER)
2215 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2217 case AV_CODEC_ID_H261:
2218 if (CONFIG_H261_ENCODER)
2219 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2221 case AV_CODEC_ID_H263:
2222 case AV_CODEC_ID_H263P:
2223 case AV_CODEC_ID_FLV1:
2224 case AV_CODEC_ID_RV10:
2225 case AV_CODEC_ID_RV20:
2226 if (CONFIG_H263_ENCODER)
2227 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2229 case AV_CODEC_ID_MJPEG:
2230 if (CONFIG_MJPEG_ENCODER)
2231 ff_mjpeg_encode_mb(s, s->block);
2238 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2240 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2241 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2244 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2247 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2250 d->mb_skip_run= s->mb_skip_run;
2252 d->last_dc[i] = s->last_dc[i];
2255 d->mv_bits= s->mv_bits;
2256 d->i_tex_bits= s->i_tex_bits;
2257 d->p_tex_bits= s->p_tex_bits;
2258 d->i_count= s->i_count;
2259 d->f_count= s->f_count;
2260 d->b_count= s->b_count;
2261 d->skip_count= s->skip_count;
2262 d->misc_bits= s->misc_bits;
2266 d->qscale= s->qscale;
2267 d->dquant= s->dquant;
2269 d->esc3_level_length= s->esc3_level_length;
2272 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2275 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2276 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2279 d->mb_skip_run= s->mb_skip_run;
2281 d->last_dc[i] = s->last_dc[i];
2284 d->mv_bits= s->mv_bits;
2285 d->i_tex_bits= s->i_tex_bits;
2286 d->p_tex_bits= s->p_tex_bits;
2287 d->i_count= s->i_count;
2288 d->f_count= s->f_count;
2289 d->b_count= s->b_count;
2290 d->skip_count= s->skip_count;
2291 d->misc_bits= s->misc_bits;
2293 d->mb_intra= s->mb_intra;
2294 d->mb_skipped= s->mb_skipped;
2295 d->mv_type= s->mv_type;
2296 d->mv_dir= s->mv_dir;
2298 if(s->data_partitioning){
2300 d->tex_pb= s->tex_pb;
2304 d->block_last_index[i]= s->block_last_index[i];
2305 d->interlaced_dct= s->interlaced_dct;
2306 d->qscale= s->qscale;
2308 d->esc3_level_length= s->esc3_level_length;
2311 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2312 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2313 int *dmin, int *next_block, int motion_x, int motion_y)
2316 uint8_t *dest_backup[3];
2318 copy_context_before_encode(s, backup, type);
2320 s->block= s->blocks[*next_block];
2321 s->pb= pb[*next_block];
2322 if(s->data_partitioning){
2323 s->pb2 = pb2 [*next_block];
2324 s->tex_pb= tex_pb[*next_block];
2328 memcpy(dest_backup, s->dest, sizeof(s->dest));
2329 s->dest[0] = s->rd_scratchpad;
2330 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2331 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2332 assert(s->linesize >= 32); //FIXME
2335 encode_mb(s, motion_x, motion_y);
2337 score= put_bits_count(&s->pb);
2338 if(s->data_partitioning){
2339 score+= put_bits_count(&s->pb2);
2340 score+= put_bits_count(&s->tex_pb);
2343 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2344 ff_mpv_decode_mb(s, s->block);
2346 score *= s->lambda2;
2347 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2351 memcpy(s->dest, dest_backup, sizeof(s->dest));
2358 copy_context_after_encode(best, s, type);
2362 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2363 uint32_t *sq = ff_square_tab + 256;
2368 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2369 else if(w==8 && h==8)
2370 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2374 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2383 static int sse_mb(MpegEncContext *s){
2387 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2388 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2391 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2392 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) +
2393 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) +
2394 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);
2396 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) +
2397 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) +
2398 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);
2401 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)
2402 +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)
2403 +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);
2406 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2407 MpegEncContext *s= *(void**)arg;
2411 s->me.dia_size= s->avctx->pre_dia_size;
2412 s->first_slice_line=1;
2413 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2414 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2415 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2417 s->first_slice_line=0;
2425 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2426 MpegEncContext *s= *(void**)arg;
2428 s->me.dia_size= s->avctx->dia_size;
2429 s->first_slice_line=1;
2430 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2431 s->mb_x=0; //for block init below
2432 ff_init_block_index(s);
2433 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2434 s->block_index[0]+=2;
2435 s->block_index[1]+=2;
2436 s->block_index[2]+=2;
2437 s->block_index[3]+=2;
2439 /* compute motion vector & mb_type and store in context */
2440 if(s->pict_type==AV_PICTURE_TYPE_B)
2441 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2443 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2445 s->first_slice_line=0;
2450 static int mb_var_thread(AVCodecContext *c, void *arg){
2451 MpegEncContext *s= *(void**)arg;
2454 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2455 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2458 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2460 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2462 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2463 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2465 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2466 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2467 s->me.mb_var_sum_temp += varc;
2473 static void write_slice_end(MpegEncContext *s){
2474 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2475 if(s->partitioned_frame){
2476 ff_mpeg4_merge_partitions(s);
2479 ff_mpeg4_stuffing(&s->pb);
2480 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2481 ff_mjpeg_encode_stuffing(&s->pb);
2484 avpriv_align_put_bits(&s->pb);
2485 flush_put_bits(&s->pb);
2487 if ((s->avctx->flags & CODEC_FLAG_PASS1) && !s->partitioned_frame)
2488 s->misc_bits+= get_bits_diff(s);
2491 static void write_mb_info(MpegEncContext *s)
2493 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2494 int offset = put_bits_count(&s->pb);
2495 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2496 int gobn = s->mb_y / s->gob_index;
2498 if (CONFIG_H263_ENCODER)
2499 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2500 bytestream_put_le32(&ptr, offset);
2501 bytestream_put_byte(&ptr, s->qscale);
2502 bytestream_put_byte(&ptr, gobn);
2503 bytestream_put_le16(&ptr, mba);
2504 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2505 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2506 /* 4MV not implemented */
2507 bytestream_put_byte(&ptr, 0); /* hmv2 */
2508 bytestream_put_byte(&ptr, 0); /* vmv2 */
2511 static void update_mb_info(MpegEncContext *s, int startcode)
2515 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2516 s->mb_info_size += 12;
2517 s->prev_mb_info = s->last_mb_info;
2520 s->prev_mb_info = put_bits_count(&s->pb)/8;
2521 /* This might have incremented mb_info_size above, and we return without
2522 * actually writing any info into that slot yet. But in that case,
2523 * this will be called again at the start of the after writing the
2524 * start code, actually writing the mb info. */
2528 s->last_mb_info = put_bits_count(&s->pb)/8;
2529 if (!s->mb_info_size)
2530 s->mb_info_size += 12;
2534 static int encode_thread(AVCodecContext *c, void *arg){
2535 MpegEncContext *s= *(void**)arg;
2536 int mb_x, mb_y, pdif = 0;
2537 int chr_h= 16>>s->chroma_y_shift;
2539 MpegEncContext best_s = { 0 }, backup_s;
2540 uint8_t bit_buf[2][MAX_MB_BYTES];
2541 uint8_t bit_buf2[2][MAX_MB_BYTES];
2542 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2543 PutBitContext pb[2], pb2[2], tex_pb[2];
2546 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2547 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2548 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2551 s->last_bits= put_bits_count(&s->pb);
2562 /* init last dc values */
2563 /* note: quant matrix value (8) is implied here */
2564 s->last_dc[i] = 128 << s->intra_dc_precision;
2566 s->current_picture.f->error[i] = 0;
2569 memset(s->last_mv, 0, sizeof(s->last_mv));
2573 switch(s->codec_id){
2574 case AV_CODEC_ID_H263:
2575 case AV_CODEC_ID_H263P:
2576 case AV_CODEC_ID_FLV1:
2577 if (CONFIG_H263_ENCODER)
2578 s->gob_index = H263_GOB_HEIGHT(s->height);
2580 case AV_CODEC_ID_MPEG4:
2581 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2582 ff_mpeg4_init_partitions(s);
2588 s->first_slice_line = 1;
2589 s->ptr_lastgob = s->pb.buf;
2590 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2594 ff_set_qscale(s, s->qscale);
2595 ff_init_block_index(s);
2597 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2598 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2599 int mb_type= s->mb_type[xy];
2604 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2605 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2608 if(s->data_partitioning){
2609 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2610 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2611 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2617 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2618 ff_update_block_index(s);
2620 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2621 ff_h261_reorder_mb_index(s);
2622 xy= s->mb_y*s->mb_stride + s->mb_x;
2623 mb_type= s->mb_type[xy];
2626 /* write gob / video packet header */
2628 int current_packet_size, is_gob_start;
2630 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2632 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2634 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2636 switch(s->codec_id){
2637 case AV_CODEC_ID_H263:
2638 case AV_CODEC_ID_H263P:
2639 if(!s->h263_slice_structured)
2640 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2642 case AV_CODEC_ID_MPEG2VIDEO:
2643 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2644 case AV_CODEC_ID_MPEG1VIDEO:
2645 if(s->mb_skip_run) is_gob_start=0;
2650 if(s->start_mb_y != mb_y || mb_x!=0){
2653 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2654 ff_mpeg4_init_partitions(s);
2658 assert((put_bits_count(&s->pb)&7) == 0);
2659 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2661 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2662 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2663 int d = 100 / s->error_rate;
2665 current_packet_size=0;
2666 s->pb.buf_ptr= s->ptr_lastgob;
2667 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2671 if (s->avctx->rtp_callback){
2672 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2673 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2675 update_mb_info(s, 1);
2677 switch(s->codec_id){
2678 case AV_CODEC_ID_MPEG4:
2679 if (CONFIG_MPEG4_ENCODER) {
2680 ff_mpeg4_encode_video_packet_header(s);
2681 ff_mpeg4_clean_buffers(s);
2684 case AV_CODEC_ID_MPEG1VIDEO:
2685 case AV_CODEC_ID_MPEG2VIDEO:
2686 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2687 ff_mpeg1_encode_slice_header(s);
2688 ff_mpeg1_clean_buffers(s);
2691 case AV_CODEC_ID_H263:
2692 case AV_CODEC_ID_H263P:
2693 if (CONFIG_H263_ENCODER)
2694 ff_h263_encode_gob_header(s, mb_y);
2698 if (s->avctx->flags & CODEC_FLAG_PASS1) {
2699 int bits= put_bits_count(&s->pb);
2700 s->misc_bits+= bits - s->last_bits;
2704 s->ptr_lastgob += current_packet_size;
2705 s->first_slice_line=1;
2706 s->resync_mb_x=mb_x;
2707 s->resync_mb_y=mb_y;
2711 if( (s->resync_mb_x == s->mb_x)
2712 && s->resync_mb_y+1 == s->mb_y){
2713 s->first_slice_line=0;
2717 s->dquant=0; //only for QP_RD
2719 update_mb_info(s, 0);
2721 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
2723 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2725 copy_context_before_encode(&backup_s, s, -1);
2727 best_s.data_partitioning= s->data_partitioning;
2728 best_s.partitioned_frame= s->partitioned_frame;
2729 if(s->data_partitioning){
2730 backup_s.pb2= s->pb2;
2731 backup_s.tex_pb= s->tex_pb;
2734 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2735 s->mv_dir = MV_DIR_FORWARD;
2736 s->mv_type = MV_TYPE_16X16;
2738 s->mv[0][0][0] = s->p_mv_table[xy][0];
2739 s->mv[0][0][1] = s->p_mv_table[xy][1];
2740 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2741 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2743 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2744 s->mv_dir = MV_DIR_FORWARD;
2745 s->mv_type = MV_TYPE_FIELD;
2748 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2749 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2750 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2752 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2753 &dmin, &next_block, 0, 0);
2755 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2756 s->mv_dir = MV_DIR_FORWARD;
2757 s->mv_type = MV_TYPE_16X16;
2761 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2762 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2764 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2765 s->mv_dir = MV_DIR_FORWARD;
2766 s->mv_type = MV_TYPE_8X8;
2769 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2770 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2772 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2773 &dmin, &next_block, 0, 0);
2775 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2776 s->mv_dir = MV_DIR_FORWARD;
2777 s->mv_type = MV_TYPE_16X16;
2779 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2780 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2781 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2782 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2784 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2785 s->mv_dir = MV_DIR_BACKWARD;
2786 s->mv_type = MV_TYPE_16X16;
2788 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2789 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2790 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2791 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2793 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2794 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2795 s->mv_type = MV_TYPE_16X16;
2797 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2798 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2799 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2800 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2801 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2802 &dmin, &next_block, 0, 0);
2804 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2805 s->mv_dir = MV_DIR_FORWARD;
2806 s->mv_type = MV_TYPE_FIELD;
2809 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2810 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2811 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2813 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2814 &dmin, &next_block, 0, 0);
2816 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2817 s->mv_dir = MV_DIR_BACKWARD;
2818 s->mv_type = MV_TYPE_FIELD;
2821 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2822 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2823 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2825 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2826 &dmin, &next_block, 0, 0);
2828 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2829 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2830 s->mv_type = MV_TYPE_FIELD;
2832 for(dir=0; dir<2; dir++){
2834 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2835 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2836 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2839 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2840 &dmin, &next_block, 0, 0);
2842 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2844 s->mv_type = MV_TYPE_16X16;
2848 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2849 &dmin, &next_block, 0, 0);
2850 if(s->h263_pred || s->h263_aic){
2852 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2854 ff_clean_intra_table_entries(s); //old mode?
2858 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2859 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2860 const int last_qp= backup_s.qscale;
2863 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2864 static const int dquant_tab[4]={-1,1,-2,2};
2866 assert(backup_s.dquant == 0);
2869 s->mv_dir= best_s.mv_dir;
2870 s->mv_type = MV_TYPE_16X16;
2871 s->mb_intra= best_s.mb_intra;
2872 s->mv[0][0][0] = best_s.mv[0][0][0];
2873 s->mv[0][0][1] = best_s.mv[0][0][1];
2874 s->mv[1][0][0] = best_s.mv[1][0][0];
2875 s->mv[1][0][1] = best_s.mv[1][0][1];
2877 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2878 for(; qpi<4; qpi++){
2879 int dquant= dquant_tab[qpi];
2880 qp= last_qp + dquant;
2881 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2883 backup_s.dquant= dquant;
2884 if(s->mb_intra && s->dc_val[0]){
2886 dc[i]= s->dc_val[0][ s->block_index[i] ];
2887 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2891 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2892 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2893 if(best_s.qscale != qp){
2894 if(s->mb_intra && s->dc_val[0]){
2896 s->dc_val[0][ s->block_index[i] ]= dc[i];
2897 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2904 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2905 int mx= s->b_direct_mv_table[xy][0];
2906 int my= s->b_direct_mv_table[xy][1];
2908 backup_s.dquant = 0;
2909 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2911 ff_mpeg4_set_direct_mv(s, mx, my);
2912 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2913 &dmin, &next_block, mx, my);
2915 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2916 backup_s.dquant = 0;
2917 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2919 ff_mpeg4_set_direct_mv(s, 0, 0);
2920 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2921 &dmin, &next_block, 0, 0);
2923 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2926 coded |= s->block_last_index[i];
2929 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2930 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2931 mx=my=0; //FIXME find the one we actually used
2932 ff_mpeg4_set_direct_mv(s, mx, my);
2933 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2941 s->mv_dir= best_s.mv_dir;
2942 s->mv_type = best_s.mv_type;
2944 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2945 s->mv[0][0][1] = best_s.mv[0][0][1];
2946 s->mv[1][0][0] = best_s.mv[1][0][0];
2947 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2950 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2951 &dmin, &next_block, mx, my);
2956 s->current_picture.qscale_table[xy] = best_s.qscale;
2958 copy_context_after_encode(s, &best_s, -1);
2960 pb_bits_count= put_bits_count(&s->pb);
2961 flush_put_bits(&s->pb);
2962 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2965 if(s->data_partitioning){
2966 pb2_bits_count= put_bits_count(&s->pb2);
2967 flush_put_bits(&s->pb2);
2968 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2969 s->pb2= backup_s.pb2;
2971 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2972 flush_put_bits(&s->tex_pb);
2973 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2974 s->tex_pb= backup_s.tex_pb;
2976 s->last_bits= put_bits_count(&s->pb);
2978 if (CONFIG_H263_ENCODER &&
2979 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2980 ff_h263_update_motion_val(s);
2982 if(next_block==0){ //FIXME 16 vs linesize16
2983 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2984 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2985 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2988 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2989 ff_mpv_decode_mb(s, s->block);
2991 int motion_x = 0, motion_y = 0;
2992 s->mv_type=MV_TYPE_16X16;
2993 // only one MB-Type possible
2996 case CANDIDATE_MB_TYPE_INTRA:
2999 motion_x= s->mv[0][0][0] = 0;
3000 motion_y= s->mv[0][0][1] = 0;
3002 case CANDIDATE_MB_TYPE_INTER:
3003 s->mv_dir = MV_DIR_FORWARD;
3005 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3006 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3008 case CANDIDATE_MB_TYPE_INTER_I:
3009 s->mv_dir = MV_DIR_FORWARD;
3010 s->mv_type = MV_TYPE_FIELD;
3013 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3014 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3015 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3018 case CANDIDATE_MB_TYPE_INTER4V:
3019 s->mv_dir = MV_DIR_FORWARD;
3020 s->mv_type = MV_TYPE_8X8;
3023 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3024 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3027 case CANDIDATE_MB_TYPE_DIRECT:
3028 if (CONFIG_MPEG4_ENCODER) {
3029 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3031 motion_x=s->b_direct_mv_table[xy][0];
3032 motion_y=s->b_direct_mv_table[xy][1];
3033 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3036 case CANDIDATE_MB_TYPE_DIRECT0:
3037 if (CONFIG_MPEG4_ENCODER) {
3038 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3040 ff_mpeg4_set_direct_mv(s, 0, 0);
3043 case CANDIDATE_MB_TYPE_BIDIR:
3044 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3046 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3047 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3048 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3049 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3051 case CANDIDATE_MB_TYPE_BACKWARD:
3052 s->mv_dir = MV_DIR_BACKWARD;
3054 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3055 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3057 case CANDIDATE_MB_TYPE_FORWARD:
3058 s->mv_dir = MV_DIR_FORWARD;
3060 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3061 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3063 case CANDIDATE_MB_TYPE_FORWARD_I:
3064 s->mv_dir = MV_DIR_FORWARD;
3065 s->mv_type = MV_TYPE_FIELD;
3068 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3069 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3070 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3073 case CANDIDATE_MB_TYPE_BACKWARD_I:
3074 s->mv_dir = MV_DIR_BACKWARD;
3075 s->mv_type = MV_TYPE_FIELD;
3078 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3079 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3080 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3083 case CANDIDATE_MB_TYPE_BIDIR_I:
3084 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3085 s->mv_type = MV_TYPE_FIELD;
3087 for(dir=0; dir<2; dir++){
3089 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3090 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3091 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3096 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3099 encode_mb(s, motion_x, motion_y);
3101 // RAL: Update last macroblock type
3102 s->last_mv_dir = s->mv_dir;
3104 if (CONFIG_H263_ENCODER &&
3105 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3106 ff_h263_update_motion_val(s);
3108 ff_mpv_decode_mb(s, s->block);
3111 /* clean the MV table in IPS frames for direct mode in B frames */
3112 if(s->mb_intra /* && I,P,S_TYPE */){
3113 s->p_mv_table[xy][0]=0;
3114 s->p_mv_table[xy][1]=0;
3117 if (s->avctx->flags & CODEC_FLAG_PSNR) {
3121 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3122 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3124 s->current_picture.f->error[0] += sse(
3125 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3126 s->dest[0], w, h, s->linesize);
3127 s->current_picture.f->error[1] += sse(
3128 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3129 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3130 s->current_picture.f->error[2] += sse(
3131 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3132 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3135 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3136 ff_h263_loop_filter(s);
3138 ff_dlog(s->avctx, "MB %d %d bits\n",
3139 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3143 //not beautiful here but we must write it before flushing so it has to be here
3144 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3145 ff_msmpeg4_encode_ext_header(s);
3149 /* Send the last GOB if RTP */
3150 if (s->avctx->rtp_callback) {
3151 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3152 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3153 /* Call the RTP callback to send the last GOB */
3155 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3161 #define MERGE(field) dst->field += src->field; src->field=0
3162 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3163 MERGE(me.scene_change_score);
3164 MERGE(me.mc_mb_var_sum_temp);
3165 MERGE(me.mb_var_sum_temp);
3168 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3171 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3172 MERGE(dct_count[1]);
3181 MERGE(er.error_count);
3182 MERGE(padding_bug_score);
3183 MERGE(current_picture.f->error[0]);
3184 MERGE(current_picture.f->error[1]);
3185 MERGE(current_picture.f->error[2]);
3187 if(dst->avctx->noise_reduction){
3188 for(i=0; i<64; i++){
3189 MERGE(dct_error_sum[0][i]);
3190 MERGE(dct_error_sum[1][i]);
3194 assert(put_bits_count(&src->pb) % 8 ==0);
3195 assert(put_bits_count(&dst->pb) % 8 ==0);
3196 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3197 flush_put_bits(&dst->pb);
3200 static int estimate_qp(MpegEncContext *s, int dry_run){
3201 if (s->next_lambda){
3202 s->current_picture_ptr->f->quality =
3203 s->current_picture.f->quality = s->next_lambda;
3204 if(!dry_run) s->next_lambda= 0;
3205 } else if (!s->fixed_qscale) {
3206 s->current_picture_ptr->f->quality =
3207 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3208 if (s->current_picture.f->quality < 0)
3212 if(s->adaptive_quant){
3213 switch(s->codec_id){
3214 case AV_CODEC_ID_MPEG4:
3215 if (CONFIG_MPEG4_ENCODER)
3216 ff_clean_mpeg4_qscales(s);
3218 case AV_CODEC_ID_H263:
3219 case AV_CODEC_ID_H263P:
3220 case AV_CODEC_ID_FLV1:
3221 if (CONFIG_H263_ENCODER)
3222 ff_clean_h263_qscales(s);
3225 ff_init_qscale_tab(s);
3228 s->lambda= s->lambda_table[0];
3231 s->lambda = s->current_picture.f->quality;
3236 /* must be called before writing the header */
3237 static void set_frame_distances(MpegEncContext * s){
3238 assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3239 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3241 if(s->pict_type==AV_PICTURE_TYPE_B){
3242 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3243 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3245 s->pp_time= s->time - s->last_non_b_time;
3246 s->last_non_b_time= s->time;
3247 assert(s->picture_number==0 || s->pp_time > 0);
3251 static int encode_picture(MpegEncContext *s, int picture_number)
3255 int context_count = s->slice_context_count;
3257 s->picture_number = picture_number;
3259 /* Reset the average MB variance */
3260 s->me.mb_var_sum_temp =
3261 s->me.mc_mb_var_sum_temp = 0;
3263 /* we need to initialize some time vars before we can encode b-frames */
3264 // RAL: Condition added for MPEG1VIDEO
3265 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3266 set_frame_distances(s);
3267 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3268 ff_set_mpeg4_time(s);
3270 s->me.scene_change_score=0;
3272 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3274 if(s->pict_type==AV_PICTURE_TYPE_I){
3275 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3276 else s->no_rounding=0;
3277 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3278 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3279 s->no_rounding ^= 1;
3282 if (s->avctx->flags & CODEC_FLAG_PASS2) {
3283 if (estimate_qp(s,1) < 0)
3285 ff_get_2pass_fcode(s);
3286 } else if (!(s->avctx->flags & CODEC_FLAG_QSCALE)) {
3287 if(s->pict_type==AV_PICTURE_TYPE_B)
3288 s->lambda= s->last_lambda_for[s->pict_type];
3290 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3294 s->mb_intra=0; //for the rate distortion & bit compare functions
3295 for(i=1; i<context_count; i++){
3296 ret = ff_update_duplicate_context(s->thread_context[i], s);
3304 /* Estimate motion for every MB */
3305 if(s->pict_type != AV_PICTURE_TYPE_I){
3306 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3307 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3308 if (s->pict_type != AV_PICTURE_TYPE_B) {
3309 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3310 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3314 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3315 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3317 for(i=0; i<s->mb_stride*s->mb_height; i++)
3318 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3320 if(!s->fixed_qscale){
3321 /* finding spatial complexity for I-frame rate control */
3322 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3325 for(i=1; i<context_count; i++){
3326 merge_context_after_me(s, s->thread_context[i]);
3328 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3329 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3332 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3333 s->pict_type= AV_PICTURE_TYPE_I;
3334 for(i=0; i<s->mb_stride*s->mb_height; i++)
3335 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3336 ff_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3337 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3341 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3342 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3344 if (s->avctx->flags & CODEC_FLAG_INTERLACED_ME) {
3346 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3347 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3348 s->f_code= FFMAX3(s->f_code, a, b);
3351 ff_fix_long_p_mvs(s);
3352 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3353 if (s->avctx->flags & CODEC_FLAG_INTERLACED_ME) {
3357 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3358 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3363 if(s->pict_type==AV_PICTURE_TYPE_B){
3366 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3367 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3368 s->f_code = FFMAX(a, b);
3370 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3371 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3372 s->b_code = FFMAX(a, b);
3374 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3375 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3376 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3377 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3378 if (s->avctx->flags & CODEC_FLAG_INTERLACED_ME) {
3380 for(dir=0; dir<2; dir++){
3383 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3384 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3385 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3386 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3394 if (estimate_qp(s, 0) < 0)
3397 if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3398 s->pict_type == AV_PICTURE_TYPE_I &&
3399 !(s->avctx->flags & CODEC_FLAG_QSCALE))
3400 s->qscale= 3; //reduce clipping problems
3402 if (s->out_format == FMT_MJPEG) {
3403 /* for mjpeg, we do include qscale in the matrix */
3405 int j = s->idsp.idct_permutation[i];
3407 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3409 s->y_dc_scale_table=
3410 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3411 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3412 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3413 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3417 //FIXME var duplication
3418 s->current_picture_ptr->f->key_frame =
3419 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3420 s->current_picture_ptr->f->pict_type =
3421 s->current_picture.f->pict_type = s->pict_type;
3423 if (s->current_picture.f->key_frame)
3424 s->picture_in_gop_number=0;
3426 s->last_bits= put_bits_count(&s->pb);
3427 switch(s->out_format) {
3429 if (CONFIG_MJPEG_ENCODER)
3430 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3434 if (CONFIG_H261_ENCODER)
3435 ff_h261_encode_picture_header(s, picture_number);
3438 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3439 ff_wmv2_encode_picture_header(s, picture_number);
3440 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3441 ff_msmpeg4_encode_picture_header(s, picture_number);
3442 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3443 ff_mpeg4_encode_picture_header(s, picture_number);
3444 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3445 ret = ff_rv10_encode_picture_header(s, picture_number);
3449 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3450 ff_rv20_encode_picture_header(s, picture_number);
3451 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3452 ff_flv_encode_picture_header(s, picture_number);
3453 else if (CONFIG_H263_ENCODER)
3454 ff_h263_encode_picture_header(s, picture_number);
3457 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3458 ff_mpeg1_encode_picture_header(s, picture_number);
3463 bits= put_bits_count(&s->pb);
3464 s->header_bits= bits - s->last_bits;
3466 for(i=1; i<context_count; i++){
3467 update_duplicate_context_after_me(s->thread_context[i], s);
3469 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3470 for(i=1; i<context_count; i++){
3471 merge_context_after_encode(s, s->thread_context[i]);
3477 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3478 const int intra= s->mb_intra;
3481 s->dct_count[intra]++;
3483 for(i=0; i<64; i++){
3484 int level= block[i];
3488 s->dct_error_sum[intra][i] += level;
3489 level -= s->dct_offset[intra][i];
3490 if(level<0) level=0;
3492 s->dct_error_sum[intra][i] -= level;
3493 level += s->dct_offset[intra][i];
3494 if(level>0) level=0;
3501 static int dct_quantize_trellis_c(MpegEncContext *s,
3502 int16_t *block, int n,
3503 int qscale, int *overflow){
3505 const uint8_t *scantable= s->intra_scantable.scantable;
3506 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3508 unsigned int threshold1, threshold2;
3520 int coeff_count[64];
3521 int qmul, qadd, start_i, last_non_zero, i, dc;
3522 const int esc_length= s->ac_esc_length;
3524 uint8_t * last_length;
3525 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3527 s->fdsp.fdct(block);
3529 if(s->dct_error_sum)
3530 s->denoise_dct(s, block);
3532 qadd= ((qscale-1)|1)*8;
3543 /* For AIC we skip quant/dequant of INTRADC */
3548 /* note: block[0] is assumed to be positive */
3549 block[0] = (block[0] + (q >> 1)) / q;
3552 qmat = s->q_intra_matrix[qscale];
3553 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3554 bias= 1<<(QMAT_SHIFT-1);
3555 length = s->intra_ac_vlc_length;
3556 last_length= s->intra_ac_vlc_last_length;
3560 qmat = s->q_inter_matrix[qscale];
3561 length = s->inter_ac_vlc_length;
3562 last_length= s->inter_ac_vlc_last_length;
3566 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3567 threshold2= (threshold1<<1);
3569 for(i=63; i>=start_i; i--) {
3570 const int j = scantable[i];
3571 int level = block[j] * qmat[j];
3573 if(((unsigned)(level+threshold1))>threshold2){
3579 for(i=start_i; i<=last_non_zero; i++) {
3580 const int j = scantable[i];
3581 int level = block[j] * qmat[j];
3583 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3584 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3585 if(((unsigned)(level+threshold1))>threshold2){
3587 level= (bias + level)>>QMAT_SHIFT;
3589 coeff[1][i]= level-1;
3590 // coeff[2][k]= level-2;
3592 level= (bias - level)>>QMAT_SHIFT;
3593 coeff[0][i]= -level;
3594 coeff[1][i]= -level+1;
3595 // coeff[2][k]= -level+2;
3597 coeff_count[i]= FFMIN(level, 2);
3598 assert(coeff_count[i]);
3601 coeff[0][i]= (level>>31)|1;
3606 *overflow= s->max_qcoeff < max; //overflow might have happened
3608 if(last_non_zero < start_i){
3609 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3610 return last_non_zero;
3613 score_tab[start_i]= 0;
3614 survivor[0]= start_i;
3617 for(i=start_i; i<=last_non_zero; i++){
3618 int level_index, j, zero_distortion;
3619 int dct_coeff= FFABS(block[ scantable[i] ]);
3620 int best_score=256*256*256*120;
3622 if (s->fdsp.fdct == ff_fdct_ifast)
3623 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3624 zero_distortion= dct_coeff*dct_coeff;
3626 for(level_index=0; level_index < coeff_count[i]; level_index++){
3628 int level= coeff[level_index][i];
3629 const int alevel= FFABS(level);
3634 if(s->out_format == FMT_H263){
3635 unquant_coeff= alevel*qmul + qadd;
3637 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3639 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3640 unquant_coeff = (unquant_coeff - 1) | 1;
3642 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3643 unquant_coeff = (unquant_coeff - 1) | 1;
3648 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3650 if((level&(~127)) == 0){
3651 for(j=survivor_count-1; j>=0; j--){
3652 int run= i - survivor[j];
3653 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3654 score += score_tab[i-run];
3656 if(score < best_score){
3659 level_tab[i+1]= level-64;
3663 if(s->out_format == FMT_H263){
3664 for(j=survivor_count-1; j>=0; j--){
3665 int run= i - survivor[j];
3666 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3667 score += score_tab[i-run];
3668 if(score < last_score){
3671 last_level= level-64;
3677 distortion += esc_length*lambda;
3678 for(j=survivor_count-1; j>=0; j--){
3679 int run= i - survivor[j];
3680 int score= distortion + score_tab[i-run];
3682 if(score < best_score){
3685 level_tab[i+1]= level-64;
3689 if(s->out_format == FMT_H263){
3690 for(j=survivor_count-1; j>=0; j--){
3691 int run= i - survivor[j];
3692 int score= distortion + score_tab[i-run];
3693 if(score < last_score){
3696 last_level= level-64;
3704 score_tab[i+1]= best_score;
3706 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3707 if(last_non_zero <= 27){
3708 for(; survivor_count; survivor_count--){
3709 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3713 for(; survivor_count; survivor_count--){
3714 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3719 survivor[ survivor_count++ ]= i+1;
3722 if(s->out_format != FMT_H263){
3723 last_score= 256*256*256*120;
3724 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3725 int score= score_tab[i];
3726 if(i) score += lambda*2; //FIXME exacter?
3728 if(score < last_score){
3731 last_level= level_tab[i];
3732 last_run= run_tab[i];
3737 s->coded_score[n] = last_score;
3739 dc= FFABS(block[0]);
3740 last_non_zero= last_i - 1;
3741 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3743 if(last_non_zero < start_i)
3744 return last_non_zero;
3746 if(last_non_zero == 0 && start_i == 0){
3748 int best_score= dc * dc;
3750 for(i=0; i<coeff_count[0]; i++){
3751 int level= coeff[i][0];
3752 int alevel= FFABS(level);
3753 int unquant_coeff, score, distortion;
3755 if(s->out_format == FMT_H263){
3756 unquant_coeff= (alevel*qmul + qadd)>>3;
3758 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3759 unquant_coeff = (unquant_coeff - 1) | 1;
3761 unquant_coeff = (unquant_coeff + 4) >> 3;
3762 unquant_coeff<<= 3 + 3;
3764 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3766 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3767 else score= distortion + esc_length*lambda;
3769 if(score < best_score){
3771 best_level= level - 64;
3774 block[0]= best_level;
3775 s->coded_score[n] = best_score - dc*dc;
3776 if(best_level == 0) return -1;
3777 else return last_non_zero;
3783 block[ perm_scantable[last_non_zero] ]= last_level;
3786 for(; i>start_i; i -= run_tab[i] + 1){
3787 block[ perm_scantable[i-1] ]= level_tab[i];
3790 return last_non_zero;
3793 //#define REFINE_STATS 1
3794 static int16_t basis[64][64];
3796 static void build_basis(uint8_t *perm){
3803 double s= 0.25*(1<<BASIS_SHIFT);
3805 int perm_index= perm[index];
3806 if(i==0) s*= sqrt(0.5);
3807 if(j==0) s*= sqrt(0.5);
3808 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
3815 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3816 int16_t *block, int16_t *weight, int16_t *orig,
3819 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3820 const uint8_t *scantable= s->intra_scantable.scantable;
3821 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3822 // unsigned int threshold1, threshold2;
3827 int qmul, qadd, start_i, last_non_zero, i, dc;
3829 uint8_t * last_length;
3831 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3834 static int after_last=0;
3835 static int to_zero=0;
3836 static int from_zero=0;
3839 static int messed_sign=0;
3842 if(basis[0][0] == 0)
3843 build_basis(s->idsp.idct_permutation);
3854 /* For AIC we skip quant/dequant of INTRADC */
3858 q <<= RECON_SHIFT-3;
3859 /* note: block[0] is assumed to be positive */
3861 // block[0] = (block[0] + (q >> 1)) / q;
3863 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3864 // bias= 1<<(QMAT_SHIFT-1);
3865 length = s->intra_ac_vlc_length;
3866 last_length= s->intra_ac_vlc_last_length;
3870 length = s->inter_ac_vlc_length;
3871 last_length= s->inter_ac_vlc_last_length;
3873 last_non_zero = s->block_last_index[n];
3878 dc += (1<<(RECON_SHIFT-1));
3879 for(i=0; i<64; i++){
3880 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3883 STOP_TIMER("memset rem[]")}
3886 for(i=0; i<64; i++){
3891 w= FFABS(weight[i]) + qns*one;
3892 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3895 // w=weight[i] = (63*qns + (w/2)) / w;
3901 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3907 for(i=start_i; i<=last_non_zero; i++){
3908 int j= perm_scantable[i];
3909 const int level= block[j];
3913 if(level<0) coeff= qmul*level - qadd;
3914 else coeff= qmul*level + qadd;
3915 run_tab[rle_index++]=run;
3918 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
3924 if(last_non_zero>0){
3925 STOP_TIMER("init rem[]")
3932 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
3935 int run2, best_unquant_change=0, analyze_gradient;
3939 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3941 if(analyze_gradient){
3945 for(i=0; i<64; i++){
3948 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3951 STOP_TIMER("rem*w*w")}
3961 const int level= block[0];
3962 int change, old_coeff;
3964 assert(s->mb_intra);
3968 for(change=-1; change<=1; change+=2){
3969 int new_level= level + change;
3970 int score, new_coeff;
3972 new_coeff= q*new_level;
3973 if(new_coeff >= 2048 || new_coeff < 0)
3976 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
3977 new_coeff - old_coeff);
3978 if(score<best_score){
3981 best_change= change;
3982 best_unquant_change= new_coeff - old_coeff;
3989 run2= run_tab[rle_index++];
3993 for(i=start_i; i<64; i++){
3994 int j= perm_scantable[i];
3995 const int level= block[j];
3996 int change, old_coeff;
3998 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4002 if(level<0) old_coeff= qmul*level - qadd;
4003 else old_coeff= qmul*level + qadd;
4004 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4008 assert(run2>=0 || i >= last_non_zero );
4011 for(change=-1; change<=1; change+=2){
4012 int new_level= level + change;
4013 int score, new_coeff, unquant_change;
4016 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4020 if(new_level<0) new_coeff= qmul*new_level - qadd;
4021 else new_coeff= qmul*new_level + qadd;
4022 if(new_coeff >= 2048 || new_coeff <= -2048)
4024 //FIXME check for overflow
4027 if(level < 63 && level > -63){
4028 if(i < last_non_zero)
4029 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4030 - length[UNI_AC_ENC_INDEX(run, level+64)];
4032 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4033 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4036 assert(FFABS(new_level)==1);
4038 if(analyze_gradient){
4039 int g= d1[ scantable[i] ];
4040 if(g && (g^new_level) >= 0)
4044 if(i < last_non_zero){
4045 int next_i= i + run2 + 1;
4046 int next_level= block[ perm_scantable[next_i] ] + 64;
4048 if(next_level&(~127))
4051 if(next_i < last_non_zero)
4052 score += length[UNI_AC_ENC_INDEX(run, 65)]
4053 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4054 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4056 score += length[UNI_AC_ENC_INDEX(run, 65)]
4057 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4058 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4060 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4062 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4063 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4069 assert(FFABS(level)==1);
4071 if(i < last_non_zero){
4072 int next_i= i + run2 + 1;
4073 int next_level= block[ perm_scantable[next_i] ] + 64;
4075 if(next_level&(~127))
4078 if(next_i < last_non_zero)
4079 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4080 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4081 - length[UNI_AC_ENC_INDEX(run, 65)];
4083 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4084 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4085 - length[UNI_AC_ENC_INDEX(run, 65)];
4087 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4089 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4090 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4097 unquant_change= new_coeff - old_coeff;
4098 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4100 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4102 if(score<best_score){
4105 best_change= change;
4106 best_unquant_change= unquant_change;
4110 prev_level= level + 64;
4111 if(prev_level&(~127))
4120 STOP_TIMER("iterative step")}
4124 int j= perm_scantable[ best_coeff ];
4126 block[j] += best_change;
4128 if(best_coeff > last_non_zero){
4129 last_non_zero= best_coeff;
4137 if(block[j] - best_change){
4138 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4150 for(; last_non_zero>=start_i; last_non_zero--){
4151 if(block[perm_scantable[last_non_zero]])
4157 if(256*256*256*64 % count == 0){
4158 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4163 for(i=start_i; i<=last_non_zero; i++){
4164 int j= perm_scantable[i];
4165 const int level= block[j];
4168 run_tab[rle_index++]=run;
4175 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4181 if(last_non_zero>0){
4182 STOP_TIMER("iterative search")
4187 return last_non_zero;
4190 int ff_dct_quantize_c(MpegEncContext *s,
4191 int16_t *block, int n,
4192 int qscale, int *overflow)
4194 int i, j, level, last_non_zero, q, start_i;
4196 const uint8_t *scantable= s->intra_scantable.scantable;
4199 unsigned int threshold1, threshold2;
4201 s->fdsp.fdct(block);
4203 if(s->dct_error_sum)
4204 s->denoise_dct(s, block);
4214 /* For AIC we skip quant/dequant of INTRADC */
4217 /* note: block[0] is assumed to be positive */
4218 block[0] = (block[0] + (q >> 1)) / q;
4221 qmat = s->q_intra_matrix[qscale];
4222 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4226 qmat = s->q_inter_matrix[qscale];
4227 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4229 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4230 threshold2= (threshold1<<1);
4231 for(i=63;i>=start_i;i--) {
4233 level = block[j] * qmat[j];
4235 if(((unsigned)(level+threshold1))>threshold2){
4242 for(i=start_i; i<=last_non_zero; i++) {
4244 level = block[j] * qmat[j];
4246 // if( bias+level >= (1<<QMAT_SHIFT)
4247 // || bias-level >= (1<<QMAT_SHIFT)){
4248 if(((unsigned)(level+threshold1))>threshold2){
4250 level= (bias + level)>>QMAT_SHIFT;
4253 level= (bias - level)>>QMAT_SHIFT;
4261 *overflow= s->max_qcoeff < max; //overflow might have happened
4263 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4264 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4265 ff_block_permute(block, s->idsp.idct_permutation,
4266 scantable, last_non_zero);
4268 return last_non_zero;
4271 #define OFFSET(x) offsetof(MpegEncContext, x)
4272 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4273 static const AVOption h263_options[] = {
4274 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4275 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4276 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4281 static const AVClass h263_class = {
4282 .class_name = "H.263 encoder",
4283 .item_name = av_default_item_name,
4284 .option = h263_options,
4285 .version = LIBAVUTIL_VERSION_INT,
4288 AVCodec ff_h263_encoder = {
4290 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4291 .type = AVMEDIA_TYPE_VIDEO,
4292 .id = AV_CODEC_ID_H263,
4293 .priv_data_size = sizeof(MpegEncContext),
4294 .init = ff_mpv_encode_init,
4295 .encode2 = ff_mpv_encode_picture,
4296 .close = ff_mpv_encode_end,
4297 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4298 .priv_class = &h263_class,
4301 static const AVOption h263p_options[] = {
4302 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4303 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4304 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4305 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4309 static const AVClass h263p_class = {
4310 .class_name = "H.263p encoder",
4311 .item_name = av_default_item_name,
4312 .option = h263p_options,
4313 .version = LIBAVUTIL_VERSION_INT,
4316 AVCodec ff_h263p_encoder = {
4318 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4319 .type = AVMEDIA_TYPE_VIDEO,
4320 .id = AV_CODEC_ID_H263P,
4321 .priv_data_size = sizeof(MpegEncContext),
4322 .init = ff_mpv_encode_init,
4323 .encode2 = ff_mpv_encode_picture,
4324 .close = ff_mpv_encode_end,
4325 .capabilities = CODEC_CAP_SLICE_THREADS,
4326 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4327 .priv_class = &h263p_class,
4330 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4332 AVCodec ff_msmpeg4v2_encoder = {
4333 .name = "msmpeg4v2",
4334 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4335 .type = AVMEDIA_TYPE_VIDEO,
4336 .id = AV_CODEC_ID_MSMPEG4V2,
4337 .priv_data_size = sizeof(MpegEncContext),
4338 .init = ff_mpv_encode_init,
4339 .encode2 = ff_mpv_encode_picture,
4340 .close = ff_mpv_encode_end,
4341 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4342 .priv_class = &msmpeg4v2_class,
4345 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4347 AVCodec ff_msmpeg4v3_encoder = {
4349 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4350 .type = AVMEDIA_TYPE_VIDEO,
4351 .id = AV_CODEC_ID_MSMPEG4V3,
4352 .priv_data_size = sizeof(MpegEncContext),
4353 .init = ff_mpv_encode_init,
4354 .encode2 = ff_mpv_encode_picture,
4355 .close = ff_mpv_encode_end,
4356 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4357 .priv_class = &msmpeg4v3_class,
4360 FF_MPV_GENERIC_CLASS(wmv1)
4362 AVCodec ff_wmv1_encoder = {
4364 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4365 .type = AVMEDIA_TYPE_VIDEO,
4366 .id = AV_CODEC_ID_WMV1,
4367 .priv_data_size = sizeof(MpegEncContext),
4368 .init = ff_mpv_encode_init,
4369 .encode2 = ff_mpv_encode_picture,
4370 .close = ff_mpv_encode_end,
4371 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4372 .priv_class = &wmv1_class,