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 FFmpeg.
10 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
31 * The simplest mpeg encoder (well, it was the simplest!).
36 #include "libavutil/internal.h"
37 #include "libavutil/intmath.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/timer.h"
46 #include "mpegvideo.h"
47 #include "mpegvideodata.h"
51 #include "mjpegenc_common.h"
53 #include "mpegutils.h"
56 #include "pixblockdsp.h"
60 #include "aandcttab.h"
62 #include "mpeg4video.h"
64 #include "bytestream.h"
70 #define QUANT_BIAS_SHIFT 8
72 #define QMAT_SHIFT_MMX 16
75 static int encode_picture(MpegEncContext *s, int picture_number);
76 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
77 static int sse_mb(MpegEncContext *s);
78 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
79 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
81 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
82 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
84 const AVOption ff_mpv_generic_options[] = {
89 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
90 uint16_t (*qmat16)[2][64],
91 const uint16_t *quant_matrix,
92 int bias, int qmin, int qmax, int intra)
94 FDCTDSPContext *fdsp = &s->fdsp;
98 for (qscale = qmin; qscale <= qmax; qscale++) {
102 if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
103 else qscale2 = qscale << 1;
105 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
107 fdsp->fdct == ff_faandct ||
108 #endif /* CONFIG_FAANDCT */
109 fdsp->fdct == ff_jpeg_fdct_islow_10) {
110 for (i = 0; i < 64; i++) {
111 const int j = s->idsp.idct_permutation[i];
112 int64_t den = (int64_t) qscale2 * quant_matrix[j];
113 /* 16 <= qscale * quant_matrix[i] <= 7905
114 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
115 * 19952 <= x <= 249205026
116 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
117 * 3444240 >= (1 << 36) / (x) >= 275 */
119 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
121 } else if (fdsp->fdct == ff_fdct_ifast) {
122 for (i = 0; i < 64; i++) {
123 const int j = s->idsp.idct_permutation[i];
124 int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
125 /* 16 <= qscale * quant_matrix[i] <= 7905
126 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
127 * 19952 <= x <= 249205026
128 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
129 * 3444240 >= (1 << 36) / (x) >= 275 */
131 qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
134 for (i = 0; i < 64; i++) {
135 const int j = s->idsp.idct_permutation[i];
136 int64_t den = (int64_t) qscale2 * quant_matrix[j];
137 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
138 * Assume x = qscale * quant_matrix[i]
140 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
141 * so 32768 >= (1 << 19) / (x) >= 67 */
142 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
143 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
144 // (qscale * quant_matrix[i]);
145 qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
147 if (qmat16[qscale][0][i] == 0 ||
148 qmat16[qscale][0][i] == 128 * 256)
149 qmat16[qscale][0][i] = 128 * 256 - 1;
150 qmat16[qscale][1][i] =
151 ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
152 qmat16[qscale][0][i]);
156 for (i = intra; i < 64; i++) {
158 if (fdsp->fdct == ff_fdct_ifast) {
159 max = (8191LL * ff_aanscales[i]) >> 14;
161 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
167 av_log(NULL, AV_LOG_INFO,
168 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
173 static inline void update_qscale(MpegEncContext *s)
175 if (s->q_scale_type == 1 && 0) {
177 int bestdiff=INT_MAX;
180 for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
181 int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
182 if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
183 (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
185 if (diff < bestdiff) {
192 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
193 (FF_LAMBDA_SHIFT + 7);
194 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
197 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
201 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
207 for (i = 0; i < 64; i++) {
208 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
215 * init s->current_picture.qscale_table from s->lambda_table
217 void ff_init_qscale_tab(MpegEncContext *s)
219 int8_t * const qscale_table = s->current_picture.qscale_table;
222 for (i = 0; i < s->mb_num; i++) {
223 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
224 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
225 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
230 static void update_duplicate_context_after_me(MpegEncContext *dst,
233 #define COPY(a) dst->a= src->a
235 COPY(current_picture);
241 COPY(picture_in_gop_number);
242 COPY(gop_picture_number);
243 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
244 COPY(progressive_frame); // FIXME don't set in encode_header
245 COPY(partitioned_frame); // FIXME don't set in encode_header
250 * Set the given MpegEncContext to defaults for encoding.
251 * the changed fields will not depend upon the prior state of the MpegEncContext.
253 static void mpv_encode_defaults(MpegEncContext *s)
256 ff_mpv_common_defaults(s);
258 for (i = -16; i < 16; i++) {
259 default_fcode_tab[i + MAX_MV] = 1;
261 s->me.mv_penalty = default_mv_penalty;
262 s->fcode_tab = default_fcode_tab;
264 s->input_picture_number = 0;
265 s->picture_in_gop_number = 0;
268 av_cold int ff_dct_encode_init(MpegEncContext *s) {
270 ff_dct_encode_init_x86(s);
272 if (CONFIG_H263_ENCODER)
273 ff_h263dsp_init(&s->h263dsp);
274 if (!s->dct_quantize)
275 s->dct_quantize = ff_dct_quantize_c;
277 s->denoise_dct = denoise_dct_c;
278 s->fast_dct_quantize = s->dct_quantize;
279 if (s->avctx->trellis)
280 s->dct_quantize = dct_quantize_trellis_c;
285 /* init video encoder */
286 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
288 MpegEncContext *s = avctx->priv_data;
289 AVCPBProperties *cpb_props;
290 int i, ret, format_supported;
292 mpv_encode_defaults(s);
294 switch (avctx->codec_id) {
295 case AV_CODEC_ID_MPEG2VIDEO:
296 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
297 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
298 av_log(avctx, AV_LOG_ERROR,
299 "only YUV420 and YUV422 are supported\n");
303 case AV_CODEC_ID_MJPEG:
304 case AV_CODEC_ID_AMV:
305 format_supported = 0;
306 /* JPEG color space */
307 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
308 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
309 avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
310 (avctx->color_range == AVCOL_RANGE_JPEG &&
311 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
312 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
313 avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
314 format_supported = 1;
315 /* MPEG color space */
316 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
317 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
318 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
319 avctx->pix_fmt == AV_PIX_FMT_YUV444P))
320 format_supported = 1;
322 if (!format_supported) {
323 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
328 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
329 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
334 switch (avctx->pix_fmt) {
335 case AV_PIX_FMT_YUVJ444P:
336 case AV_PIX_FMT_YUV444P:
337 s->chroma_format = CHROMA_444;
339 case AV_PIX_FMT_YUVJ422P:
340 case AV_PIX_FMT_YUV422P:
341 s->chroma_format = CHROMA_422;
343 case AV_PIX_FMT_YUVJ420P:
344 case AV_PIX_FMT_YUV420P:
346 s->chroma_format = CHROMA_420;
350 s->bit_rate = avctx->bit_rate;
351 s->width = avctx->width;
352 s->height = avctx->height;
353 if (avctx->gop_size > 600 &&
354 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
355 av_log(avctx, AV_LOG_WARNING,
356 "keyframe interval too large!, reducing it from %d to %d\n",
357 avctx->gop_size, 600);
358 avctx->gop_size = 600;
360 s->gop_size = avctx->gop_size;
362 if (avctx->max_b_frames > MAX_B_FRAMES) {
363 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
364 "is %d.\n", MAX_B_FRAMES);
365 avctx->max_b_frames = MAX_B_FRAMES;
367 s->max_b_frames = avctx->max_b_frames;
368 s->codec_id = avctx->codec->id;
369 s->strict_std_compliance = avctx->strict_std_compliance;
370 s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
371 s->mpeg_quant = avctx->mpeg_quant;
372 s->rtp_mode = !!avctx->rtp_payload_size;
373 s->intra_dc_precision = avctx->intra_dc_precision;
375 // workaround some differences between how applications specify dc precision
376 if (s->intra_dc_precision < 0) {
377 s->intra_dc_precision += 8;
378 } else if (s->intra_dc_precision >= 8)
379 s->intra_dc_precision -= 8;
381 if (s->intra_dc_precision < 0) {
382 av_log(avctx, AV_LOG_ERROR,
383 "intra dc precision must be positive, note some applications use"
384 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
385 return AVERROR(EINVAL);
388 if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
389 av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
390 return AVERROR(EINVAL);
392 s->user_specified_pts = AV_NOPTS_VALUE;
394 if (s->gop_size <= 1) {
401 #if FF_API_MOTION_EST
402 FF_DISABLE_DEPRECATION_WARNINGS
403 s->me_method = avctx->me_method;
404 FF_ENABLE_DEPRECATION_WARNINGS
408 s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
411 FF_DISABLE_DEPRECATION_WARNINGS
412 if (avctx->border_masking != 0.0)
413 s->border_masking = avctx->border_masking;
414 FF_ENABLE_DEPRECATION_WARNINGS
417 s->adaptive_quant = (s->avctx->lumi_masking ||
418 s->avctx->dark_masking ||
419 s->avctx->temporal_cplx_masking ||
420 s->avctx->spatial_cplx_masking ||
421 s->avctx->p_masking ||
423 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
426 s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
428 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
429 switch(avctx->codec_id) {
430 case AV_CODEC_ID_MPEG1VIDEO:
431 case AV_CODEC_ID_MPEG2VIDEO:
432 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
434 case AV_CODEC_ID_MPEG4:
435 case AV_CODEC_ID_MSMPEG4V1:
436 case AV_CODEC_ID_MSMPEG4V2:
437 case AV_CODEC_ID_MSMPEG4V3:
438 if (avctx->rc_max_rate >= 15000000) {
439 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
440 } else if(avctx->rc_max_rate >= 2000000) {
441 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000LL) * (320- 80) / (15000000 - 2000000);
442 } else if(avctx->rc_max_rate >= 384000) {
443 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000LL) * ( 80- 40) / ( 2000000 - 384000);
445 avctx->rc_buffer_size = 40;
446 avctx->rc_buffer_size *= 16384;
449 if (avctx->rc_buffer_size) {
450 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
454 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
455 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
459 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
460 av_log(avctx, AV_LOG_INFO,
461 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
464 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
465 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
469 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
470 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
474 if (avctx->rc_max_rate &&
475 avctx->rc_max_rate == avctx->bit_rate &&
476 avctx->rc_max_rate != avctx->rc_min_rate) {
477 av_log(avctx, AV_LOG_INFO,
478 "impossible bitrate constraints, this will fail\n");
481 if (avctx->rc_buffer_size &&
482 avctx->bit_rate * (int64_t)avctx->time_base.num >
483 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
484 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
488 if (!s->fixed_qscale &&
489 avctx->bit_rate * av_q2d(avctx->time_base) >
490 avctx->bit_rate_tolerance) {
491 av_log(avctx, AV_LOG_WARNING,
492 "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, (int64_t)avctx->bit_rate);
493 avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
496 if (s->avctx->rc_max_rate &&
497 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
498 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
499 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
500 90000LL * (avctx->rc_buffer_size - 1) >
501 s->avctx->rc_max_rate * 0xFFFFLL) {
502 av_log(avctx, AV_LOG_INFO,
503 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
504 "specified vbv buffer is too large for the given bitrate!\n");
507 if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
508 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
509 s->codec_id != AV_CODEC_ID_FLV1) {
510 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
514 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
515 av_log(avctx, AV_LOG_ERROR,
516 "OBMC is only supported with simple mb decision\n");
520 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
521 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
525 if (s->max_b_frames &&
526 s->codec_id != AV_CODEC_ID_MPEG4 &&
527 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
528 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
529 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
532 if (s->max_b_frames < 0) {
533 av_log(avctx, AV_LOG_ERROR,
534 "max b frames must be 0 or positive for mpegvideo based encoders\n");
538 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
539 s->codec_id == AV_CODEC_ID_H263 ||
540 s->codec_id == AV_CODEC_ID_H263P) &&
541 (avctx->sample_aspect_ratio.num > 255 ||
542 avctx->sample_aspect_ratio.den > 255)) {
543 av_log(avctx, AV_LOG_WARNING,
544 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
545 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
546 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
547 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
550 if ((s->codec_id == AV_CODEC_ID_H263 ||
551 s->codec_id == AV_CODEC_ID_H263P) &&
552 (avctx->width > 2048 ||
553 avctx->height > 1152 )) {
554 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
557 if ((s->codec_id == AV_CODEC_ID_H263 ||
558 s->codec_id == AV_CODEC_ID_H263P) &&
559 ((avctx->width &3) ||
560 (avctx->height&3) )) {
561 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
565 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
566 (avctx->width > 4095 ||
567 avctx->height > 4095 )) {
568 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
572 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
573 (avctx->width > 16383 ||
574 avctx->height > 16383 )) {
575 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
579 if (s->codec_id == AV_CODEC_ID_RV10 &&
581 avctx->height&15 )) {
582 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
583 return AVERROR(EINVAL);
586 if (s->codec_id == AV_CODEC_ID_RV20 &&
589 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
590 return AVERROR(EINVAL);
593 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
594 s->codec_id == AV_CODEC_ID_WMV2) &&
596 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
600 if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
601 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
602 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
606 // FIXME mpeg2 uses that too
607 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
608 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
609 av_log(avctx, AV_LOG_ERROR,
610 "mpeg2 style quantization not supported by codec\n");
614 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
615 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
619 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
620 s->avctx->mb_decision != FF_MB_DECISION_RD) {
621 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
625 if (s->avctx->scenechange_threshold < 1000000000 &&
626 (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
627 av_log(avctx, AV_LOG_ERROR,
628 "closed gop with scene change detection are not supported yet, "
629 "set threshold to 1000000000\n");
633 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
634 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
635 av_log(avctx, AV_LOG_ERROR,
636 "low delay forcing is only available for mpeg2\n");
639 if (s->max_b_frames != 0) {
640 av_log(avctx, AV_LOG_ERROR,
641 "b frames cannot be used with low delay\n");
646 if (s->q_scale_type == 1) {
647 if (avctx->qmax > 28) {
648 av_log(avctx, AV_LOG_ERROR,
649 "non linear quant only supports qmax <= 28 currently\n");
654 if (avctx->slices > 1 &&
655 (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
656 av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
657 return AVERROR(EINVAL);
660 if (s->avctx->thread_count > 1 &&
661 s->codec_id != AV_CODEC_ID_MPEG4 &&
662 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
663 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
664 s->codec_id != AV_CODEC_ID_MJPEG &&
665 (s->codec_id != AV_CODEC_ID_H263P)) {
666 av_log(avctx, AV_LOG_ERROR,
667 "multi threaded encoding not supported by codec\n");
671 if (s->avctx->thread_count < 1) {
672 av_log(avctx, AV_LOG_ERROR,
673 "automatic thread number detection not supported by codec, "
678 if (!avctx->time_base.den || !avctx->time_base.num) {
679 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
683 if (avctx->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
684 av_log(avctx, AV_LOG_INFO,
685 "notice: b_frame_strategy only affects the first pass\n");
686 avctx->b_frame_strategy = 0;
689 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
691 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
692 avctx->time_base.den /= i;
693 avctx->time_base.num /= i;
697 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
698 // (a + x * 3 / 8) / x
699 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
700 s->inter_quant_bias = 0;
702 s->intra_quant_bias = 0;
704 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
707 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
708 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
709 return AVERROR(EINVAL);
712 #if FF_API_QUANT_BIAS
713 FF_DISABLE_DEPRECATION_WARNINGS
714 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
715 s->intra_quant_bias = avctx->intra_quant_bias;
716 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
717 s->inter_quant_bias = avctx->inter_quant_bias;
718 FF_ENABLE_DEPRECATION_WARNINGS
721 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
723 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
724 s->avctx->time_base.den > (1 << 16) - 1) {
725 av_log(avctx, AV_LOG_ERROR,
726 "timebase %d/%d not supported by MPEG 4 standard, "
727 "the maximum admitted value for the timebase denominator "
728 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
732 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
734 switch (avctx->codec->id) {
735 case AV_CODEC_ID_MPEG1VIDEO:
736 s->out_format = FMT_MPEG1;
737 s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
738 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
740 case AV_CODEC_ID_MPEG2VIDEO:
741 s->out_format = FMT_MPEG1;
742 s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
743 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
746 case AV_CODEC_ID_MJPEG:
747 case AV_CODEC_ID_AMV:
748 s->out_format = FMT_MJPEG;
749 s->intra_only = 1; /* force intra only for jpeg */
750 if (!CONFIG_MJPEG_ENCODER ||
751 ff_mjpeg_encode_init(s) < 0)
756 case AV_CODEC_ID_H261:
757 if (!CONFIG_H261_ENCODER)
759 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
760 av_log(avctx, AV_LOG_ERROR,
761 "The specified picture size of %dx%d is not valid for the "
762 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
763 s->width, s->height);
766 s->out_format = FMT_H261;
769 s->rtp_mode = 0; /* Sliced encoding not supported */
771 case AV_CODEC_ID_H263:
772 if (!CONFIG_H263_ENCODER)
774 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
775 s->width, s->height) == 8) {
776 av_log(avctx, AV_LOG_ERROR,
777 "The specified picture size of %dx%d is not valid for "
778 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
779 "352x288, 704x576, and 1408x1152. "
780 "Try H.263+.\n", s->width, s->height);
783 s->out_format = FMT_H263;
787 case AV_CODEC_ID_H263P:
788 s->out_format = FMT_H263;
791 s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
792 s->modified_quant = s->h263_aic;
793 s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
794 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
797 /* These are just to be sure */
801 case AV_CODEC_ID_FLV1:
802 s->out_format = FMT_H263;
803 s->h263_flv = 2; /* format = 1; 11-bit codes */
804 s->unrestricted_mv = 1;
805 s->rtp_mode = 0; /* don't allow GOB */
809 case AV_CODEC_ID_RV10:
810 s->out_format = FMT_H263;
814 case AV_CODEC_ID_RV20:
815 s->out_format = FMT_H263;
818 s->modified_quant = 1;
822 s->unrestricted_mv = 0;
824 case AV_CODEC_ID_MPEG4:
825 s->out_format = FMT_H263;
827 s->unrestricted_mv = 1;
828 s->low_delay = s->max_b_frames ? 0 : 1;
829 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
831 case AV_CODEC_ID_MSMPEG4V2:
832 s->out_format = FMT_H263;
834 s->unrestricted_mv = 1;
835 s->msmpeg4_version = 2;
839 case AV_CODEC_ID_MSMPEG4V3:
840 s->out_format = FMT_H263;
842 s->unrestricted_mv = 1;
843 s->msmpeg4_version = 3;
844 s->flipflop_rounding = 1;
848 case AV_CODEC_ID_WMV1:
849 s->out_format = FMT_H263;
851 s->unrestricted_mv = 1;
852 s->msmpeg4_version = 4;
853 s->flipflop_rounding = 1;
857 case AV_CODEC_ID_WMV2:
858 s->out_format = FMT_H263;
860 s->unrestricted_mv = 1;
861 s->msmpeg4_version = 5;
862 s->flipflop_rounding = 1;
870 avctx->has_b_frames = !s->low_delay;
874 s->progressive_frame =
875 s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
876 AV_CODEC_FLAG_INTERLACED_ME) ||
881 if (ff_mpv_common_init(s) < 0)
884 ff_fdctdsp_init(&s->fdsp, avctx);
885 ff_me_cmp_init(&s->mecc, avctx);
886 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
887 ff_pixblockdsp_init(&s->pdsp, avctx);
888 ff_qpeldsp_init(&s->qdsp);
890 if (s->msmpeg4_version) {
891 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
892 2 * 2 * (MAX_LEVEL + 1) *
893 (MAX_RUN + 1) * 2 * sizeof(int), fail);
895 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
897 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
898 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
899 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
900 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
901 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
902 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
903 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
904 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
905 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
906 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
908 if (s->avctx->noise_reduction) {
909 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
910 2 * 64 * sizeof(uint16_t), fail);
913 ff_dct_encode_init(s);
915 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
916 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
918 if (s->slice_context_count > 1) {
921 if (avctx->codec_id == AV_CODEC_ID_H263P)
922 s->h263_slice_structured = 1;
925 s->quant_precision = 5;
927 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
928 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->avctx->frame_skip_cmp);
930 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
931 ff_h261_encode_init(s);
932 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
933 ff_h263_encode_init(s);
934 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
935 if ((ret = ff_msmpeg4_encode_init(s)) < 0)
937 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
938 && s->out_format == FMT_MPEG1)
939 ff_mpeg1_encode_init(s);
942 for (i = 0; i < 64; i++) {
943 int j = s->idsp.idct_permutation[i];
944 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
946 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
947 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
948 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
950 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
953 s->chroma_intra_matrix[j] =
954 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
955 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
957 if (s->avctx->intra_matrix)
958 s->intra_matrix[j] = s->avctx->intra_matrix[i];
959 if (s->avctx->inter_matrix)
960 s->inter_matrix[j] = s->avctx->inter_matrix[i];
963 /* precompute matrix */
964 /* for mjpeg, we do include qscale in the matrix */
965 if (s->out_format != FMT_MJPEG) {
966 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
967 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
969 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
970 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
974 if (ff_rate_control_init(s) < 0)
977 #if FF_API_ERROR_RATE
978 FF_DISABLE_DEPRECATION_WARNINGS
979 if (avctx->error_rate)
980 s->error_rate = avctx->error_rate;
981 FF_ENABLE_DEPRECATION_WARNINGS;
984 #if FF_API_NORMALIZE_AQP
985 FF_DISABLE_DEPRECATION_WARNINGS
986 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
987 s->mpv_flags |= FF_MPV_FLAG_NAQ;
988 FF_ENABLE_DEPRECATION_WARNINGS;
992 FF_DISABLE_DEPRECATION_WARNINGS
993 if (avctx->flags & CODEC_FLAG_MV0)
994 s->mpv_flags |= FF_MPV_FLAG_MV0;
995 FF_ENABLE_DEPRECATION_WARNINGS
999 FF_DISABLE_DEPRECATION_WARNINGS
1000 if (avctx->rc_qsquish != 0.0)
1001 s->rc_qsquish = avctx->rc_qsquish;
1002 if (avctx->rc_qmod_amp != 0.0)
1003 s->rc_qmod_amp = avctx->rc_qmod_amp;
1004 if (avctx->rc_qmod_freq)
1005 s->rc_qmod_freq = avctx->rc_qmod_freq;
1006 if (avctx->rc_buffer_aggressivity != 1.0)
1007 s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
1008 if (avctx->rc_initial_cplx != 0.0)
1009 s->rc_initial_cplx = avctx->rc_initial_cplx;
1011 s->lmin = avctx->lmin;
1013 s->lmax = avctx->lmax;
1016 av_freep(&s->rc_eq);
1017 s->rc_eq = av_strdup(avctx->rc_eq);
1019 return AVERROR(ENOMEM);
1021 FF_ENABLE_DEPRECATION_WARNINGS
1024 if (avctx->b_frame_strategy == 2) {
1025 for (i = 0; i < s->max_b_frames + 2; i++) {
1026 s->tmp_frames[i] = av_frame_alloc();
1027 if (!s->tmp_frames[i])
1028 return AVERROR(ENOMEM);
1030 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1031 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
1032 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
1034 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
1040 cpb_props = ff_add_cpb_side_data(avctx);
1042 return AVERROR(ENOMEM);
1043 cpb_props->max_bitrate = avctx->rc_max_rate;
1044 cpb_props->min_bitrate = avctx->rc_min_rate;
1045 cpb_props->avg_bitrate = avctx->bit_rate;
1046 cpb_props->buffer_size = avctx->rc_buffer_size;
1050 ff_mpv_encode_end(avctx);
1051 return AVERROR_UNKNOWN;
1054 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1056 MpegEncContext *s = avctx->priv_data;
1059 ff_rate_control_uninit(s);
1061 ff_mpv_common_end(s);
1062 if (CONFIG_MJPEG_ENCODER &&
1063 s->out_format == FMT_MJPEG)
1064 ff_mjpeg_encode_close(s);
1066 av_freep(&avctx->extradata);
1068 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1069 av_frame_free(&s->tmp_frames[i]);
1071 ff_free_picture_tables(&s->new_picture);
1072 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1074 av_freep(&s->avctx->stats_out);
1075 av_freep(&s->ac_stats);
1077 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1078 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1079 s->q_chroma_intra_matrix= NULL;
1080 s->q_chroma_intra_matrix16= NULL;
1081 av_freep(&s->q_intra_matrix);
1082 av_freep(&s->q_inter_matrix);
1083 av_freep(&s->q_intra_matrix16);
1084 av_freep(&s->q_inter_matrix16);
1085 av_freep(&s->input_picture);
1086 av_freep(&s->reordered_input_picture);
1087 av_freep(&s->dct_offset);
1092 static int get_sae(uint8_t *src, int ref, int stride)
1097 for (y = 0; y < 16; y++) {
1098 for (x = 0; x < 16; x++) {
1099 acc += FFABS(src[x + y * stride] - ref);
1106 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1107 uint8_t *ref, int stride)
1113 h = s->height & ~15;
1115 for (y = 0; y < h; y += 16) {
1116 for (x = 0; x < w; x += 16) {
1117 int offset = x + y * stride;
1118 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1120 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1121 int sae = get_sae(src + offset, mean, stride);
1123 acc += sae + 500 < sad;
1129 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1131 return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1132 s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1133 s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1134 &s->linesize, &s->uvlinesize);
1137 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1139 Picture *pic = NULL;
1141 int i, display_picture_number = 0, ret;
1142 int encoding_delay = s->max_b_frames ? s->max_b_frames
1143 : (s->low_delay ? 0 : 1);
1144 int flush_offset = 1;
1149 display_picture_number = s->input_picture_number++;
1151 if (pts != AV_NOPTS_VALUE) {
1152 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1153 int64_t last = s->user_specified_pts;
1156 av_log(s->avctx, AV_LOG_ERROR,
1157 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1159 return AVERROR(EINVAL);
1162 if (!s->low_delay && display_picture_number == 1)
1163 s->dts_delta = pts - last;
1165 s->user_specified_pts = pts;
1167 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1168 s->user_specified_pts =
1169 pts = s->user_specified_pts + 1;
1170 av_log(s->avctx, AV_LOG_INFO,
1171 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1174 pts = display_picture_number;
1178 if (!pic_arg->buf[0] ||
1179 pic_arg->linesize[0] != s->linesize ||
1180 pic_arg->linesize[1] != s->uvlinesize ||
1181 pic_arg->linesize[2] != s->uvlinesize)
1183 if ((s->width & 15) || (s->height & 15))
1185 if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1187 if (s->linesize & (STRIDE_ALIGN-1))
1190 ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1191 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1193 i = ff_find_unused_picture(s->avctx, s->picture, direct);
1197 pic = &s->picture[i];
1201 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1204 ret = alloc_picture(s, pic, direct);
1209 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1210 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1211 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1214 int h_chroma_shift, v_chroma_shift;
1215 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1219 for (i = 0; i < 3; i++) {
1220 int src_stride = pic_arg->linesize[i];
1221 int dst_stride = i ? s->uvlinesize : s->linesize;
1222 int h_shift = i ? h_chroma_shift : 0;
1223 int v_shift = i ? v_chroma_shift : 0;
1224 int w = s->width >> h_shift;
1225 int h = s->height >> v_shift;
1226 uint8_t *src = pic_arg->data[i];
1227 uint8_t *dst = pic->f->data[i];
1230 if ( s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1231 && !s->progressive_sequence
1232 && FFALIGN(s->height, 32) - s->height > 16)
1235 if (!s->avctx->rc_buffer_size)
1236 dst += INPLACE_OFFSET;
1238 if (src_stride == dst_stride)
1239 memcpy(dst, src, src_stride * h);
1242 uint8_t *dst2 = dst;
1244 memcpy(dst2, src, w);
1249 if ((s->width & 15) || (s->height & (vpad-1))) {
1250 s->mpvencdsp.draw_edges(dst, dst_stride,
1259 ret = av_frame_copy_props(pic->f, pic_arg);
1263 pic->f->display_picture_number = display_picture_number;
1264 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1266 /* Flushing: When we have not received enough input frames,
1267 * ensure s->input_picture[0] contains the first picture */
1268 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1269 if (s->input_picture[flush_offset])
1272 if (flush_offset <= 1)
1275 encoding_delay = encoding_delay - flush_offset + 1;
1278 /* shift buffer entries */
1279 for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1280 s->input_picture[i - flush_offset] = s->input_picture[i];
1282 s->input_picture[encoding_delay] = (Picture*) pic;
1287 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1291 int64_t score64 = 0;
1293 for (plane = 0; plane < 3; plane++) {
1294 const int stride = p->f->linesize[plane];
1295 const int bw = plane ? 1 : 2;
1296 for (y = 0; y < s->mb_height * bw; y++) {
1297 for (x = 0; x < s->mb_width * bw; x++) {
1298 int off = p->shared ? 0 : 16;
1299 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1300 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1301 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1303 switch (FFABS(s->avctx->frame_skip_exp)) {
1304 case 0: score = FFMAX(score, v); break;
1305 case 1: score += FFABS(v); break;
1306 case 2: score64 += v * (int64_t)v; break;
1307 case 3: score64 += FFABS(v * (int64_t)v * v); break;
1308 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1317 if (s->avctx->frame_skip_exp < 0)
1318 score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1319 -1.0/s->avctx->frame_skip_exp);
1321 if (score64 < s->avctx->frame_skip_threshold)
1323 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1328 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1330 AVPacket pkt = { 0 };
1331 int ret, got_output;
1333 av_init_packet(&pkt);
1334 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1339 av_packet_unref(&pkt);
1343 static int estimate_best_b_count(MpegEncContext *s)
1345 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1346 AVCodecContext *c = avcodec_alloc_context3(NULL);
1347 const int scale = s->avctx->brd_scale;
1348 int i, j, out_size, p_lambda, b_lambda, lambda2;
1349 int64_t best_rd = INT64_MAX;
1350 int best_b_count = -1;
1353 return AVERROR(ENOMEM);
1354 av_assert0(scale >= 0 && scale <= 3);
1357 //s->next_picture_ptr->quality;
1358 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1359 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1360 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1361 if (!b_lambda) // FIXME we should do this somewhere else
1362 b_lambda = p_lambda;
1363 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1366 c->width = s->width >> scale;
1367 c->height = s->height >> scale;
1368 c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1369 c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1370 c->mb_decision = s->avctx->mb_decision;
1371 c->me_cmp = s->avctx->me_cmp;
1372 c->mb_cmp = s->avctx->mb_cmp;
1373 c->me_sub_cmp = s->avctx->me_sub_cmp;
1374 c->pix_fmt = AV_PIX_FMT_YUV420P;
1375 c->time_base = s->avctx->time_base;
1376 c->max_b_frames = s->max_b_frames;
1378 if (avcodec_open2(c, codec, NULL) < 0)
1381 for (i = 0; i < s->max_b_frames + 2; i++) {
1382 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1383 s->next_picture_ptr;
1386 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1387 pre_input = *pre_input_ptr;
1388 memcpy(data, pre_input_ptr->f->data, sizeof(data));
1390 if (!pre_input.shared && i) {
1391 data[0] += INPLACE_OFFSET;
1392 data[1] += INPLACE_OFFSET;
1393 data[2] += INPLACE_OFFSET;
1396 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1397 s->tmp_frames[i]->linesize[0],
1399 pre_input.f->linesize[0],
1400 c->width, c->height);
1401 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1402 s->tmp_frames[i]->linesize[1],
1404 pre_input.f->linesize[1],
1405 c->width >> 1, c->height >> 1);
1406 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1407 s->tmp_frames[i]->linesize[2],
1409 pre_input.f->linesize[2],
1410 c->width >> 1, c->height >> 1);
1414 for (j = 0; j < s->max_b_frames + 1; j++) {
1417 if (!s->input_picture[j])
1420 c->error[0] = c->error[1] = c->error[2] = 0;
1422 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1423 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1425 out_size = encode_frame(c, s->tmp_frames[0]);
1427 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1429 for (i = 0; i < s->max_b_frames + 1; i++) {
1430 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1432 s->tmp_frames[i + 1]->pict_type = is_p ?
1433 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1434 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1436 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1438 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1441 /* get the delayed frames */
1443 out_size = encode_frame(c, NULL);
1444 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1447 rd += c->error[0] + c->error[1] + c->error[2];
1458 return best_b_count;
1461 static int select_input_picture(MpegEncContext *s)
1465 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1466 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1467 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1469 /* set next picture type & ordering */
1470 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1471 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1472 if (s->picture_in_gop_number < s->gop_size &&
1473 s->next_picture_ptr &&
1474 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1475 // FIXME check that te gop check above is +-1 correct
1476 av_frame_unref(s->input_picture[0]->f);
1478 ff_vbv_update(s, 0);
1484 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1485 !s->next_picture_ptr || s->intra_only) {
1486 s->reordered_input_picture[0] = s->input_picture[0];
1487 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1488 s->reordered_input_picture[0]->f->coded_picture_number =
1489 s->coded_picture_number++;
1493 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1494 for (i = 0; i < s->max_b_frames + 1; i++) {
1495 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1497 if (pict_num >= s->rc_context.num_entries)
1499 if (!s->input_picture[i]) {
1500 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1504 s->input_picture[i]->f->pict_type =
1505 s->rc_context.entry[pict_num].new_pict_type;
1509 if (s->avctx->b_frame_strategy == 0) {
1510 b_frames = s->max_b_frames;
1511 while (b_frames && !s->input_picture[b_frames])
1513 } else if (s->avctx->b_frame_strategy == 1) {
1514 for (i = 1; i < s->max_b_frames + 1; i++) {
1515 if (s->input_picture[i] &&
1516 s->input_picture[i]->b_frame_score == 0) {
1517 s->input_picture[i]->b_frame_score =
1519 s->input_picture[i ]->f->data[0],
1520 s->input_picture[i - 1]->f->data[0],
1524 for (i = 0; i < s->max_b_frames + 1; i++) {
1525 if (!s->input_picture[i] ||
1526 s->input_picture[i]->b_frame_score - 1 >
1527 s->mb_num / s->avctx->b_sensitivity)
1531 b_frames = FFMAX(0, i - 1);
1534 for (i = 0; i < b_frames + 1; i++) {
1535 s->input_picture[i]->b_frame_score = 0;
1537 } else if (s->avctx->b_frame_strategy == 2) {
1538 b_frames = estimate_best_b_count(s);
1540 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1546 for (i = b_frames - 1; i >= 0; i--) {
1547 int type = s->input_picture[i]->f->pict_type;
1548 if (type && type != AV_PICTURE_TYPE_B)
1551 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1552 b_frames == s->max_b_frames) {
1553 av_log(s->avctx, AV_LOG_ERROR,
1554 "warning, too many b frames in a row\n");
1557 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1558 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1559 s->gop_size > s->picture_in_gop_number) {
1560 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1562 if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1564 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1568 if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1569 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1572 s->reordered_input_picture[0] = s->input_picture[b_frames];
1573 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1574 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1575 s->reordered_input_picture[0]->f->coded_picture_number =
1576 s->coded_picture_number++;
1577 for (i = 0; i < b_frames; i++) {
1578 s->reordered_input_picture[i + 1] = s->input_picture[i];
1579 s->reordered_input_picture[i + 1]->f->pict_type =
1581 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1582 s->coded_picture_number++;
1587 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1589 if (s->reordered_input_picture[0]) {
1590 s->reordered_input_picture[0]->reference =
1591 s->reordered_input_picture[0]->f->pict_type !=
1592 AV_PICTURE_TYPE_B ? 3 : 0;
1594 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1597 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1598 // input is a shared pix, so we can't modifiy it -> alloc a new
1599 // one & ensure that the shared one is reuseable
1602 int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1605 pic = &s->picture[i];
1607 pic->reference = s->reordered_input_picture[0]->reference;
1608 if (alloc_picture(s, pic, 0) < 0) {
1612 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1616 /* mark us unused / free shared pic */
1617 av_frame_unref(s->reordered_input_picture[0]->f);
1618 s->reordered_input_picture[0]->shared = 0;
1620 s->current_picture_ptr = pic;
1622 // input is not a shared pix -> reuse buffer for current_pix
1623 s->current_picture_ptr = s->reordered_input_picture[0];
1624 for (i = 0; i < 4; i++) {
1625 s->new_picture.f->data[i] += INPLACE_OFFSET;
1628 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1629 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1630 s->current_picture_ptr)) < 0)
1633 s->picture_number = s->new_picture.f->display_picture_number;
1638 static void frame_end(MpegEncContext *s)
1640 if (s->unrestricted_mv &&
1641 s->current_picture.reference &&
1643 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1644 int hshift = desc->log2_chroma_w;
1645 int vshift = desc->log2_chroma_h;
1646 s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
1647 s->current_picture.f->linesize[0],
1648 s->h_edge_pos, s->v_edge_pos,
1649 EDGE_WIDTH, EDGE_WIDTH,
1650 EDGE_TOP | EDGE_BOTTOM);
1651 s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
1652 s->current_picture.f->linesize[1],
1653 s->h_edge_pos >> hshift,
1654 s->v_edge_pos >> vshift,
1655 EDGE_WIDTH >> hshift,
1656 EDGE_WIDTH >> vshift,
1657 EDGE_TOP | EDGE_BOTTOM);
1658 s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
1659 s->current_picture.f->linesize[2],
1660 s->h_edge_pos >> hshift,
1661 s->v_edge_pos >> vshift,
1662 EDGE_WIDTH >> hshift,
1663 EDGE_WIDTH >> vshift,
1664 EDGE_TOP | EDGE_BOTTOM);
1669 s->last_pict_type = s->pict_type;
1670 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1671 if (s->pict_type!= AV_PICTURE_TYPE_B)
1672 s->last_non_b_pict_type = s->pict_type;
1674 #if FF_API_CODED_FRAME
1675 FF_DISABLE_DEPRECATION_WARNINGS
1676 av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1677 FF_ENABLE_DEPRECATION_WARNINGS
1679 #if FF_API_ERROR_FRAME
1680 FF_DISABLE_DEPRECATION_WARNINGS
1681 memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1682 sizeof(s->current_picture.encoding_error));
1683 FF_ENABLE_DEPRECATION_WARNINGS
1687 static void update_noise_reduction(MpegEncContext *s)
1691 for (intra = 0; intra < 2; intra++) {
1692 if (s->dct_count[intra] > (1 << 16)) {
1693 for (i = 0; i < 64; i++) {
1694 s->dct_error_sum[intra][i] >>= 1;
1696 s->dct_count[intra] >>= 1;
1699 for (i = 0; i < 64; i++) {
1700 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1701 s->dct_count[intra] +
1702 s->dct_error_sum[intra][i] / 2) /
1703 (s->dct_error_sum[intra][i] + 1);
1708 static int frame_start(MpegEncContext *s)
1712 /* mark & release old frames */
1713 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1714 s->last_picture_ptr != s->next_picture_ptr &&
1715 s->last_picture_ptr->f->buf[0]) {
1716 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1719 s->current_picture_ptr->f->pict_type = s->pict_type;
1720 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1722 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1723 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1724 s->current_picture_ptr)) < 0)
1727 if (s->pict_type != AV_PICTURE_TYPE_B) {
1728 s->last_picture_ptr = s->next_picture_ptr;
1730 s->next_picture_ptr = s->current_picture_ptr;
1733 if (s->last_picture_ptr) {
1734 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1735 if (s->last_picture_ptr->f->buf[0] &&
1736 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1737 s->last_picture_ptr)) < 0)
1740 if (s->next_picture_ptr) {
1741 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1742 if (s->next_picture_ptr->f->buf[0] &&
1743 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1744 s->next_picture_ptr)) < 0)
1748 if (s->picture_structure!= PICT_FRAME) {
1750 for (i = 0; i < 4; i++) {
1751 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1752 s->current_picture.f->data[i] +=
1753 s->current_picture.f->linesize[i];
1755 s->current_picture.f->linesize[i] *= 2;
1756 s->last_picture.f->linesize[i] *= 2;
1757 s->next_picture.f->linesize[i] *= 2;
1761 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1762 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1763 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1764 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1765 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1766 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1768 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1769 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1772 if (s->dct_error_sum) {
1773 av_assert2(s->avctx->noise_reduction && s->encoding);
1774 update_noise_reduction(s);
1780 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1781 const AVFrame *pic_arg, int *got_packet)
1783 MpegEncContext *s = avctx->priv_data;
1784 int i, stuffing_count, ret;
1785 int context_count = s->slice_context_count;
1787 s->vbv_ignore_qmax = 0;
1789 s->picture_in_gop_number++;
1791 if (load_input_picture(s, pic_arg) < 0)
1794 if (select_input_picture(s) < 0) {
1799 if (s->new_picture.f->data[0]) {
1800 int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1801 int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1803 s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1804 if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1807 s->mb_info_ptr = av_packet_new_side_data(pkt,
1808 AV_PKT_DATA_H263_MB_INFO,
1809 s->mb_width*s->mb_height*12);
1810 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1813 for (i = 0; i < context_count; i++) {
1814 int start_y = s->thread_context[i]->start_mb_y;
1815 int end_y = s->thread_context[i]-> end_mb_y;
1816 int h = s->mb_height;
1817 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1818 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1820 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1823 s->pict_type = s->new_picture.f->pict_type;
1825 ret = frame_start(s);
1829 ret = encode_picture(s, s->picture_number);
1830 if (growing_buffer) {
1831 av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1832 pkt->data = s->pb.buf;
1833 pkt->size = avctx->internal->byte_buffer_size;
1838 #if FF_API_STAT_BITS
1839 FF_DISABLE_DEPRECATION_WARNINGS
1840 avctx->header_bits = s->header_bits;
1841 avctx->mv_bits = s->mv_bits;
1842 avctx->misc_bits = s->misc_bits;
1843 avctx->i_tex_bits = s->i_tex_bits;
1844 avctx->p_tex_bits = s->p_tex_bits;
1845 avctx->i_count = s->i_count;
1846 // FIXME f/b_count in avctx
1847 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1848 avctx->skip_count = s->skip_count;
1849 FF_ENABLE_DEPRECATION_WARNINGS
1854 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1855 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1857 if (avctx->rc_buffer_size) {
1858 RateControlContext *rcc = &s->rc_context;
1859 int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1860 int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1861 int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1863 if (put_bits_count(&s->pb) > max_size &&
1864 s->lambda < s->lmax) {
1865 s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1866 (s->qscale + 1) / s->qscale);
1867 if (s->adaptive_quant) {
1869 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1870 s->lambda_table[i] =
1871 FFMAX(s->lambda_table[i] + min_step,
1872 s->lambda_table[i] * (s->qscale + 1) /
1875 s->mb_skipped = 0; // done in frame_start()
1876 // done in encode_picture() so we must undo it
1877 if (s->pict_type == AV_PICTURE_TYPE_P) {
1878 if (s->flipflop_rounding ||
1879 s->codec_id == AV_CODEC_ID_H263P ||
1880 s->codec_id == AV_CODEC_ID_MPEG4)
1881 s->no_rounding ^= 1;
1883 if (s->pict_type != AV_PICTURE_TYPE_B) {
1884 s->time_base = s->last_time_base;
1885 s->last_non_b_time = s->time - s->pp_time;
1887 for (i = 0; i < context_count; i++) {
1888 PutBitContext *pb = &s->thread_context[i]->pb;
1889 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1891 s->vbv_ignore_qmax = 1;
1892 av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1896 av_assert0(s->avctx->rc_max_rate);
1899 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1900 ff_write_pass1_stats(s);
1902 for (i = 0; i < 4; i++) {
1903 s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1904 avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1906 ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
1907 s->current_picture_ptr->encoding_error,
1908 (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1911 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1912 assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1913 s->misc_bits + s->i_tex_bits +
1915 flush_put_bits(&s->pb);
1916 s->frame_bits = put_bits_count(&s->pb);
1918 stuffing_count = ff_vbv_update(s, s->frame_bits);
1919 s->stuffing_bits = 8*stuffing_count;
1920 if (stuffing_count) {
1921 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1922 stuffing_count + 50) {
1923 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1927 switch (s->codec_id) {
1928 case AV_CODEC_ID_MPEG1VIDEO:
1929 case AV_CODEC_ID_MPEG2VIDEO:
1930 while (stuffing_count--) {
1931 put_bits(&s->pb, 8, 0);
1934 case AV_CODEC_ID_MPEG4:
1935 put_bits(&s->pb, 16, 0);
1936 put_bits(&s->pb, 16, 0x1C3);
1937 stuffing_count -= 4;
1938 while (stuffing_count--) {
1939 put_bits(&s->pb, 8, 0xFF);
1943 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1945 flush_put_bits(&s->pb);
1946 s->frame_bits = put_bits_count(&s->pb);
1949 /* update mpeg1/2 vbv_delay for CBR */
1950 if (s->avctx->rc_max_rate &&
1951 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1952 s->out_format == FMT_MPEG1 &&
1953 90000LL * (avctx->rc_buffer_size - 1) <=
1954 s->avctx->rc_max_rate * 0xFFFFLL) {
1955 AVCPBProperties *props;
1958 int vbv_delay, min_delay;
1959 double inbits = s->avctx->rc_max_rate *
1960 av_q2d(s->avctx->time_base);
1961 int minbits = s->frame_bits - 8 *
1962 (s->vbv_delay_ptr - s->pb.buf - 1);
1963 double bits = s->rc_context.buffer_index + minbits - inbits;
1966 av_log(s->avctx, AV_LOG_ERROR,
1967 "Internal error, negative bits\n");
1969 assert(s->repeat_first_field == 0);
1971 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1972 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1973 s->avctx->rc_max_rate;
1975 vbv_delay = FFMAX(vbv_delay, min_delay);
1977 av_assert0(vbv_delay < 0xFFFF);
1979 s->vbv_delay_ptr[0] &= 0xF8;
1980 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1981 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1982 s->vbv_delay_ptr[2] &= 0x07;
1983 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1985 props = av_cpb_properties_alloc(&props_size);
1987 return AVERROR(ENOMEM);
1988 props->vbv_delay = vbv_delay * 300;
1990 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
1991 (uint8_t*)props, props_size);
1997 #if FF_API_VBV_DELAY
1998 FF_DISABLE_DEPRECATION_WARNINGS
1999 avctx->vbv_delay = vbv_delay * 300;
2000 FF_ENABLE_DEPRECATION_WARNINGS
2003 s->total_bits += s->frame_bits;
2004 #if FF_API_STAT_BITS
2005 FF_DISABLE_DEPRECATION_WARNINGS
2006 avctx->frame_bits = s->frame_bits;
2007 FF_ENABLE_DEPRECATION_WARNINGS
2011 pkt->pts = s->current_picture.f->pts;
2012 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2013 if (!s->current_picture.f->coded_picture_number)
2014 pkt->dts = pkt->pts - s->dts_delta;
2016 pkt->dts = s->reordered_pts;
2017 s->reordered_pts = pkt->pts;
2019 pkt->dts = pkt->pts;
2020 if (s->current_picture.f->key_frame)
2021 pkt->flags |= AV_PKT_FLAG_KEY;
2023 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2028 /* release non-reference frames */
2029 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2030 if (!s->picture[i].reference)
2031 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2034 av_assert1((s->frame_bits & 7) == 0);
2036 pkt->size = s->frame_bits / 8;
2037 *got_packet = !!pkt->size;
2041 static inline void dct_single_coeff_elimination(MpegEncContext *s,
2042 int n, int threshold)
2044 static const char tab[64] = {
2045 3, 2, 2, 1, 1, 1, 1, 1,
2046 1, 1, 1, 1, 1, 1, 1, 1,
2047 1, 1, 1, 1, 1, 1, 1, 1,
2048 0, 0, 0, 0, 0, 0, 0, 0,
2049 0, 0, 0, 0, 0, 0, 0, 0,
2050 0, 0, 0, 0, 0, 0, 0, 0,
2051 0, 0, 0, 0, 0, 0, 0, 0,
2052 0, 0, 0, 0, 0, 0, 0, 0
2057 int16_t *block = s->block[n];
2058 const int last_index = s->block_last_index[n];
2061 if (threshold < 0) {
2063 threshold = -threshold;
2067 /* Are all we could set to zero already zero? */
2068 if (last_index <= skip_dc - 1)
2071 for (i = 0; i <= last_index; i++) {
2072 const int j = s->intra_scantable.permutated[i];
2073 const int level = FFABS(block[j]);
2075 if (skip_dc && i == 0)
2079 } else if (level > 1) {
2085 if (score >= threshold)
2087 for (i = skip_dc; i <= last_index; i++) {
2088 const int j = s->intra_scantable.permutated[i];
2092 s->block_last_index[n] = 0;
2094 s->block_last_index[n] = -1;
2097 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2101 const int maxlevel = s->max_qcoeff;
2102 const int minlevel = s->min_qcoeff;
2106 i = 1; // skip clipping of intra dc
2110 for (; i <= last_index; i++) {
2111 const int j = s->intra_scantable.permutated[i];
2112 int level = block[j];
2114 if (level > maxlevel) {
2117 } else if (level < minlevel) {
2125 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2126 av_log(s->avctx, AV_LOG_INFO,
2127 "warning, clipping %d dct coefficients to %d..%d\n",
2128 overflow, minlevel, maxlevel);
2131 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2135 for (y = 0; y < 8; y++) {
2136 for (x = 0; x < 8; x++) {
2142 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2143 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2144 int v = ptr[x2 + y2 * stride];
2150 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2155 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2156 int motion_x, int motion_y,
2157 int mb_block_height,
2161 int16_t weight[12][64];
2162 int16_t orig[12][64];
2163 const int mb_x = s->mb_x;
2164 const int mb_y = s->mb_y;
2167 int dct_offset = s->linesize * 8; // default for progressive frames
2168 int uv_dct_offset = s->uvlinesize * 8;
2169 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2170 ptrdiff_t wrap_y, wrap_c;
2172 for (i = 0; i < mb_block_count; i++)
2173 skip_dct[i] = s->skipdct;
2175 if (s->adaptive_quant) {
2176 const int last_qp = s->qscale;
2177 const int mb_xy = mb_x + mb_y * s->mb_stride;
2179 s->lambda = s->lambda_table[mb_xy];
2182 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2183 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2184 s->dquant = s->qscale - last_qp;
2186 if (s->out_format == FMT_H263) {
2187 s->dquant = av_clip(s->dquant, -2, 2);
2189 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2191 if (s->pict_type == AV_PICTURE_TYPE_B) {
2192 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2195 if (s->mv_type == MV_TYPE_8X8)
2201 ff_set_qscale(s, last_qp + s->dquant);
2202 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2203 ff_set_qscale(s, s->qscale + s->dquant);
2205 wrap_y = s->linesize;
2206 wrap_c = s->uvlinesize;
2207 ptr_y = s->new_picture.f->data[0] +
2208 (mb_y * 16 * wrap_y) + mb_x * 16;
2209 ptr_cb = s->new_picture.f->data[1] +
2210 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2211 ptr_cr = s->new_picture.f->data[2] +
2212 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2214 if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2215 uint8_t *ebuf = s->sc.edge_emu_buffer + 36 * wrap_y;
2216 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2217 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2218 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2220 16, 16, mb_x * 16, mb_y * 16,
2221 s->width, s->height);
2223 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2225 mb_block_width, mb_block_height,
2226 mb_x * mb_block_width, mb_y * mb_block_height,
2228 ptr_cb = ebuf + 16 * wrap_y;
2229 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2231 mb_block_width, mb_block_height,
2232 mb_x * mb_block_width, mb_y * mb_block_height,
2234 ptr_cr = ebuf + 16 * wrap_y + 16;
2238 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2239 int progressive_score, interlaced_score;
2241 s->interlaced_dct = 0;
2242 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2243 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2244 NULL, wrap_y, 8) - 400;
2246 if (progressive_score > 0) {
2247 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2248 NULL, wrap_y * 2, 8) +
2249 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2250 NULL, wrap_y * 2, 8);
2251 if (progressive_score > interlaced_score) {
2252 s->interlaced_dct = 1;
2254 dct_offset = wrap_y;
2255 uv_dct_offset = wrap_c;
2257 if (s->chroma_format == CHROMA_422 ||
2258 s->chroma_format == CHROMA_444)
2264 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2265 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2266 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2267 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2269 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2273 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2274 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2275 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2276 s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2277 s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2278 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2279 s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2280 s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2281 s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2282 s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2283 s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2284 s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2288 op_pixels_func (*op_pix)[4];
2289 qpel_mc_func (*op_qpix)[16];
2290 uint8_t *dest_y, *dest_cb, *dest_cr;
2292 dest_y = s->dest[0];
2293 dest_cb = s->dest[1];
2294 dest_cr = s->dest[2];
2296 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2297 op_pix = s->hdsp.put_pixels_tab;
2298 op_qpix = s->qdsp.put_qpel_pixels_tab;
2300 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2301 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2304 if (s->mv_dir & MV_DIR_FORWARD) {
2305 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2306 s->last_picture.f->data,
2308 op_pix = s->hdsp.avg_pixels_tab;
2309 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2311 if (s->mv_dir & MV_DIR_BACKWARD) {
2312 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2313 s->next_picture.f->data,
2317 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2318 int progressive_score, interlaced_score;
2320 s->interlaced_dct = 0;
2321 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2322 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2326 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2327 progressive_score -= 400;
2329 if (progressive_score > 0) {
2330 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2332 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2336 if (progressive_score > interlaced_score) {
2337 s->interlaced_dct = 1;
2339 dct_offset = wrap_y;
2340 uv_dct_offset = wrap_c;
2342 if (s->chroma_format == CHROMA_422)
2348 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2349 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2350 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2351 dest_y + dct_offset, wrap_y);
2352 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2353 dest_y + dct_offset + 8, wrap_y);
2355 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2359 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2360 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2361 if (!s->chroma_y_shift) { /* 422 */
2362 s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2363 dest_cb + uv_dct_offset, wrap_c);
2364 s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2365 dest_cr + uv_dct_offset, wrap_c);
2368 /* pre quantization */
2369 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2370 2 * s->qscale * s->qscale) {
2372 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2374 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2376 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2377 wrap_y, 8) < 20 * s->qscale)
2379 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2380 wrap_y, 8) < 20 * s->qscale)
2382 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2384 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2386 if (!s->chroma_y_shift) { /* 422 */
2387 if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2388 dest_cb + uv_dct_offset,
2389 wrap_c, 8) < 20 * s->qscale)
2391 if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2392 dest_cr + uv_dct_offset,
2393 wrap_c, 8) < 20 * s->qscale)
2399 if (s->quantizer_noise_shaping) {
2401 get_visual_weight(weight[0], ptr_y , wrap_y);
2403 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2405 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2407 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2409 get_visual_weight(weight[4], ptr_cb , wrap_c);
2411 get_visual_weight(weight[5], ptr_cr , wrap_c);
2412 if (!s->chroma_y_shift) { /* 422 */
2414 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2417 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2420 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2423 /* DCT & quantize */
2424 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2426 for (i = 0; i < mb_block_count; i++) {
2429 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2430 // FIXME we could decide to change to quantizer instead of
2432 // JS: I don't think that would be a good idea it could lower
2433 // quality instead of improve it. Just INTRADC clipping
2434 // deserves changes in quantizer
2436 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2438 s->block_last_index[i] = -1;
2440 if (s->quantizer_noise_shaping) {
2441 for (i = 0; i < mb_block_count; i++) {
2443 s->block_last_index[i] =
2444 dct_quantize_refine(s, s->block[i], weight[i],
2445 orig[i], i, s->qscale);
2450 if (s->luma_elim_threshold && !s->mb_intra)
2451 for (i = 0; i < 4; i++)
2452 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2453 if (s->chroma_elim_threshold && !s->mb_intra)
2454 for (i = 4; i < mb_block_count; i++)
2455 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2457 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2458 for (i = 0; i < mb_block_count; i++) {
2459 if (s->block_last_index[i] == -1)
2460 s->coded_score[i] = INT_MAX / 256;
2465 if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2466 s->block_last_index[4] =
2467 s->block_last_index[5] = 0;
2469 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2470 if (!s->chroma_y_shift) { /* 422 / 444 */
2471 for (i=6; i<12; i++) {
2472 s->block_last_index[i] = 0;
2473 s->block[i][0] = s->block[4][0];
2478 // non c quantize code returns incorrect block_last_index FIXME
2479 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2480 for (i = 0; i < mb_block_count; i++) {
2482 if (s->block_last_index[i] > 0) {
2483 for (j = 63; j > 0; j--) {
2484 if (s->block[i][s->intra_scantable.permutated[j]])
2487 s->block_last_index[i] = j;
2492 /* huffman encode */
2493 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2494 case AV_CODEC_ID_MPEG1VIDEO:
2495 case AV_CODEC_ID_MPEG2VIDEO:
2496 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2497 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2499 case AV_CODEC_ID_MPEG4:
2500 if (CONFIG_MPEG4_ENCODER)
2501 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2503 case AV_CODEC_ID_MSMPEG4V2:
2504 case AV_CODEC_ID_MSMPEG4V3:
2505 case AV_CODEC_ID_WMV1:
2506 if (CONFIG_MSMPEG4_ENCODER)
2507 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2509 case AV_CODEC_ID_WMV2:
2510 if (CONFIG_WMV2_ENCODER)
2511 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2513 case AV_CODEC_ID_H261:
2514 if (CONFIG_H261_ENCODER)
2515 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2517 case AV_CODEC_ID_H263:
2518 case AV_CODEC_ID_H263P:
2519 case AV_CODEC_ID_FLV1:
2520 case AV_CODEC_ID_RV10:
2521 case AV_CODEC_ID_RV20:
2522 if (CONFIG_H263_ENCODER)
2523 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2525 case AV_CODEC_ID_MJPEG:
2526 case AV_CODEC_ID_AMV:
2527 if (CONFIG_MJPEG_ENCODER)
2528 ff_mjpeg_encode_mb(s, s->block);
2535 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2537 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2538 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2539 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2542 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2545 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2548 d->mb_skip_run= s->mb_skip_run;
2550 d->last_dc[i] = s->last_dc[i];
2553 d->mv_bits= s->mv_bits;
2554 d->i_tex_bits= s->i_tex_bits;
2555 d->p_tex_bits= s->p_tex_bits;
2556 d->i_count= s->i_count;
2557 d->f_count= s->f_count;
2558 d->b_count= s->b_count;
2559 d->skip_count= s->skip_count;
2560 d->misc_bits= s->misc_bits;
2564 d->qscale= s->qscale;
2565 d->dquant= s->dquant;
2567 d->esc3_level_length= s->esc3_level_length;
2570 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2573 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2574 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2577 d->mb_skip_run= s->mb_skip_run;
2579 d->last_dc[i] = s->last_dc[i];
2582 d->mv_bits= s->mv_bits;
2583 d->i_tex_bits= s->i_tex_bits;
2584 d->p_tex_bits= s->p_tex_bits;
2585 d->i_count= s->i_count;
2586 d->f_count= s->f_count;
2587 d->b_count= s->b_count;
2588 d->skip_count= s->skip_count;
2589 d->misc_bits= s->misc_bits;
2591 d->mb_intra= s->mb_intra;
2592 d->mb_skipped= s->mb_skipped;
2593 d->mv_type= s->mv_type;
2594 d->mv_dir= s->mv_dir;
2596 if(s->data_partitioning){
2598 d->tex_pb= s->tex_pb;
2602 d->block_last_index[i]= s->block_last_index[i];
2603 d->interlaced_dct= s->interlaced_dct;
2604 d->qscale= s->qscale;
2606 d->esc3_level_length= s->esc3_level_length;
2609 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2610 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2611 int *dmin, int *next_block, int motion_x, int motion_y)
2614 uint8_t *dest_backup[3];
2616 copy_context_before_encode(s, backup, type);
2618 s->block= s->blocks[*next_block];
2619 s->pb= pb[*next_block];
2620 if(s->data_partitioning){
2621 s->pb2 = pb2 [*next_block];
2622 s->tex_pb= tex_pb[*next_block];
2626 memcpy(dest_backup, s->dest, sizeof(s->dest));
2627 s->dest[0] = s->sc.rd_scratchpad;
2628 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2629 s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2630 av_assert0(s->linesize >= 32); //FIXME
2633 encode_mb(s, motion_x, motion_y);
2635 score= put_bits_count(&s->pb);
2636 if(s->data_partitioning){
2637 score+= put_bits_count(&s->pb2);
2638 score+= put_bits_count(&s->tex_pb);
2641 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2642 ff_mpv_decode_mb(s, s->block);
2644 score *= s->lambda2;
2645 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2649 memcpy(s->dest, dest_backup, sizeof(s->dest));
2656 copy_context_after_encode(best, s, type);
2660 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2661 uint32_t *sq = ff_square_tab + 256;
2666 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2667 else if(w==8 && h==8)
2668 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2672 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2681 static int sse_mb(MpegEncContext *s){
2685 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2686 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2689 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2690 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) +
2691 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) +
2692 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);
2694 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) +
2695 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) +
2696 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);
2699 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)
2700 +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)
2701 +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);
2704 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2705 MpegEncContext *s= *(void**)arg;
2709 s->me.dia_size= s->avctx->pre_dia_size;
2710 s->first_slice_line=1;
2711 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2712 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2713 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2715 s->first_slice_line=0;
2723 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2724 MpegEncContext *s= *(void**)arg;
2726 ff_check_alignment();
2728 s->me.dia_size= s->avctx->dia_size;
2729 s->first_slice_line=1;
2730 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2731 s->mb_x=0; //for block init below
2732 ff_init_block_index(s);
2733 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2734 s->block_index[0]+=2;
2735 s->block_index[1]+=2;
2736 s->block_index[2]+=2;
2737 s->block_index[3]+=2;
2739 /* compute motion vector & mb_type and store in context */
2740 if(s->pict_type==AV_PICTURE_TYPE_B)
2741 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2743 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2745 s->first_slice_line=0;
2750 static int mb_var_thread(AVCodecContext *c, void *arg){
2751 MpegEncContext *s= *(void**)arg;
2754 ff_check_alignment();
2756 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2757 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2760 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2762 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2764 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2765 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2767 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2768 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2769 s->me.mb_var_sum_temp += varc;
2775 static void write_slice_end(MpegEncContext *s){
2776 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2777 if(s->partitioned_frame){
2778 ff_mpeg4_merge_partitions(s);
2781 ff_mpeg4_stuffing(&s->pb);
2782 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2783 ff_mjpeg_encode_stuffing(s);
2786 avpriv_align_put_bits(&s->pb);
2787 flush_put_bits(&s->pb);
2789 if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2790 s->misc_bits+= get_bits_diff(s);
2793 static void write_mb_info(MpegEncContext *s)
2795 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2796 int offset = put_bits_count(&s->pb);
2797 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2798 int gobn = s->mb_y / s->gob_index;
2800 if (CONFIG_H263_ENCODER)
2801 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2802 bytestream_put_le32(&ptr, offset);
2803 bytestream_put_byte(&ptr, s->qscale);
2804 bytestream_put_byte(&ptr, gobn);
2805 bytestream_put_le16(&ptr, mba);
2806 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2807 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2808 /* 4MV not implemented */
2809 bytestream_put_byte(&ptr, 0); /* hmv2 */
2810 bytestream_put_byte(&ptr, 0); /* vmv2 */
2813 static void update_mb_info(MpegEncContext *s, int startcode)
2817 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2818 s->mb_info_size += 12;
2819 s->prev_mb_info = s->last_mb_info;
2822 s->prev_mb_info = put_bits_count(&s->pb)/8;
2823 /* This might have incremented mb_info_size above, and we return without
2824 * actually writing any info into that slot yet. But in that case,
2825 * this will be called again at the start of the after writing the
2826 * start code, actually writing the mb info. */
2830 s->last_mb_info = put_bits_count(&s->pb)/8;
2831 if (!s->mb_info_size)
2832 s->mb_info_size += 12;
2836 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2838 if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2839 && s->slice_context_count == 1
2840 && s->pb.buf == s->avctx->internal->byte_buffer) {
2841 int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2842 int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2844 uint8_t *new_buffer = NULL;
2845 int new_buffer_size = 0;
2847 av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2848 s->avctx->internal->byte_buffer_size + size_increase);
2850 return AVERROR(ENOMEM);
2852 memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2853 av_free(s->avctx->internal->byte_buffer);
2854 s->avctx->internal->byte_buffer = new_buffer;
2855 s->avctx->internal->byte_buffer_size = new_buffer_size;
2856 rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2857 s->ptr_lastgob = s->pb.buf + lastgob_pos;
2858 s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2860 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2861 return AVERROR(EINVAL);
2865 static int encode_thread(AVCodecContext *c, void *arg){
2866 MpegEncContext *s= *(void**)arg;
2867 int mb_x, mb_y, pdif = 0;
2868 int chr_h= 16>>s->chroma_y_shift;
2870 MpegEncContext best_s = { 0 }, backup_s;
2871 uint8_t bit_buf[2][MAX_MB_BYTES];
2872 uint8_t bit_buf2[2][MAX_MB_BYTES];
2873 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2874 PutBitContext pb[2], pb2[2], tex_pb[2];
2876 ff_check_alignment();
2879 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2880 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2881 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2884 s->last_bits= put_bits_count(&s->pb);
2895 /* init last dc values */
2896 /* note: quant matrix value (8) is implied here */
2897 s->last_dc[i] = 128 << s->intra_dc_precision;
2899 s->current_picture.encoding_error[i] = 0;
2901 if(s->codec_id==AV_CODEC_ID_AMV){
2902 s->last_dc[0] = 128*8/13;
2903 s->last_dc[1] = 128*8/14;
2904 s->last_dc[2] = 128*8/14;
2907 memset(s->last_mv, 0, sizeof(s->last_mv));
2911 switch(s->codec_id){
2912 case AV_CODEC_ID_H263:
2913 case AV_CODEC_ID_H263P:
2914 case AV_CODEC_ID_FLV1:
2915 if (CONFIG_H263_ENCODER)
2916 s->gob_index = H263_GOB_HEIGHT(s->height);
2918 case AV_CODEC_ID_MPEG4:
2919 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2920 ff_mpeg4_init_partitions(s);
2926 s->first_slice_line = 1;
2927 s->ptr_lastgob = s->pb.buf;
2928 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2932 ff_set_qscale(s, s->qscale);
2933 ff_init_block_index(s);
2935 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2936 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2937 int mb_type= s->mb_type[xy];
2941 int size_increase = s->avctx->internal->byte_buffer_size/4
2942 + s->mb_width*MAX_MB_BYTES;
2944 ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
2945 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2946 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2949 if(s->data_partitioning){
2950 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2951 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2952 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2958 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2959 ff_update_block_index(s);
2961 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2962 ff_h261_reorder_mb_index(s);
2963 xy= s->mb_y*s->mb_stride + s->mb_x;
2964 mb_type= s->mb_type[xy];
2967 /* write gob / video packet header */
2969 int current_packet_size, is_gob_start;
2971 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2973 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2975 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2977 switch(s->codec_id){
2978 case AV_CODEC_ID_H263:
2979 case AV_CODEC_ID_H263P:
2980 if(!s->h263_slice_structured)
2981 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2983 case AV_CODEC_ID_MPEG2VIDEO:
2984 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2985 case AV_CODEC_ID_MPEG1VIDEO:
2986 if(s->mb_skip_run) is_gob_start=0;
2988 case AV_CODEC_ID_MJPEG:
2989 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2994 if(s->start_mb_y != mb_y || mb_x!=0){
2997 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2998 ff_mpeg4_init_partitions(s);
3002 av_assert2((put_bits_count(&s->pb)&7) == 0);
3003 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3005 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3006 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3007 int d = 100 / s->error_rate;
3009 current_packet_size=0;
3010 s->pb.buf_ptr= s->ptr_lastgob;
3011 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3015 #if FF_API_RTP_CALLBACK
3016 FF_DISABLE_DEPRECATION_WARNINGS
3017 if (s->avctx->rtp_callback){
3018 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3019 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3021 FF_ENABLE_DEPRECATION_WARNINGS
3023 update_mb_info(s, 1);
3025 switch(s->codec_id){
3026 case AV_CODEC_ID_MPEG4:
3027 if (CONFIG_MPEG4_ENCODER) {
3028 ff_mpeg4_encode_video_packet_header(s);
3029 ff_mpeg4_clean_buffers(s);
3032 case AV_CODEC_ID_MPEG1VIDEO:
3033 case AV_CODEC_ID_MPEG2VIDEO:
3034 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3035 ff_mpeg1_encode_slice_header(s);
3036 ff_mpeg1_clean_buffers(s);
3039 case AV_CODEC_ID_H263:
3040 case AV_CODEC_ID_H263P:
3041 if (CONFIG_H263_ENCODER)
3042 ff_h263_encode_gob_header(s, mb_y);
3046 if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3047 int bits= put_bits_count(&s->pb);
3048 s->misc_bits+= bits - s->last_bits;
3052 s->ptr_lastgob += current_packet_size;
3053 s->first_slice_line=1;
3054 s->resync_mb_x=mb_x;
3055 s->resync_mb_y=mb_y;
3059 if( (s->resync_mb_x == s->mb_x)
3060 && s->resync_mb_y+1 == s->mb_y){
3061 s->first_slice_line=0;
3065 s->dquant=0; //only for QP_RD
3067 update_mb_info(s, 0);
3069 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
3071 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3073 copy_context_before_encode(&backup_s, s, -1);
3075 best_s.data_partitioning= s->data_partitioning;
3076 best_s.partitioned_frame= s->partitioned_frame;
3077 if(s->data_partitioning){
3078 backup_s.pb2= s->pb2;
3079 backup_s.tex_pb= s->tex_pb;
3082 if(mb_type&CANDIDATE_MB_TYPE_INTER){
3083 s->mv_dir = MV_DIR_FORWARD;
3084 s->mv_type = MV_TYPE_16X16;
3086 s->mv[0][0][0] = s->p_mv_table[xy][0];
3087 s->mv[0][0][1] = s->p_mv_table[xy][1];
3088 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3089 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3091 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3092 s->mv_dir = MV_DIR_FORWARD;
3093 s->mv_type = MV_TYPE_FIELD;
3096 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3097 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3098 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3100 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3101 &dmin, &next_block, 0, 0);
3103 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3104 s->mv_dir = MV_DIR_FORWARD;
3105 s->mv_type = MV_TYPE_16X16;
3109 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3110 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3112 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3113 s->mv_dir = MV_DIR_FORWARD;
3114 s->mv_type = MV_TYPE_8X8;
3117 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3118 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3120 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3121 &dmin, &next_block, 0, 0);
3123 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3124 s->mv_dir = MV_DIR_FORWARD;
3125 s->mv_type = MV_TYPE_16X16;
3127 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3128 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3129 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3130 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3132 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3133 s->mv_dir = MV_DIR_BACKWARD;
3134 s->mv_type = MV_TYPE_16X16;
3136 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3137 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3138 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3139 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3141 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3142 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3143 s->mv_type = MV_TYPE_16X16;
3145 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3146 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3147 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3148 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3149 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3150 &dmin, &next_block, 0, 0);
3152 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3153 s->mv_dir = MV_DIR_FORWARD;
3154 s->mv_type = MV_TYPE_FIELD;
3157 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3158 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3159 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3161 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3162 &dmin, &next_block, 0, 0);
3164 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3165 s->mv_dir = MV_DIR_BACKWARD;
3166 s->mv_type = MV_TYPE_FIELD;
3169 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3170 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3171 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3173 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3174 &dmin, &next_block, 0, 0);
3176 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3177 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3178 s->mv_type = MV_TYPE_FIELD;
3180 for(dir=0; dir<2; dir++){
3182 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3183 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3184 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3187 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3188 &dmin, &next_block, 0, 0);
3190 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3192 s->mv_type = MV_TYPE_16X16;
3196 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3197 &dmin, &next_block, 0, 0);
3198 if(s->h263_pred || s->h263_aic){
3200 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3202 ff_clean_intra_table_entries(s); //old mode?
3206 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3207 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3208 const int last_qp= backup_s.qscale;
3211 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3212 static const int dquant_tab[4]={-1,1,-2,2};
3213 int storecoefs = s->mb_intra && s->dc_val[0];
3215 av_assert2(backup_s.dquant == 0);
3218 s->mv_dir= best_s.mv_dir;
3219 s->mv_type = MV_TYPE_16X16;
3220 s->mb_intra= best_s.mb_intra;
3221 s->mv[0][0][0] = best_s.mv[0][0][0];
3222 s->mv[0][0][1] = best_s.mv[0][0][1];
3223 s->mv[1][0][0] = best_s.mv[1][0][0];
3224 s->mv[1][0][1] = best_s.mv[1][0][1];
3226 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3227 for(; qpi<4; qpi++){
3228 int dquant= dquant_tab[qpi];
3229 qp= last_qp + dquant;
3230 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3232 backup_s.dquant= dquant;
3235 dc[i]= s->dc_val[0][ s->block_index[i] ];
3236 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3240 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3241 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3242 if(best_s.qscale != qp){
3245 s->dc_val[0][ s->block_index[i] ]= dc[i];
3246 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3253 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3254 int mx= s->b_direct_mv_table[xy][0];
3255 int my= s->b_direct_mv_table[xy][1];
3257 backup_s.dquant = 0;
3258 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3260 ff_mpeg4_set_direct_mv(s, mx, my);
3261 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3262 &dmin, &next_block, mx, my);
3264 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3265 backup_s.dquant = 0;
3266 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3268 ff_mpeg4_set_direct_mv(s, 0, 0);
3269 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3270 &dmin, &next_block, 0, 0);
3272 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3275 coded |= s->block_last_index[i];
3278 memcpy(s->mv, best_s.mv, sizeof(s->mv));
3279 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3280 mx=my=0; //FIXME find the one we actually used
3281 ff_mpeg4_set_direct_mv(s, mx, my);
3282 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3290 s->mv_dir= best_s.mv_dir;
3291 s->mv_type = best_s.mv_type;
3293 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3294 s->mv[0][0][1] = best_s.mv[0][0][1];
3295 s->mv[1][0][0] = best_s.mv[1][0][0];
3296 s->mv[1][0][1] = best_s.mv[1][0][1];*/
3299 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3300 &dmin, &next_block, mx, my);
3305 s->current_picture.qscale_table[xy] = best_s.qscale;
3307 copy_context_after_encode(s, &best_s, -1);
3309 pb_bits_count= put_bits_count(&s->pb);
3310 flush_put_bits(&s->pb);
3311 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3314 if(s->data_partitioning){
3315 pb2_bits_count= put_bits_count(&s->pb2);
3316 flush_put_bits(&s->pb2);
3317 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3318 s->pb2= backup_s.pb2;
3320 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3321 flush_put_bits(&s->tex_pb);
3322 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3323 s->tex_pb= backup_s.tex_pb;
3325 s->last_bits= put_bits_count(&s->pb);
3327 if (CONFIG_H263_ENCODER &&
3328 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3329 ff_h263_update_motion_val(s);
3331 if(next_block==0){ //FIXME 16 vs linesize16
3332 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3333 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3334 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3337 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3338 ff_mpv_decode_mb(s, s->block);
3340 int motion_x = 0, motion_y = 0;
3341 s->mv_type=MV_TYPE_16X16;
3342 // only one MB-Type possible
3345 case CANDIDATE_MB_TYPE_INTRA:
3348 motion_x= s->mv[0][0][0] = 0;
3349 motion_y= s->mv[0][0][1] = 0;
3351 case CANDIDATE_MB_TYPE_INTER:
3352 s->mv_dir = MV_DIR_FORWARD;
3354 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3355 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3357 case CANDIDATE_MB_TYPE_INTER_I:
3358 s->mv_dir = MV_DIR_FORWARD;
3359 s->mv_type = MV_TYPE_FIELD;
3362 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3363 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3364 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3367 case CANDIDATE_MB_TYPE_INTER4V:
3368 s->mv_dir = MV_DIR_FORWARD;
3369 s->mv_type = MV_TYPE_8X8;
3372 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3373 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3376 case CANDIDATE_MB_TYPE_DIRECT:
3377 if (CONFIG_MPEG4_ENCODER) {
3378 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3380 motion_x=s->b_direct_mv_table[xy][0];
3381 motion_y=s->b_direct_mv_table[xy][1];
3382 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3385 case CANDIDATE_MB_TYPE_DIRECT0:
3386 if (CONFIG_MPEG4_ENCODER) {
3387 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3389 ff_mpeg4_set_direct_mv(s, 0, 0);
3392 case CANDIDATE_MB_TYPE_BIDIR:
3393 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3395 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3396 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3397 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3398 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3400 case CANDIDATE_MB_TYPE_BACKWARD:
3401 s->mv_dir = MV_DIR_BACKWARD;
3403 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3404 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3406 case CANDIDATE_MB_TYPE_FORWARD:
3407 s->mv_dir = MV_DIR_FORWARD;
3409 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3410 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3412 case CANDIDATE_MB_TYPE_FORWARD_I:
3413 s->mv_dir = MV_DIR_FORWARD;
3414 s->mv_type = MV_TYPE_FIELD;
3417 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3418 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3419 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3422 case CANDIDATE_MB_TYPE_BACKWARD_I:
3423 s->mv_dir = MV_DIR_BACKWARD;
3424 s->mv_type = MV_TYPE_FIELD;
3427 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3428 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3429 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3432 case CANDIDATE_MB_TYPE_BIDIR_I:
3433 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3434 s->mv_type = MV_TYPE_FIELD;
3436 for(dir=0; dir<2; dir++){
3438 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3439 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3440 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3445 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3448 encode_mb(s, motion_x, motion_y);
3450 // RAL: Update last macroblock type
3451 s->last_mv_dir = s->mv_dir;
3453 if (CONFIG_H263_ENCODER &&
3454 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3455 ff_h263_update_motion_val(s);
3457 ff_mpv_decode_mb(s, s->block);
3460 /* clean the MV table in IPS frames for direct mode in B frames */
3461 if(s->mb_intra /* && I,P,S_TYPE */){
3462 s->p_mv_table[xy][0]=0;
3463 s->p_mv_table[xy][1]=0;
3466 if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3470 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3471 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3473 s->current_picture.encoding_error[0] += sse(
3474 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3475 s->dest[0], w, h, s->linesize);
3476 s->current_picture.encoding_error[1] += sse(
3477 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3478 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3479 s->current_picture.encoding_error[2] += sse(
3480 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3481 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3484 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3485 ff_h263_loop_filter(s);
3487 ff_dlog(s->avctx, "MB %d %d bits\n",
3488 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3492 //not beautiful here but we must write it before flushing so it has to be here
3493 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3494 ff_msmpeg4_encode_ext_header(s);
3498 #if FF_API_RTP_CALLBACK
3499 FF_DISABLE_DEPRECATION_WARNINGS
3500 /* Send the last GOB if RTP */
3501 if (s->avctx->rtp_callback) {
3502 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3503 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3504 /* Call the RTP callback to send the last GOB */
3506 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3508 FF_ENABLE_DEPRECATION_WARNINGS
3514 #define MERGE(field) dst->field += src->field; src->field=0
3515 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3516 MERGE(me.scene_change_score);
3517 MERGE(me.mc_mb_var_sum_temp);
3518 MERGE(me.mb_var_sum_temp);
3521 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3524 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3525 MERGE(dct_count[1]);
3534 MERGE(er.error_count);
3535 MERGE(padding_bug_score);
3536 MERGE(current_picture.encoding_error[0]);
3537 MERGE(current_picture.encoding_error[1]);
3538 MERGE(current_picture.encoding_error[2]);
3540 if(dst->avctx->noise_reduction){
3541 for(i=0; i<64; i++){
3542 MERGE(dct_error_sum[0][i]);
3543 MERGE(dct_error_sum[1][i]);
3547 assert(put_bits_count(&src->pb) % 8 ==0);
3548 assert(put_bits_count(&dst->pb) % 8 ==0);
3549 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3550 flush_put_bits(&dst->pb);
3553 static int estimate_qp(MpegEncContext *s, int dry_run){
3554 if (s->next_lambda){
3555 s->current_picture_ptr->f->quality =
3556 s->current_picture.f->quality = s->next_lambda;
3557 if(!dry_run) s->next_lambda= 0;
3558 } else if (!s->fixed_qscale) {
3559 s->current_picture_ptr->f->quality =
3560 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3561 if (s->current_picture.f->quality < 0)
3565 if(s->adaptive_quant){
3566 switch(s->codec_id){
3567 case AV_CODEC_ID_MPEG4:
3568 if (CONFIG_MPEG4_ENCODER)
3569 ff_clean_mpeg4_qscales(s);
3571 case AV_CODEC_ID_H263:
3572 case AV_CODEC_ID_H263P:
3573 case AV_CODEC_ID_FLV1:
3574 if (CONFIG_H263_ENCODER)
3575 ff_clean_h263_qscales(s);
3578 ff_init_qscale_tab(s);
3581 s->lambda= s->lambda_table[0];
3584 s->lambda = s->current_picture.f->quality;
3589 /* must be called before writing the header */
3590 static void set_frame_distances(MpegEncContext * s){
3591 av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3592 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3594 if(s->pict_type==AV_PICTURE_TYPE_B){
3595 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3596 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3598 s->pp_time= s->time - s->last_non_b_time;
3599 s->last_non_b_time= s->time;
3600 assert(s->picture_number==0 || s->pp_time > 0);
3604 static int encode_picture(MpegEncContext *s, int picture_number)
3608 int context_count = s->slice_context_count;
3610 s->picture_number = picture_number;
3612 /* Reset the average MB variance */
3613 s->me.mb_var_sum_temp =
3614 s->me.mc_mb_var_sum_temp = 0;
3616 /* we need to initialize some time vars before we can encode b-frames */
3617 // RAL: Condition added for MPEG1VIDEO
3618 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3619 set_frame_distances(s);
3620 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3621 ff_set_mpeg4_time(s);
3623 s->me.scene_change_score=0;
3625 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3627 if(s->pict_type==AV_PICTURE_TYPE_I){
3628 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3629 else s->no_rounding=0;
3630 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3631 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3632 s->no_rounding ^= 1;
3635 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3636 if (estimate_qp(s,1) < 0)
3638 ff_get_2pass_fcode(s);
3639 } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3640 if(s->pict_type==AV_PICTURE_TYPE_B)
3641 s->lambda= s->last_lambda_for[s->pict_type];
3643 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3647 if(s->codec_id != AV_CODEC_ID_AMV && s->codec_id != AV_CODEC_ID_MJPEG){
3648 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3649 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3650 s->q_chroma_intra_matrix = s->q_intra_matrix;
3651 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3654 s->mb_intra=0; //for the rate distortion & bit compare functions
3655 for(i=1; i<context_count; i++){
3656 ret = ff_update_duplicate_context(s->thread_context[i], s);
3664 /* Estimate motion for every MB */
3665 if(s->pict_type != AV_PICTURE_TYPE_I){
3666 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3667 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3668 if (s->pict_type != AV_PICTURE_TYPE_B) {
3669 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3670 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3674 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3675 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3677 for(i=0; i<s->mb_stride*s->mb_height; i++)
3678 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3680 if(!s->fixed_qscale){
3681 /* finding spatial complexity for I-frame rate control */
3682 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3685 for(i=1; i<context_count; i++){
3686 merge_context_after_me(s, s->thread_context[i]);
3688 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3689 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3692 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3693 s->pict_type= AV_PICTURE_TYPE_I;
3694 for(i=0; i<s->mb_stride*s->mb_height; i++)
3695 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3696 if(s->msmpeg4_version >= 3)
3698 ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3699 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3703 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3704 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3706 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3708 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3709 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3710 s->f_code= FFMAX3(s->f_code, a, b);
3713 ff_fix_long_p_mvs(s);
3714 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3715 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3719 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3720 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3725 if(s->pict_type==AV_PICTURE_TYPE_B){
3728 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3729 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3730 s->f_code = FFMAX(a, b);
3732 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3733 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3734 s->b_code = FFMAX(a, b);
3736 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3737 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3738 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3739 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3740 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3742 for(dir=0; dir<2; dir++){
3745 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3746 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3747 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3748 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3756 if (estimate_qp(s, 0) < 0)
3759 if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3760 s->pict_type == AV_PICTURE_TYPE_I &&
3761 !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3762 s->qscale= 3; //reduce clipping problems
3764 if (s->out_format == FMT_MJPEG) {
3765 const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3766 const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3768 if (s->avctx->intra_matrix) {
3770 luma_matrix = s->avctx->intra_matrix;
3772 if (s->avctx->chroma_intra_matrix)
3773 chroma_matrix = s->avctx->chroma_intra_matrix;
3775 /* for mjpeg, we do include qscale in the matrix */
3777 int j = s->idsp.idct_permutation[i];
3779 s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3780 s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3782 s->y_dc_scale_table=
3783 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3784 s->chroma_intra_matrix[0] =
3785 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3786 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3787 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3788 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3789 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3792 if(s->codec_id == AV_CODEC_ID_AMV){
3793 static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
3794 static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
3796 int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3798 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3799 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3801 s->y_dc_scale_table= y;
3802 s->c_dc_scale_table= c;
3803 s->intra_matrix[0] = 13;
3804 s->chroma_intra_matrix[0] = 14;
3805 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3806 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3807 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3808 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3812 //FIXME var duplication
3813 s->current_picture_ptr->f->key_frame =
3814 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3815 s->current_picture_ptr->f->pict_type =
3816 s->current_picture.f->pict_type = s->pict_type;
3818 if (s->current_picture.f->key_frame)
3819 s->picture_in_gop_number=0;
3821 s->mb_x = s->mb_y = 0;
3822 s->last_bits= put_bits_count(&s->pb);
3823 switch(s->out_format) {
3825 if (CONFIG_MJPEG_ENCODER)
3826 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3827 s->intra_matrix, s->chroma_intra_matrix);
3830 if (CONFIG_H261_ENCODER)
3831 ff_h261_encode_picture_header(s, picture_number);
3834 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3835 ff_wmv2_encode_picture_header(s, picture_number);
3836 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3837 ff_msmpeg4_encode_picture_header(s, picture_number);
3838 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3839 ff_mpeg4_encode_picture_header(s, picture_number);
3840 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3841 ret = ff_rv10_encode_picture_header(s, picture_number);
3845 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3846 ff_rv20_encode_picture_header(s, picture_number);
3847 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3848 ff_flv_encode_picture_header(s, picture_number);
3849 else if (CONFIG_H263_ENCODER)
3850 ff_h263_encode_picture_header(s, picture_number);
3853 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3854 ff_mpeg1_encode_picture_header(s, picture_number);
3859 bits= put_bits_count(&s->pb);
3860 s->header_bits= bits - s->last_bits;
3862 for(i=1; i<context_count; i++){
3863 update_duplicate_context_after_me(s->thread_context[i], s);
3865 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3866 for(i=1; i<context_count; i++){
3867 if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3868 set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
3869 merge_context_after_encode(s, s->thread_context[i]);
3875 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3876 const int intra= s->mb_intra;
3879 s->dct_count[intra]++;
3881 for(i=0; i<64; i++){
3882 int level= block[i];
3886 s->dct_error_sum[intra][i] += level;
3887 level -= s->dct_offset[intra][i];
3888 if(level<0) level=0;
3890 s->dct_error_sum[intra][i] -= level;
3891 level += s->dct_offset[intra][i];
3892 if(level>0) level=0;
3899 static int dct_quantize_trellis_c(MpegEncContext *s,
3900 int16_t *block, int n,
3901 int qscale, int *overflow){
3903 const uint16_t *matrix;
3904 const uint8_t *scantable= s->intra_scantable.scantable;
3905 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3907 unsigned int threshold1, threshold2;
3919 int coeff_count[64];
3920 int qmul, qadd, start_i, last_non_zero, i, dc;
3921 const int esc_length= s->ac_esc_length;
3923 uint8_t * last_length;
3924 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3927 s->fdsp.fdct(block);
3929 if(s->dct_error_sum)
3930 s->denoise_dct(s, block);
3932 qadd= ((qscale-1)|1)*8;
3934 if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
3935 else mpeg2_qscale = qscale << 1;
3946 /* For AIC we skip quant/dequant of INTRADC */
3951 /* note: block[0] is assumed to be positive */
3952 block[0] = (block[0] + (q >> 1)) / q;
3955 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3956 matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
3957 if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
3958 bias= 1<<(QMAT_SHIFT-1);
3960 if (n > 3 && s->intra_chroma_ac_vlc_length) {
3961 length = s->intra_chroma_ac_vlc_length;
3962 last_length= s->intra_chroma_ac_vlc_last_length;
3964 length = s->intra_ac_vlc_length;
3965 last_length= s->intra_ac_vlc_last_length;
3970 qmat = s->q_inter_matrix[qscale];
3971 matrix = s->inter_matrix;
3972 length = s->inter_ac_vlc_length;
3973 last_length= s->inter_ac_vlc_last_length;
3977 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3978 threshold2= (threshold1<<1);
3980 for(i=63; i>=start_i; i--) {
3981 const int j = scantable[i];
3982 int level = block[j] * qmat[j];
3984 if(((unsigned)(level+threshold1))>threshold2){
3990 for(i=start_i; i<=last_non_zero; i++) {
3991 const int j = scantable[i];
3992 int level = block[j] * qmat[j];
3994 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3995 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3996 if(((unsigned)(level+threshold1))>threshold2){
3998 level= (bias + level)>>QMAT_SHIFT;
4000 coeff[1][i]= level-1;
4001 // coeff[2][k]= level-2;
4003 level= (bias - level)>>QMAT_SHIFT;
4004 coeff[0][i]= -level;
4005 coeff[1][i]= -level+1;
4006 // coeff[2][k]= -level+2;
4008 coeff_count[i]= FFMIN(level, 2);
4009 av_assert2(coeff_count[i]);
4012 coeff[0][i]= (level>>31)|1;
4017 *overflow= s->max_qcoeff < max; //overflow might have happened
4019 if(last_non_zero < start_i){
4020 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4021 return last_non_zero;
4024 score_tab[start_i]= 0;
4025 survivor[0]= start_i;
4028 for(i=start_i; i<=last_non_zero; i++){
4029 int level_index, j, zero_distortion;
4030 int dct_coeff= FFABS(block[ scantable[i] ]);
4031 int best_score=256*256*256*120;
4033 if (s->fdsp.fdct == ff_fdct_ifast)
4034 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4035 zero_distortion= dct_coeff*dct_coeff;
4037 for(level_index=0; level_index < coeff_count[i]; level_index++){
4039 int level= coeff[level_index][i];
4040 const int alevel= FFABS(level);
4045 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4046 unquant_coeff= alevel*qmul + qadd;
4047 } else if(s->out_format == FMT_MJPEG) {
4048 j = s->idsp.idct_permutation[scantable[i]];
4049 unquant_coeff = alevel * matrix[j] * 8;
4051 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4053 unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4054 unquant_coeff = (unquant_coeff - 1) | 1;
4056 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4057 unquant_coeff = (unquant_coeff - 1) | 1;
4062 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4064 if((level&(~127)) == 0){
4065 for(j=survivor_count-1; j>=0; j--){
4066 int run= i - survivor[j];
4067 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4068 score += score_tab[i-run];
4070 if(score < best_score){
4073 level_tab[i+1]= level-64;
4077 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4078 for(j=survivor_count-1; j>=0; j--){
4079 int run= i - survivor[j];
4080 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4081 score += score_tab[i-run];
4082 if(score < last_score){
4085 last_level= level-64;
4091 distortion += esc_length*lambda;
4092 for(j=survivor_count-1; j>=0; j--){
4093 int run= i - survivor[j];
4094 int score= distortion + score_tab[i-run];
4096 if(score < best_score){
4099 level_tab[i+1]= level-64;
4103 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4104 for(j=survivor_count-1; j>=0; j--){
4105 int run= i - survivor[j];
4106 int score= distortion + score_tab[i-run];
4107 if(score < last_score){
4110 last_level= level-64;
4118 score_tab[i+1]= best_score;
4120 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4121 if(last_non_zero <= 27){
4122 for(; survivor_count; survivor_count--){
4123 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4127 for(; survivor_count; survivor_count--){
4128 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4133 survivor[ survivor_count++ ]= i+1;
4136 if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4137 last_score= 256*256*256*120;
4138 for(i= survivor[0]; i<=last_non_zero + 1; i++){
4139 int score= score_tab[i];
4140 if(i) score += lambda*2; //FIXME exacter?
4142 if(score < last_score){
4145 last_level= level_tab[i];
4146 last_run= run_tab[i];
4151 s->coded_score[n] = last_score;
4153 dc= FFABS(block[0]);
4154 last_non_zero= last_i - 1;
4155 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4157 if(last_non_zero < start_i)
4158 return last_non_zero;
4160 if(last_non_zero == 0 && start_i == 0){
4162 int best_score= dc * dc;
4164 for(i=0; i<coeff_count[0]; i++){
4165 int level= coeff[i][0];
4166 int alevel= FFABS(level);
4167 int unquant_coeff, score, distortion;
4169 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4170 unquant_coeff= (alevel*qmul + qadd)>>3;
4172 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4173 unquant_coeff = (unquant_coeff - 1) | 1;
4175 unquant_coeff = (unquant_coeff + 4) >> 3;
4176 unquant_coeff<<= 3 + 3;
4178 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4180 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4181 else score= distortion + esc_length*lambda;
4183 if(score < best_score){
4185 best_level= level - 64;
4188 block[0]= best_level;
4189 s->coded_score[n] = best_score - dc*dc;
4190 if(best_level == 0) return -1;
4191 else return last_non_zero;
4195 av_assert2(last_level);
4197 block[ perm_scantable[last_non_zero] ]= last_level;
4200 for(; i>start_i; i -= run_tab[i] + 1){
4201 block[ perm_scantable[i-1] ]= level_tab[i];
4204 return last_non_zero;
4207 //#define REFINE_STATS 1
4208 static int16_t basis[64][64];
4210 static void build_basis(uint8_t *perm){
4217 double s= 0.25*(1<<BASIS_SHIFT);
4219 int perm_index= perm[index];
4220 if(i==0) s*= sqrt(0.5);
4221 if(j==0) s*= sqrt(0.5);
4222 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)));
4229 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4230 int16_t *block, int16_t *weight, int16_t *orig,
4233 LOCAL_ALIGNED_16(int16_t, d1, [64]);
4234 const uint8_t *scantable= s->intra_scantable.scantable;
4235 const uint8_t *perm_scantable= s->intra_scantable.permutated;
4236 // unsigned int threshold1, threshold2;
4241 int qmul, qadd, start_i, last_non_zero, i, dc;
4243 uint8_t * last_length;
4245 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4248 static int after_last=0;
4249 static int to_zero=0;
4250 static int from_zero=0;
4253 static int messed_sign=0;
4256 if(basis[0][0] == 0)
4257 build_basis(s->idsp.idct_permutation);
4268 /* For AIC we skip quant/dequant of INTRADC */
4272 q <<= RECON_SHIFT-3;
4273 /* note: block[0] is assumed to be positive */
4275 // block[0] = (block[0] + (q >> 1)) / q;
4277 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4278 // bias= 1<<(QMAT_SHIFT-1);
4279 if (n > 3 && s->intra_chroma_ac_vlc_length) {
4280 length = s->intra_chroma_ac_vlc_length;
4281 last_length= s->intra_chroma_ac_vlc_last_length;
4283 length = s->intra_ac_vlc_length;
4284 last_length= s->intra_ac_vlc_last_length;
4289 length = s->inter_ac_vlc_length;
4290 last_length= s->inter_ac_vlc_last_length;
4292 last_non_zero = s->block_last_index[n];
4297 dc += (1<<(RECON_SHIFT-1));
4298 for(i=0; i<64; i++){
4299 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
4302 STOP_TIMER("memset rem[]")}
4305 for(i=0; i<64; i++){
4310 w= FFABS(weight[i]) + qns*one;
4311 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4314 // w=weight[i] = (63*qns + (w/2)) / w;
4317 av_assert2(w<(1<<6));
4320 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4326 for(i=start_i; i<=last_non_zero; i++){
4327 int j= perm_scantable[i];
4328 const int level= block[j];
4332 if(level<0) coeff= qmul*level - qadd;
4333 else coeff= qmul*level + qadd;
4334 run_tab[rle_index++]=run;
4337 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4343 if(last_non_zero>0){
4344 STOP_TIMER("init rem[]")
4351 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4354 int run2, best_unquant_change=0, analyze_gradient;
4358 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4360 if(analyze_gradient){
4364 for(i=0; i<64; i++){
4367 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4370 STOP_TIMER("rem*w*w")}
4380 const int level= block[0];
4381 int change, old_coeff;
4383 av_assert2(s->mb_intra);
4387 for(change=-1; change<=1; change+=2){
4388 int new_level= level + change;
4389 int score, new_coeff;
4391 new_coeff= q*new_level;
4392 if(new_coeff >= 2048 || new_coeff < 0)
4395 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4396 new_coeff - old_coeff);
4397 if(score<best_score){
4400 best_change= change;
4401 best_unquant_change= new_coeff - old_coeff;
4408 run2= run_tab[rle_index++];
4412 for(i=start_i; i<64; i++){
4413 int j= perm_scantable[i];
4414 const int level= block[j];
4415 int change, old_coeff;
4417 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4421 if(level<0) old_coeff= qmul*level - qadd;
4422 else old_coeff= qmul*level + qadd;
4423 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4427 av_assert2(run2>=0 || i >= last_non_zero );
4430 for(change=-1; change<=1; change+=2){
4431 int new_level= level + change;
4432 int score, new_coeff, unquant_change;
4435 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4439 if(new_level<0) new_coeff= qmul*new_level - qadd;
4440 else new_coeff= qmul*new_level + qadd;
4441 if(new_coeff >= 2048 || new_coeff <= -2048)
4443 //FIXME check for overflow
4446 if(level < 63 && level > -63){
4447 if(i < last_non_zero)
4448 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4449 - length[UNI_AC_ENC_INDEX(run, level+64)];
4451 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4452 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4455 av_assert2(FFABS(new_level)==1);
4457 if(analyze_gradient){
4458 int g= d1[ scantable[i] ];
4459 if(g && (g^new_level) >= 0)
4463 if(i < last_non_zero){
4464 int next_i= i + run2 + 1;
4465 int next_level= block[ perm_scantable[next_i] ] + 64;
4467 if(next_level&(~127))
4470 if(next_i < last_non_zero)
4471 score += length[UNI_AC_ENC_INDEX(run, 65)]
4472 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4473 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4475 score += length[UNI_AC_ENC_INDEX(run, 65)]
4476 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4477 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4479 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4481 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4482 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4488 av_assert2(FFABS(level)==1);
4490 if(i < last_non_zero){
4491 int next_i= i + run2 + 1;
4492 int next_level= block[ perm_scantable[next_i] ] + 64;
4494 if(next_level&(~127))
4497 if(next_i < last_non_zero)
4498 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4499 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4500 - length[UNI_AC_ENC_INDEX(run, 65)];
4502 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4503 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4504 - length[UNI_AC_ENC_INDEX(run, 65)];
4506 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4508 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4509 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4516 unquant_change= new_coeff - old_coeff;
4517 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4519 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4521 if(score<best_score){
4524 best_change= change;
4525 best_unquant_change= unquant_change;
4529 prev_level= level + 64;
4530 if(prev_level&(~127))
4539 STOP_TIMER("iterative step")}
4543 int j= perm_scantable[ best_coeff ];
4545 block[j] += best_change;
4547 if(best_coeff > last_non_zero){
4548 last_non_zero= best_coeff;
4549 av_assert2(block[j]);
4556 if(block[j] - best_change){
4557 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4569 for(; last_non_zero>=start_i; last_non_zero--){
4570 if(block[perm_scantable[last_non_zero]])
4576 if(256*256*256*64 % count == 0){
4577 av_log(s->avctx, AV_LOG_DEBUG, "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);
4582 for(i=start_i; i<=last_non_zero; i++){
4583 int j= perm_scantable[i];
4584 const int level= block[j];
4587 run_tab[rle_index++]=run;
4594 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4600 if(last_non_zero>0){
4601 STOP_TIMER("iterative search")
4606 return last_non_zero;
4610 * Permute an 8x8 block according to permuatation.
4611 * @param block the block which will be permuted according to
4612 * the given permutation vector
4613 * @param permutation the permutation vector
4614 * @param last the last non zero coefficient in scantable order, used to
4615 * speed the permutation up
4616 * @param scantable the used scantable, this is only used to speed the
4617 * permutation up, the block is not (inverse) permutated
4618 * to scantable order!
4620 void ff_block_permute(int16_t *block, uint8_t *permutation,
4621 const uint8_t *scantable, int last)
4628 //FIXME it is ok but not clean and might fail for some permutations
4629 // if (permutation[1] == 1)
4632 for (i = 0; i <= last; i++) {
4633 const int j = scantable[i];
4638 for (i = 0; i <= last; i++) {
4639 const int j = scantable[i];
4640 const int perm_j = permutation[j];
4641 block[perm_j] = temp[j];
4645 int ff_dct_quantize_c(MpegEncContext *s,
4646 int16_t *block, int n,
4647 int qscale, int *overflow)
4649 int i, j, level, last_non_zero, q, start_i;
4651 const uint8_t *scantable= s->intra_scantable.scantable;
4654 unsigned int threshold1, threshold2;
4656 s->fdsp.fdct(block);
4658 if(s->dct_error_sum)
4659 s->denoise_dct(s, block);
4669 /* For AIC we skip quant/dequant of INTRADC */
4672 /* note: block[0] is assumed to be positive */
4673 block[0] = (block[0] + (q >> 1)) / q;
4676 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4677 bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4681 qmat = s->q_inter_matrix[qscale];
4682 bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4684 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4685 threshold2= (threshold1<<1);
4686 for(i=63;i>=start_i;i--) {
4688 level = block[j] * qmat[j];
4690 if(((unsigned)(level+threshold1))>threshold2){
4697 for(i=start_i; i<=last_non_zero; i++) {
4699 level = block[j] * qmat[j];
4701 // if( bias+level >= (1<<QMAT_SHIFT)
4702 // || bias-level >= (1<<QMAT_SHIFT)){
4703 if(((unsigned)(level+threshold1))>threshold2){
4705 level= (bias + level)>>QMAT_SHIFT;
4708 level= (bias - level)>>QMAT_SHIFT;
4716 *overflow= s->max_qcoeff < max; //overflow might have happened
4718 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4719 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4720 ff_block_permute(block, s->idsp.idct_permutation,
4721 scantable, last_non_zero);
4723 return last_non_zero;
4726 #define OFFSET(x) offsetof(MpegEncContext, x)
4727 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4728 static const AVOption h263_options[] = {
4729 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4730 { "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 },
4735 static const AVClass h263_class = {
4736 .class_name = "H.263 encoder",
4737 .item_name = av_default_item_name,
4738 .option = h263_options,
4739 .version = LIBAVUTIL_VERSION_INT,
4742 AVCodec ff_h263_encoder = {
4744 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4745 .type = AVMEDIA_TYPE_VIDEO,
4746 .id = AV_CODEC_ID_H263,
4747 .priv_data_size = sizeof(MpegEncContext),
4748 .init = ff_mpv_encode_init,
4749 .encode2 = ff_mpv_encode_picture,
4750 .close = ff_mpv_encode_end,
4751 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4752 .priv_class = &h263_class,
4755 static const AVOption h263p_options[] = {
4756 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4757 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4758 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4759 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
4763 static const AVClass h263p_class = {
4764 .class_name = "H.263p encoder",
4765 .item_name = av_default_item_name,
4766 .option = h263p_options,
4767 .version = LIBAVUTIL_VERSION_INT,
4770 AVCodec ff_h263p_encoder = {
4772 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4773 .type = AVMEDIA_TYPE_VIDEO,
4774 .id = AV_CODEC_ID_H263P,
4775 .priv_data_size = sizeof(MpegEncContext),
4776 .init = ff_mpv_encode_init,
4777 .encode2 = ff_mpv_encode_picture,
4778 .close = ff_mpv_encode_end,
4779 .capabilities = AV_CODEC_CAP_SLICE_THREADS,
4780 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4781 .priv_class = &h263p_class,
4784 static const AVClass msmpeg4v2_class = {
4785 .class_name = "msmpeg4v2 encoder",
4786 .item_name = av_default_item_name,
4787 .option = ff_mpv_generic_options,
4788 .version = LIBAVUTIL_VERSION_INT,
4791 AVCodec ff_msmpeg4v2_encoder = {
4792 .name = "msmpeg4v2",
4793 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4794 .type = AVMEDIA_TYPE_VIDEO,
4795 .id = AV_CODEC_ID_MSMPEG4V2,
4796 .priv_data_size = sizeof(MpegEncContext),
4797 .init = ff_mpv_encode_init,
4798 .encode2 = ff_mpv_encode_picture,
4799 .close = ff_mpv_encode_end,
4800 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4801 .priv_class = &msmpeg4v2_class,
4804 static const AVClass msmpeg4v3_class = {
4805 .class_name = "msmpeg4v3 encoder",
4806 .item_name = av_default_item_name,
4807 .option = ff_mpv_generic_options,
4808 .version = LIBAVUTIL_VERSION_INT,
4811 AVCodec ff_msmpeg4v3_encoder = {
4813 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4814 .type = AVMEDIA_TYPE_VIDEO,
4815 .id = AV_CODEC_ID_MSMPEG4V3,
4816 .priv_data_size = sizeof(MpegEncContext),
4817 .init = ff_mpv_encode_init,
4818 .encode2 = ff_mpv_encode_picture,
4819 .close = ff_mpv_encode_end,
4820 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4821 .priv_class = &msmpeg4v3_class,
4824 static const AVClass wmv1_class = {
4825 .class_name = "wmv1 encoder",
4826 .item_name = av_default_item_name,
4827 .option = ff_mpv_generic_options,
4828 .version = LIBAVUTIL_VERSION_INT,
4831 AVCodec ff_wmv1_encoder = {
4833 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4834 .type = AVMEDIA_TYPE_VIDEO,
4835 .id = AV_CODEC_ID_WMV1,
4836 .priv_data_size = sizeof(MpegEncContext),
4837 .init = ff_mpv_encode_init,
4838 .encode2 = ff_mpv_encode_picture,
4839 .close = ff_mpv_encode_end,
4840 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4841 .priv_class = &wmv1_class,