2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of Libav.
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "libavutil/internal.h"
33 #include "libavutil/intmath.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/timer.h"
42 #include "mpegvideo.h"
43 #include "mpegvideodata.h"
47 #include "mjpegenc_common.h"
49 #include "mpegutils.h"
52 #include "pixblockdsp.h"
56 #include "aandcttab.h"
58 #include "mpeg4video.h"
60 #include "bytestream.h"
65 #define QUANT_BIAS_SHIFT 8
67 #define QMAT_SHIFT_MMX 16
70 static int encode_picture(MpegEncContext *s, int picture_number);
71 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
72 static int sse_mb(MpegEncContext *s);
73 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
74 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
76 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
77 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
79 const AVOption ff_mpv_generic_options[] = {
84 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
85 uint16_t (*qmat16)[2][64],
86 const uint16_t *quant_matrix,
87 int bias, int qmin, int qmax, int intra)
89 FDCTDSPContext *fdsp = &s->fdsp;
93 for (qscale = qmin; qscale <= qmax; qscale++) {
95 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
97 fdsp->fdct == ff_faandct ||
98 #endif /* CONFIG_FAANDCT */
99 fdsp->fdct == ff_jpeg_fdct_islow_10) {
100 for (i = 0; i < 64; i++) {
101 const int j = s->idsp.idct_permutation[i];
102 int64_t den = (int64_t) qscale * quant_matrix[j];
103 /* 16 <= qscale * quant_matrix[i] <= 7905
104 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
105 * 19952 <= x <= 249205026
106 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
107 * 3444240 >= (1 << 36) / (x) >= 275 */
109 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
111 } else if (fdsp->fdct == ff_fdct_ifast) {
112 for (i = 0; i < 64; i++) {
113 const int j = s->idsp.idct_permutation[i];
114 int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
115 /* 16 <= qscale * quant_matrix[i] <= 7905
116 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
117 * 19952 <= x <= 249205026
118 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
119 * 3444240 >= (1 << 36) / (x) >= 275 */
121 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
124 for (i = 0; i < 64; i++) {
125 const int j = s->idsp.idct_permutation[i];
126 int64_t den = (int64_t) qscale * quant_matrix[j];
127 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
128 * Assume x = qscale * quant_matrix[i]
130 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
131 * so 32768 >= (1 << 19) / (x) >= 67 */
132 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
133 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
134 // (qscale * quant_matrix[i]);
135 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
137 if (qmat16[qscale][0][i] == 0 ||
138 qmat16[qscale][0][i] == 128 * 256)
139 qmat16[qscale][0][i] = 128 * 256 - 1;
140 qmat16[qscale][1][i] =
141 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
142 qmat16[qscale][0][i]);
146 for (i = intra; i < 64; i++) {
148 if (fdsp->fdct == ff_fdct_ifast) {
149 max = (8191LL * ff_aanscales[i]) >> 14;
151 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
157 av_log(NULL, AV_LOG_INFO,
158 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
163 static inline void update_qscale(MpegEncContext *s)
165 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
166 (FF_LAMBDA_SHIFT + 7);
167 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
169 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
173 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
179 for (i = 0; i < 64; i++) {
180 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
187 * init s->current_picture.qscale_table from s->lambda_table
189 void ff_init_qscale_tab(MpegEncContext *s)
191 int8_t * const qscale_table = s->current_picture.qscale_table;
194 for (i = 0; i < s->mb_num; i++) {
195 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
196 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
197 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
202 static void update_duplicate_context_after_me(MpegEncContext *dst,
205 #define COPY(a) dst->a= src->a
207 COPY(current_picture);
213 COPY(picture_in_gop_number);
214 COPY(gop_picture_number);
215 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
216 COPY(progressive_frame); // FIXME don't set in encode_header
217 COPY(partitioned_frame); // FIXME don't set in encode_header
222 * Set the given MpegEncContext to defaults for encoding.
223 * the changed fields will not depend upon the prior state of the MpegEncContext.
225 static void mpv_encode_defaults(MpegEncContext *s)
228 ff_mpv_common_defaults(s);
230 for (i = -16; i < 16; i++) {
231 default_fcode_tab[i + MAX_MV] = 1;
233 s->me.mv_penalty = default_mv_penalty;
234 s->fcode_tab = default_fcode_tab;
236 s->input_picture_number = 0;
237 s->picture_in_gop_number = 0;
240 /* init video encoder */
241 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
243 MpegEncContext *s = avctx->priv_data;
244 AVCPBProperties *cpb_props;
245 int i, ret, format_supported;
247 mpv_encode_defaults(s);
249 switch (avctx->codec_id) {
250 case AV_CODEC_ID_MPEG2VIDEO:
251 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
252 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
253 av_log(avctx, AV_LOG_ERROR,
254 "only YUV420 and YUV422 are supported\n");
258 case AV_CODEC_ID_MJPEG:
259 format_supported = 0;
260 /* JPEG color space */
261 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
262 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
263 (avctx->color_range == AVCOL_RANGE_JPEG &&
264 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
265 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
266 format_supported = 1;
267 /* MPEG color space */
268 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
269 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
270 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
271 format_supported = 1;
273 if (!format_supported) {
274 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
279 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
280 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
285 switch (avctx->pix_fmt) {
286 case AV_PIX_FMT_YUVJ422P:
287 case AV_PIX_FMT_YUV422P:
288 s->chroma_format = CHROMA_422;
290 case AV_PIX_FMT_YUVJ420P:
291 case AV_PIX_FMT_YUV420P:
293 s->chroma_format = CHROMA_420;
297 #if FF_API_PRIVATE_OPT
298 FF_DISABLE_DEPRECATION_WARNINGS
299 if (avctx->rtp_payload_size)
300 s->rtp_payload_size = avctx->rtp_payload_size;
301 if (avctx->me_penalty_compensation)
302 s->me_penalty_compensation = avctx->me_penalty_compensation;
304 s->me_pre = avctx->pre_me;
305 FF_ENABLE_DEPRECATION_WARNINGS
308 s->bit_rate = avctx->bit_rate;
309 s->width = avctx->width;
310 s->height = avctx->height;
311 if (avctx->gop_size > 600 &&
312 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
313 av_log(avctx, AV_LOG_ERROR,
314 "Warning keyframe interval too large! reducing it ...\n");
315 avctx->gop_size = 600;
317 s->gop_size = avctx->gop_size;
319 if (avctx->max_b_frames > MAX_B_FRAMES) {
320 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
321 "is %d.\n", MAX_B_FRAMES);
323 s->max_b_frames = avctx->max_b_frames;
324 s->codec_id = avctx->codec->id;
325 s->strict_std_compliance = avctx->strict_std_compliance;
326 s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
327 s->rtp_mode = !!s->rtp_payload_size;
328 s->intra_dc_precision = avctx->intra_dc_precision;
329 s->user_specified_pts = AV_NOPTS_VALUE;
331 if (s->gop_size <= 1) {
338 #if FF_API_MOTION_EST
339 FF_DISABLE_DEPRECATION_WARNINGS
340 s->me_method = avctx->me_method;
341 FF_ENABLE_DEPRECATION_WARNINGS
345 s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
348 FF_DISABLE_DEPRECATION_WARNINGS
349 if (avctx->border_masking != 0.0)
350 s->border_masking = avctx->border_masking;
351 FF_ENABLE_DEPRECATION_WARNINGS
354 s->adaptive_quant = (s->avctx->lumi_masking ||
355 s->avctx->dark_masking ||
356 s->avctx->temporal_cplx_masking ||
357 s->avctx->spatial_cplx_masking ||
358 s->avctx->p_masking ||
360 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
363 s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
365 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
366 av_log(avctx, AV_LOG_ERROR,
367 "a vbv buffer size is needed, "
368 "for encoding with a maximum bitrate\n");
372 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
373 av_log(avctx, AV_LOG_INFO,
374 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
377 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
378 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
382 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
383 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
387 if (avctx->rc_max_rate &&
388 avctx->rc_max_rate == avctx->bit_rate &&
389 avctx->rc_max_rate != avctx->rc_min_rate) {
390 av_log(avctx, AV_LOG_INFO,
391 "impossible bitrate constraints, this will fail\n");
394 if (avctx->rc_buffer_size &&
395 avctx->bit_rate * (int64_t)avctx->time_base.num >
396 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
397 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
401 if (!s->fixed_qscale &&
402 avctx->bit_rate * av_q2d(avctx->time_base) >
403 avctx->bit_rate_tolerance) {
404 av_log(avctx, AV_LOG_ERROR,
405 "bitrate tolerance too small for bitrate\n");
409 if (s->avctx->rc_max_rate &&
410 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
411 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
412 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
413 90000LL * (avctx->rc_buffer_size - 1) >
414 s->avctx->rc_max_rate * 0xFFFFLL) {
415 av_log(avctx, AV_LOG_INFO,
416 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
417 "specified vbv buffer is too large for the given bitrate!\n");
420 if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
421 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
422 s->codec_id != AV_CODEC_ID_FLV1) {
423 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
427 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
428 av_log(avctx, AV_LOG_ERROR,
429 "OBMC is only supported with simple mb decision\n");
433 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
434 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
438 if (s->max_b_frames &&
439 s->codec_id != AV_CODEC_ID_MPEG4 &&
440 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
441 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
442 av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
446 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
447 s->codec_id == AV_CODEC_ID_H263 ||
448 s->codec_id == AV_CODEC_ID_H263P) &&
449 (avctx->sample_aspect_ratio.num > 255 ||
450 avctx->sample_aspect_ratio.den > 255)) {
451 av_log(avctx, AV_LOG_ERROR,
452 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
453 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
457 if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
458 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
459 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
463 #if FF_API_PRIVATE_OPT
464 FF_DISABLE_DEPRECATION_WARNINGS
465 if (avctx->mpeg_quant)
466 s->mpeg_quant = avctx->mpeg_quant;
467 FF_ENABLE_DEPRECATION_WARNINGS
470 // FIXME mpeg2 uses that too
471 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
472 av_log(avctx, AV_LOG_ERROR,
473 "mpeg2 style quantization not supported by codec\n");
477 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
478 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
482 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
483 s->avctx->mb_decision != FF_MB_DECISION_RD) {
484 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
488 #if FF_API_PRIVATE_OPT
489 FF_DISABLE_DEPRECATION_WARNINGS
490 if (avctx->scenechange_threshold)
491 s->scenechange_threshold = avctx->scenechange_threshold;
492 FF_ENABLE_DEPRECATION_WARNINGS
495 if (s->scenechange_threshold < 1000000000 &&
496 (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
497 av_log(avctx, AV_LOG_ERROR,
498 "closed gop with scene change detection are not supported yet, "
499 "set threshold to 1000000000\n");
503 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
504 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
505 av_log(avctx, AV_LOG_ERROR,
506 "low delay forcing is only available for mpeg2\n");
509 if (s->max_b_frames != 0) {
510 av_log(avctx, AV_LOG_ERROR,
511 "B-frames cannot be used with low delay\n");
516 if (s->q_scale_type == 1) {
517 if (avctx->qmax > 12) {
518 av_log(avctx, AV_LOG_ERROR,
519 "non linear quant only supports qmax <= 12 currently\n");
524 if (avctx->slices > 1 &&
525 (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
526 av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
527 return AVERROR(EINVAL);
530 if (s->avctx->thread_count > 1 &&
531 s->codec_id != AV_CODEC_ID_MPEG4 &&
532 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
533 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
534 (s->codec_id != AV_CODEC_ID_H263P)) {
535 av_log(avctx, AV_LOG_ERROR,
536 "multi threaded encoding not supported by codec\n");
540 if (s->avctx->thread_count < 1) {
541 av_log(avctx, AV_LOG_ERROR,
542 "automatic thread number detection not supported by codec,"
547 if (!avctx->time_base.den || !avctx->time_base.num) {
548 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
552 #if FF_API_PRIVATE_OPT
553 FF_DISABLE_DEPRECATION_WARNINGS
554 if (avctx->b_frame_strategy)
555 s->b_frame_strategy = avctx->b_frame_strategy;
556 if (avctx->b_sensitivity != 40)
557 s->b_sensitivity = avctx->b_sensitivity;
558 FF_ENABLE_DEPRECATION_WARNINGS
561 if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
562 av_log(avctx, AV_LOG_INFO,
563 "notice: b_frame_strategy only affects the first pass\n");
564 s->b_frame_strategy = 0;
567 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
569 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
570 avctx->time_base.den /= i;
571 avctx->time_base.num /= i;
575 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
576 s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
577 // (a + x * 3 / 8) / x
578 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
579 s->inter_quant_bias = 0;
581 s->intra_quant_bias = 0;
583 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
586 #if FF_API_QUANT_BIAS
587 FF_DISABLE_DEPRECATION_WARNINGS
588 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
589 s->intra_quant_bias = avctx->intra_quant_bias;
590 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
591 s->inter_quant_bias = avctx->inter_quant_bias;
592 FF_ENABLE_DEPRECATION_WARNINGS
595 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
596 s->avctx->time_base.den > (1 << 16) - 1) {
597 av_log(avctx, AV_LOG_ERROR,
598 "timebase %d/%d not supported by MPEG 4 standard, "
599 "the maximum admitted value for the timebase denominator "
600 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
604 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
606 switch (avctx->codec->id) {
607 case AV_CODEC_ID_MPEG1VIDEO:
608 s->out_format = FMT_MPEG1;
609 s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
610 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
612 case AV_CODEC_ID_MPEG2VIDEO:
613 s->out_format = FMT_MPEG1;
614 s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
615 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
618 case AV_CODEC_ID_MJPEG:
619 s->out_format = FMT_MJPEG;
620 s->intra_only = 1; /* force intra only for jpeg */
621 if (!CONFIG_MJPEG_ENCODER ||
622 ff_mjpeg_encode_init(s) < 0)
627 case AV_CODEC_ID_H261:
628 if (!CONFIG_H261_ENCODER)
630 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
631 av_log(avctx, AV_LOG_ERROR,
632 "The specified picture size of %dx%d is not valid for the "
633 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
634 s->width, s->height);
637 s->out_format = FMT_H261;
640 s->rtp_mode = 0; /* Sliced encoding not supported */
642 case AV_CODEC_ID_H263:
643 if (!CONFIG_H263_ENCODER)
645 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
646 s->width, s->height) == 8) {
647 av_log(avctx, AV_LOG_INFO,
648 "The specified picture size of %dx%d is not valid for "
649 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
650 "352x288, 704x576, and 1408x1152."
651 "Try H.263+.\n", s->width, s->height);
654 s->out_format = FMT_H263;
658 case AV_CODEC_ID_H263P:
659 s->out_format = FMT_H263;
662 s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
663 s->modified_quant = s->h263_aic;
664 s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
665 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
668 /* These are just to be sure */
672 case AV_CODEC_ID_FLV1:
673 s->out_format = FMT_H263;
674 s->h263_flv = 2; /* format = 1; 11-bit codes */
675 s->unrestricted_mv = 1;
676 s->rtp_mode = 0; /* don't allow GOB */
680 case AV_CODEC_ID_RV10:
681 s->out_format = FMT_H263;
685 case AV_CODEC_ID_RV20:
686 s->out_format = FMT_H263;
689 s->modified_quant = 1;
693 s->unrestricted_mv = 0;
695 case AV_CODEC_ID_MPEG4:
696 s->out_format = FMT_H263;
698 s->unrestricted_mv = 1;
699 s->low_delay = s->max_b_frames ? 0 : 1;
700 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
702 case AV_CODEC_ID_MSMPEG4V2:
703 s->out_format = FMT_H263;
705 s->unrestricted_mv = 1;
706 s->msmpeg4_version = 2;
710 case AV_CODEC_ID_MSMPEG4V3:
711 s->out_format = FMT_H263;
713 s->unrestricted_mv = 1;
714 s->msmpeg4_version = 3;
715 s->flipflop_rounding = 1;
719 case AV_CODEC_ID_WMV1:
720 s->out_format = FMT_H263;
722 s->unrestricted_mv = 1;
723 s->msmpeg4_version = 4;
724 s->flipflop_rounding = 1;
728 case AV_CODEC_ID_WMV2:
729 s->out_format = FMT_H263;
731 s->unrestricted_mv = 1;
732 s->msmpeg4_version = 5;
733 s->flipflop_rounding = 1;
741 #if FF_API_PRIVATE_OPT
742 FF_DISABLE_DEPRECATION_WARNINGS
743 if (avctx->noise_reduction)
744 s->noise_reduction = avctx->noise_reduction;
745 FF_ENABLE_DEPRECATION_WARNINGS
748 avctx->has_b_frames = !s->low_delay;
752 s->progressive_frame =
753 s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
754 AV_CODEC_FLAG_INTERLACED_ME) ||
759 if (ff_mpv_common_init(s) < 0)
763 ff_mpv_encode_init_x86(s);
765 ff_fdctdsp_init(&s->fdsp, avctx);
766 ff_me_cmp_init(&s->mecc, avctx);
767 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
768 ff_pixblockdsp_init(&s->pdsp, avctx);
769 ff_qpeldsp_init(&s->qdsp);
771 if (s->msmpeg4_version) {
772 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
773 2 * 2 * (MAX_LEVEL + 1) *
774 (MAX_RUN + 1) * 2 * sizeof(int), fail);
776 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
778 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
779 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
780 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
781 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
782 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
783 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
784 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
785 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
788 if (s->noise_reduction) {
789 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
790 2 * 64 * sizeof(uint16_t), fail);
793 if (CONFIG_H263_ENCODER)
794 ff_h263dsp_init(&s->h263dsp);
795 if (!s->dct_quantize)
796 s->dct_quantize = ff_dct_quantize_c;
798 s->denoise_dct = denoise_dct_c;
799 s->fast_dct_quantize = s->dct_quantize;
801 s->dct_quantize = dct_quantize_trellis_c;
803 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
804 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
806 if (s->slice_context_count > 1) {
809 if (avctx->codec_id == AV_CODEC_ID_H263 || avctx->codec_id == AV_CODEC_ID_H263P)
810 s->h263_slice_structured = 1;
813 s->quant_precision = 5;
815 #if FF_API_PRIVATE_OPT
816 FF_DISABLE_DEPRECATION_WARNINGS
817 if (avctx->frame_skip_threshold)
818 s->frame_skip_threshold = avctx->frame_skip_threshold;
819 if (avctx->frame_skip_factor)
820 s->frame_skip_factor = avctx->frame_skip_factor;
821 if (avctx->frame_skip_exp)
822 s->frame_skip_exp = avctx->frame_skip_exp;
823 if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
824 s->frame_skip_cmp = avctx->frame_skip_cmp;
825 FF_ENABLE_DEPRECATION_WARNINGS
828 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
829 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
831 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
832 ff_h261_encode_init(s);
833 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
834 ff_h263_encode_init(s);
835 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
836 if ((ret = ff_msmpeg4_encode_init(s)) < 0)
838 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
839 && s->out_format == FMT_MPEG1)
840 ff_mpeg1_encode_init(s);
843 for (i = 0; i < 64; i++) {
844 int j = s->idsp.idct_permutation[i];
845 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
847 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
848 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
849 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
851 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
854 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
855 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
857 if (s->avctx->intra_matrix)
858 s->intra_matrix[j] = s->avctx->intra_matrix[i];
859 if (s->avctx->inter_matrix)
860 s->inter_matrix[j] = s->avctx->inter_matrix[i];
863 /* precompute matrix */
864 /* for mjpeg, we do include qscale in the matrix */
865 if (s->out_format != FMT_MJPEG) {
866 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
867 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
869 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
870 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
874 if (ff_rate_control_init(s) < 0)
877 #if FF_API_ERROR_RATE
878 FF_DISABLE_DEPRECATION_WARNINGS
879 if (avctx->error_rate)
880 s->error_rate = avctx->error_rate;
881 FF_ENABLE_DEPRECATION_WARNINGS;
884 #if FF_API_NORMALIZE_AQP
885 FF_DISABLE_DEPRECATION_WARNINGS
886 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
887 s->mpv_flags |= FF_MPV_FLAG_NAQ;
888 FF_ENABLE_DEPRECATION_WARNINGS;
892 FF_DISABLE_DEPRECATION_WARNINGS
893 if (avctx->flags & CODEC_FLAG_MV0)
894 s->mpv_flags |= FF_MPV_FLAG_MV0;
895 FF_ENABLE_DEPRECATION_WARNINGS
899 FF_DISABLE_DEPRECATION_WARNINGS
900 if (avctx->rc_qsquish != 0.0)
901 s->rc_qsquish = avctx->rc_qsquish;
902 if (avctx->rc_qmod_amp != 0.0)
903 s->rc_qmod_amp = avctx->rc_qmod_amp;
904 if (avctx->rc_qmod_freq)
905 s->rc_qmod_freq = avctx->rc_qmod_freq;
906 if (avctx->rc_buffer_aggressivity != 1.0)
907 s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
908 if (avctx->rc_initial_cplx != 0.0)
909 s->rc_initial_cplx = avctx->rc_initial_cplx;
911 s->lmin = avctx->lmin;
913 s->lmax = avctx->lmax;
917 s->rc_eq = av_strdup(avctx->rc_eq);
919 return AVERROR(ENOMEM);
921 FF_ENABLE_DEPRECATION_WARNINGS
924 #if FF_API_PRIVATE_OPT
925 FF_DISABLE_DEPRECATION_WARNINGS
926 if (avctx->brd_scale)
927 s->brd_scale = avctx->brd_scale;
929 if (avctx->prediction_method)
930 s->pred = avctx->prediction_method + 1;
931 FF_ENABLE_DEPRECATION_WARNINGS
934 if (s->b_frame_strategy == 2) {
935 for (i = 0; i < s->max_b_frames + 2; i++) {
936 s->tmp_frames[i] = av_frame_alloc();
937 if (!s->tmp_frames[i])
938 return AVERROR(ENOMEM);
940 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
941 s->tmp_frames[i]->width = s->width >> s->brd_scale;
942 s->tmp_frames[i]->height = s->height >> s->brd_scale;
944 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
950 cpb_props = ff_add_cpb_side_data(avctx);
952 return AVERROR(ENOMEM);
953 cpb_props->max_bitrate = avctx->rc_max_rate;
954 cpb_props->min_bitrate = avctx->rc_min_rate;
955 cpb_props->avg_bitrate = avctx->bit_rate;
956 cpb_props->buffer_size = avctx->rc_buffer_size;
960 ff_mpv_encode_end(avctx);
961 return AVERROR_UNKNOWN;
964 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
966 MpegEncContext *s = avctx->priv_data;
969 ff_rate_control_uninit(s);
970 ff_mpv_common_end(s);
971 if (CONFIG_MJPEG_ENCODER &&
972 s->out_format == FMT_MJPEG)
973 ff_mjpeg_encode_close(s);
975 av_freep(&avctx->extradata);
977 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
978 av_frame_free(&s->tmp_frames[i]);
980 ff_free_picture_tables(&s->new_picture);
981 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
983 av_freep(&s->avctx->stats_out);
984 av_freep(&s->ac_stats);
986 av_freep(&s->q_intra_matrix);
987 av_freep(&s->q_inter_matrix);
988 av_freep(&s->q_intra_matrix16);
989 av_freep(&s->q_inter_matrix16);
990 av_freep(&s->input_picture);
991 av_freep(&s->reordered_input_picture);
992 av_freep(&s->dct_offset);
997 static int get_sae(uint8_t *src, int ref, int stride)
1002 for (y = 0; y < 16; y++) {
1003 for (x = 0; x < 16; x++) {
1004 acc += FFABS(src[x + y * stride] - ref);
1011 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1012 uint8_t *ref, int stride)
1018 h = s->height & ~15;
1020 for (y = 0; y < h; y += 16) {
1021 for (x = 0; x < w; x += 16) {
1022 int offset = x + y * stride;
1023 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1025 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1026 int sae = get_sae(src + offset, mean, stride);
1028 acc += sae + 500 < sad;
1034 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1036 return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1037 s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1038 s->mb_stride, s->mb_height, s->b8_stride,
1039 &s->linesize, &s->uvlinesize);
1042 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1044 Picture *pic = NULL;
1046 int i, display_picture_number = 0, ret;
1047 int encoding_delay = s->max_b_frames ? s->max_b_frames
1048 : (s->low_delay ? 0 : 1);
1049 int flush_offset = 1;
1054 display_picture_number = s->input_picture_number++;
1056 if (pts != AV_NOPTS_VALUE) {
1057 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1059 int64_t last = s->user_specified_pts;
1062 av_log(s->avctx, AV_LOG_ERROR,
1063 "Error, Invalid timestamp=%"PRId64", "
1064 "last=%"PRId64"\n", pts, s->user_specified_pts);
1068 if (!s->low_delay && display_picture_number == 1)
1069 s->dts_delta = time - last;
1071 s->user_specified_pts = pts;
1073 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1074 s->user_specified_pts =
1075 pts = s->user_specified_pts + 1;
1076 av_log(s->avctx, AV_LOG_INFO,
1077 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1080 pts = display_picture_number;
1084 if (!pic_arg->buf[0] ||
1085 pic_arg->linesize[0] != s->linesize ||
1086 pic_arg->linesize[1] != s->uvlinesize ||
1087 pic_arg->linesize[2] != s->uvlinesize)
1089 if ((s->width & 15) || (s->height & 15))
1092 ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
1093 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1095 i = ff_find_unused_picture(s->avctx, s->picture, direct);
1099 pic = &s->picture[i];
1103 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1106 ret = alloc_picture(s, pic, direct);
1111 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1112 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1113 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1116 int h_chroma_shift, v_chroma_shift;
1117 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1121 for (i = 0; i < 3; i++) {
1122 int src_stride = pic_arg->linesize[i];
1123 int dst_stride = i ? s->uvlinesize : s->linesize;
1124 int h_shift = i ? h_chroma_shift : 0;
1125 int v_shift = i ? v_chroma_shift : 0;
1126 int w = s->width >> h_shift;
1127 int h = s->height >> v_shift;
1128 uint8_t *src = pic_arg->data[i];
1129 uint8_t *dst = pic->f->data[i];
1131 if (!s->avctx->rc_buffer_size)
1132 dst += INPLACE_OFFSET;
1134 if (src_stride == dst_stride)
1135 memcpy(dst, src, src_stride * h);
1138 uint8_t *dst2 = dst;
1140 memcpy(dst2, src, w);
1145 if ((s->width & 15) || (s->height & 15)) {
1146 s->mpvencdsp.draw_edges(dst, dst_stride,
1155 ret = av_frame_copy_props(pic->f, pic_arg);
1159 pic->f->display_picture_number = display_picture_number;
1160 pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1162 /* Flushing: When we have not received enough input frames,
1163 * ensure s->input_picture[0] contains the first picture */
1164 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1165 if (s->input_picture[flush_offset])
1168 if (flush_offset <= 1)
1171 encoding_delay = encoding_delay - flush_offset + 1;
1174 /* shift buffer entries */
1175 for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1176 s->input_picture[i - flush_offset] = s->input_picture[i];
1178 s->input_picture[encoding_delay] = (Picture*) pic;
1183 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1187 int64_t score64 = 0;
1189 for (plane = 0; plane < 3; plane++) {
1190 const int stride = p->f->linesize[plane];
1191 const int bw = plane ? 1 : 2;
1192 for (y = 0; y < s->mb_height * bw; y++) {
1193 for (x = 0; x < s->mb_width * bw; x++) {
1194 int off = p->shared ? 0 : 16;
1195 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1196 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1197 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1199 switch (s->frame_skip_exp) {
1200 case 0: score = FFMAX(score, v); break;
1201 case 1: score += FFABS(v); break;
1202 case 2: score += v * v; break;
1203 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1204 case 4: score64 += v * v * (int64_t)(v * v); break;
1213 if (score64 < s->frame_skip_threshold)
1215 if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1220 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1222 AVPacket pkt = { 0 };
1226 av_init_packet(&pkt);
1228 ret = avcodec_send_frame(c, frame);
1233 ret = avcodec_receive_packet(c, &pkt);
1236 av_packet_unref(&pkt);
1237 } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1244 static int estimate_best_b_count(MpegEncContext *s)
1246 const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1247 const int scale = s->brd_scale;
1248 int width = s->width >> scale;
1249 int height = s->height >> scale;
1250 int i, j, out_size, p_lambda, b_lambda, lambda2;
1251 int64_t best_rd = INT64_MAX;
1252 int best_b_count = -1;
1255 assert(scale >= 0 && scale <= 3);
1258 //s->next_picture_ptr->quality;
1259 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1260 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1261 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1262 if (!b_lambda) // FIXME we should do this somewhere else
1263 b_lambda = p_lambda;
1264 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1267 for (i = 0; i < s->max_b_frames + 2; i++) {
1268 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1269 s->next_picture_ptr;
1271 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1272 pre_input = *pre_input_ptr;
1274 if (!pre_input.shared && i) {
1275 pre_input.f->data[0] += INPLACE_OFFSET;
1276 pre_input.f->data[1] += INPLACE_OFFSET;
1277 pre_input.f->data[2] += INPLACE_OFFSET;
1280 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1281 s->tmp_frames[i]->linesize[0],
1282 pre_input.f->data[0],
1283 pre_input.f->linesize[0],
1285 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1286 s->tmp_frames[i]->linesize[1],
1287 pre_input.f->data[1],
1288 pre_input.f->linesize[1],
1289 width >> 1, height >> 1);
1290 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1291 s->tmp_frames[i]->linesize[2],
1292 pre_input.f->data[2],
1293 pre_input.f->linesize[2],
1294 width >> 1, height >> 1);
1298 for (j = 0; j < s->max_b_frames + 1; j++) {
1302 if (!s->input_picture[j])
1305 c = avcodec_alloc_context3(NULL);
1307 return AVERROR(ENOMEM);
1311 c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1312 c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1313 c->mb_decision = s->avctx->mb_decision;
1314 c->me_cmp = s->avctx->me_cmp;
1315 c->mb_cmp = s->avctx->mb_cmp;
1316 c->me_sub_cmp = s->avctx->me_sub_cmp;
1317 c->pix_fmt = AV_PIX_FMT_YUV420P;
1318 c->time_base = s->avctx->time_base;
1319 c->max_b_frames = s->max_b_frames;
1321 ret = avcodec_open2(c, codec, NULL);
1325 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1326 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1328 out_size = encode_frame(c, s->tmp_frames[0]);
1334 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1336 for (i = 0; i < s->max_b_frames + 1; i++) {
1337 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1339 s->tmp_frames[i + 1]->pict_type = is_p ?
1340 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1341 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1343 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1349 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1352 /* get the delayed frames */
1353 out_size = encode_frame(c, NULL);
1358 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1360 rd += c->error[0] + c->error[1] + c->error[2];
1368 avcodec_free_context(&c);
1373 return best_b_count;
1376 static int select_input_picture(MpegEncContext *s)
1380 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1381 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1382 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1384 /* set next picture type & ordering */
1385 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1386 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1387 !s->next_picture_ptr || s->intra_only) {
1388 s->reordered_input_picture[0] = s->input_picture[0];
1389 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1390 s->reordered_input_picture[0]->f->coded_picture_number =
1391 s->coded_picture_number++;
1395 if (s->frame_skip_threshold || s->frame_skip_factor) {
1396 if (s->picture_in_gop_number < s->gop_size &&
1397 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1398 // FIXME check that the gop check above is +-1 correct
1399 av_frame_unref(s->input_picture[0]->f);
1402 ff_vbv_update(s, 0);
1408 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1409 for (i = 0; i < s->max_b_frames + 1; i++) {
1410 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1412 if (pict_num >= s->rc_context.num_entries)
1414 if (!s->input_picture[i]) {
1415 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1419 s->input_picture[i]->f->pict_type =
1420 s->rc_context.entry[pict_num].new_pict_type;
1424 if (s->b_frame_strategy == 0) {
1425 b_frames = s->max_b_frames;
1426 while (b_frames && !s->input_picture[b_frames])
1428 } else if (s->b_frame_strategy == 1) {
1429 for (i = 1; i < s->max_b_frames + 1; i++) {
1430 if (s->input_picture[i] &&
1431 s->input_picture[i]->b_frame_score == 0) {
1432 s->input_picture[i]->b_frame_score =
1434 s->input_picture[i ]->f->data[0],
1435 s->input_picture[i - 1]->f->data[0],
1439 for (i = 0; i < s->max_b_frames + 1; i++) {
1440 if (!s->input_picture[i] ||
1441 s->input_picture[i]->b_frame_score - 1 >
1442 s->mb_num / s->b_sensitivity)
1446 b_frames = FFMAX(0, i - 1);
1449 for (i = 0; i < b_frames + 1; i++) {
1450 s->input_picture[i]->b_frame_score = 0;
1452 } else if (s->b_frame_strategy == 2) {
1453 b_frames = estimate_best_b_count(s);
1460 for (i = b_frames - 1; i >= 0; i--) {
1461 int type = s->input_picture[i]->f->pict_type;
1462 if (type && type != AV_PICTURE_TYPE_B)
1465 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1466 b_frames == s->max_b_frames) {
1467 av_log(s->avctx, AV_LOG_ERROR,
1468 "warning, too many B-frames in a row\n");
1471 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1472 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1473 s->gop_size > s->picture_in_gop_number) {
1474 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1476 if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1478 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1482 if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1483 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1486 s->reordered_input_picture[0] = s->input_picture[b_frames];
1487 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1488 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1489 s->reordered_input_picture[0]->f->coded_picture_number =
1490 s->coded_picture_number++;
1491 for (i = 0; i < b_frames; i++) {
1492 s->reordered_input_picture[i + 1] = s->input_picture[i];
1493 s->reordered_input_picture[i + 1]->f->pict_type =
1495 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1496 s->coded_picture_number++;
1501 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1503 if (s->reordered_input_picture[0]) {
1504 s->reordered_input_picture[0]->reference =
1505 s->reordered_input_picture[0]->f->pict_type !=
1506 AV_PICTURE_TYPE_B ? 3 : 0;
1508 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1511 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1512 // input is a shared pix, so we can't modify it -> allocate a new
1513 // one & ensure that the shared one is reuseable
1516 int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1519 pic = &s->picture[i];
1521 pic->reference = s->reordered_input_picture[0]->reference;
1522 if (alloc_picture(s, pic, 0) < 0) {
1526 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1530 /* mark us unused / free shared pic */
1531 av_frame_unref(s->reordered_input_picture[0]->f);
1532 s->reordered_input_picture[0]->shared = 0;
1534 s->current_picture_ptr = pic;
1536 // input is not a shared pix -> reuse buffer for current_pix
1537 s->current_picture_ptr = s->reordered_input_picture[0];
1538 for (i = 0; i < 4; i++) {
1539 s->new_picture.f->data[i] += INPLACE_OFFSET;
1542 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1543 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1544 s->current_picture_ptr)) < 0)
1547 s->picture_number = s->new_picture.f->display_picture_number;
1552 static void frame_end(MpegEncContext *s)
1556 if (s->unrestricted_mv &&
1557 s->current_picture.reference &&
1559 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1560 int hshift = desc->log2_chroma_w;
1561 int vshift = desc->log2_chroma_h;
1562 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1563 s->h_edge_pos, s->v_edge_pos,
1564 EDGE_WIDTH, EDGE_WIDTH,
1565 EDGE_TOP | EDGE_BOTTOM);
1566 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1567 s->h_edge_pos >> hshift,
1568 s->v_edge_pos >> vshift,
1569 EDGE_WIDTH >> hshift,
1570 EDGE_WIDTH >> vshift,
1571 EDGE_TOP | EDGE_BOTTOM);
1572 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1573 s->h_edge_pos >> hshift,
1574 s->v_edge_pos >> vshift,
1575 EDGE_WIDTH >> hshift,
1576 EDGE_WIDTH >> vshift,
1577 EDGE_TOP | EDGE_BOTTOM);
1582 s->last_pict_type = s->pict_type;
1583 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1584 if (s->pict_type!= AV_PICTURE_TYPE_B)
1585 s->last_non_b_pict_type = s->pict_type;
1588 /* release non-reference frames */
1589 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1590 if (!s->picture[i].reference)
1591 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1595 #if FF_API_CODED_FRAME
1596 FF_DISABLE_DEPRECATION_WARNINGS
1597 av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1598 FF_ENABLE_DEPRECATION_WARNINGS
1600 #if FF_API_ERROR_FRAME
1601 FF_DISABLE_DEPRECATION_WARNINGS
1602 memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1603 sizeof(s->current_picture.encoding_error));
1604 FF_ENABLE_DEPRECATION_WARNINGS
1608 static void update_noise_reduction(MpegEncContext *s)
1612 for (intra = 0; intra < 2; intra++) {
1613 if (s->dct_count[intra] > (1 << 16)) {
1614 for (i = 0; i < 64; i++) {
1615 s->dct_error_sum[intra][i] >>= 1;
1617 s->dct_count[intra] >>= 1;
1620 for (i = 0; i < 64; i++) {
1621 s->dct_offset[intra][i] = (s->noise_reduction *
1622 s->dct_count[intra] +
1623 s->dct_error_sum[intra][i] / 2) /
1624 (s->dct_error_sum[intra][i] + 1);
1629 static int frame_start(MpegEncContext *s)
1633 /* mark & release old frames */
1634 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1635 s->last_picture_ptr != s->next_picture_ptr &&
1636 s->last_picture_ptr->f->buf[0]) {
1637 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1640 s->current_picture_ptr->f->pict_type = s->pict_type;
1641 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1643 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1644 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1645 s->current_picture_ptr)) < 0)
1648 if (s->pict_type != AV_PICTURE_TYPE_B) {
1649 s->last_picture_ptr = s->next_picture_ptr;
1651 s->next_picture_ptr = s->current_picture_ptr;
1654 if (s->last_picture_ptr) {
1655 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1656 if (s->last_picture_ptr->f->buf[0] &&
1657 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1658 s->last_picture_ptr)) < 0)
1661 if (s->next_picture_ptr) {
1662 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1663 if (s->next_picture_ptr->f->buf[0] &&
1664 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1665 s->next_picture_ptr)) < 0)
1669 if (s->picture_structure!= PICT_FRAME) {
1671 for (i = 0; i < 4; i++) {
1672 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1673 s->current_picture.f->data[i] +=
1674 s->current_picture.f->linesize[i];
1676 s->current_picture.f->linesize[i] *= 2;
1677 s->last_picture.f->linesize[i] *= 2;
1678 s->next_picture.f->linesize[i] *= 2;
1682 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1683 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1684 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1685 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1686 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1687 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1689 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1690 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1693 if (s->dct_error_sum) {
1694 assert(s->noise_reduction && s->encoding);
1695 update_noise_reduction(s);
1701 static void write_pass1_stats(MpegEncContext *s)
1703 snprintf(s->avctx->stats_out, 256,
1704 "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
1705 "fcode:%d bcode:%d mc-var:%d var:%d icount:%d skipcount:%d "
1707 s->current_picture_ptr->f->display_picture_number,
1708 s->current_picture_ptr->f->coded_picture_number,
1710 s->current_picture.f->quality,
1717 s->current_picture.mc_mb_var_sum,
1718 s->current_picture.mb_var_sum,
1719 s->i_count, s->skip_count,
1723 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1724 const AVFrame *pic_arg, int *got_packet)
1726 MpegEncContext *s = avctx->priv_data;
1727 int i, stuffing_count, ret;
1728 int context_count = s->slice_context_count;
1730 s->picture_in_gop_number++;
1732 if (load_input_picture(s, pic_arg) < 0)
1735 if (select_input_picture(s) < 0) {
1740 if (s->new_picture.f->data[0]) {
1743 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1746 s->mb_info_ptr = av_packet_new_side_data(pkt,
1747 AV_PKT_DATA_H263_MB_INFO,
1748 s->mb_width*s->mb_height*12);
1749 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1752 for (i = 0; i < context_count; i++) {
1753 int start_y = s->thread_context[i]->start_mb_y;
1754 int end_y = s->thread_context[i]-> end_mb_y;
1755 int h = s->mb_height;
1756 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1757 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1759 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1762 s->pict_type = s->new_picture.f->pict_type;
1764 ret = frame_start(s);
1768 if (encode_picture(s, s->picture_number) < 0)
1771 #if FF_API_STAT_BITS
1772 FF_DISABLE_DEPRECATION_WARNINGS
1773 avctx->header_bits = s->header_bits;
1774 avctx->mv_bits = s->mv_bits;
1775 avctx->misc_bits = s->misc_bits;
1776 avctx->i_tex_bits = s->i_tex_bits;
1777 avctx->p_tex_bits = s->p_tex_bits;
1778 avctx->i_count = s->i_count;
1779 // FIXME f/b_count in avctx
1780 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1781 avctx->skip_count = s->skip_count;
1782 FF_ENABLE_DEPRECATION_WARNINGS
1787 sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
1790 return AVERROR(ENOMEM);
1791 *(int *)sd = s->current_picture.f->quality;
1793 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1794 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1796 if (avctx->rc_buffer_size) {
1797 RateControlContext *rcc = &s->rc_context;
1798 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1800 if (put_bits_count(&s->pb) > max_size &&
1801 s->lambda < s->lmax) {
1802 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1803 (s->qscale + 1) / s->qscale);
1804 if (s->adaptive_quant) {
1806 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1807 s->lambda_table[i] =
1808 FFMAX(s->lambda_table[i] + 1,
1809 s->lambda_table[i] * (s->qscale + 1) /
1812 s->mb_skipped = 0; // done in frame_start()
1813 // done in encode_picture() so we must undo it
1814 if (s->pict_type == AV_PICTURE_TYPE_P) {
1815 if (s->flipflop_rounding ||
1816 s->codec_id == AV_CODEC_ID_H263P ||
1817 s->codec_id == AV_CODEC_ID_MPEG4)
1818 s->no_rounding ^= 1;
1820 if (s->pict_type != AV_PICTURE_TYPE_B) {
1821 s->time_base = s->last_time_base;
1822 s->last_non_b_time = s->time - s->pp_time;
1824 for (i = 0; i < context_count; i++) {
1825 PutBitContext *pb = &s->thread_context[i]->pb;
1826 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1831 assert(s->avctx->rc_max_rate);
1834 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1835 write_pass1_stats(s);
1837 for (i = 0; i < 4; i++) {
1838 s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1839 avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1842 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1843 assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1844 s->misc_bits + s->i_tex_bits +
1846 flush_put_bits(&s->pb);
1847 s->frame_bits = put_bits_count(&s->pb);
1849 stuffing_count = ff_vbv_update(s, s->frame_bits);
1850 if (stuffing_count) {
1851 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1852 stuffing_count + 50) {
1853 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1857 switch (s->codec_id) {
1858 case AV_CODEC_ID_MPEG1VIDEO:
1859 case AV_CODEC_ID_MPEG2VIDEO:
1860 while (stuffing_count--) {
1861 put_bits(&s->pb, 8, 0);
1864 case AV_CODEC_ID_MPEG4:
1865 put_bits(&s->pb, 16, 0);
1866 put_bits(&s->pb, 16, 0x1C3);
1867 stuffing_count -= 4;
1868 while (stuffing_count--) {
1869 put_bits(&s->pb, 8, 0xFF);
1873 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1875 flush_put_bits(&s->pb);
1876 s->frame_bits = put_bits_count(&s->pb);
1879 /* update MPEG-1/2 vbv_delay for CBR */
1880 if (s->avctx->rc_max_rate &&
1881 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1882 s->out_format == FMT_MPEG1 &&
1883 90000LL * (avctx->rc_buffer_size - 1) <=
1884 s->avctx->rc_max_rate * 0xFFFFLL) {
1885 AVCPBProperties *props;
1888 int vbv_delay, min_delay;
1889 double inbits = s->avctx->rc_max_rate *
1890 av_q2d(s->avctx->time_base);
1891 int minbits = s->frame_bits - 8 *
1892 (s->vbv_delay_ptr - s->pb.buf - 1);
1893 double bits = s->rc_context.buffer_index + minbits - inbits;
1896 av_log(s->avctx, AV_LOG_ERROR,
1897 "Internal error, negative bits\n");
1899 assert(s->repeat_first_field == 0);
1901 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1902 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1903 s->avctx->rc_max_rate;
1905 vbv_delay = FFMAX(vbv_delay, min_delay);
1907 assert(vbv_delay < 0xFFFF);
1909 s->vbv_delay_ptr[0] &= 0xF8;
1910 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1911 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1912 s->vbv_delay_ptr[2] &= 0x07;
1913 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1915 props = av_cpb_properties_alloc(&props_size);
1917 return AVERROR(ENOMEM);
1918 props->vbv_delay = vbv_delay * 300;
1920 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
1921 (uint8_t*)props, props_size);
1927 #if FF_API_VBV_DELAY
1928 FF_DISABLE_DEPRECATION_WARNINGS
1929 avctx->vbv_delay = vbv_delay * 300;
1930 FF_ENABLE_DEPRECATION_WARNINGS
1933 s->total_bits += s->frame_bits;
1934 #if FF_API_STAT_BITS
1935 FF_DISABLE_DEPRECATION_WARNINGS
1936 avctx->frame_bits = s->frame_bits;
1937 FF_ENABLE_DEPRECATION_WARNINGS
1941 pkt->pts = s->current_picture.f->pts;
1942 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1943 if (!s->current_picture.f->coded_picture_number)
1944 pkt->dts = pkt->pts - s->dts_delta;
1946 pkt->dts = s->reordered_pts;
1947 s->reordered_pts = pkt->pts;
1949 pkt->dts = pkt->pts;
1950 if (s->current_picture.f->key_frame)
1951 pkt->flags |= AV_PKT_FLAG_KEY;
1953 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1957 assert((s->frame_bits & 7) == 0);
1959 pkt->size = s->frame_bits / 8;
1960 *got_packet = !!pkt->size;
1964 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1965 int n, int threshold)
1967 static const char tab[64] = {
1968 3, 2, 2, 1, 1, 1, 1, 1,
1969 1, 1, 1, 1, 1, 1, 1, 1,
1970 1, 1, 1, 1, 1, 1, 1, 1,
1971 0, 0, 0, 0, 0, 0, 0, 0,
1972 0, 0, 0, 0, 0, 0, 0, 0,
1973 0, 0, 0, 0, 0, 0, 0, 0,
1974 0, 0, 0, 0, 0, 0, 0, 0,
1975 0, 0, 0, 0, 0, 0, 0, 0
1980 int16_t *block = s->block[n];
1981 const int last_index = s->block_last_index[n];
1984 if (threshold < 0) {
1986 threshold = -threshold;
1990 /* Are all we could set to zero already zero? */
1991 if (last_index <= skip_dc - 1)
1994 for (i = 0; i <= last_index; i++) {
1995 const int j = s->intra_scantable.permutated[i];
1996 const int level = FFABS(block[j]);
1998 if (skip_dc && i == 0)
2002 } else if (level > 1) {
2008 if (score >= threshold)
2010 for (i = skip_dc; i <= last_index; i++) {
2011 const int j = s->intra_scantable.permutated[i];
2015 s->block_last_index[n] = 0;
2017 s->block_last_index[n] = -1;
2020 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2024 const int maxlevel = s->max_qcoeff;
2025 const int minlevel = s->min_qcoeff;
2029 i = 1; // skip clipping of intra dc
2033 for (; i <= last_index; i++) {
2034 const int j = s->intra_scantable.permutated[i];
2035 int level = block[j];
2037 if (level > maxlevel) {
2040 } else if (level < minlevel) {
2048 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2049 av_log(s->avctx, AV_LOG_INFO,
2050 "warning, clipping %d dct coefficients to %d..%d\n",
2051 overflow, minlevel, maxlevel);
2054 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2058 for (y = 0; y < 8; y++) {
2059 for (x = 0; x < 8; x++) {
2065 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2066 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2067 int v = ptr[x2 + y2 * stride];
2073 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2078 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2079 int motion_x, int motion_y,
2080 int mb_block_height,
2083 int16_t weight[8][64];
2084 int16_t orig[8][64];
2085 const int mb_x = s->mb_x;
2086 const int mb_y = s->mb_y;
2089 int dct_offset = s->linesize * 8; // default for progressive frames
2090 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2091 ptrdiff_t wrap_y, wrap_c;
2093 for (i = 0; i < mb_block_count; i++)
2094 skip_dct[i] = s->skipdct;
2096 if (s->adaptive_quant) {
2097 const int last_qp = s->qscale;
2098 const int mb_xy = mb_x + mb_y * s->mb_stride;
2100 s->lambda = s->lambda_table[mb_xy];
2103 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2104 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2105 s->dquant = s->qscale - last_qp;
2107 if (s->out_format == FMT_H263) {
2108 s->dquant = av_clip(s->dquant, -2, 2);
2110 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2112 if (s->pict_type == AV_PICTURE_TYPE_B) {
2113 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2116 if (s->mv_type == MV_TYPE_8X8)
2122 ff_set_qscale(s, last_qp + s->dquant);
2123 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2124 ff_set_qscale(s, s->qscale + s->dquant);
2126 wrap_y = s->linesize;
2127 wrap_c = s->uvlinesize;
2128 ptr_y = s->new_picture.f->data[0] +
2129 (mb_y * 16 * wrap_y) + mb_x * 16;
2130 ptr_cb = s->new_picture.f->data[1] +
2131 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
2132 ptr_cr = s->new_picture.f->data[2] +
2133 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
2135 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
2136 uint8_t *ebuf = s->sc.edge_emu_buffer + 32;
2137 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2139 16, 16, mb_x * 16, mb_y * 16,
2140 s->width, s->height);
2142 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
2144 8, mb_block_height, mb_x * 8, mb_y * 8,
2145 s->width >> 1, s->height >> 1);
2146 ptr_cb = ebuf + 18 * wrap_y;
2147 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
2149 8, mb_block_height, mb_x * 8, mb_y * 8,
2150 s->width >> 1, s->height >> 1);
2151 ptr_cr = ebuf + 18 * wrap_y + 8;
2155 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2156 int progressive_score, interlaced_score;
2158 s->interlaced_dct = 0;
2159 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2160 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2161 NULL, wrap_y, 8) - 400;
2163 if (progressive_score > 0) {
2164 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2165 NULL, wrap_y * 2, 8) +
2166 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2167 NULL, wrap_y * 2, 8);
2168 if (progressive_score > interlaced_score) {
2169 s->interlaced_dct = 1;
2171 dct_offset = wrap_y;
2173 if (s->chroma_format == CHROMA_422)
2179 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2180 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2181 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2182 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2184 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2188 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2189 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2190 if (!s->chroma_y_shift) { /* 422 */
2191 s->pdsp.get_pixels(s->block[6],
2192 ptr_cb + (dct_offset >> 1), wrap_c);
2193 s->pdsp.get_pixels(s->block[7],
2194 ptr_cr + (dct_offset >> 1), wrap_c);
2198 op_pixels_func (*op_pix)[4];
2199 qpel_mc_func (*op_qpix)[16];
2200 uint8_t *dest_y, *dest_cb, *dest_cr;
2202 dest_y = s->dest[0];
2203 dest_cb = s->dest[1];
2204 dest_cr = s->dest[2];
2206 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2207 op_pix = s->hdsp.put_pixels_tab;
2208 op_qpix = s->qdsp.put_qpel_pixels_tab;
2210 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2211 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2214 if (s->mv_dir & MV_DIR_FORWARD) {
2215 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2216 s->last_picture.f->data,
2218 op_pix = s->hdsp.avg_pixels_tab;
2219 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2221 if (s->mv_dir & MV_DIR_BACKWARD) {
2222 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2223 s->next_picture.f->data,
2227 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2228 int progressive_score, interlaced_score;
2230 s->interlaced_dct = 0;
2231 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2232 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2236 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2237 progressive_score -= 400;
2239 if (progressive_score > 0) {
2240 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2242 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2246 if (progressive_score > interlaced_score) {
2247 s->interlaced_dct = 1;
2249 dct_offset = wrap_y;
2251 if (s->chroma_format == CHROMA_422)
2257 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2258 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2259 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2260 dest_y + dct_offset, wrap_y);
2261 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2262 dest_y + dct_offset + 8, wrap_y);
2264 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2268 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2269 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2270 if (!s->chroma_y_shift) { /* 422 */
2271 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2272 dest_cb + (dct_offset >> 1), wrap_c);
2273 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2274 dest_cr + (dct_offset >> 1), wrap_c);
2277 /* pre quantization */
2278 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2279 2 * s->qscale * s->qscale) {
2281 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2283 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2285 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2286 wrap_y, 8) < 20 * s->qscale)
2288 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2289 wrap_y, 8) < 20 * s->qscale)
2291 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2293 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2295 if (!s->chroma_y_shift) { /* 422 */
2296 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2297 dest_cb + (dct_offset >> 1),
2298 wrap_c, 8) < 20 * s->qscale)
2300 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2301 dest_cr + (dct_offset >> 1),
2302 wrap_c, 8) < 20 * s->qscale)
2308 if (s->quantizer_noise_shaping) {
2310 get_visual_weight(weight[0], ptr_y , wrap_y);
2312 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2314 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2316 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2318 get_visual_weight(weight[4], ptr_cb , wrap_c);
2320 get_visual_weight(weight[5], ptr_cr , wrap_c);
2321 if (!s->chroma_y_shift) { /* 422 */
2323 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2326 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2329 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2332 /* DCT & quantize */
2333 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2335 for (i = 0; i < mb_block_count; i++) {
2338 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2339 // FIXME we could decide to change to quantizer instead of
2341 // JS: I don't think that would be a good idea it could lower
2342 // quality instead of improve it. Just INTRADC clipping
2343 // deserves changes in quantizer
2345 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2347 s->block_last_index[i] = -1;
2349 if (s->quantizer_noise_shaping) {
2350 for (i = 0; i < mb_block_count; i++) {
2352 s->block_last_index[i] =
2353 dct_quantize_refine(s, s->block[i], weight[i],
2354 orig[i], i, s->qscale);
2359 if (s->luma_elim_threshold && !s->mb_intra)
2360 for (i = 0; i < 4; i++)
2361 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2362 if (s->chroma_elim_threshold && !s->mb_intra)
2363 for (i = 4; i < mb_block_count; i++)
2364 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2366 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2367 for (i = 0; i < mb_block_count; i++) {
2368 if (s->block_last_index[i] == -1)
2369 s->coded_score[i] = INT_MAX / 256;
2374 if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2375 s->block_last_index[4] =
2376 s->block_last_index[5] = 0;
2378 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2381 // non c quantize code returns incorrect block_last_index FIXME
2382 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2383 for (i = 0; i < mb_block_count; i++) {
2385 if (s->block_last_index[i] > 0) {
2386 for (j = 63; j > 0; j--) {
2387 if (s->block[i][s->intra_scantable.permutated[j]])
2390 s->block_last_index[i] = j;
2395 /* huffman encode */
2396 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2397 case AV_CODEC_ID_MPEG1VIDEO:
2398 case AV_CODEC_ID_MPEG2VIDEO:
2399 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2400 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2402 case AV_CODEC_ID_MPEG4:
2403 if (CONFIG_MPEG4_ENCODER)
2404 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2406 case AV_CODEC_ID_MSMPEG4V2:
2407 case AV_CODEC_ID_MSMPEG4V3:
2408 case AV_CODEC_ID_WMV1:
2409 if (CONFIG_MSMPEG4_ENCODER)
2410 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2412 case AV_CODEC_ID_WMV2:
2413 if (CONFIG_WMV2_ENCODER)
2414 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2416 case AV_CODEC_ID_H261:
2417 if (CONFIG_H261_ENCODER)
2418 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2420 case AV_CODEC_ID_H263:
2421 case AV_CODEC_ID_H263P:
2422 case AV_CODEC_ID_FLV1:
2423 case AV_CODEC_ID_RV10:
2424 case AV_CODEC_ID_RV20:
2425 if (CONFIG_H263_ENCODER)
2426 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2428 case AV_CODEC_ID_MJPEG:
2429 if (CONFIG_MJPEG_ENCODER)
2430 ff_mjpeg_encode_mb(s, s->block);
2437 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2439 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2440 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2443 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2446 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2449 d->mb_skip_run= s->mb_skip_run;
2451 d->last_dc[i] = s->last_dc[i];
2454 d->mv_bits= s->mv_bits;
2455 d->i_tex_bits= s->i_tex_bits;
2456 d->p_tex_bits= s->p_tex_bits;
2457 d->i_count= s->i_count;
2458 d->f_count= s->f_count;
2459 d->b_count= s->b_count;
2460 d->skip_count= s->skip_count;
2461 d->misc_bits= s->misc_bits;
2465 d->qscale= s->qscale;
2466 d->dquant= s->dquant;
2468 d->esc3_level_length= s->esc3_level_length;
2471 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2474 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2475 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2478 d->mb_skip_run= s->mb_skip_run;
2480 d->last_dc[i] = s->last_dc[i];
2483 d->mv_bits= s->mv_bits;
2484 d->i_tex_bits= s->i_tex_bits;
2485 d->p_tex_bits= s->p_tex_bits;
2486 d->i_count= s->i_count;
2487 d->f_count= s->f_count;
2488 d->b_count= s->b_count;
2489 d->skip_count= s->skip_count;
2490 d->misc_bits= s->misc_bits;
2492 d->mb_intra= s->mb_intra;
2493 d->mb_skipped= s->mb_skipped;
2494 d->mv_type= s->mv_type;
2495 d->mv_dir= s->mv_dir;
2497 if(s->data_partitioning){
2499 d->tex_pb= s->tex_pb;
2503 d->block_last_index[i]= s->block_last_index[i];
2504 d->interlaced_dct= s->interlaced_dct;
2505 d->qscale= s->qscale;
2507 d->esc3_level_length= s->esc3_level_length;
2510 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2511 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2512 int *dmin, int *next_block, int motion_x, int motion_y)
2515 uint8_t *dest_backup[3];
2517 copy_context_before_encode(s, backup, type);
2519 s->block= s->blocks[*next_block];
2520 s->pb= pb[*next_block];
2521 if(s->data_partitioning){
2522 s->pb2 = pb2 [*next_block];
2523 s->tex_pb= tex_pb[*next_block];
2527 memcpy(dest_backup, s->dest, sizeof(s->dest));
2528 s->dest[0] = s->sc.rd_scratchpad;
2529 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2530 s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2531 assert(s->linesize >= 32); //FIXME
2534 encode_mb(s, motion_x, motion_y);
2536 score= put_bits_count(&s->pb);
2537 if(s->data_partitioning){
2538 score+= put_bits_count(&s->pb2);
2539 score+= put_bits_count(&s->tex_pb);
2542 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2543 ff_mpv_decode_mb(s, s->block);
2545 score *= s->lambda2;
2546 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2550 memcpy(s->dest, dest_backup, sizeof(s->dest));
2557 copy_context_after_encode(best, s, type);
2561 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2562 uint32_t *sq = ff_square_tab + 256;
2567 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2568 else if(w==8 && h==8)
2569 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2573 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2582 static int sse_mb(MpegEncContext *s){
2586 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2587 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2590 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2591 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) +
2592 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) +
2593 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);
2595 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) +
2596 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) +
2597 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);
2600 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)
2601 +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)
2602 +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);
2605 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2606 MpegEncContext *s= *(void**)arg;
2610 s->me.dia_size= s->avctx->pre_dia_size;
2611 s->first_slice_line=1;
2612 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2613 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2614 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2616 s->first_slice_line=0;
2624 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2625 MpegEncContext *s= *(void**)arg;
2627 s->me.dia_size= s->avctx->dia_size;
2628 s->first_slice_line=1;
2629 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2630 s->mb_x=0; //for block init below
2631 ff_init_block_index(s);
2632 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2633 s->block_index[0]+=2;
2634 s->block_index[1]+=2;
2635 s->block_index[2]+=2;
2636 s->block_index[3]+=2;
2638 /* compute motion vector & mb_type and store in context */
2639 if(s->pict_type==AV_PICTURE_TYPE_B)
2640 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2642 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2644 s->first_slice_line=0;
2649 static int mb_var_thread(AVCodecContext *c, void *arg){
2650 MpegEncContext *s= *(void**)arg;
2653 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2654 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2657 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2659 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2661 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2662 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2664 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2665 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2666 s->me.mb_var_sum_temp += varc;
2672 static void write_slice_end(MpegEncContext *s){
2673 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2674 if(s->partitioned_frame){
2675 ff_mpeg4_merge_partitions(s);
2678 ff_mpeg4_stuffing(&s->pb);
2679 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2680 ff_mjpeg_encode_stuffing(&s->pb);
2683 avpriv_align_put_bits(&s->pb);
2684 flush_put_bits(&s->pb);
2686 if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2687 s->misc_bits+= get_bits_diff(s);
2690 static void write_mb_info(MpegEncContext *s)
2692 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2693 int offset = put_bits_count(&s->pb);
2694 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2695 int gobn = s->mb_y / s->gob_index;
2697 if (CONFIG_H263_ENCODER)
2698 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2699 bytestream_put_le32(&ptr, offset);
2700 bytestream_put_byte(&ptr, s->qscale);
2701 bytestream_put_byte(&ptr, gobn);
2702 bytestream_put_le16(&ptr, mba);
2703 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2704 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2705 /* 4MV not implemented */
2706 bytestream_put_byte(&ptr, 0); /* hmv2 */
2707 bytestream_put_byte(&ptr, 0); /* vmv2 */
2710 static void update_mb_info(MpegEncContext *s, int startcode)
2714 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2715 s->mb_info_size += 12;
2716 s->prev_mb_info = s->last_mb_info;
2719 s->prev_mb_info = put_bits_count(&s->pb)/8;
2720 /* This might have incremented mb_info_size above, and we return without
2721 * actually writing any info into that slot yet. But in that case,
2722 * this will be called again at the start of the after writing the
2723 * start code, actually writing the mb info. */
2727 s->last_mb_info = put_bits_count(&s->pb)/8;
2728 if (!s->mb_info_size)
2729 s->mb_info_size += 12;
2733 static int encode_thread(AVCodecContext *c, void *arg){
2734 MpegEncContext *s= *(void**)arg;
2736 int chr_h= 16>>s->chroma_y_shift;
2738 MpegEncContext best_s = { 0 }, backup_s;
2739 uint8_t bit_buf[2][MAX_MB_BYTES];
2740 uint8_t bit_buf2[2][MAX_MB_BYTES];
2741 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2742 PutBitContext pb[2], pb2[2], tex_pb[2];
2745 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2746 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2747 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2750 s->last_bits= put_bits_count(&s->pb);
2761 /* init last dc values */
2762 /* note: quant matrix value (8) is implied here */
2763 s->last_dc[i] = 128 << s->intra_dc_precision;
2765 s->current_picture.encoding_error[i] = 0;
2768 memset(s->last_mv, 0, sizeof(s->last_mv));
2772 switch(s->codec_id){
2773 case AV_CODEC_ID_H263:
2774 case AV_CODEC_ID_H263P:
2775 case AV_CODEC_ID_FLV1:
2776 if (CONFIG_H263_ENCODER)
2777 s->gob_index = H263_GOB_HEIGHT(s->height);
2779 case AV_CODEC_ID_MPEG4:
2780 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2781 ff_mpeg4_init_partitions(s);
2787 s->first_slice_line = 1;
2788 s->ptr_lastgob = s->pb.buf;
2789 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2793 ff_set_qscale(s, s->qscale);
2794 ff_init_block_index(s);
2796 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2797 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2798 int mb_type= s->mb_type[xy];
2803 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2804 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2807 if(s->data_partitioning){
2808 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2809 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2810 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2816 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2817 ff_update_block_index(s);
2819 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2820 ff_h261_reorder_mb_index(s);
2821 xy= s->mb_y*s->mb_stride + s->mb_x;
2822 mb_type= s->mb_type[xy];
2825 /* write gob / video packet header */
2827 int current_packet_size, is_gob_start;
2829 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2831 is_gob_start = s->rtp_payload_size &&
2832 current_packet_size >= s->rtp_payload_size &&
2835 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2837 switch(s->codec_id){
2838 case AV_CODEC_ID_H263:
2839 case AV_CODEC_ID_H263P:
2840 if(!s->h263_slice_structured)
2841 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2843 case AV_CODEC_ID_MPEG2VIDEO:
2844 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2845 case AV_CODEC_ID_MPEG1VIDEO:
2846 if(s->mb_skip_run) is_gob_start=0;
2851 if(s->start_mb_y != mb_y || mb_x!=0){
2854 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2855 ff_mpeg4_init_partitions(s);
2859 assert((put_bits_count(&s->pb)&7) == 0);
2860 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2862 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2863 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2864 int d = 100 / s->error_rate;
2866 current_packet_size=0;
2867 s->pb.buf_ptr= s->ptr_lastgob;
2868 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2872 #if FF_API_RTP_CALLBACK
2873 FF_DISABLE_DEPRECATION_WARNINGS
2874 if (s->avctx->rtp_callback){
2875 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2876 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2878 FF_ENABLE_DEPRECATION_WARNINGS
2880 update_mb_info(s, 1);
2882 switch(s->codec_id){
2883 case AV_CODEC_ID_MPEG4:
2884 if (CONFIG_MPEG4_ENCODER) {
2885 ff_mpeg4_encode_video_packet_header(s);
2886 ff_mpeg4_clean_buffers(s);
2889 case AV_CODEC_ID_MPEG1VIDEO:
2890 case AV_CODEC_ID_MPEG2VIDEO:
2891 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2892 ff_mpeg1_encode_slice_header(s);
2893 ff_mpeg1_clean_buffers(s);
2896 case AV_CODEC_ID_H263:
2897 case AV_CODEC_ID_H263P:
2898 if (CONFIG_H263_ENCODER)
2899 ff_h263_encode_gob_header(s, mb_y);
2903 if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
2904 int bits= put_bits_count(&s->pb);
2905 s->misc_bits+= bits - s->last_bits;
2909 s->ptr_lastgob += current_packet_size;
2910 s->first_slice_line=1;
2911 s->resync_mb_x=mb_x;
2912 s->resync_mb_y=mb_y;
2916 if( (s->resync_mb_x == s->mb_x)
2917 && s->resync_mb_y+1 == s->mb_y){
2918 s->first_slice_line=0;
2922 s->dquant=0; //only for QP_RD
2924 update_mb_info(s, 0);
2926 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
2928 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2930 copy_context_before_encode(&backup_s, s, -1);
2932 best_s.data_partitioning= s->data_partitioning;
2933 best_s.partitioned_frame= s->partitioned_frame;
2934 if(s->data_partitioning){
2935 backup_s.pb2= s->pb2;
2936 backup_s.tex_pb= s->tex_pb;
2939 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2940 s->mv_dir = MV_DIR_FORWARD;
2941 s->mv_type = MV_TYPE_16X16;
2943 s->mv[0][0][0] = s->p_mv_table[xy][0];
2944 s->mv[0][0][1] = s->p_mv_table[xy][1];
2945 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2946 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2948 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2949 s->mv_dir = MV_DIR_FORWARD;
2950 s->mv_type = MV_TYPE_FIELD;
2953 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2954 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2955 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2957 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2958 &dmin, &next_block, 0, 0);
2960 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2961 s->mv_dir = MV_DIR_FORWARD;
2962 s->mv_type = MV_TYPE_16X16;
2966 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2967 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2969 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2970 s->mv_dir = MV_DIR_FORWARD;
2971 s->mv_type = MV_TYPE_8X8;
2974 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2975 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2977 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2978 &dmin, &next_block, 0, 0);
2980 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2981 s->mv_dir = MV_DIR_FORWARD;
2982 s->mv_type = MV_TYPE_16X16;
2984 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2985 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2986 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2987 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2989 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2990 s->mv_dir = MV_DIR_BACKWARD;
2991 s->mv_type = MV_TYPE_16X16;
2993 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2994 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2995 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2996 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2998 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2999 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3000 s->mv_type = MV_TYPE_16X16;
3002 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3003 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3004 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3005 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3006 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3007 &dmin, &next_block, 0, 0);
3009 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3010 s->mv_dir = MV_DIR_FORWARD;
3011 s->mv_type = MV_TYPE_FIELD;
3014 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3015 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3016 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3018 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3019 &dmin, &next_block, 0, 0);
3021 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3022 s->mv_dir = MV_DIR_BACKWARD;
3023 s->mv_type = MV_TYPE_FIELD;
3026 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3027 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3028 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3030 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3031 &dmin, &next_block, 0, 0);
3033 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3034 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3035 s->mv_type = MV_TYPE_FIELD;
3037 for(dir=0; dir<2; dir++){
3039 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3040 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3041 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3044 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3045 &dmin, &next_block, 0, 0);
3047 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3049 s->mv_type = MV_TYPE_16X16;
3053 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3054 &dmin, &next_block, 0, 0);
3055 if(s->h263_pred || s->h263_aic){
3057 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3059 ff_clean_intra_table_entries(s); //old mode?
3063 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3064 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3065 const int last_qp= backup_s.qscale;
3068 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3069 static const int dquant_tab[4]={-1,1,-2,2};
3071 assert(backup_s.dquant == 0);
3074 s->mv_dir= best_s.mv_dir;
3075 s->mv_type = MV_TYPE_16X16;
3076 s->mb_intra= best_s.mb_intra;
3077 s->mv[0][0][0] = best_s.mv[0][0][0];
3078 s->mv[0][0][1] = best_s.mv[0][0][1];
3079 s->mv[1][0][0] = best_s.mv[1][0][0];
3080 s->mv[1][0][1] = best_s.mv[1][0][1];
3082 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3083 for(; qpi<4; qpi++){
3084 int dquant= dquant_tab[qpi];
3085 qp= last_qp + dquant;
3086 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3088 backup_s.dquant= dquant;
3089 if(s->mb_intra && s->dc_val[0]){
3091 dc[i]= s->dc_val[0][ s->block_index[i] ];
3092 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3096 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3097 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3098 if(best_s.qscale != qp){
3099 if(s->mb_intra && s->dc_val[0]){
3101 s->dc_val[0][ s->block_index[i] ]= dc[i];
3102 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3109 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3110 int mx= s->b_direct_mv_table[xy][0];
3111 int my= s->b_direct_mv_table[xy][1];
3113 backup_s.dquant = 0;
3114 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3116 ff_mpeg4_set_direct_mv(s, mx, my);
3117 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3118 &dmin, &next_block, mx, my);
3120 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3121 backup_s.dquant = 0;
3122 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3124 ff_mpeg4_set_direct_mv(s, 0, 0);
3125 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3126 &dmin, &next_block, 0, 0);
3128 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3131 coded |= s->block_last_index[i];
3134 memcpy(s->mv, best_s.mv, sizeof(s->mv));
3135 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3136 mx=my=0; //FIXME find the one we actually used
3137 ff_mpeg4_set_direct_mv(s, mx, my);
3138 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3146 s->mv_dir= best_s.mv_dir;
3147 s->mv_type = best_s.mv_type;
3149 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3150 s->mv[0][0][1] = best_s.mv[0][0][1];
3151 s->mv[1][0][0] = best_s.mv[1][0][0];
3152 s->mv[1][0][1] = best_s.mv[1][0][1];*/
3155 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3156 &dmin, &next_block, mx, my);
3161 s->current_picture.qscale_table[xy] = best_s.qscale;
3163 copy_context_after_encode(s, &best_s, -1);
3165 pb_bits_count= put_bits_count(&s->pb);
3166 flush_put_bits(&s->pb);
3167 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3170 if(s->data_partitioning){
3171 pb2_bits_count= put_bits_count(&s->pb2);
3172 flush_put_bits(&s->pb2);
3173 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3174 s->pb2= backup_s.pb2;
3176 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3177 flush_put_bits(&s->tex_pb);
3178 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3179 s->tex_pb= backup_s.tex_pb;
3181 s->last_bits= put_bits_count(&s->pb);
3183 if (CONFIG_H263_ENCODER &&
3184 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3185 ff_h263_update_motion_val(s);
3187 if(next_block==0){ //FIXME 16 vs linesize16
3188 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3189 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3190 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3193 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3194 ff_mpv_decode_mb(s, s->block);
3196 int motion_x = 0, motion_y = 0;
3197 s->mv_type=MV_TYPE_16X16;
3198 // only one MB-Type possible
3201 case CANDIDATE_MB_TYPE_INTRA:
3204 motion_x= s->mv[0][0][0] = 0;
3205 motion_y= s->mv[0][0][1] = 0;
3207 case CANDIDATE_MB_TYPE_INTER:
3208 s->mv_dir = MV_DIR_FORWARD;
3210 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3211 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3213 case CANDIDATE_MB_TYPE_INTER_I:
3214 s->mv_dir = MV_DIR_FORWARD;
3215 s->mv_type = MV_TYPE_FIELD;
3218 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3219 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3220 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3223 case CANDIDATE_MB_TYPE_INTER4V:
3224 s->mv_dir = MV_DIR_FORWARD;
3225 s->mv_type = MV_TYPE_8X8;
3228 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3229 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3232 case CANDIDATE_MB_TYPE_DIRECT:
3233 if (CONFIG_MPEG4_ENCODER) {
3234 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3236 motion_x=s->b_direct_mv_table[xy][0];
3237 motion_y=s->b_direct_mv_table[xy][1];
3238 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3241 case CANDIDATE_MB_TYPE_DIRECT0:
3242 if (CONFIG_MPEG4_ENCODER) {
3243 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3245 ff_mpeg4_set_direct_mv(s, 0, 0);
3248 case CANDIDATE_MB_TYPE_BIDIR:
3249 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3251 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3252 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3253 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3254 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3256 case CANDIDATE_MB_TYPE_BACKWARD:
3257 s->mv_dir = MV_DIR_BACKWARD;
3259 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3260 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3262 case CANDIDATE_MB_TYPE_FORWARD:
3263 s->mv_dir = MV_DIR_FORWARD;
3265 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3266 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3268 case CANDIDATE_MB_TYPE_FORWARD_I:
3269 s->mv_dir = MV_DIR_FORWARD;
3270 s->mv_type = MV_TYPE_FIELD;
3273 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3274 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3275 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3278 case CANDIDATE_MB_TYPE_BACKWARD_I:
3279 s->mv_dir = MV_DIR_BACKWARD;
3280 s->mv_type = MV_TYPE_FIELD;
3283 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3284 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3285 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3288 case CANDIDATE_MB_TYPE_BIDIR_I:
3289 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3290 s->mv_type = MV_TYPE_FIELD;
3292 for(dir=0; dir<2; dir++){
3294 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3295 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3296 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3301 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3304 encode_mb(s, motion_x, motion_y);
3306 // RAL: Update last macroblock type
3307 s->last_mv_dir = s->mv_dir;
3309 if (CONFIG_H263_ENCODER &&
3310 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3311 ff_h263_update_motion_val(s);
3313 ff_mpv_decode_mb(s, s->block);
3316 /* clean the MV table in IPS frames for direct mode in B-frames */
3317 if(s->mb_intra /* && I,P,S_TYPE */){
3318 s->p_mv_table[xy][0]=0;
3319 s->p_mv_table[xy][1]=0;
3322 if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3326 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3327 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3329 s->current_picture.encoding_error[0] += sse(
3330 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3331 s->dest[0], w, h, s->linesize);
3332 s->current_picture.encoding_error[1] += sse(
3333 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3334 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3335 s->current_picture.encoding_error[2] += sse(
3336 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3337 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3340 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3341 ff_h263_loop_filter(s);
3343 ff_dlog(s->avctx, "MB %d %d bits\n",
3344 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3348 //not beautiful here but we must write it before flushing so it has to be here
3349 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3350 ff_msmpeg4_encode_ext_header(s);
3354 #if FF_API_RTP_CALLBACK
3355 FF_DISABLE_DEPRECATION_WARNINGS
3356 /* Send the last GOB if RTP */
3357 if (s->avctx->rtp_callback) {
3358 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3359 int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3360 /* Call the RTP callback to send the last GOB */
3362 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3364 FF_ENABLE_DEPRECATION_WARNINGS
3370 #define MERGE(field) dst->field += src->field; src->field=0
3371 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3372 MERGE(me.scene_change_score);
3373 MERGE(me.mc_mb_var_sum_temp);
3374 MERGE(me.mb_var_sum_temp);
3377 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3380 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3381 MERGE(dct_count[1]);
3390 MERGE(er.error_count);
3391 MERGE(padding_bug_score);
3392 MERGE(current_picture.encoding_error[0]);
3393 MERGE(current_picture.encoding_error[1]);
3394 MERGE(current_picture.encoding_error[2]);
3396 if (dst->noise_reduction){
3397 for(i=0; i<64; i++){
3398 MERGE(dct_error_sum[0][i]);
3399 MERGE(dct_error_sum[1][i]);
3403 assert(put_bits_count(&src->pb) % 8 ==0);
3404 assert(put_bits_count(&dst->pb) % 8 ==0);
3405 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3406 flush_put_bits(&dst->pb);
3409 static int estimate_qp(MpegEncContext *s, int dry_run){
3410 if (s->next_lambda){
3411 s->current_picture_ptr->f->quality =
3412 s->current_picture.f->quality = s->next_lambda;
3413 if(!dry_run) s->next_lambda= 0;
3414 } else if (!s->fixed_qscale) {
3416 quality = ff_rate_estimate_qscale(s, dry_run);
3417 s->current_picture_ptr->f->quality =
3418 s->current_picture.f->quality = quality;
3419 if (s->current_picture.f->quality < 0)
3423 if(s->adaptive_quant){
3424 switch(s->codec_id){
3425 case AV_CODEC_ID_MPEG4:
3426 if (CONFIG_MPEG4_ENCODER)
3427 ff_clean_mpeg4_qscales(s);
3429 case AV_CODEC_ID_H263:
3430 case AV_CODEC_ID_H263P:
3431 case AV_CODEC_ID_FLV1:
3432 if (CONFIG_H263_ENCODER)
3433 ff_clean_h263_qscales(s);
3436 ff_init_qscale_tab(s);
3439 s->lambda= s->lambda_table[0];
3442 s->lambda = s->current_picture.f->quality;
3447 /* must be called before writing the header */
3448 static void set_frame_distances(MpegEncContext * s){
3449 assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3450 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3452 if(s->pict_type==AV_PICTURE_TYPE_B){
3453 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3454 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3456 s->pp_time= s->time - s->last_non_b_time;
3457 s->last_non_b_time= s->time;
3458 assert(s->picture_number==0 || s->pp_time > 0);
3462 static int encode_picture(MpegEncContext *s, int picture_number)
3466 int context_count = s->slice_context_count;
3468 s->picture_number = picture_number;
3470 /* Reset the average MB variance */
3471 s->me.mb_var_sum_temp =
3472 s->me.mc_mb_var_sum_temp = 0;
3474 /* we need to initialize some time vars before we can encode B-frames */
3475 // RAL: Condition added for MPEG1VIDEO
3476 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3477 set_frame_distances(s);
3478 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3479 ff_set_mpeg4_time(s);
3481 s->me.scene_change_score=0;
3483 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3485 if(s->pict_type==AV_PICTURE_TYPE_I){
3486 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3487 else s->no_rounding=0;
3488 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3489 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3490 s->no_rounding ^= 1;
3493 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3494 if (estimate_qp(s,1) < 0)
3496 ff_get_2pass_fcode(s);
3497 } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3498 if(s->pict_type==AV_PICTURE_TYPE_B)
3499 s->lambda= s->last_lambda_for[s->pict_type];
3501 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3505 s->mb_intra=0; //for the rate distortion & bit compare functions
3506 for(i=1; i<context_count; i++){
3507 ret = ff_update_duplicate_context(s->thread_context[i], s);
3515 /* Estimate motion for every MB */
3516 if(s->pict_type != AV_PICTURE_TYPE_I){
3517 s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3518 s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3519 if (s->pict_type != AV_PICTURE_TYPE_B) {
3520 if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3522 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3526 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3527 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3529 for(i=0; i<s->mb_stride*s->mb_height; i++)
3530 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3532 if(!s->fixed_qscale){
3533 /* finding spatial complexity for I-frame rate control */
3534 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3537 for(i=1; i<context_count; i++){
3538 merge_context_after_me(s, s->thread_context[i]);
3540 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3541 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3544 if (s->me.scene_change_score > s->scenechange_threshold &&
3545 s->pict_type == AV_PICTURE_TYPE_P) {
3546 s->pict_type= AV_PICTURE_TYPE_I;
3547 for(i=0; i<s->mb_stride*s->mb_height; i++)
3548 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3549 ff_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3550 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3554 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3555 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3557 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3559 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3560 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3561 s->f_code= FFMAX3(s->f_code, a, b);
3564 ff_fix_long_p_mvs(s);
3565 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3566 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3570 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3571 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3576 if(s->pict_type==AV_PICTURE_TYPE_B){
3579 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3580 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3581 s->f_code = FFMAX(a, b);
3583 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3584 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3585 s->b_code = FFMAX(a, b);
3587 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3588 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3589 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3590 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3591 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3593 for(dir=0; dir<2; dir++){
3596 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3597 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3598 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3599 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3607 if (estimate_qp(s, 0) < 0)
3610 if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3611 s->pict_type == AV_PICTURE_TYPE_I &&
3612 !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3613 s->qscale= 3; //reduce clipping problems
3615 if (s->out_format == FMT_MJPEG) {
3616 /* for mjpeg, we do include qscale in the matrix */
3618 int j = s->idsp.idct_permutation[i];
3620 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3622 s->y_dc_scale_table=
3623 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3624 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3625 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3626 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3630 //FIXME var duplication
3631 s->current_picture_ptr->f->key_frame =
3632 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3633 s->current_picture_ptr->f->pict_type =
3634 s->current_picture.f->pict_type = s->pict_type;
3636 if (s->current_picture.f->key_frame)
3637 s->picture_in_gop_number=0;
3639 s->last_bits= put_bits_count(&s->pb);
3640 switch(s->out_format) {
3642 if (CONFIG_MJPEG_ENCODER)
3643 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3644 s->pred, s->intra_matrix);
3647 if (CONFIG_H261_ENCODER)
3648 ff_h261_encode_picture_header(s, picture_number);
3651 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3652 ff_wmv2_encode_picture_header(s, picture_number);
3653 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3654 ff_msmpeg4_encode_picture_header(s, picture_number);
3655 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3656 ff_mpeg4_encode_picture_header(s, picture_number);
3657 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3658 ret = ff_rv10_encode_picture_header(s, picture_number);
3662 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3663 ff_rv20_encode_picture_header(s, picture_number);
3664 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3665 ff_flv_encode_picture_header(s, picture_number);
3666 else if (CONFIG_H263_ENCODER)
3667 ff_h263_encode_picture_header(s, picture_number);
3670 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3671 ff_mpeg1_encode_picture_header(s, picture_number);
3676 bits= put_bits_count(&s->pb);
3677 s->header_bits= bits - s->last_bits;
3679 for(i=1; i<context_count; i++){
3680 update_duplicate_context_after_me(s->thread_context[i], s);
3682 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3683 for(i=1; i<context_count; i++){
3684 merge_context_after_encode(s, s->thread_context[i]);
3690 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3691 const int intra= s->mb_intra;
3694 s->dct_count[intra]++;
3696 for(i=0; i<64; i++){
3697 int level= block[i];
3701 s->dct_error_sum[intra][i] += level;
3702 level -= s->dct_offset[intra][i];
3703 if(level<0) level=0;
3705 s->dct_error_sum[intra][i] -= level;
3706 level += s->dct_offset[intra][i];
3707 if(level>0) level=0;
3714 static int dct_quantize_trellis_c(MpegEncContext *s,
3715 int16_t *block, int n,
3716 int qscale, int *overflow){
3718 const uint8_t *scantable= s->intra_scantable.scantable;
3719 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3721 unsigned int threshold1, threshold2;
3733 int coeff_count[64];
3734 int qmul, qadd, start_i, last_non_zero, i, dc;
3735 const int esc_length= s->ac_esc_length;
3737 uint8_t * last_length;
3738 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3740 s->fdsp.fdct(block);
3742 if(s->dct_error_sum)
3743 s->denoise_dct(s, block);
3745 qadd= ((qscale-1)|1)*8;
3756 /* For AIC we skip quant/dequant of INTRADC */
3761 /* note: block[0] is assumed to be positive */
3762 block[0] = (block[0] + (q >> 1)) / q;
3765 qmat = s->q_intra_matrix[qscale];
3766 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3767 bias= 1<<(QMAT_SHIFT-1);
3768 length = s->intra_ac_vlc_length;
3769 last_length= s->intra_ac_vlc_last_length;
3773 qmat = s->q_inter_matrix[qscale];
3774 length = s->inter_ac_vlc_length;
3775 last_length= s->inter_ac_vlc_last_length;
3779 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3780 threshold2= (threshold1<<1);
3782 for(i=63; i>=start_i; i--) {
3783 const int j = scantable[i];
3784 int level = block[j] * qmat[j];
3786 if(((unsigned)(level+threshold1))>threshold2){
3792 for(i=start_i; i<=last_non_zero; i++) {
3793 const int j = scantable[i];
3794 int level = block[j] * qmat[j];
3796 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3797 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3798 if(((unsigned)(level+threshold1))>threshold2){
3800 level= (bias + level)>>QMAT_SHIFT;
3802 coeff[1][i]= level-1;
3803 // coeff[2][k]= level-2;
3805 level= (bias - level)>>QMAT_SHIFT;
3806 coeff[0][i]= -level;
3807 coeff[1][i]= -level+1;
3808 // coeff[2][k]= -level+2;
3810 coeff_count[i]= FFMIN(level, 2);
3811 assert(coeff_count[i]);
3814 coeff[0][i]= (level>>31)|1;
3819 *overflow= s->max_qcoeff < max; //overflow might have happened
3821 if(last_non_zero < start_i){
3822 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3823 return last_non_zero;
3826 score_tab[start_i]= 0;
3827 survivor[0]= start_i;
3830 for(i=start_i; i<=last_non_zero; i++){
3831 int level_index, j, zero_distortion;
3832 int dct_coeff= FFABS(block[ scantable[i] ]);
3833 int best_score=256*256*256*120;
3835 if (s->fdsp.fdct == ff_fdct_ifast)
3836 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3837 zero_distortion= dct_coeff*dct_coeff;
3839 for(level_index=0; level_index < coeff_count[i]; level_index++){
3841 int level= coeff[level_index][i];
3842 const int alevel= FFABS(level);
3847 if(s->out_format == FMT_H263){
3848 unquant_coeff= alevel*qmul + qadd;
3850 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3852 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3853 unquant_coeff = (unquant_coeff - 1) | 1;
3855 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3856 unquant_coeff = (unquant_coeff - 1) | 1;
3861 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3863 if((level&(~127)) == 0){
3864 for(j=survivor_count-1; j>=0; j--){
3865 int run= i - survivor[j];
3866 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3867 score += score_tab[i-run];
3869 if(score < best_score){
3872 level_tab[i+1]= level-64;
3876 if(s->out_format == FMT_H263){
3877 for(j=survivor_count-1; j>=0; j--){
3878 int run= i - survivor[j];
3879 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3880 score += score_tab[i-run];
3881 if(score < last_score){
3884 last_level= level-64;
3890 distortion += esc_length*lambda;
3891 for(j=survivor_count-1; j>=0; j--){
3892 int run= i - survivor[j];
3893 int score= distortion + score_tab[i-run];
3895 if(score < best_score){
3898 level_tab[i+1]= level-64;
3902 if(s->out_format == FMT_H263){
3903 for(j=survivor_count-1; j>=0; j--){
3904 int run= i - survivor[j];
3905 int score= distortion + score_tab[i-run];
3906 if(score < last_score){
3909 last_level= level-64;
3917 score_tab[i+1]= best_score;
3919 // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
3920 if(last_non_zero <= 27){
3921 for(; survivor_count; survivor_count--){
3922 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3926 for(; survivor_count; survivor_count--){
3927 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3932 survivor[ survivor_count++ ]= i+1;
3935 if(s->out_format != FMT_H263){
3936 last_score= 256*256*256*120;
3937 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3938 int score= score_tab[i];
3940 score += lambda * 2; // FIXME more exact?
3942 if(score < last_score){
3945 last_level= level_tab[i];
3946 last_run= run_tab[i];
3951 s->coded_score[n] = last_score;
3953 dc= FFABS(block[0]);
3954 last_non_zero= last_i - 1;
3955 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3957 if(last_non_zero < start_i)
3958 return last_non_zero;
3960 if(last_non_zero == 0 && start_i == 0){
3962 int best_score= dc * dc;
3964 for(i=0; i<coeff_count[0]; i++){
3965 int level= coeff[i][0];
3966 int alevel= FFABS(level);
3967 int unquant_coeff, score, distortion;
3969 if(s->out_format == FMT_H263){
3970 unquant_coeff= (alevel*qmul + qadd)>>3;
3972 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3973 unquant_coeff = (unquant_coeff - 1) | 1;
3975 unquant_coeff = (unquant_coeff + 4) >> 3;
3976 unquant_coeff<<= 3 + 3;
3978 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3980 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3981 else score= distortion + esc_length*lambda;
3983 if(score < best_score){
3985 best_level= level - 64;
3988 block[0]= best_level;
3989 s->coded_score[n] = best_score - dc*dc;
3990 if(best_level == 0) return -1;
3991 else return last_non_zero;
3997 block[ perm_scantable[last_non_zero] ]= last_level;
4000 for(; i>start_i; i -= run_tab[i] + 1){
4001 block[ perm_scantable[i-1] ]= level_tab[i];
4004 return last_non_zero;
4007 //#define REFINE_STATS 1
4008 static int16_t basis[64][64];
4010 static void build_basis(uint8_t *perm){
4017 double s= 0.25*(1<<BASIS_SHIFT);
4019 int perm_index= perm[index];
4020 if(i==0) s*= sqrt(0.5);
4021 if(j==0) s*= sqrt(0.5);
4022 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)));
4029 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4030 int16_t *block, int16_t *weight, int16_t *orig,
4033 LOCAL_ALIGNED_16(int16_t, d1, [64]);
4034 const uint8_t *scantable= s->intra_scantable.scantable;
4035 const uint8_t *perm_scantable= s->intra_scantable.permutated;
4036 // unsigned int threshold1, threshold2;
4041 int qmul, qadd, start_i, last_non_zero, i, dc;
4043 uint8_t * last_length;
4045 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4048 static int after_last=0;
4049 static int to_zero=0;
4050 static int from_zero=0;
4053 static int messed_sign=0;
4056 if(basis[0][0] == 0)
4057 build_basis(s->idsp.idct_permutation);
4068 /* For AIC we skip quant/dequant of INTRADC */
4072 q <<= RECON_SHIFT-3;
4073 /* note: block[0] is assumed to be positive */
4075 // block[0] = (block[0] + (q >> 1)) / q;
4077 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4078 // bias= 1<<(QMAT_SHIFT-1);
4079 length = s->intra_ac_vlc_length;
4080 last_length= s->intra_ac_vlc_last_length;
4084 length = s->inter_ac_vlc_length;
4085 last_length= s->inter_ac_vlc_last_length;
4087 last_non_zero = s->block_last_index[n];
4092 dc += (1<<(RECON_SHIFT-1));
4093 for(i=0; i<64; i++){
4094 rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4097 STOP_TIMER("memset rem[]")}
4100 for(i=0; i<64; i++){
4105 w= FFABS(weight[i]) + qns*one;
4106 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4109 // w=weight[i] = (63*qns + (w/2)) / w;
4115 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4121 for(i=start_i; i<=last_non_zero; i++){
4122 int j= perm_scantable[i];
4123 const int level= block[j];
4127 if(level<0) coeff= qmul*level - qadd;
4128 else coeff= qmul*level + qadd;
4129 run_tab[rle_index++]=run;
4132 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4138 if(last_non_zero>0){
4139 STOP_TIMER("init rem[]")
4146 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4149 int run2, best_unquant_change=0, analyze_gradient;
4153 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4155 if(analyze_gradient){
4159 for(i=0; i<64; i++){
4162 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4165 STOP_TIMER("rem*w*w")}
4175 const int level= block[0];
4176 int change, old_coeff;
4178 assert(s->mb_intra);
4182 for(change=-1; change<=1; change+=2){
4183 int new_level= level + change;
4184 int score, new_coeff;
4186 new_coeff= q*new_level;
4187 if(new_coeff >= 2048 || new_coeff < 0)
4190 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4191 new_coeff - old_coeff);
4192 if(score<best_score){
4195 best_change= change;
4196 best_unquant_change= new_coeff - old_coeff;
4203 run2= run_tab[rle_index++];
4207 for(i=start_i; i<64; i++){
4208 int j= perm_scantable[i];
4209 const int level= block[j];
4210 int change, old_coeff;
4212 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4216 if(level<0) old_coeff= qmul*level - qadd;
4217 else old_coeff= qmul*level + qadd;
4218 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4222 assert(run2>=0 || i >= last_non_zero );
4225 for(change=-1; change<=1; change+=2){
4226 int new_level= level + change;
4227 int score, new_coeff, unquant_change;
4230 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4234 if(new_level<0) new_coeff= qmul*new_level - qadd;
4235 else new_coeff= qmul*new_level + qadd;
4236 if(new_coeff >= 2048 || new_coeff <= -2048)
4238 //FIXME check for overflow
4241 if(level < 63 && level > -63){
4242 if(i < last_non_zero)
4243 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4244 - length[UNI_AC_ENC_INDEX(run, level+64)];
4246 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4247 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4250 assert(FFABS(new_level)==1);
4252 if(analyze_gradient){
4253 int g= d1[ scantable[i] ];
4254 if(g && (g^new_level) >= 0)
4258 if(i < last_non_zero){
4259 int next_i= i + run2 + 1;
4260 int next_level= block[ perm_scantable[next_i] ] + 64;
4262 if(next_level&(~127))
4265 if(next_i < last_non_zero)
4266 score += length[UNI_AC_ENC_INDEX(run, 65)]
4267 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4268 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4270 score += length[UNI_AC_ENC_INDEX(run, 65)]
4271 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4272 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4274 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4276 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4277 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4283 assert(FFABS(level)==1);
4285 if(i < last_non_zero){
4286 int next_i= i + run2 + 1;
4287 int next_level= block[ perm_scantable[next_i] ] + 64;
4289 if(next_level&(~127))
4292 if(next_i < last_non_zero)
4293 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4294 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4295 - length[UNI_AC_ENC_INDEX(run, 65)];
4297 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4298 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4299 - length[UNI_AC_ENC_INDEX(run, 65)];
4301 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4303 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4304 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4311 unquant_change= new_coeff - old_coeff;
4312 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4314 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4316 if(score<best_score){
4319 best_change= change;
4320 best_unquant_change= unquant_change;
4324 prev_level= level + 64;
4325 if(prev_level&(~127))
4334 STOP_TIMER("iterative step")}
4338 int j= perm_scantable[ best_coeff ];
4340 block[j] += best_change;
4342 if(best_coeff > last_non_zero){
4343 last_non_zero= best_coeff;
4351 if(block[j] - best_change){
4352 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4364 for(; last_non_zero>=start_i; last_non_zero--){
4365 if(block[perm_scantable[last_non_zero]])
4371 if(256*256*256*64 % count == 0){
4372 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);
4377 for(i=start_i; i<=last_non_zero; i++){
4378 int j= perm_scantable[i];
4379 const int level= block[j];
4382 run_tab[rle_index++]=run;
4389 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4395 if(last_non_zero>0){
4396 STOP_TIMER("iterative search")
4401 return last_non_zero;
4405 * Permute an 8x8 block according to permutation.
4406 * @param block the block which will be permuted according to
4407 * the given permutation vector
4408 * @param permutation the permutation vector
4409 * @param last the last non zero coefficient in scantable order, used to
4410 * speed the permutation up
4411 * @param scantable the used scantable, this is only used to speed the
4412 * permutation up, the block is not (inverse) permutated
4413 * to scantable order!
4415 static void block_permute(int16_t *block, uint8_t *permutation,
4416 const uint8_t *scantable, int last)
4423 //FIXME it is ok but not clean and might fail for some permutations
4424 // if (permutation[1] == 1)
4427 for (i = 0; i <= last; i++) {
4428 const int j = scantable[i];
4433 for (i = 0; i <= last; i++) {
4434 const int j = scantable[i];
4435 const int perm_j = permutation[j];
4436 block[perm_j] = temp[j];
4440 int ff_dct_quantize_c(MpegEncContext *s,
4441 int16_t *block, int n,
4442 int qscale, int *overflow)
4444 int i, j, level, last_non_zero, q, start_i;
4446 const uint8_t *scantable= s->intra_scantable.scantable;
4449 unsigned int threshold1, threshold2;
4451 s->fdsp.fdct(block);
4453 if(s->dct_error_sum)
4454 s->denoise_dct(s, block);
4464 /* For AIC we skip quant/dequant of INTRADC */
4467 /* note: block[0] is assumed to be positive */
4468 block[0] = (block[0] + (q >> 1)) / q;
4471 qmat = s->q_intra_matrix[qscale];
4472 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4476 qmat = s->q_inter_matrix[qscale];
4477 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4479 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4480 threshold2= (threshold1<<1);
4481 for(i=63;i>=start_i;i--) {
4483 level = block[j] * qmat[j];
4485 if(((unsigned)(level+threshold1))>threshold2){
4492 for(i=start_i; i<=last_non_zero; i++) {
4494 level = block[j] * qmat[j];
4496 // if( bias+level >= (1<<QMAT_SHIFT)
4497 // || bias-level >= (1<<QMAT_SHIFT)){
4498 if(((unsigned)(level+threshold1))>threshold2){
4500 level= (bias + level)>>QMAT_SHIFT;
4503 level= (bias - level)>>QMAT_SHIFT;
4511 *overflow= s->max_qcoeff < max; //overflow might have happened
4513 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4514 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4515 block_permute(block, s->idsp.idct_permutation,
4516 scantable, last_non_zero);
4518 return last_non_zero;
4521 #define OFFSET(x) offsetof(MpegEncContext, x)
4522 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4523 static const AVOption h263_options[] = {
4524 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4525 { "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},
4526 { "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 },
4531 static const AVClass h263_class = {
4532 .class_name = "H.263 encoder",
4533 .item_name = av_default_item_name,
4534 .option = h263_options,
4535 .version = LIBAVUTIL_VERSION_INT,
4538 AVCodec ff_h263_encoder = {
4540 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4541 .type = AVMEDIA_TYPE_VIDEO,
4542 .id = AV_CODEC_ID_H263,
4543 .priv_data_size = sizeof(MpegEncContext),
4544 .init = ff_mpv_encode_init,
4545 .encode2 = ff_mpv_encode_picture,
4546 .close = ff_mpv_encode_end,
4547 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4548 .priv_class = &h263_class,
4551 static const AVOption h263p_options[] = {
4552 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4553 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4554 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4555 { "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},
4559 static const AVClass h263p_class = {
4560 .class_name = "H.263p encoder",
4561 .item_name = av_default_item_name,
4562 .option = h263p_options,
4563 .version = LIBAVUTIL_VERSION_INT,
4566 AVCodec ff_h263p_encoder = {
4568 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4569 .type = AVMEDIA_TYPE_VIDEO,
4570 .id = AV_CODEC_ID_H263P,
4571 .priv_data_size = sizeof(MpegEncContext),
4572 .init = ff_mpv_encode_init,
4573 .encode2 = ff_mpv_encode_picture,
4574 .close = ff_mpv_encode_end,
4575 .capabilities = AV_CODEC_CAP_SLICE_THREADS,
4576 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4577 .priv_class = &h263p_class,
4580 static const AVClass msmpeg4v2_class = {
4581 .class_name = "msmpeg4v2 encoder",
4582 .item_name = av_default_item_name,
4583 .option = ff_mpv_generic_options,
4584 .version = LIBAVUTIL_VERSION_INT,
4587 AVCodec ff_msmpeg4v2_encoder = {
4588 .name = "msmpeg4v2",
4589 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4590 .type = AVMEDIA_TYPE_VIDEO,
4591 .id = AV_CODEC_ID_MSMPEG4V2,
4592 .priv_data_size = sizeof(MpegEncContext),
4593 .init = ff_mpv_encode_init,
4594 .encode2 = ff_mpv_encode_picture,
4595 .close = ff_mpv_encode_end,
4596 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4597 .priv_class = &msmpeg4v2_class,
4600 static const AVClass msmpeg4v3_class = {
4601 .class_name = "msmpeg4v3 encoder",
4602 .item_name = av_default_item_name,
4603 .option = ff_mpv_generic_options,
4604 .version = LIBAVUTIL_VERSION_INT,
4607 AVCodec ff_msmpeg4v3_encoder = {
4609 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4610 .type = AVMEDIA_TYPE_VIDEO,
4611 .id = AV_CODEC_ID_MSMPEG4V3,
4612 .priv_data_size = sizeof(MpegEncContext),
4613 .init = ff_mpv_encode_init,
4614 .encode2 = ff_mpv_encode_picture,
4615 .close = ff_mpv_encode_end,
4616 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4617 .priv_class = &msmpeg4v3_class,
4620 static const AVClass wmv1_class = {
4621 .class_name = "wmv1 encoder",
4622 .item_name = av_default_item_name,
4623 .option = ff_mpv_generic_options,
4624 .version = LIBAVUTIL_VERSION_INT,
4627 AVCodec ff_wmv1_encoder = {
4629 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4630 .type = AVMEDIA_TYPE_VIDEO,
4631 .id = AV_CODEC_ID_WMV1,
4632 .priv_data_size = sizeof(MpegEncContext),
4633 .init = ff_mpv_encode_init,
4634 .encode2 = ff_mpv_encode_picture,
4635 .close = ff_mpv_encode_end,
4636 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4637 .priv_class = &wmv1_class,