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"
71 #define QUANT_BIAS_SHIFT 8
73 #define QMAT_SHIFT_MMX 16
76 static int encode_picture(MpegEncContext *s, int picture_number);
77 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
78 static int sse_mb(MpegEncContext *s);
79 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
80 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
82 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
83 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
85 const AVOption ff_mpv_generic_options[] = {
90 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
91 uint16_t (*qmat16)[2][64],
92 const uint16_t *quant_matrix,
93 int bias, int qmin, int qmax, int intra)
95 FDCTDSPContext *fdsp = &s->fdsp;
99 for (qscale = qmin; qscale <= qmax; qscale++) {
103 if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
104 else qscale2 = qscale << 1;
106 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
108 fdsp->fdct == ff_faandct ||
109 #endif /* CONFIG_FAANDCT */
110 fdsp->fdct == ff_jpeg_fdct_islow_10) {
111 for (i = 0; i < 64; i++) {
112 const int j = s->idsp.idct_permutation[i];
113 int64_t den = (int64_t) qscale2 * quant_matrix[j];
114 /* 16 <= qscale * quant_matrix[i] <= 7905
115 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
116 * 19952 <= x <= 249205026
117 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
118 * 3444240 >= (1 << 36) / (x) >= 275 */
120 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
122 } else if (fdsp->fdct == ff_fdct_ifast) {
123 for (i = 0; i < 64; i++) {
124 const int j = s->idsp.idct_permutation[i];
125 int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
126 /* 16 <= qscale * quant_matrix[i] <= 7905
127 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
128 * 19952 <= x <= 249205026
129 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
130 * 3444240 >= (1 << 36) / (x) >= 275 */
132 qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
135 for (i = 0; i < 64; i++) {
136 const int j = s->idsp.idct_permutation[i];
137 int64_t den = (int64_t) qscale2 * quant_matrix[j];
138 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
139 * Assume x = qscale * quant_matrix[i]
141 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
142 * so 32768 >= (1 << 19) / (x) >= 67 */
143 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
144 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
145 // (qscale * quant_matrix[i]);
146 qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
148 if (qmat16[qscale][0][i] == 0 ||
149 qmat16[qscale][0][i] == 128 * 256)
150 qmat16[qscale][0][i] = 128 * 256 - 1;
151 qmat16[qscale][1][i] =
152 ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
153 qmat16[qscale][0][i]);
157 for (i = intra; i < 64; i++) {
159 if (fdsp->fdct == ff_fdct_ifast) {
160 max = (8191LL * ff_aanscales[i]) >> 14;
162 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
168 av_log(NULL, AV_LOG_INFO,
169 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
174 static inline void update_qscale(MpegEncContext *s)
176 if (s->q_scale_type == 1 && 0) {
178 int bestdiff=INT_MAX;
181 for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
182 int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
183 if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
184 (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
186 if (diff < bestdiff) {
193 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
194 (FF_LAMBDA_SHIFT + 7);
195 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
198 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
202 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
208 for (i = 0; i < 64; i++) {
209 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
216 * init s->current_picture.qscale_table from s->lambda_table
218 void ff_init_qscale_tab(MpegEncContext *s)
220 int8_t * const qscale_table = s->current_picture.qscale_table;
223 for (i = 0; i < s->mb_num; i++) {
224 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
225 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
226 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
231 static void update_duplicate_context_after_me(MpegEncContext *dst,
234 #define COPY(a) dst->a= src->a
236 COPY(current_picture);
242 COPY(picture_in_gop_number);
243 COPY(gop_picture_number);
244 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
245 COPY(progressive_frame); // FIXME don't set in encode_header
246 COPY(partitioned_frame); // FIXME don't set in encode_header
251 * Set the given MpegEncContext to defaults for encoding.
252 * the changed fields will not depend upon the prior state of the MpegEncContext.
254 static void mpv_encode_defaults(MpegEncContext *s)
257 ff_mpv_common_defaults(s);
259 for (i = -16; i < 16; i++) {
260 default_fcode_tab[i + MAX_MV] = 1;
262 s->me.mv_penalty = default_mv_penalty;
263 s->fcode_tab = default_fcode_tab;
265 s->input_picture_number = 0;
266 s->picture_in_gop_number = 0;
269 av_cold int ff_dct_encode_init(MpegEncContext *s)
272 ff_dct_encode_init_x86(s);
274 if (CONFIG_H263_ENCODER)
275 ff_h263dsp_init(&s->h263dsp);
276 if (!s->dct_quantize)
277 s->dct_quantize = ff_dct_quantize_c;
279 s->denoise_dct = denoise_dct_c;
280 s->fast_dct_quantize = s->dct_quantize;
281 if (s->avctx->trellis)
282 s->dct_quantize = dct_quantize_trellis_c;
287 /* init video encoder */
288 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
290 MpegEncContext *s = avctx->priv_data;
291 AVCPBProperties *cpb_props;
292 int i, ret, format_supported;
294 mpv_encode_defaults(s);
296 switch (avctx->codec_id) {
297 case AV_CODEC_ID_MPEG2VIDEO:
298 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
299 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
300 av_log(avctx, AV_LOG_ERROR,
301 "only YUV420 and YUV422 are supported\n");
305 case AV_CODEC_ID_MJPEG:
306 case AV_CODEC_ID_AMV:
307 format_supported = 0;
308 /* JPEG color space */
309 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
310 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
311 avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
312 (avctx->color_range == AVCOL_RANGE_JPEG &&
313 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
314 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
315 avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
316 format_supported = 1;
317 /* MPEG color space */
318 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
319 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
320 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
321 avctx->pix_fmt == AV_PIX_FMT_YUV444P))
322 format_supported = 1;
324 if (!format_supported) {
325 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
330 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
331 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
336 switch (avctx->pix_fmt) {
337 case AV_PIX_FMT_YUVJ444P:
338 case AV_PIX_FMT_YUV444P:
339 s->chroma_format = CHROMA_444;
341 case AV_PIX_FMT_YUVJ422P:
342 case AV_PIX_FMT_YUV422P:
343 s->chroma_format = CHROMA_422;
345 case AV_PIX_FMT_YUVJ420P:
346 case AV_PIX_FMT_YUV420P:
348 s->chroma_format = CHROMA_420;
352 avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
354 #if FF_API_PRIVATE_OPT
355 FF_DISABLE_DEPRECATION_WARNINGS
356 if (avctx->rtp_payload_size)
357 s->rtp_payload_size = avctx->rtp_payload_size;
358 if (avctx->me_penalty_compensation)
359 s->me_penalty_compensation = avctx->me_penalty_compensation;
361 s->me_pre = avctx->pre_me;
362 FF_ENABLE_DEPRECATION_WARNINGS
365 s->bit_rate = avctx->bit_rate;
366 s->width = avctx->width;
367 s->height = avctx->height;
368 if (avctx->gop_size > 600 &&
369 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
370 av_log(avctx, AV_LOG_WARNING,
371 "keyframe interval too large!, reducing it from %d to %d\n",
372 avctx->gop_size, 600);
373 avctx->gop_size = 600;
375 s->gop_size = avctx->gop_size;
377 if (avctx->max_b_frames > MAX_B_FRAMES) {
378 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
379 "is %d.\n", MAX_B_FRAMES);
380 avctx->max_b_frames = MAX_B_FRAMES;
382 s->max_b_frames = avctx->max_b_frames;
383 s->codec_id = avctx->codec->id;
384 s->strict_std_compliance = avctx->strict_std_compliance;
385 s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
386 s->rtp_mode = !!s->rtp_payload_size;
387 s->intra_dc_precision = avctx->intra_dc_precision;
389 // workaround some differences between how applications specify dc precision
390 if (s->intra_dc_precision < 0) {
391 s->intra_dc_precision += 8;
392 } else if (s->intra_dc_precision >= 8)
393 s->intra_dc_precision -= 8;
395 if (s->intra_dc_precision < 0) {
396 av_log(avctx, AV_LOG_ERROR,
397 "intra dc precision must be positive, note some applications use"
398 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
399 return AVERROR(EINVAL);
402 if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
405 if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
406 av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
407 return AVERROR(EINVAL);
409 s->user_specified_pts = AV_NOPTS_VALUE;
411 if (s->gop_size <= 1) {
419 s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
421 s->adaptive_quant = (s->avctx->lumi_masking ||
422 s->avctx->dark_masking ||
423 s->avctx->temporal_cplx_masking ||
424 s->avctx->spatial_cplx_masking ||
425 s->avctx->p_masking ||
427 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
430 s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
432 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
433 switch(avctx->codec_id) {
434 case AV_CODEC_ID_MPEG1VIDEO:
435 case AV_CODEC_ID_MPEG2VIDEO:
436 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
438 case AV_CODEC_ID_MPEG4:
439 case AV_CODEC_ID_MSMPEG4V1:
440 case AV_CODEC_ID_MSMPEG4V2:
441 case AV_CODEC_ID_MSMPEG4V3:
442 if (avctx->rc_max_rate >= 15000000) {
443 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
444 } else if(avctx->rc_max_rate >= 2000000) {
445 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000LL) * (320- 80) / (15000000 - 2000000);
446 } else if(avctx->rc_max_rate >= 384000) {
447 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000LL) * ( 80- 40) / ( 2000000 - 384000);
449 avctx->rc_buffer_size = 40;
450 avctx->rc_buffer_size *= 16384;
453 if (avctx->rc_buffer_size) {
454 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
458 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
459 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
463 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
464 av_log(avctx, AV_LOG_INFO,
465 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
468 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
469 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
473 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
474 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
478 if (avctx->rc_max_rate &&
479 avctx->rc_max_rate == avctx->bit_rate &&
480 avctx->rc_max_rate != avctx->rc_min_rate) {
481 av_log(avctx, AV_LOG_INFO,
482 "impossible bitrate constraints, this will fail\n");
485 if (avctx->rc_buffer_size &&
486 avctx->bit_rate * (int64_t)avctx->time_base.num >
487 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
488 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
492 if (!s->fixed_qscale &&
493 avctx->bit_rate * av_q2d(avctx->time_base) >
494 avctx->bit_rate_tolerance) {
495 av_log(avctx, AV_LOG_WARNING,
496 "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
497 avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
500 if (s->avctx->rc_max_rate &&
501 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
502 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
503 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
504 90000LL * (avctx->rc_buffer_size - 1) >
505 s->avctx->rc_max_rate * 0xFFFFLL) {
506 av_log(avctx, AV_LOG_INFO,
507 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
508 "specified vbv buffer is too large for the given bitrate!\n");
511 if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
512 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
513 s->codec_id != AV_CODEC_ID_FLV1) {
514 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
518 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
519 av_log(avctx, AV_LOG_ERROR,
520 "OBMC is only supported with simple mb decision\n");
524 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
525 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
529 if (s->max_b_frames &&
530 s->codec_id != AV_CODEC_ID_MPEG4 &&
531 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
532 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
533 av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
536 if (s->max_b_frames < 0) {
537 av_log(avctx, AV_LOG_ERROR,
538 "max b frames must be 0 or positive for mpegvideo based encoders\n");
542 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
543 s->codec_id == AV_CODEC_ID_H263 ||
544 s->codec_id == AV_CODEC_ID_H263P) &&
545 (avctx->sample_aspect_ratio.num > 255 ||
546 avctx->sample_aspect_ratio.den > 255)) {
547 av_log(avctx, AV_LOG_WARNING,
548 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
549 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
550 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
551 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
554 if ((s->codec_id == AV_CODEC_ID_H263 ||
555 s->codec_id == AV_CODEC_ID_H263P) &&
556 (avctx->width > 2048 ||
557 avctx->height > 1152 )) {
558 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
561 if ((s->codec_id == AV_CODEC_ID_H263 ||
562 s->codec_id == AV_CODEC_ID_H263P) &&
563 ((avctx->width &3) ||
564 (avctx->height&3) )) {
565 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
569 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
570 (avctx->width > 4095 ||
571 avctx->height > 4095 )) {
572 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
576 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
577 (avctx->width > 16383 ||
578 avctx->height > 16383 )) {
579 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
583 if (s->codec_id == AV_CODEC_ID_RV10 &&
585 avctx->height&15 )) {
586 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
587 return AVERROR(EINVAL);
590 if (s->codec_id == AV_CODEC_ID_RV20 &&
593 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
594 return AVERROR(EINVAL);
597 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
598 s->codec_id == AV_CODEC_ID_WMV2) &&
600 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
604 if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
605 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
606 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
610 #if FF_API_PRIVATE_OPT
611 FF_DISABLE_DEPRECATION_WARNINGS
612 if (avctx->mpeg_quant)
613 s->mpeg_quant = avctx->mpeg_quant;
614 FF_ENABLE_DEPRECATION_WARNINGS
617 // FIXME mpeg2 uses that too
618 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
619 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
620 av_log(avctx, AV_LOG_ERROR,
621 "mpeg2 style quantization not supported by codec\n");
625 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
626 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
630 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
631 s->avctx->mb_decision != FF_MB_DECISION_RD) {
632 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
636 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
637 (s->codec_id == AV_CODEC_ID_AMV ||
638 s->codec_id == AV_CODEC_ID_MJPEG)) {
639 // Used to produce garbage with MJPEG.
640 av_log(avctx, AV_LOG_ERROR,
641 "QP RD is no longer compatible with MJPEG or AMV\n");
645 #if FF_API_PRIVATE_OPT
646 FF_DISABLE_DEPRECATION_WARNINGS
647 if (avctx->scenechange_threshold)
648 s->scenechange_threshold = avctx->scenechange_threshold;
649 FF_ENABLE_DEPRECATION_WARNINGS
652 if (s->scenechange_threshold < 1000000000 &&
653 (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
654 av_log(avctx, AV_LOG_ERROR,
655 "closed gop with scene change detection are not supported yet, "
656 "set threshold to 1000000000\n");
660 if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
661 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
662 s->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
663 av_log(avctx, AV_LOG_ERROR,
664 "low delay forcing is only available for mpeg2, "
665 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
668 if (s->max_b_frames != 0) {
669 av_log(avctx, AV_LOG_ERROR,
670 "B-frames cannot be used with low delay\n");
675 if (s->q_scale_type == 1) {
676 if (avctx->qmax > 28) {
677 av_log(avctx, AV_LOG_ERROR,
678 "non linear quant only supports qmax <= 28 currently\n");
683 if (avctx->slices > 1 &&
684 (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
685 av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
686 return AVERROR(EINVAL);
689 if (s->avctx->thread_count > 1 &&
690 s->codec_id != AV_CODEC_ID_MPEG4 &&
691 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
692 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
693 s->codec_id != AV_CODEC_ID_MJPEG &&
694 (s->codec_id != AV_CODEC_ID_H263P)) {
695 av_log(avctx, AV_LOG_ERROR,
696 "multi threaded encoding not supported by codec\n");
700 if (s->avctx->thread_count < 1) {
701 av_log(avctx, AV_LOG_ERROR,
702 "automatic thread number detection not supported by codec, "
707 if (!avctx->time_base.den || !avctx->time_base.num) {
708 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
712 #if FF_API_PRIVATE_OPT
713 FF_DISABLE_DEPRECATION_WARNINGS
714 if (avctx->b_frame_strategy)
715 s->b_frame_strategy = avctx->b_frame_strategy;
716 if (avctx->b_sensitivity != 40)
717 s->b_sensitivity = avctx->b_sensitivity;
718 FF_ENABLE_DEPRECATION_WARNINGS
721 if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
722 av_log(avctx, AV_LOG_INFO,
723 "notice: b_frame_strategy only affects the first pass\n");
724 s->b_frame_strategy = 0;
727 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
729 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
730 avctx->time_base.den /= i;
731 avctx->time_base.num /= i;
735 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) {
736 // (a + x * 3 / 8) / x
737 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
738 s->inter_quant_bias = 0;
740 s->intra_quant_bias = 0;
742 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
745 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
746 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
747 return AVERROR(EINVAL);
750 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
752 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
753 s->avctx->time_base.den > (1 << 16) - 1) {
754 av_log(avctx, AV_LOG_ERROR,
755 "timebase %d/%d not supported by MPEG 4 standard, "
756 "the maximum admitted value for the timebase denominator "
757 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
761 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
763 switch (avctx->codec->id) {
764 case AV_CODEC_ID_MPEG1VIDEO:
765 s->out_format = FMT_MPEG1;
766 s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
767 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
769 case AV_CODEC_ID_MPEG2VIDEO:
770 s->out_format = FMT_MPEG1;
771 s->low_delay = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
772 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
775 case AV_CODEC_ID_MJPEG:
776 case AV_CODEC_ID_AMV:
777 s->out_format = FMT_MJPEG;
778 s->intra_only = 1; /* force intra only for jpeg */
779 if (!CONFIG_MJPEG_ENCODER ||
780 ff_mjpeg_encode_init(s) < 0)
785 case AV_CODEC_ID_H261:
786 if (!CONFIG_H261_ENCODER)
788 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
789 av_log(avctx, AV_LOG_ERROR,
790 "The specified picture size of %dx%d is not valid for the "
791 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
792 s->width, s->height);
795 s->out_format = FMT_H261;
798 s->rtp_mode = 0; /* Sliced encoding not supported */
800 case AV_CODEC_ID_H263:
801 if (!CONFIG_H263_ENCODER)
803 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
804 s->width, s->height) == 8) {
805 av_log(avctx, AV_LOG_ERROR,
806 "The specified picture size of %dx%d is not valid for "
807 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
808 "352x288, 704x576, and 1408x1152. "
809 "Try H.263+.\n", s->width, s->height);
812 s->out_format = FMT_H263;
816 case AV_CODEC_ID_H263P:
817 s->out_format = FMT_H263;
820 s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
821 s->modified_quant = s->h263_aic;
822 s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
823 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
826 /* These are just to be sure */
830 case AV_CODEC_ID_FLV1:
831 s->out_format = FMT_H263;
832 s->h263_flv = 2; /* format = 1; 11-bit codes */
833 s->unrestricted_mv = 1;
834 s->rtp_mode = 0; /* don't allow GOB */
838 case AV_CODEC_ID_RV10:
839 s->out_format = FMT_H263;
843 case AV_CODEC_ID_RV20:
844 s->out_format = FMT_H263;
847 s->modified_quant = 1;
851 s->unrestricted_mv = 0;
853 case AV_CODEC_ID_MPEG4:
854 s->out_format = FMT_H263;
856 s->unrestricted_mv = 1;
857 s->low_delay = s->max_b_frames ? 0 : 1;
858 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
860 case AV_CODEC_ID_MSMPEG4V2:
861 s->out_format = FMT_H263;
863 s->unrestricted_mv = 1;
864 s->msmpeg4_version = 2;
868 case AV_CODEC_ID_MSMPEG4V3:
869 s->out_format = FMT_H263;
871 s->unrestricted_mv = 1;
872 s->msmpeg4_version = 3;
873 s->flipflop_rounding = 1;
877 case AV_CODEC_ID_WMV1:
878 s->out_format = FMT_H263;
880 s->unrestricted_mv = 1;
881 s->msmpeg4_version = 4;
882 s->flipflop_rounding = 1;
886 case AV_CODEC_ID_WMV2:
887 s->out_format = FMT_H263;
889 s->unrestricted_mv = 1;
890 s->msmpeg4_version = 5;
891 s->flipflop_rounding = 1;
899 #if FF_API_PRIVATE_OPT
900 FF_DISABLE_DEPRECATION_WARNINGS
901 if (avctx->noise_reduction)
902 s->noise_reduction = avctx->noise_reduction;
903 FF_ENABLE_DEPRECATION_WARNINGS
906 avctx->has_b_frames = !s->low_delay;
910 s->progressive_frame =
911 s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
912 AV_CODEC_FLAG_INTERLACED_ME) ||
917 if (ff_mpv_common_init(s) < 0)
920 ff_fdctdsp_init(&s->fdsp, avctx);
921 ff_me_cmp_init(&s->mecc, avctx);
922 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
923 ff_pixblockdsp_init(&s->pdsp, avctx);
924 ff_qpeldsp_init(&s->qdsp);
926 if (s->msmpeg4_version) {
927 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
928 2 * 2 * (MAX_LEVEL + 1) *
929 (MAX_RUN + 1) * 2 * sizeof(int), fail);
931 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
933 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
934 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
935 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
936 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
937 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
938 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
939 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
940 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
941 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
942 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
945 if (s->noise_reduction) {
946 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
947 2 * 64 * sizeof(uint16_t), fail);
950 ff_dct_encode_init(s);
952 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
953 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
955 if (s->slice_context_count > 1) {
958 if (avctx->codec_id == AV_CODEC_ID_H263P)
959 s->h263_slice_structured = 1;
962 s->quant_precision = 5;
964 #if FF_API_PRIVATE_OPT
965 FF_DISABLE_DEPRECATION_WARNINGS
966 if (avctx->frame_skip_threshold)
967 s->frame_skip_threshold = avctx->frame_skip_threshold;
968 if (avctx->frame_skip_factor)
969 s->frame_skip_factor = avctx->frame_skip_factor;
970 if (avctx->frame_skip_exp)
971 s->frame_skip_exp = avctx->frame_skip_exp;
972 if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
973 s->frame_skip_cmp = avctx->frame_skip_cmp;
974 FF_ENABLE_DEPRECATION_WARNINGS
977 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
978 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
980 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
981 ff_h261_encode_init(s);
982 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
983 ff_h263_encode_init(s);
984 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
985 if ((ret = ff_msmpeg4_encode_init(s)) < 0)
987 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
988 && s->out_format == FMT_MPEG1)
989 ff_mpeg1_encode_init(s);
992 for (i = 0; i < 64; i++) {
993 int j = s->idsp.idct_permutation[i];
994 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
996 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
997 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
998 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1000 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1003 s->chroma_intra_matrix[j] =
1004 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1005 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1007 if (s->avctx->intra_matrix)
1008 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1009 if (s->avctx->inter_matrix)
1010 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1013 /* precompute matrix */
1014 /* for mjpeg, we do include qscale in the matrix */
1015 if (s->out_format != FMT_MJPEG) {
1016 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
1017 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1019 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
1020 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1024 if (ff_rate_control_init(s) < 0)
1027 if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID) {
1029 ret = ff_xvid_rate_control_init(s);
1031 ret = AVERROR(ENOSYS);
1032 av_log(s->avctx, AV_LOG_ERROR,
1033 "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
1039 #if FF_API_PRIVATE_OPT
1040 FF_DISABLE_DEPRECATION_WARNINGS
1041 if (avctx->brd_scale)
1042 s->brd_scale = avctx->brd_scale;
1044 if (avctx->prediction_method)
1045 s->pred = avctx->prediction_method + 1;
1046 FF_ENABLE_DEPRECATION_WARNINGS
1049 if (s->b_frame_strategy == 2) {
1050 for (i = 0; i < s->max_b_frames + 2; i++) {
1051 s->tmp_frames[i] = av_frame_alloc();
1052 if (!s->tmp_frames[i])
1053 return AVERROR(ENOMEM);
1055 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1056 s->tmp_frames[i]->width = s->width >> s->brd_scale;
1057 s->tmp_frames[i]->height = s->height >> s->brd_scale;
1059 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
1065 cpb_props = ff_add_cpb_side_data(avctx);
1067 return AVERROR(ENOMEM);
1068 cpb_props->max_bitrate = avctx->rc_max_rate;
1069 cpb_props->min_bitrate = avctx->rc_min_rate;
1070 cpb_props->avg_bitrate = avctx->bit_rate;
1071 cpb_props->buffer_size = avctx->rc_buffer_size;
1075 ff_mpv_encode_end(avctx);
1076 return AVERROR_UNKNOWN;
1079 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1081 MpegEncContext *s = avctx->priv_data;
1084 ff_rate_control_uninit(s);
1086 if ((avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
1087 ff_xvid_rate_control_uninit(s);
1090 ff_mpv_common_end(s);
1091 if (CONFIG_MJPEG_ENCODER &&
1092 s->out_format == FMT_MJPEG)
1093 ff_mjpeg_encode_close(s);
1095 av_freep(&avctx->extradata);
1097 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1098 av_frame_free(&s->tmp_frames[i]);
1100 ff_free_picture_tables(&s->new_picture);
1101 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1103 av_freep(&s->avctx->stats_out);
1104 av_freep(&s->ac_stats);
1106 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1107 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1108 s->q_chroma_intra_matrix= NULL;
1109 s->q_chroma_intra_matrix16= NULL;
1110 av_freep(&s->q_intra_matrix);
1111 av_freep(&s->q_inter_matrix);
1112 av_freep(&s->q_intra_matrix16);
1113 av_freep(&s->q_inter_matrix16);
1114 av_freep(&s->input_picture);
1115 av_freep(&s->reordered_input_picture);
1116 av_freep(&s->dct_offset);
1121 static int get_sae(uint8_t *src, int ref, int stride)
1126 for (y = 0; y < 16; y++) {
1127 for (x = 0; x < 16; x++) {
1128 acc += FFABS(src[x + y * stride] - ref);
1135 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1136 uint8_t *ref, int stride)
1142 h = s->height & ~15;
1144 for (y = 0; y < h; y += 16) {
1145 for (x = 0; x < w; x += 16) {
1146 int offset = x + y * stride;
1147 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1149 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1150 int sae = get_sae(src + offset, mean, stride);
1152 acc += sae + 500 < sad;
1158 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1160 return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1161 s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1162 s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1163 &s->linesize, &s->uvlinesize);
1166 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1168 Picture *pic = NULL;
1170 int i, display_picture_number = 0, ret;
1171 int encoding_delay = s->max_b_frames ? s->max_b_frames
1172 : (s->low_delay ? 0 : 1);
1173 int flush_offset = 1;
1178 display_picture_number = s->input_picture_number++;
1180 if (pts != AV_NOPTS_VALUE) {
1181 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1182 int64_t last = s->user_specified_pts;
1185 av_log(s->avctx, AV_LOG_ERROR,
1186 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1188 return AVERROR(EINVAL);
1191 if (!s->low_delay && display_picture_number == 1)
1192 s->dts_delta = pts - last;
1194 s->user_specified_pts = pts;
1196 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1197 s->user_specified_pts =
1198 pts = s->user_specified_pts + 1;
1199 av_log(s->avctx, AV_LOG_INFO,
1200 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1203 pts = display_picture_number;
1207 if (!pic_arg->buf[0] ||
1208 pic_arg->linesize[0] != s->linesize ||
1209 pic_arg->linesize[1] != s->uvlinesize ||
1210 pic_arg->linesize[2] != s->uvlinesize)
1212 if ((s->width & 15) || (s->height & 15))
1214 if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1216 if (s->linesize & (STRIDE_ALIGN-1))
1219 ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1220 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1222 i = ff_find_unused_picture(s->avctx, s->picture, direct);
1226 pic = &s->picture[i];
1230 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1233 ret = alloc_picture(s, pic, direct);
1238 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1239 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1240 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1243 int h_chroma_shift, v_chroma_shift;
1244 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1248 for (i = 0; i < 3; i++) {
1249 int src_stride = pic_arg->linesize[i];
1250 int dst_stride = i ? s->uvlinesize : s->linesize;
1251 int h_shift = i ? h_chroma_shift : 0;
1252 int v_shift = i ? v_chroma_shift : 0;
1253 int w = s->width >> h_shift;
1254 int h = s->height >> v_shift;
1255 uint8_t *src = pic_arg->data[i];
1256 uint8_t *dst = pic->f->data[i];
1259 if ( s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1260 && !s->progressive_sequence
1261 && FFALIGN(s->height, 32) - s->height > 16)
1264 if (!s->avctx->rc_buffer_size)
1265 dst += INPLACE_OFFSET;
1267 if (src_stride == dst_stride)
1268 memcpy(dst, src, src_stride * h);
1271 uint8_t *dst2 = dst;
1273 memcpy(dst2, src, w);
1278 if ((s->width & 15) || (s->height & (vpad-1))) {
1279 s->mpvencdsp.draw_edges(dst, dst_stride,
1289 ret = av_frame_copy_props(pic->f, pic_arg);
1293 pic->f->display_picture_number = display_picture_number;
1294 pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1296 /* Flushing: When we have not received enough input frames,
1297 * ensure s->input_picture[0] contains the first picture */
1298 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1299 if (s->input_picture[flush_offset])
1302 if (flush_offset <= 1)
1305 encoding_delay = encoding_delay - flush_offset + 1;
1308 /* shift buffer entries */
1309 for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1310 s->input_picture[i - flush_offset] = s->input_picture[i];
1312 s->input_picture[encoding_delay] = (Picture*) pic;
1317 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1321 int64_t score64 = 0;
1323 for (plane = 0; plane < 3; plane++) {
1324 const int stride = p->f->linesize[plane];
1325 const int bw = plane ? 1 : 2;
1326 for (y = 0; y < s->mb_height * bw; y++) {
1327 for (x = 0; x < s->mb_width * bw; x++) {
1328 int off = p->shared ? 0 : 16;
1329 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1330 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1331 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1333 switch (FFABS(s->frame_skip_exp)) {
1334 case 0: score = FFMAX(score, v); break;
1335 case 1: score += FFABS(v); break;
1336 case 2: score64 += v * (int64_t)v; break;
1337 case 3: score64 += FFABS(v * (int64_t)v * v); break;
1338 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1347 if (s->frame_skip_exp < 0)
1348 score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1349 -1.0/s->frame_skip_exp);
1351 if (score64 < s->frame_skip_threshold)
1353 if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1358 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1360 AVPacket pkt = { 0 };
1364 av_init_packet(&pkt);
1366 ret = avcodec_send_frame(c, frame);
1371 ret = avcodec_receive_packet(c, &pkt);
1374 av_packet_unref(&pkt);
1375 } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1382 static int estimate_best_b_count(MpegEncContext *s)
1384 const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1385 const int scale = s->brd_scale;
1386 int width = s->width >> scale;
1387 int height = s->height >> scale;
1388 int i, j, out_size, p_lambda, b_lambda, lambda2;
1389 int64_t best_rd = INT64_MAX;
1390 int best_b_count = -1;
1393 av_assert0(scale >= 0 && scale <= 3);
1396 //s->next_picture_ptr->quality;
1397 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1398 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1399 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1400 if (!b_lambda) // FIXME we should do this somewhere else
1401 b_lambda = p_lambda;
1402 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1405 for (i = 0; i < s->max_b_frames + 2; i++) {
1406 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1407 s->next_picture_ptr;
1410 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1411 pre_input = *pre_input_ptr;
1412 memcpy(data, pre_input_ptr->f->data, sizeof(data));
1414 if (!pre_input.shared && i) {
1415 data[0] += INPLACE_OFFSET;
1416 data[1] += INPLACE_OFFSET;
1417 data[2] += INPLACE_OFFSET;
1420 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1421 s->tmp_frames[i]->linesize[0],
1423 pre_input.f->linesize[0],
1425 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1426 s->tmp_frames[i]->linesize[1],
1428 pre_input.f->linesize[1],
1429 width >> 1, height >> 1);
1430 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1431 s->tmp_frames[i]->linesize[2],
1433 pre_input.f->linesize[2],
1434 width >> 1, height >> 1);
1438 for (j = 0; j < s->max_b_frames + 1; j++) {
1442 if (!s->input_picture[j])
1445 c = avcodec_alloc_context3(NULL);
1447 return AVERROR(ENOMEM);
1451 c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1452 c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1453 c->mb_decision = s->avctx->mb_decision;
1454 c->me_cmp = s->avctx->me_cmp;
1455 c->mb_cmp = s->avctx->mb_cmp;
1456 c->me_sub_cmp = s->avctx->me_sub_cmp;
1457 c->pix_fmt = AV_PIX_FMT_YUV420P;
1458 c->time_base = s->avctx->time_base;
1459 c->max_b_frames = s->max_b_frames;
1461 ret = avcodec_open2(c, codec, NULL);
1465 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1466 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1468 out_size = encode_frame(c, s->tmp_frames[0]);
1474 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1476 for (i = 0; i < s->max_b_frames + 1; i++) {
1477 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1479 s->tmp_frames[i + 1]->pict_type = is_p ?
1480 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1481 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1483 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1489 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1492 /* get the delayed frames */
1493 out_size = encode_frame(c, NULL);
1498 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1500 rd += c->error[0] + c->error[1] + c->error[2];
1508 avcodec_free_context(&c);
1513 return best_b_count;
1516 static int select_input_picture(MpegEncContext *s)
1520 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1521 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1522 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1524 /* set next picture type & ordering */
1525 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1526 if (s->frame_skip_threshold || s->frame_skip_factor) {
1527 if (s->picture_in_gop_number < s->gop_size &&
1528 s->next_picture_ptr &&
1529 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1530 // FIXME check that the gop check above is +-1 correct
1531 av_frame_unref(s->input_picture[0]->f);
1533 ff_vbv_update(s, 0);
1539 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1540 !s->next_picture_ptr || s->intra_only) {
1541 s->reordered_input_picture[0] = s->input_picture[0];
1542 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1543 s->reordered_input_picture[0]->f->coded_picture_number =
1544 s->coded_picture_number++;
1548 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1549 for (i = 0; i < s->max_b_frames + 1; i++) {
1550 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1552 if (pict_num >= s->rc_context.num_entries)
1554 if (!s->input_picture[i]) {
1555 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1559 s->input_picture[i]->f->pict_type =
1560 s->rc_context.entry[pict_num].new_pict_type;
1564 if (s->b_frame_strategy == 0) {
1565 b_frames = s->max_b_frames;
1566 while (b_frames && !s->input_picture[b_frames])
1568 } else if (s->b_frame_strategy == 1) {
1569 for (i = 1; i < s->max_b_frames + 1; i++) {
1570 if (s->input_picture[i] &&
1571 s->input_picture[i]->b_frame_score == 0) {
1572 s->input_picture[i]->b_frame_score =
1574 s->input_picture[i ]->f->data[0],
1575 s->input_picture[i - 1]->f->data[0],
1579 for (i = 0; i < s->max_b_frames + 1; i++) {
1580 if (!s->input_picture[i] ||
1581 s->input_picture[i]->b_frame_score - 1 >
1582 s->mb_num / s->b_sensitivity)
1586 b_frames = FFMAX(0, i - 1);
1589 for (i = 0; i < b_frames + 1; i++) {
1590 s->input_picture[i]->b_frame_score = 0;
1592 } else if (s->b_frame_strategy == 2) {
1593 b_frames = estimate_best_b_count(s);
1600 for (i = b_frames - 1; i >= 0; i--) {
1601 int type = s->input_picture[i]->f->pict_type;
1602 if (type && type != AV_PICTURE_TYPE_B)
1605 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1606 b_frames == s->max_b_frames) {
1607 av_log(s->avctx, AV_LOG_ERROR,
1608 "warning, too many B-frames in a row\n");
1611 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1612 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1613 s->gop_size > s->picture_in_gop_number) {
1614 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1616 if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1618 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1622 if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1623 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1626 s->reordered_input_picture[0] = s->input_picture[b_frames];
1627 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1628 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1629 s->reordered_input_picture[0]->f->coded_picture_number =
1630 s->coded_picture_number++;
1631 for (i = 0; i < b_frames; i++) {
1632 s->reordered_input_picture[i + 1] = s->input_picture[i];
1633 s->reordered_input_picture[i + 1]->f->pict_type =
1635 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1636 s->coded_picture_number++;
1641 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1643 if (s->reordered_input_picture[0]) {
1644 s->reordered_input_picture[0]->reference =
1645 s->reordered_input_picture[0]->f->pict_type !=
1646 AV_PICTURE_TYPE_B ? 3 : 0;
1648 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1651 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1652 // input is a shared pix, so we can't modify it -> allocate a new
1653 // one & ensure that the shared one is reuseable
1656 int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1659 pic = &s->picture[i];
1661 pic->reference = s->reordered_input_picture[0]->reference;
1662 if (alloc_picture(s, pic, 0) < 0) {
1666 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1670 /* mark us unused / free shared pic */
1671 av_frame_unref(s->reordered_input_picture[0]->f);
1672 s->reordered_input_picture[0]->shared = 0;
1674 s->current_picture_ptr = pic;
1676 // input is not a shared pix -> reuse buffer for current_pix
1677 s->current_picture_ptr = s->reordered_input_picture[0];
1678 for (i = 0; i < 4; i++) {
1679 s->new_picture.f->data[i] += INPLACE_OFFSET;
1682 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1683 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1684 s->current_picture_ptr)) < 0)
1687 s->picture_number = s->new_picture.f->display_picture_number;
1692 static void frame_end(MpegEncContext *s)
1694 if (s->unrestricted_mv &&
1695 s->current_picture.reference &&
1697 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1698 int hshift = desc->log2_chroma_w;
1699 int vshift = desc->log2_chroma_h;
1700 s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
1701 s->current_picture.f->linesize[0],
1702 s->h_edge_pos, s->v_edge_pos,
1703 EDGE_WIDTH, EDGE_WIDTH,
1704 EDGE_TOP | EDGE_BOTTOM);
1705 s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
1706 s->current_picture.f->linesize[1],
1707 s->h_edge_pos >> hshift,
1708 s->v_edge_pos >> vshift,
1709 EDGE_WIDTH >> hshift,
1710 EDGE_WIDTH >> vshift,
1711 EDGE_TOP | EDGE_BOTTOM);
1712 s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
1713 s->current_picture.f->linesize[2],
1714 s->h_edge_pos >> hshift,
1715 s->v_edge_pos >> vshift,
1716 EDGE_WIDTH >> hshift,
1717 EDGE_WIDTH >> vshift,
1718 EDGE_TOP | EDGE_BOTTOM);
1723 s->last_pict_type = s->pict_type;
1724 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1725 if (s->pict_type!= AV_PICTURE_TYPE_B)
1726 s->last_non_b_pict_type = s->pict_type;
1728 #if FF_API_CODED_FRAME
1729 FF_DISABLE_DEPRECATION_WARNINGS
1730 av_frame_unref(s->avctx->coded_frame);
1731 av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1732 FF_ENABLE_DEPRECATION_WARNINGS
1734 #if FF_API_ERROR_FRAME
1735 FF_DISABLE_DEPRECATION_WARNINGS
1736 memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1737 sizeof(s->current_picture.encoding_error));
1738 FF_ENABLE_DEPRECATION_WARNINGS
1742 static void update_noise_reduction(MpegEncContext *s)
1746 for (intra = 0; intra < 2; intra++) {
1747 if (s->dct_count[intra] > (1 << 16)) {
1748 for (i = 0; i < 64; i++) {
1749 s->dct_error_sum[intra][i] >>= 1;
1751 s->dct_count[intra] >>= 1;
1754 for (i = 0; i < 64; i++) {
1755 s->dct_offset[intra][i] = (s->noise_reduction *
1756 s->dct_count[intra] +
1757 s->dct_error_sum[intra][i] / 2) /
1758 (s->dct_error_sum[intra][i] + 1);
1763 static int frame_start(MpegEncContext *s)
1767 /* mark & release old frames */
1768 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1769 s->last_picture_ptr != s->next_picture_ptr &&
1770 s->last_picture_ptr->f->buf[0]) {
1771 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1774 s->current_picture_ptr->f->pict_type = s->pict_type;
1775 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1777 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1778 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1779 s->current_picture_ptr)) < 0)
1782 if (s->pict_type != AV_PICTURE_TYPE_B) {
1783 s->last_picture_ptr = s->next_picture_ptr;
1785 s->next_picture_ptr = s->current_picture_ptr;
1788 if (s->last_picture_ptr) {
1789 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1790 if (s->last_picture_ptr->f->buf[0] &&
1791 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1792 s->last_picture_ptr)) < 0)
1795 if (s->next_picture_ptr) {
1796 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1797 if (s->next_picture_ptr->f->buf[0] &&
1798 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1799 s->next_picture_ptr)) < 0)
1803 if (s->picture_structure!= PICT_FRAME) {
1805 for (i = 0; i < 4; i++) {
1806 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1807 s->current_picture.f->data[i] +=
1808 s->current_picture.f->linesize[i];
1810 s->current_picture.f->linesize[i] *= 2;
1811 s->last_picture.f->linesize[i] *= 2;
1812 s->next_picture.f->linesize[i] *= 2;
1816 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1817 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1818 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1819 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1820 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1821 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1823 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1824 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1827 if (s->dct_error_sum) {
1828 av_assert2(s->noise_reduction && s->encoding);
1829 update_noise_reduction(s);
1835 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1836 const AVFrame *pic_arg, int *got_packet)
1838 MpegEncContext *s = avctx->priv_data;
1839 int i, stuffing_count, ret;
1840 int context_count = s->slice_context_count;
1842 s->vbv_ignore_qmax = 0;
1844 s->picture_in_gop_number++;
1846 if (load_input_picture(s, pic_arg) < 0)
1849 if (select_input_picture(s) < 0) {
1854 if (s->new_picture.f->data[0]) {
1855 int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1856 int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1858 s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1859 if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1862 s->mb_info_ptr = av_packet_new_side_data(pkt,
1863 AV_PKT_DATA_H263_MB_INFO,
1864 s->mb_width*s->mb_height*12);
1865 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1868 for (i = 0; i < context_count; i++) {
1869 int start_y = s->thread_context[i]->start_mb_y;
1870 int end_y = s->thread_context[i]-> end_mb_y;
1871 int h = s->mb_height;
1872 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1873 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1875 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1878 s->pict_type = s->new_picture.f->pict_type;
1880 ret = frame_start(s);
1884 ret = encode_picture(s, s->picture_number);
1885 if (growing_buffer) {
1886 av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1887 pkt->data = s->pb.buf;
1888 pkt->size = avctx->internal->byte_buffer_size;
1893 #if FF_API_STAT_BITS
1894 FF_DISABLE_DEPRECATION_WARNINGS
1895 avctx->header_bits = s->header_bits;
1896 avctx->mv_bits = s->mv_bits;
1897 avctx->misc_bits = s->misc_bits;
1898 avctx->i_tex_bits = s->i_tex_bits;
1899 avctx->p_tex_bits = s->p_tex_bits;
1900 avctx->i_count = s->i_count;
1901 // FIXME f/b_count in avctx
1902 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1903 avctx->skip_count = s->skip_count;
1904 FF_ENABLE_DEPRECATION_WARNINGS
1909 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1910 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1912 if (avctx->rc_buffer_size) {
1913 RateControlContext *rcc = &s->rc_context;
1914 int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1915 int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1916 int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1918 if (put_bits_count(&s->pb) > max_size &&
1919 s->lambda < s->lmax) {
1920 s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1921 (s->qscale + 1) / s->qscale);
1922 if (s->adaptive_quant) {
1924 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1925 s->lambda_table[i] =
1926 FFMAX(s->lambda_table[i] + min_step,
1927 s->lambda_table[i] * (s->qscale + 1) /
1930 s->mb_skipped = 0; // done in frame_start()
1931 // done in encode_picture() so we must undo it
1932 if (s->pict_type == AV_PICTURE_TYPE_P) {
1933 if (s->flipflop_rounding ||
1934 s->codec_id == AV_CODEC_ID_H263P ||
1935 s->codec_id == AV_CODEC_ID_MPEG4)
1936 s->no_rounding ^= 1;
1938 if (s->pict_type != AV_PICTURE_TYPE_B) {
1939 s->time_base = s->last_time_base;
1940 s->last_non_b_time = s->time - s->pp_time;
1942 for (i = 0; i < context_count; i++) {
1943 PutBitContext *pb = &s->thread_context[i]->pb;
1944 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1946 s->vbv_ignore_qmax = 1;
1947 av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1951 av_assert0(s->avctx->rc_max_rate);
1954 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1955 ff_write_pass1_stats(s);
1957 for (i = 0; i < 4; i++) {
1958 s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1959 avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1961 ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
1962 s->current_picture_ptr->encoding_error,
1963 (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1966 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1967 assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1968 s->misc_bits + s->i_tex_bits +
1970 flush_put_bits(&s->pb);
1971 s->frame_bits = put_bits_count(&s->pb);
1973 stuffing_count = ff_vbv_update(s, s->frame_bits);
1974 s->stuffing_bits = 8*stuffing_count;
1975 if (stuffing_count) {
1976 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1977 stuffing_count + 50) {
1978 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1982 switch (s->codec_id) {
1983 case AV_CODEC_ID_MPEG1VIDEO:
1984 case AV_CODEC_ID_MPEG2VIDEO:
1985 while (stuffing_count--) {
1986 put_bits(&s->pb, 8, 0);
1989 case AV_CODEC_ID_MPEG4:
1990 put_bits(&s->pb, 16, 0);
1991 put_bits(&s->pb, 16, 0x1C3);
1992 stuffing_count -= 4;
1993 while (stuffing_count--) {
1994 put_bits(&s->pb, 8, 0xFF);
1998 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2000 flush_put_bits(&s->pb);
2001 s->frame_bits = put_bits_count(&s->pb);
2004 /* update MPEG-1/2 vbv_delay for CBR */
2005 if (s->avctx->rc_max_rate &&
2006 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
2007 s->out_format == FMT_MPEG1 &&
2008 90000LL * (avctx->rc_buffer_size - 1) <=
2009 s->avctx->rc_max_rate * 0xFFFFLL) {
2010 AVCPBProperties *props;
2013 int vbv_delay, min_delay;
2014 double inbits = s->avctx->rc_max_rate *
2015 av_q2d(s->avctx->time_base);
2016 int minbits = s->frame_bits - 8 *
2017 (s->vbv_delay_ptr - s->pb.buf - 1);
2018 double bits = s->rc_context.buffer_index + minbits - inbits;
2021 av_log(s->avctx, AV_LOG_ERROR,
2022 "Internal error, negative bits\n");
2024 assert(s->repeat_first_field == 0);
2026 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
2027 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
2028 s->avctx->rc_max_rate;
2030 vbv_delay = FFMAX(vbv_delay, min_delay);
2032 av_assert0(vbv_delay < 0xFFFF);
2034 s->vbv_delay_ptr[0] &= 0xF8;
2035 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2036 s->vbv_delay_ptr[1] = vbv_delay >> 5;
2037 s->vbv_delay_ptr[2] &= 0x07;
2038 s->vbv_delay_ptr[2] |= vbv_delay << 3;
2040 props = av_cpb_properties_alloc(&props_size);
2042 return AVERROR(ENOMEM);
2043 props->vbv_delay = vbv_delay * 300;
2045 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2046 (uint8_t*)props, props_size);
2052 #if FF_API_VBV_DELAY
2053 FF_DISABLE_DEPRECATION_WARNINGS
2054 avctx->vbv_delay = vbv_delay * 300;
2055 FF_ENABLE_DEPRECATION_WARNINGS
2058 s->total_bits += s->frame_bits;
2059 #if FF_API_STAT_BITS
2060 FF_DISABLE_DEPRECATION_WARNINGS
2061 avctx->frame_bits = s->frame_bits;
2062 FF_ENABLE_DEPRECATION_WARNINGS
2066 pkt->pts = s->current_picture.f->pts;
2067 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2068 if (!s->current_picture.f->coded_picture_number)
2069 pkt->dts = pkt->pts - s->dts_delta;
2071 pkt->dts = s->reordered_pts;
2072 s->reordered_pts = pkt->pts;
2074 pkt->dts = pkt->pts;
2075 if (s->current_picture.f->key_frame)
2076 pkt->flags |= AV_PKT_FLAG_KEY;
2078 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2083 /* release non-reference frames */
2084 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2085 if (!s->picture[i].reference)
2086 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2089 av_assert1((s->frame_bits & 7) == 0);
2091 pkt->size = s->frame_bits / 8;
2092 *got_packet = !!pkt->size;
2096 static inline void dct_single_coeff_elimination(MpegEncContext *s,
2097 int n, int threshold)
2099 static const char tab[64] = {
2100 3, 2, 2, 1, 1, 1, 1, 1,
2101 1, 1, 1, 1, 1, 1, 1, 1,
2102 1, 1, 1, 1, 1, 1, 1, 1,
2103 0, 0, 0, 0, 0, 0, 0, 0,
2104 0, 0, 0, 0, 0, 0, 0, 0,
2105 0, 0, 0, 0, 0, 0, 0, 0,
2106 0, 0, 0, 0, 0, 0, 0, 0,
2107 0, 0, 0, 0, 0, 0, 0, 0
2112 int16_t *block = s->block[n];
2113 const int last_index = s->block_last_index[n];
2116 if (threshold < 0) {
2118 threshold = -threshold;
2122 /* Are all we could set to zero already zero? */
2123 if (last_index <= skip_dc - 1)
2126 for (i = 0; i <= last_index; i++) {
2127 const int j = s->intra_scantable.permutated[i];
2128 const int level = FFABS(block[j]);
2130 if (skip_dc && i == 0)
2134 } else if (level > 1) {
2140 if (score >= threshold)
2142 for (i = skip_dc; i <= last_index; i++) {
2143 const int j = s->intra_scantable.permutated[i];
2147 s->block_last_index[n] = 0;
2149 s->block_last_index[n] = -1;
2152 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2156 const int maxlevel = s->max_qcoeff;
2157 const int minlevel = s->min_qcoeff;
2161 i = 1; // skip clipping of intra dc
2165 for (; i <= last_index; i++) {
2166 const int j = s->intra_scantable.permutated[i];
2167 int level = block[j];
2169 if (level > maxlevel) {
2172 } else if (level < minlevel) {
2180 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2181 av_log(s->avctx, AV_LOG_INFO,
2182 "warning, clipping %d dct coefficients to %d..%d\n",
2183 overflow, minlevel, maxlevel);
2186 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2190 for (y = 0; y < 8; y++) {
2191 for (x = 0; x < 8; x++) {
2197 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2198 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2199 int v = ptr[x2 + y2 * stride];
2205 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2210 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2211 int motion_x, int motion_y,
2212 int mb_block_height,
2216 int16_t weight[12][64];
2217 int16_t orig[12][64];
2218 const int mb_x = s->mb_x;
2219 const int mb_y = s->mb_y;
2222 int dct_offset = s->linesize * 8; // default for progressive frames
2223 int uv_dct_offset = s->uvlinesize * 8;
2224 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2225 ptrdiff_t wrap_y, wrap_c;
2227 for (i = 0; i < mb_block_count; i++)
2228 skip_dct[i] = s->skipdct;
2230 if (s->adaptive_quant) {
2231 const int last_qp = s->qscale;
2232 const int mb_xy = mb_x + mb_y * s->mb_stride;
2234 s->lambda = s->lambda_table[mb_xy];
2237 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2238 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2239 s->dquant = s->qscale - last_qp;
2241 if (s->out_format == FMT_H263) {
2242 s->dquant = av_clip(s->dquant, -2, 2);
2244 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2246 if (s->pict_type == AV_PICTURE_TYPE_B) {
2247 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2250 if (s->mv_type == MV_TYPE_8X8)
2256 ff_set_qscale(s, last_qp + s->dquant);
2257 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2258 ff_set_qscale(s, s->qscale + s->dquant);
2260 wrap_y = s->linesize;
2261 wrap_c = s->uvlinesize;
2262 ptr_y = s->new_picture.f->data[0] +
2263 (mb_y * 16 * wrap_y) + mb_x * 16;
2264 ptr_cb = s->new_picture.f->data[1] +
2265 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2266 ptr_cr = s->new_picture.f->data[2] +
2267 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2269 if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2270 uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2271 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2272 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2273 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2275 16, 16, mb_x * 16, mb_y * 16,
2276 s->width, s->height);
2278 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2280 mb_block_width, mb_block_height,
2281 mb_x * mb_block_width, mb_y * mb_block_height,
2283 ptr_cb = ebuf + 16 * wrap_y;
2284 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2286 mb_block_width, mb_block_height,
2287 mb_x * mb_block_width, mb_y * mb_block_height,
2289 ptr_cr = ebuf + 16 * wrap_y + 16;
2293 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2294 int progressive_score, interlaced_score;
2296 s->interlaced_dct = 0;
2297 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2298 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2299 NULL, wrap_y, 8) - 400;
2301 if (progressive_score > 0) {
2302 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2303 NULL, wrap_y * 2, 8) +
2304 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2305 NULL, wrap_y * 2, 8);
2306 if (progressive_score > interlaced_score) {
2307 s->interlaced_dct = 1;
2309 dct_offset = wrap_y;
2310 uv_dct_offset = wrap_c;
2312 if (s->chroma_format == CHROMA_422 ||
2313 s->chroma_format == CHROMA_444)
2319 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2320 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2321 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2322 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2324 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2328 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2329 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2330 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2331 s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2332 s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2333 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2334 s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2335 s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2336 s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2337 s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2338 s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2339 s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2343 op_pixels_func (*op_pix)[4];
2344 qpel_mc_func (*op_qpix)[16];
2345 uint8_t *dest_y, *dest_cb, *dest_cr;
2347 dest_y = s->dest[0];
2348 dest_cb = s->dest[1];
2349 dest_cr = s->dest[2];
2351 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2352 op_pix = s->hdsp.put_pixels_tab;
2353 op_qpix = s->qdsp.put_qpel_pixels_tab;
2355 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2356 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2359 if (s->mv_dir & MV_DIR_FORWARD) {
2360 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2361 s->last_picture.f->data,
2363 op_pix = s->hdsp.avg_pixels_tab;
2364 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2366 if (s->mv_dir & MV_DIR_BACKWARD) {
2367 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2368 s->next_picture.f->data,
2372 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2373 int progressive_score, interlaced_score;
2375 s->interlaced_dct = 0;
2376 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2377 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2381 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2382 progressive_score -= 400;
2384 if (progressive_score > 0) {
2385 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2387 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2391 if (progressive_score > interlaced_score) {
2392 s->interlaced_dct = 1;
2394 dct_offset = wrap_y;
2395 uv_dct_offset = wrap_c;
2397 if (s->chroma_format == CHROMA_422)
2403 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2404 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2405 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2406 dest_y + dct_offset, wrap_y);
2407 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2408 dest_y + dct_offset + 8, wrap_y);
2410 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2414 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2415 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2416 if (!s->chroma_y_shift) { /* 422 */
2417 s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2418 dest_cb + uv_dct_offset, wrap_c);
2419 s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2420 dest_cr + uv_dct_offset, wrap_c);
2423 /* pre quantization */
2424 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2425 2 * s->qscale * s->qscale) {
2427 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2429 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2431 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2432 wrap_y, 8) < 20 * s->qscale)
2434 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2435 wrap_y, 8) < 20 * s->qscale)
2437 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2439 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2441 if (!s->chroma_y_shift) { /* 422 */
2442 if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2443 dest_cb + uv_dct_offset,
2444 wrap_c, 8) < 20 * s->qscale)
2446 if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2447 dest_cr + uv_dct_offset,
2448 wrap_c, 8) < 20 * s->qscale)
2454 if (s->quantizer_noise_shaping) {
2456 get_visual_weight(weight[0], ptr_y , wrap_y);
2458 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2460 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2462 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2464 get_visual_weight(weight[4], ptr_cb , wrap_c);
2466 get_visual_weight(weight[5], ptr_cr , wrap_c);
2467 if (!s->chroma_y_shift) { /* 422 */
2469 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2472 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2475 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2478 /* DCT & quantize */
2479 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2481 for (i = 0; i < mb_block_count; i++) {
2484 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2485 // FIXME we could decide to change to quantizer instead of
2487 // JS: I don't think that would be a good idea it could lower
2488 // quality instead of improve it. Just INTRADC clipping
2489 // deserves changes in quantizer
2491 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2493 s->block_last_index[i] = -1;
2495 if (s->quantizer_noise_shaping) {
2496 for (i = 0; i < mb_block_count; i++) {
2498 s->block_last_index[i] =
2499 dct_quantize_refine(s, s->block[i], weight[i],
2500 orig[i], i, s->qscale);
2505 if (s->luma_elim_threshold && !s->mb_intra)
2506 for (i = 0; i < 4; i++)
2507 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2508 if (s->chroma_elim_threshold && !s->mb_intra)
2509 for (i = 4; i < mb_block_count; i++)
2510 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2512 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2513 for (i = 0; i < mb_block_count; i++) {
2514 if (s->block_last_index[i] == -1)
2515 s->coded_score[i] = INT_MAX / 256;
2520 if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2521 s->block_last_index[4] =
2522 s->block_last_index[5] = 0;
2524 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2525 if (!s->chroma_y_shift) { /* 422 / 444 */
2526 for (i=6; i<12; i++) {
2527 s->block_last_index[i] = 0;
2528 s->block[i][0] = s->block[4][0];
2533 // non c quantize code returns incorrect block_last_index FIXME
2534 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2535 for (i = 0; i < mb_block_count; i++) {
2537 if (s->block_last_index[i] > 0) {
2538 for (j = 63; j > 0; j--) {
2539 if (s->block[i][s->intra_scantable.permutated[j]])
2542 s->block_last_index[i] = j;
2547 /* huffman encode */
2548 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2549 case AV_CODEC_ID_MPEG1VIDEO:
2550 case AV_CODEC_ID_MPEG2VIDEO:
2551 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2552 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2554 case AV_CODEC_ID_MPEG4:
2555 if (CONFIG_MPEG4_ENCODER)
2556 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2558 case AV_CODEC_ID_MSMPEG4V2:
2559 case AV_CODEC_ID_MSMPEG4V3:
2560 case AV_CODEC_ID_WMV1:
2561 if (CONFIG_MSMPEG4_ENCODER)
2562 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2564 case AV_CODEC_ID_WMV2:
2565 if (CONFIG_WMV2_ENCODER)
2566 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2568 case AV_CODEC_ID_H261:
2569 if (CONFIG_H261_ENCODER)
2570 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2572 case AV_CODEC_ID_H263:
2573 case AV_CODEC_ID_H263P:
2574 case AV_CODEC_ID_FLV1:
2575 case AV_CODEC_ID_RV10:
2576 case AV_CODEC_ID_RV20:
2577 if (CONFIG_H263_ENCODER)
2578 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2580 case AV_CODEC_ID_MJPEG:
2581 case AV_CODEC_ID_AMV:
2582 if (CONFIG_MJPEG_ENCODER)
2583 ff_mjpeg_encode_mb(s, s->block);
2590 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2592 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2593 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2594 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2597 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2600 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2603 d->mb_skip_run= s->mb_skip_run;
2605 d->last_dc[i] = s->last_dc[i];
2608 d->mv_bits= s->mv_bits;
2609 d->i_tex_bits= s->i_tex_bits;
2610 d->p_tex_bits= s->p_tex_bits;
2611 d->i_count= s->i_count;
2612 d->f_count= s->f_count;
2613 d->b_count= s->b_count;
2614 d->skip_count= s->skip_count;
2615 d->misc_bits= s->misc_bits;
2619 d->qscale= s->qscale;
2620 d->dquant= s->dquant;
2622 d->esc3_level_length= s->esc3_level_length;
2625 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2628 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2629 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2632 d->mb_skip_run= s->mb_skip_run;
2634 d->last_dc[i] = s->last_dc[i];
2637 d->mv_bits= s->mv_bits;
2638 d->i_tex_bits= s->i_tex_bits;
2639 d->p_tex_bits= s->p_tex_bits;
2640 d->i_count= s->i_count;
2641 d->f_count= s->f_count;
2642 d->b_count= s->b_count;
2643 d->skip_count= s->skip_count;
2644 d->misc_bits= s->misc_bits;
2646 d->mb_intra= s->mb_intra;
2647 d->mb_skipped= s->mb_skipped;
2648 d->mv_type= s->mv_type;
2649 d->mv_dir= s->mv_dir;
2651 if(s->data_partitioning){
2653 d->tex_pb= s->tex_pb;
2657 d->block_last_index[i]= s->block_last_index[i];
2658 d->interlaced_dct= s->interlaced_dct;
2659 d->qscale= s->qscale;
2661 d->esc3_level_length= s->esc3_level_length;
2664 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2665 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2666 int *dmin, int *next_block, int motion_x, int motion_y)
2669 uint8_t *dest_backup[3];
2671 copy_context_before_encode(s, backup, type);
2673 s->block= s->blocks[*next_block];
2674 s->pb= pb[*next_block];
2675 if(s->data_partitioning){
2676 s->pb2 = pb2 [*next_block];
2677 s->tex_pb= tex_pb[*next_block];
2681 memcpy(dest_backup, s->dest, sizeof(s->dest));
2682 s->dest[0] = s->sc.rd_scratchpad;
2683 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2684 s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2685 av_assert0(s->linesize >= 32); //FIXME
2688 encode_mb(s, motion_x, motion_y);
2690 score= put_bits_count(&s->pb);
2691 if(s->data_partitioning){
2692 score+= put_bits_count(&s->pb2);
2693 score+= put_bits_count(&s->tex_pb);
2696 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2697 ff_mpv_reconstruct_mb(s, s->block);
2699 score *= s->lambda2;
2700 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2704 memcpy(s->dest, dest_backup, sizeof(s->dest));
2711 copy_context_after_encode(best, s, type);
2715 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2716 uint32_t *sq = ff_square_tab + 256;
2721 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2722 else if(w==8 && h==8)
2723 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2727 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2736 static int sse_mb(MpegEncContext *s){
2740 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2741 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2744 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2745 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) +
2746 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) +
2747 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);
2749 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) +
2750 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) +
2751 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);
2754 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)
2755 +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)
2756 +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);
2759 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2760 MpegEncContext *s= *(void**)arg;
2764 s->me.dia_size= s->avctx->pre_dia_size;
2765 s->first_slice_line=1;
2766 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2767 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2768 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2770 s->first_slice_line=0;
2778 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2779 MpegEncContext *s= *(void**)arg;
2781 ff_check_alignment();
2783 s->me.dia_size= s->avctx->dia_size;
2784 s->first_slice_line=1;
2785 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2786 s->mb_x=0; //for block init below
2787 ff_init_block_index(s);
2788 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2789 s->block_index[0]+=2;
2790 s->block_index[1]+=2;
2791 s->block_index[2]+=2;
2792 s->block_index[3]+=2;
2794 /* compute motion vector & mb_type and store in context */
2795 if(s->pict_type==AV_PICTURE_TYPE_B)
2796 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2798 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2800 s->first_slice_line=0;
2805 static int mb_var_thread(AVCodecContext *c, void *arg){
2806 MpegEncContext *s= *(void**)arg;
2809 ff_check_alignment();
2811 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2812 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2815 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2817 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2819 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2820 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2822 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2823 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2824 s->me.mb_var_sum_temp += varc;
2830 static void write_slice_end(MpegEncContext *s){
2831 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2832 if(s->partitioned_frame){
2833 ff_mpeg4_merge_partitions(s);
2836 ff_mpeg4_stuffing(&s->pb);
2837 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2838 ff_mjpeg_encode_stuffing(s);
2841 avpriv_align_put_bits(&s->pb);
2842 flush_put_bits(&s->pb);
2844 if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2845 s->misc_bits+= get_bits_diff(s);
2848 static void write_mb_info(MpegEncContext *s)
2850 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2851 int offset = put_bits_count(&s->pb);
2852 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2853 int gobn = s->mb_y / s->gob_index;
2855 if (CONFIG_H263_ENCODER)
2856 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2857 bytestream_put_le32(&ptr, offset);
2858 bytestream_put_byte(&ptr, s->qscale);
2859 bytestream_put_byte(&ptr, gobn);
2860 bytestream_put_le16(&ptr, mba);
2861 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2862 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2863 /* 4MV not implemented */
2864 bytestream_put_byte(&ptr, 0); /* hmv2 */
2865 bytestream_put_byte(&ptr, 0); /* vmv2 */
2868 static void update_mb_info(MpegEncContext *s, int startcode)
2872 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2873 s->mb_info_size += 12;
2874 s->prev_mb_info = s->last_mb_info;
2877 s->prev_mb_info = put_bits_count(&s->pb)/8;
2878 /* This might have incremented mb_info_size above, and we return without
2879 * actually writing any info into that slot yet. But in that case,
2880 * this will be called again at the start of the after writing the
2881 * start code, actually writing the mb info. */
2885 s->last_mb_info = put_bits_count(&s->pb)/8;
2886 if (!s->mb_info_size)
2887 s->mb_info_size += 12;
2891 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2893 if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2894 && s->slice_context_count == 1
2895 && s->pb.buf == s->avctx->internal->byte_buffer) {
2896 int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2897 int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2899 uint8_t *new_buffer = NULL;
2900 int new_buffer_size = 0;
2902 if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2903 av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2904 return AVERROR(ENOMEM);
2909 av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2910 s->avctx->internal->byte_buffer_size + size_increase);
2912 return AVERROR(ENOMEM);
2914 memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2915 av_free(s->avctx->internal->byte_buffer);
2916 s->avctx->internal->byte_buffer = new_buffer;
2917 s->avctx->internal->byte_buffer_size = new_buffer_size;
2918 rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2919 s->ptr_lastgob = s->pb.buf + lastgob_pos;
2920 s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2922 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2923 return AVERROR(EINVAL);
2927 static int encode_thread(AVCodecContext *c, void *arg){
2928 MpegEncContext *s= *(void**)arg;
2930 int chr_h= 16>>s->chroma_y_shift;
2932 MpegEncContext best_s = { 0 }, backup_s;
2933 uint8_t bit_buf[2][MAX_MB_BYTES];
2934 uint8_t bit_buf2[2][MAX_MB_BYTES];
2935 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2936 PutBitContext pb[2], pb2[2], tex_pb[2];
2938 ff_check_alignment();
2941 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2942 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2943 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2946 s->last_bits= put_bits_count(&s->pb);
2957 /* init last dc values */
2958 /* note: quant matrix value (8) is implied here */
2959 s->last_dc[i] = 128 << s->intra_dc_precision;
2961 s->current_picture.encoding_error[i] = 0;
2963 if(s->codec_id==AV_CODEC_ID_AMV){
2964 s->last_dc[0] = 128*8/13;
2965 s->last_dc[1] = 128*8/14;
2966 s->last_dc[2] = 128*8/14;
2969 memset(s->last_mv, 0, sizeof(s->last_mv));
2973 switch(s->codec_id){
2974 case AV_CODEC_ID_H263:
2975 case AV_CODEC_ID_H263P:
2976 case AV_CODEC_ID_FLV1:
2977 if (CONFIG_H263_ENCODER)
2978 s->gob_index = H263_GOB_HEIGHT(s->height);
2980 case AV_CODEC_ID_MPEG4:
2981 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2982 ff_mpeg4_init_partitions(s);
2988 s->first_slice_line = 1;
2989 s->ptr_lastgob = s->pb.buf;
2990 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2994 ff_set_qscale(s, s->qscale);
2995 ff_init_block_index(s);
2997 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2998 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2999 int mb_type= s->mb_type[xy];
3003 int size_increase = s->avctx->internal->byte_buffer_size/4
3004 + s->mb_width*MAX_MB_BYTES;
3006 ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3007 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3008 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3011 if(s->data_partitioning){
3012 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
3013 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3014 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3020 s->mb_y = mb_y; // moved into loop, can get changed by H.261
3021 ff_update_block_index(s);
3023 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3024 ff_h261_reorder_mb_index(s);
3025 xy= s->mb_y*s->mb_stride + s->mb_x;
3026 mb_type= s->mb_type[xy];
3029 /* write gob / video packet header */
3031 int current_packet_size, is_gob_start;
3033 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3035 is_gob_start = s->rtp_payload_size &&
3036 current_packet_size >= s->rtp_payload_size &&
3039 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3041 switch(s->codec_id){
3042 case AV_CODEC_ID_H263:
3043 case AV_CODEC_ID_H263P:
3044 if(!s->h263_slice_structured)
3045 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3047 case AV_CODEC_ID_MPEG2VIDEO:
3048 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3049 case AV_CODEC_ID_MPEG1VIDEO:
3050 if(s->mb_skip_run) is_gob_start=0;
3052 case AV_CODEC_ID_MJPEG:
3053 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3058 if(s->start_mb_y != mb_y || mb_x!=0){
3061 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3062 ff_mpeg4_init_partitions(s);
3066 av_assert2((put_bits_count(&s->pb)&7) == 0);
3067 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3069 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3070 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3071 int d = 100 / s->error_rate;
3073 current_packet_size=0;
3074 s->pb.buf_ptr= s->ptr_lastgob;
3075 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3079 #if FF_API_RTP_CALLBACK
3080 FF_DISABLE_DEPRECATION_WARNINGS
3081 if (s->avctx->rtp_callback){
3082 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3083 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3085 FF_ENABLE_DEPRECATION_WARNINGS
3087 update_mb_info(s, 1);
3089 switch(s->codec_id){
3090 case AV_CODEC_ID_MPEG4:
3091 if (CONFIG_MPEG4_ENCODER) {
3092 ff_mpeg4_encode_video_packet_header(s);
3093 ff_mpeg4_clean_buffers(s);
3096 case AV_CODEC_ID_MPEG1VIDEO:
3097 case AV_CODEC_ID_MPEG2VIDEO:
3098 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3099 ff_mpeg1_encode_slice_header(s);
3100 ff_mpeg1_clean_buffers(s);
3103 case AV_CODEC_ID_H263:
3104 case AV_CODEC_ID_H263P:
3105 if (CONFIG_H263_ENCODER)
3106 ff_h263_encode_gob_header(s, mb_y);
3110 if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3111 int bits= put_bits_count(&s->pb);
3112 s->misc_bits+= bits - s->last_bits;
3116 s->ptr_lastgob += current_packet_size;
3117 s->first_slice_line=1;
3118 s->resync_mb_x=mb_x;
3119 s->resync_mb_y=mb_y;
3123 if( (s->resync_mb_x == s->mb_x)
3124 && s->resync_mb_y+1 == s->mb_y){
3125 s->first_slice_line=0;
3129 s->dquant=0; //only for QP_RD
3131 update_mb_info(s, 0);
3133 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
3135 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3137 copy_context_before_encode(&backup_s, s, -1);
3139 best_s.data_partitioning= s->data_partitioning;
3140 best_s.partitioned_frame= s->partitioned_frame;
3141 if(s->data_partitioning){
3142 backup_s.pb2= s->pb2;
3143 backup_s.tex_pb= s->tex_pb;
3146 if(mb_type&CANDIDATE_MB_TYPE_INTER){
3147 s->mv_dir = MV_DIR_FORWARD;
3148 s->mv_type = MV_TYPE_16X16;
3150 s->mv[0][0][0] = s->p_mv_table[xy][0];
3151 s->mv[0][0][1] = s->p_mv_table[xy][1];
3152 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3153 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3155 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3156 s->mv_dir = MV_DIR_FORWARD;
3157 s->mv_type = MV_TYPE_FIELD;
3160 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3161 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3162 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3164 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3165 &dmin, &next_block, 0, 0);
3167 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3168 s->mv_dir = MV_DIR_FORWARD;
3169 s->mv_type = MV_TYPE_16X16;
3173 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3174 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3176 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3177 s->mv_dir = MV_DIR_FORWARD;
3178 s->mv_type = MV_TYPE_8X8;
3181 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3182 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3184 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3185 &dmin, &next_block, 0, 0);
3187 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3188 s->mv_dir = MV_DIR_FORWARD;
3189 s->mv_type = MV_TYPE_16X16;
3191 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3192 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3193 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3194 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3196 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3197 s->mv_dir = MV_DIR_BACKWARD;
3198 s->mv_type = MV_TYPE_16X16;
3200 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3201 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3202 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3203 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3205 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3206 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3207 s->mv_type = MV_TYPE_16X16;
3209 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3210 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3211 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3212 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3213 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3214 &dmin, &next_block, 0, 0);
3216 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3217 s->mv_dir = MV_DIR_FORWARD;
3218 s->mv_type = MV_TYPE_FIELD;
3221 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3222 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3223 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3225 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3226 &dmin, &next_block, 0, 0);
3228 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3229 s->mv_dir = MV_DIR_BACKWARD;
3230 s->mv_type = MV_TYPE_FIELD;
3233 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3234 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3235 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3237 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3238 &dmin, &next_block, 0, 0);
3240 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3241 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3242 s->mv_type = MV_TYPE_FIELD;
3244 for(dir=0; dir<2; dir++){
3246 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3247 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3248 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3251 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3252 &dmin, &next_block, 0, 0);
3254 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3256 s->mv_type = MV_TYPE_16X16;
3260 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3261 &dmin, &next_block, 0, 0);
3262 if(s->h263_pred || s->h263_aic){
3264 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3266 ff_clean_intra_table_entries(s); //old mode?
3270 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3271 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3272 const int last_qp= backup_s.qscale;
3275 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3276 static const int dquant_tab[4]={-1,1,-2,2};
3277 int storecoefs = s->mb_intra && s->dc_val[0];
3279 av_assert2(backup_s.dquant == 0);
3282 s->mv_dir= best_s.mv_dir;
3283 s->mv_type = MV_TYPE_16X16;
3284 s->mb_intra= best_s.mb_intra;
3285 s->mv[0][0][0] = best_s.mv[0][0][0];
3286 s->mv[0][0][1] = best_s.mv[0][0][1];
3287 s->mv[1][0][0] = best_s.mv[1][0][0];
3288 s->mv[1][0][1] = best_s.mv[1][0][1];
3290 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3291 for(; qpi<4; qpi++){
3292 int dquant= dquant_tab[qpi];
3293 qp= last_qp + dquant;
3294 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3296 backup_s.dquant= dquant;
3299 dc[i]= s->dc_val[0][ s->block_index[i] ];
3300 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3304 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3305 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3306 if(best_s.qscale != qp){
3309 s->dc_val[0][ s->block_index[i] ]= dc[i];
3310 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3317 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3318 int mx= s->b_direct_mv_table[xy][0];
3319 int my= s->b_direct_mv_table[xy][1];
3321 backup_s.dquant = 0;
3322 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3324 ff_mpeg4_set_direct_mv(s, mx, my);
3325 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3326 &dmin, &next_block, mx, my);
3328 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3329 backup_s.dquant = 0;
3330 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3332 ff_mpeg4_set_direct_mv(s, 0, 0);
3333 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3334 &dmin, &next_block, 0, 0);
3336 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3339 coded |= s->block_last_index[i];
3342 memcpy(s->mv, best_s.mv, sizeof(s->mv));
3343 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3344 mx=my=0; //FIXME find the one we actually used
3345 ff_mpeg4_set_direct_mv(s, mx, my);
3346 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3354 s->mv_dir= best_s.mv_dir;
3355 s->mv_type = best_s.mv_type;
3357 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3358 s->mv[0][0][1] = best_s.mv[0][0][1];
3359 s->mv[1][0][0] = best_s.mv[1][0][0];
3360 s->mv[1][0][1] = best_s.mv[1][0][1];*/
3363 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3364 &dmin, &next_block, mx, my);
3369 s->current_picture.qscale_table[xy] = best_s.qscale;
3371 copy_context_after_encode(s, &best_s, -1);
3373 pb_bits_count= put_bits_count(&s->pb);
3374 flush_put_bits(&s->pb);
3375 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3378 if(s->data_partitioning){
3379 pb2_bits_count= put_bits_count(&s->pb2);
3380 flush_put_bits(&s->pb2);
3381 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3382 s->pb2= backup_s.pb2;
3384 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3385 flush_put_bits(&s->tex_pb);
3386 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3387 s->tex_pb= backup_s.tex_pb;
3389 s->last_bits= put_bits_count(&s->pb);
3391 if (CONFIG_H263_ENCODER &&
3392 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3393 ff_h263_update_motion_val(s);
3395 if(next_block==0){ //FIXME 16 vs linesize16
3396 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3397 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3398 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3401 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3402 ff_mpv_reconstruct_mb(s, s->block);
3404 int motion_x = 0, motion_y = 0;
3405 s->mv_type=MV_TYPE_16X16;
3406 // only one MB-Type possible
3409 case CANDIDATE_MB_TYPE_INTRA:
3412 motion_x= s->mv[0][0][0] = 0;
3413 motion_y= s->mv[0][0][1] = 0;
3415 case CANDIDATE_MB_TYPE_INTER:
3416 s->mv_dir = MV_DIR_FORWARD;
3418 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3419 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3421 case CANDIDATE_MB_TYPE_INTER_I:
3422 s->mv_dir = MV_DIR_FORWARD;
3423 s->mv_type = MV_TYPE_FIELD;
3426 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3427 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3428 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3431 case CANDIDATE_MB_TYPE_INTER4V:
3432 s->mv_dir = MV_DIR_FORWARD;
3433 s->mv_type = MV_TYPE_8X8;
3436 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3437 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3440 case CANDIDATE_MB_TYPE_DIRECT:
3441 if (CONFIG_MPEG4_ENCODER) {
3442 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3444 motion_x=s->b_direct_mv_table[xy][0];
3445 motion_y=s->b_direct_mv_table[xy][1];
3446 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3449 case CANDIDATE_MB_TYPE_DIRECT0:
3450 if (CONFIG_MPEG4_ENCODER) {
3451 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3453 ff_mpeg4_set_direct_mv(s, 0, 0);
3456 case CANDIDATE_MB_TYPE_BIDIR:
3457 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3459 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3460 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3461 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3462 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3464 case CANDIDATE_MB_TYPE_BACKWARD:
3465 s->mv_dir = MV_DIR_BACKWARD;
3467 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3468 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3470 case CANDIDATE_MB_TYPE_FORWARD:
3471 s->mv_dir = MV_DIR_FORWARD;
3473 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3474 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3476 case CANDIDATE_MB_TYPE_FORWARD_I:
3477 s->mv_dir = MV_DIR_FORWARD;
3478 s->mv_type = MV_TYPE_FIELD;
3481 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3482 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3483 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3486 case CANDIDATE_MB_TYPE_BACKWARD_I:
3487 s->mv_dir = MV_DIR_BACKWARD;
3488 s->mv_type = MV_TYPE_FIELD;
3491 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3492 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3493 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3496 case CANDIDATE_MB_TYPE_BIDIR_I:
3497 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3498 s->mv_type = MV_TYPE_FIELD;
3500 for(dir=0; dir<2; dir++){
3502 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3503 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3504 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3509 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3512 encode_mb(s, motion_x, motion_y);
3514 // RAL: Update last macroblock type
3515 s->last_mv_dir = s->mv_dir;
3517 if (CONFIG_H263_ENCODER &&
3518 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3519 ff_h263_update_motion_val(s);
3521 ff_mpv_reconstruct_mb(s, s->block);
3524 /* clean the MV table in IPS frames for direct mode in B-frames */
3525 if(s->mb_intra /* && I,P,S_TYPE */){
3526 s->p_mv_table[xy][0]=0;
3527 s->p_mv_table[xy][1]=0;
3530 if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3534 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3535 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3537 s->current_picture.encoding_error[0] += sse(
3538 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3539 s->dest[0], w, h, s->linesize);
3540 s->current_picture.encoding_error[1] += sse(
3541 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3542 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3543 s->current_picture.encoding_error[2] += sse(
3544 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3545 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3548 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3549 ff_h263_loop_filter(s);
3551 ff_dlog(s->avctx, "MB %d %d bits\n",
3552 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3556 //not beautiful here but we must write it before flushing so it has to be here
3557 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3558 ff_msmpeg4_encode_ext_header(s);
3562 #if FF_API_RTP_CALLBACK
3563 FF_DISABLE_DEPRECATION_WARNINGS
3564 /* Send the last GOB if RTP */
3565 if (s->avctx->rtp_callback) {
3566 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3567 int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3568 /* Call the RTP callback to send the last GOB */
3570 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3572 FF_ENABLE_DEPRECATION_WARNINGS
3578 #define MERGE(field) dst->field += src->field; src->field=0
3579 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3580 MERGE(me.scene_change_score);
3581 MERGE(me.mc_mb_var_sum_temp);
3582 MERGE(me.mb_var_sum_temp);
3585 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3588 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3589 MERGE(dct_count[1]);
3598 MERGE(er.error_count);
3599 MERGE(padding_bug_score);
3600 MERGE(current_picture.encoding_error[0]);
3601 MERGE(current_picture.encoding_error[1]);
3602 MERGE(current_picture.encoding_error[2]);
3604 if (dst->noise_reduction){
3605 for(i=0; i<64; i++){
3606 MERGE(dct_error_sum[0][i]);
3607 MERGE(dct_error_sum[1][i]);
3611 assert(put_bits_count(&src->pb) % 8 ==0);
3612 assert(put_bits_count(&dst->pb) % 8 ==0);
3613 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3614 flush_put_bits(&dst->pb);
3617 static int estimate_qp(MpegEncContext *s, int dry_run){
3618 if (s->next_lambda){
3619 s->current_picture_ptr->f->quality =
3620 s->current_picture.f->quality = s->next_lambda;
3621 if(!dry_run) s->next_lambda= 0;
3622 } else if (!s->fixed_qscale) {
3625 if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
3626 quality = ff_xvid_rate_estimate_qscale(s, dry_run);
3629 quality = ff_rate_estimate_qscale(s, dry_run);
3630 s->current_picture_ptr->f->quality =
3631 s->current_picture.f->quality = quality;
3632 if (s->current_picture.f->quality < 0)
3636 if(s->adaptive_quant){
3637 switch(s->codec_id){
3638 case AV_CODEC_ID_MPEG4:
3639 if (CONFIG_MPEG4_ENCODER)
3640 ff_clean_mpeg4_qscales(s);
3642 case AV_CODEC_ID_H263:
3643 case AV_CODEC_ID_H263P:
3644 case AV_CODEC_ID_FLV1:
3645 if (CONFIG_H263_ENCODER)
3646 ff_clean_h263_qscales(s);
3649 ff_init_qscale_tab(s);
3652 s->lambda= s->lambda_table[0];
3655 s->lambda = s->current_picture.f->quality;
3660 /* must be called before writing the header */
3661 static void set_frame_distances(MpegEncContext * s){
3662 av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3663 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3665 if(s->pict_type==AV_PICTURE_TYPE_B){
3666 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3667 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3669 s->pp_time= s->time - s->last_non_b_time;
3670 s->last_non_b_time= s->time;
3671 assert(s->picture_number==0 || s->pp_time > 0);
3675 static int encode_picture(MpegEncContext *s, int picture_number)
3679 int context_count = s->slice_context_count;
3681 s->picture_number = picture_number;
3683 /* Reset the average MB variance */
3684 s->me.mb_var_sum_temp =
3685 s->me.mc_mb_var_sum_temp = 0;
3687 /* we need to initialize some time vars before we can encode B-frames */
3688 // RAL: Condition added for MPEG1VIDEO
3689 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3690 set_frame_distances(s);
3691 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3692 ff_set_mpeg4_time(s);
3694 s->me.scene_change_score=0;
3696 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3698 if(s->pict_type==AV_PICTURE_TYPE_I){
3699 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3700 else s->no_rounding=0;
3701 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3702 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3703 s->no_rounding ^= 1;
3706 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3707 if (estimate_qp(s,1) < 0)
3709 ff_get_2pass_fcode(s);
3710 } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3711 if(s->pict_type==AV_PICTURE_TYPE_B)
3712 s->lambda= s->last_lambda_for[s->pict_type];
3714 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3718 if(s->codec_id != AV_CODEC_ID_AMV && s->codec_id != AV_CODEC_ID_MJPEG){
3719 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3720 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3721 s->q_chroma_intra_matrix = s->q_intra_matrix;
3722 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3725 s->mb_intra=0; //for the rate distortion & bit compare functions
3726 for(i=1; i<context_count; i++){
3727 ret = ff_update_duplicate_context(s->thread_context[i], s);
3735 /* Estimate motion for every MB */
3736 if(s->pict_type != AV_PICTURE_TYPE_I){
3737 s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3738 s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3739 if (s->pict_type != AV_PICTURE_TYPE_B) {
3740 if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3742 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3746 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3747 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3749 for(i=0; i<s->mb_stride*s->mb_height; i++)
3750 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3752 if(!s->fixed_qscale){
3753 /* finding spatial complexity for I-frame rate control */
3754 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3757 for(i=1; i<context_count; i++){
3758 merge_context_after_me(s, s->thread_context[i]);
3760 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3761 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3764 if (s->me.scene_change_score > s->scenechange_threshold &&
3765 s->pict_type == AV_PICTURE_TYPE_P) {
3766 s->pict_type= AV_PICTURE_TYPE_I;
3767 for(i=0; i<s->mb_stride*s->mb_height; i++)
3768 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3769 if(s->msmpeg4_version >= 3)
3771 ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3772 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3776 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3777 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3779 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3781 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3782 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3783 s->f_code= FFMAX3(s->f_code, a, b);
3786 ff_fix_long_p_mvs(s);
3787 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3788 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3792 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3793 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3798 if(s->pict_type==AV_PICTURE_TYPE_B){
3801 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3802 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3803 s->f_code = FFMAX(a, b);
3805 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3806 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3807 s->b_code = FFMAX(a, b);
3809 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3810 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3811 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3812 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3813 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3815 for(dir=0; dir<2; dir++){
3818 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3819 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3820 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3821 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3829 if (estimate_qp(s, 0) < 0)
3832 if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3833 s->pict_type == AV_PICTURE_TYPE_I &&
3834 !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3835 s->qscale= 3; //reduce clipping problems
3837 if (s->out_format == FMT_MJPEG) {
3838 const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3839 const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3841 if (s->avctx->intra_matrix) {
3843 luma_matrix = s->avctx->intra_matrix;
3845 if (s->avctx->chroma_intra_matrix)
3846 chroma_matrix = s->avctx->chroma_intra_matrix;
3848 /* for mjpeg, we do include qscale in the matrix */
3850 int j = s->idsp.idct_permutation[i];
3852 s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3853 s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3855 s->y_dc_scale_table=
3856 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3857 s->chroma_intra_matrix[0] =
3858 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3859 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3860 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3861 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3862 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3865 if(s->codec_id == AV_CODEC_ID_AMV){
3866 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};
3867 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};
3869 int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3871 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3872 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3874 s->y_dc_scale_table= y;
3875 s->c_dc_scale_table= c;
3876 s->intra_matrix[0] = 13;
3877 s->chroma_intra_matrix[0] = 14;
3878 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3879 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3880 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3881 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3885 //FIXME var duplication
3886 s->current_picture_ptr->f->key_frame =
3887 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3888 s->current_picture_ptr->f->pict_type =
3889 s->current_picture.f->pict_type = s->pict_type;
3891 if (s->current_picture.f->key_frame)
3892 s->picture_in_gop_number=0;
3894 s->mb_x = s->mb_y = 0;
3895 s->last_bits= put_bits_count(&s->pb);
3896 switch(s->out_format) {
3898 if (CONFIG_MJPEG_ENCODER && s->huffman != HUFFMAN_TABLE_OPTIMAL)
3899 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3900 s->pred, s->intra_matrix, s->chroma_intra_matrix);
3903 if (CONFIG_H261_ENCODER)
3904 ff_h261_encode_picture_header(s, picture_number);
3907 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3908 ff_wmv2_encode_picture_header(s, picture_number);
3909 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3910 ff_msmpeg4_encode_picture_header(s, picture_number);
3911 else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3912 ret = ff_mpeg4_encode_picture_header(s, picture_number);
3915 } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3916 ret = ff_rv10_encode_picture_header(s, picture_number);
3920 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3921 ff_rv20_encode_picture_header(s, picture_number);
3922 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3923 ff_flv_encode_picture_header(s, picture_number);
3924 else if (CONFIG_H263_ENCODER)
3925 ff_h263_encode_picture_header(s, picture_number);
3928 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3929 ff_mpeg1_encode_picture_header(s, picture_number);
3934 bits= put_bits_count(&s->pb);
3935 s->header_bits= bits - s->last_bits;
3937 for(i=1; i<context_count; i++){
3938 update_duplicate_context_after_me(s->thread_context[i], s);
3940 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3941 for(i=1; i<context_count; i++){
3942 if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3943 set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
3944 merge_context_after_encode(s, s->thread_context[i]);
3950 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3951 const int intra= s->mb_intra;
3954 s->dct_count[intra]++;
3956 for(i=0; i<64; i++){
3957 int level= block[i];
3961 s->dct_error_sum[intra][i] += level;
3962 level -= s->dct_offset[intra][i];
3963 if(level<0) level=0;
3965 s->dct_error_sum[intra][i] -= level;
3966 level += s->dct_offset[intra][i];
3967 if(level>0) level=0;
3974 static int dct_quantize_trellis_c(MpegEncContext *s,
3975 int16_t *block, int n,
3976 int qscale, int *overflow){
3978 const uint16_t *matrix;
3979 const uint8_t *scantable;
3980 const uint8_t *perm_scantable;
3982 unsigned int threshold1, threshold2;
3994 int coeff_count[64];
3995 int qmul, qadd, start_i, last_non_zero, i, dc;
3996 const int esc_length= s->ac_esc_length;
3998 uint8_t * last_length;
3999 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4002 s->fdsp.fdct(block);
4004 if(s->dct_error_sum)
4005 s->denoise_dct(s, block);
4007 qadd= ((qscale-1)|1)*8;
4009 if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
4010 else mpeg2_qscale = qscale << 1;
4014 scantable= s->intra_scantable.scantable;
4015 perm_scantable= s->intra_scantable.permutated;
4023 /* For AIC we skip quant/dequant of INTRADC */
4028 /* note: block[0] is assumed to be positive */
4029 block[0] = (block[0] + (q >> 1)) / q;
4032 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4033 matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4034 if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4035 bias= 1<<(QMAT_SHIFT-1);
4037 if (n > 3 && s->intra_chroma_ac_vlc_length) {
4038 length = s->intra_chroma_ac_vlc_length;
4039 last_length= s->intra_chroma_ac_vlc_last_length;
4041 length = s->intra_ac_vlc_length;
4042 last_length= s->intra_ac_vlc_last_length;
4045 scantable= s->inter_scantable.scantable;
4046 perm_scantable= s->inter_scantable.permutated;
4049 qmat = s->q_inter_matrix[qscale];
4050 matrix = s->inter_matrix;
4051 length = s->inter_ac_vlc_length;
4052 last_length= s->inter_ac_vlc_last_length;
4056 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4057 threshold2= (threshold1<<1);
4059 for(i=63; i>=start_i; i--) {
4060 const int j = scantable[i];
4061 int level = block[j] * qmat[j];
4063 if(((unsigned)(level+threshold1))>threshold2){
4069 for(i=start_i; i<=last_non_zero; i++) {
4070 const int j = scantable[i];
4071 int level = block[j] * qmat[j];
4073 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4074 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4075 if(((unsigned)(level+threshold1))>threshold2){
4077 level= (bias + level)>>QMAT_SHIFT;
4079 coeff[1][i]= level-1;
4080 // coeff[2][k]= level-2;
4082 level= (bias - level)>>QMAT_SHIFT;
4083 coeff[0][i]= -level;
4084 coeff[1][i]= -level+1;
4085 // coeff[2][k]= -level+2;
4087 coeff_count[i]= FFMIN(level, 2);
4088 av_assert2(coeff_count[i]);
4091 coeff[0][i]= (level>>31)|1;
4096 *overflow= s->max_qcoeff < max; //overflow might have happened
4098 if(last_non_zero < start_i){
4099 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4100 return last_non_zero;
4103 score_tab[start_i]= 0;
4104 survivor[0]= start_i;
4107 for(i=start_i; i<=last_non_zero; i++){
4108 int level_index, j, zero_distortion;
4109 int dct_coeff= FFABS(block[ scantable[i] ]);
4110 int best_score=256*256*256*120;
4112 if (s->fdsp.fdct == ff_fdct_ifast)
4113 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4114 zero_distortion= dct_coeff*dct_coeff;
4116 for(level_index=0; level_index < coeff_count[i]; level_index++){
4118 int level= coeff[level_index][i];
4119 const int alevel= FFABS(level);
4124 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4125 unquant_coeff= alevel*qmul + qadd;
4126 } else if(s->out_format == FMT_MJPEG) {
4127 j = s->idsp.idct_permutation[scantable[i]];
4128 unquant_coeff = alevel * matrix[j] * 8;
4130 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4132 unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4133 unquant_coeff = (unquant_coeff - 1) | 1;
4135 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4136 unquant_coeff = (unquant_coeff - 1) | 1;
4141 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4143 if((level&(~127)) == 0){
4144 for(j=survivor_count-1; j>=0; j--){
4145 int run= i - survivor[j];
4146 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4147 score += score_tab[i-run];
4149 if(score < best_score){
4152 level_tab[i+1]= level-64;
4156 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4157 for(j=survivor_count-1; j>=0; j--){
4158 int run= i - survivor[j];
4159 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4160 score += score_tab[i-run];
4161 if(score < last_score){
4164 last_level= level-64;
4170 distortion += esc_length*lambda;
4171 for(j=survivor_count-1; j>=0; j--){
4172 int run= i - survivor[j];
4173 int score= distortion + score_tab[i-run];
4175 if(score < best_score){
4178 level_tab[i+1]= level-64;
4182 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4183 for(j=survivor_count-1; j>=0; j--){
4184 int run= i - survivor[j];
4185 int score= distortion + score_tab[i-run];
4186 if(score < last_score){
4189 last_level= level-64;
4197 score_tab[i+1]= best_score;
4199 // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
4200 if(last_non_zero <= 27){
4201 for(; survivor_count; survivor_count--){
4202 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4206 for(; survivor_count; survivor_count--){
4207 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4212 survivor[ survivor_count++ ]= i+1;
4215 if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4216 last_score= 256*256*256*120;
4217 for(i= survivor[0]; i<=last_non_zero + 1; i++){
4218 int score= score_tab[i];
4220 score += lambda * 2; // FIXME more exact?
4222 if(score < last_score){
4225 last_level= level_tab[i];
4226 last_run= run_tab[i];
4231 s->coded_score[n] = last_score;
4233 dc= FFABS(block[0]);
4234 last_non_zero= last_i - 1;
4235 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4237 if(last_non_zero < start_i)
4238 return last_non_zero;
4240 if(last_non_zero == 0 && start_i == 0){
4242 int best_score= dc * dc;
4244 for(i=0; i<coeff_count[0]; i++){
4245 int level= coeff[i][0];
4246 int alevel= FFABS(level);
4247 int unquant_coeff, score, distortion;
4249 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4250 unquant_coeff= (alevel*qmul + qadd)>>3;
4252 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4253 unquant_coeff = (unquant_coeff - 1) | 1;
4255 unquant_coeff = (unquant_coeff + 4) >> 3;
4256 unquant_coeff<<= 3 + 3;
4258 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4260 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4261 else score= distortion + esc_length*lambda;
4263 if(score < best_score){
4265 best_level= level - 64;
4268 block[0]= best_level;
4269 s->coded_score[n] = best_score - dc*dc;
4270 if(best_level == 0) return -1;
4271 else return last_non_zero;
4275 av_assert2(last_level);
4277 block[ perm_scantable[last_non_zero] ]= last_level;
4280 for(; i>start_i; i -= run_tab[i] + 1){
4281 block[ perm_scantable[i-1] ]= level_tab[i];
4284 return last_non_zero;
4287 //#define REFINE_STATS 1
4288 static int16_t basis[64][64];
4290 static void build_basis(uint8_t *perm){
4297 double s= 0.25*(1<<BASIS_SHIFT);
4299 int perm_index= perm[index];
4300 if(i==0) s*= sqrt(0.5);
4301 if(j==0) s*= sqrt(0.5);
4302 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)));
4309 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4310 int16_t *block, int16_t *weight, int16_t *orig,
4313 LOCAL_ALIGNED_16(int16_t, d1, [64]);
4314 const uint8_t *scantable;
4315 const uint8_t *perm_scantable;
4316 // unsigned int threshold1, threshold2;
4321 int qmul, qadd, start_i, last_non_zero, i, dc;
4323 uint8_t * last_length;
4325 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4328 static int after_last=0;
4329 static int to_zero=0;
4330 static int from_zero=0;
4333 static int messed_sign=0;
4336 if(basis[0][0] == 0)
4337 build_basis(s->idsp.idct_permutation);
4342 scantable= s->intra_scantable.scantable;
4343 perm_scantable= s->intra_scantable.permutated;
4350 /* For AIC we skip quant/dequant of INTRADC */
4354 q <<= RECON_SHIFT-3;
4355 /* note: block[0] is assumed to be positive */
4357 // block[0] = (block[0] + (q >> 1)) / q;
4359 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4360 // bias= 1<<(QMAT_SHIFT-1);
4361 if (n > 3 && s->intra_chroma_ac_vlc_length) {
4362 length = s->intra_chroma_ac_vlc_length;
4363 last_length= s->intra_chroma_ac_vlc_last_length;
4365 length = s->intra_ac_vlc_length;
4366 last_length= s->intra_ac_vlc_last_length;
4369 scantable= s->inter_scantable.scantable;
4370 perm_scantable= s->inter_scantable.permutated;
4373 length = s->inter_ac_vlc_length;
4374 last_length= s->inter_ac_vlc_last_length;
4376 last_non_zero = s->block_last_index[n];
4381 dc += (1<<(RECON_SHIFT-1));
4382 for(i=0; i<64; i++){
4383 rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4386 STOP_TIMER("memset rem[]")}
4389 for(i=0; i<64; i++){
4394 w= FFABS(weight[i]) + qns*one;
4395 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4398 // w=weight[i] = (63*qns + (w/2)) / w;
4401 av_assert2(w<(1<<6));
4404 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4410 for(i=start_i; i<=last_non_zero; i++){
4411 int j= perm_scantable[i];
4412 const int level= block[j];
4416 if(level<0) coeff= qmul*level - qadd;
4417 else coeff= qmul*level + qadd;
4418 run_tab[rle_index++]=run;
4421 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4427 if(last_non_zero>0){
4428 STOP_TIMER("init rem[]")
4435 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4438 int run2, best_unquant_change=0, analyze_gradient;
4442 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4444 if(analyze_gradient){
4448 for(i=0; i<64; i++){
4451 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4454 STOP_TIMER("rem*w*w")}
4464 const int level= block[0];
4465 int change, old_coeff;
4467 av_assert2(s->mb_intra);
4471 for(change=-1; change<=1; change+=2){
4472 int new_level= level + change;
4473 int score, new_coeff;
4475 new_coeff= q*new_level;
4476 if(new_coeff >= 2048 || new_coeff < 0)
4479 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4480 new_coeff - old_coeff);
4481 if(score<best_score){
4484 best_change= change;
4485 best_unquant_change= new_coeff - old_coeff;
4492 run2= run_tab[rle_index++];
4496 for(i=start_i; i<64; i++){
4497 int j= perm_scantable[i];
4498 const int level= block[j];
4499 int change, old_coeff;
4501 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4505 if(level<0) old_coeff= qmul*level - qadd;
4506 else old_coeff= qmul*level + qadd;
4507 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4511 av_assert2(run2>=0 || i >= last_non_zero );
4514 for(change=-1; change<=1; change+=2){
4515 int new_level= level + change;
4516 int score, new_coeff, unquant_change;
4519 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4523 if(new_level<0) new_coeff= qmul*new_level - qadd;
4524 else new_coeff= qmul*new_level + qadd;
4525 if(new_coeff >= 2048 || new_coeff <= -2048)
4527 //FIXME check for overflow
4530 if(level < 63 && level > -63){
4531 if(i < last_non_zero)
4532 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4533 - length[UNI_AC_ENC_INDEX(run, level+64)];
4535 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4536 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4539 av_assert2(FFABS(new_level)==1);
4541 if(analyze_gradient){
4542 int g= d1[ scantable[i] ];
4543 if(g && (g^new_level) >= 0)
4547 if(i < last_non_zero){
4548 int next_i= i + run2 + 1;
4549 int next_level= block[ perm_scantable[next_i] ] + 64;
4551 if(next_level&(~127))
4554 if(next_i < last_non_zero)
4555 score += length[UNI_AC_ENC_INDEX(run, 65)]
4556 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4557 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4559 score += length[UNI_AC_ENC_INDEX(run, 65)]
4560 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4561 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4563 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4565 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4566 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4572 av_assert2(FFABS(level)==1);
4574 if(i < last_non_zero){
4575 int next_i= i + run2 + 1;
4576 int next_level= block[ perm_scantable[next_i] ] + 64;
4578 if(next_level&(~127))
4581 if(next_i < last_non_zero)
4582 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4583 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4584 - length[UNI_AC_ENC_INDEX(run, 65)];
4586 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4587 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4588 - length[UNI_AC_ENC_INDEX(run, 65)];
4590 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4592 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4593 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4600 unquant_change= new_coeff - old_coeff;
4601 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4603 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4605 if(score<best_score){
4608 best_change= change;
4609 best_unquant_change= unquant_change;
4613 prev_level= level + 64;
4614 if(prev_level&(~127))
4623 STOP_TIMER("iterative step")}
4627 int j= perm_scantable[ best_coeff ];
4629 block[j] += best_change;
4631 if(best_coeff > last_non_zero){
4632 last_non_zero= best_coeff;
4633 av_assert2(block[j]);
4640 if(block[j] - best_change){
4641 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4653 for(; last_non_zero>=start_i; last_non_zero--){
4654 if(block[perm_scantable[last_non_zero]])
4660 if(256*256*256*64 % count == 0){
4661 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);
4666 for(i=start_i; i<=last_non_zero; i++){
4667 int j= perm_scantable[i];
4668 const int level= block[j];
4671 run_tab[rle_index++]=run;
4678 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4684 if(last_non_zero>0){
4685 STOP_TIMER("iterative search")
4690 return last_non_zero;
4694 * Permute an 8x8 block according to permutation.
4695 * @param block the block which will be permuted according to
4696 * the given permutation vector
4697 * @param permutation the permutation vector
4698 * @param last the last non zero coefficient in scantable order, used to
4699 * speed the permutation up
4700 * @param scantable the used scantable, this is only used to speed the
4701 * permutation up, the block is not (inverse) permutated
4702 * to scantable order!
4704 void ff_block_permute(int16_t *block, uint8_t *permutation,
4705 const uint8_t *scantable, int last)
4712 //FIXME it is ok but not clean and might fail for some permutations
4713 // if (permutation[1] == 1)
4716 for (i = 0; i <= last; i++) {
4717 const int j = scantable[i];
4722 for (i = 0; i <= last; i++) {
4723 const int j = scantable[i];
4724 const int perm_j = permutation[j];
4725 block[perm_j] = temp[j];
4729 int ff_dct_quantize_c(MpegEncContext *s,
4730 int16_t *block, int n,
4731 int qscale, int *overflow)
4733 int i, j, level, last_non_zero, q, start_i;
4735 const uint8_t *scantable;
4738 unsigned int threshold1, threshold2;
4740 s->fdsp.fdct(block);
4742 if(s->dct_error_sum)
4743 s->denoise_dct(s, block);
4746 scantable= s->intra_scantable.scantable;
4754 /* For AIC we skip quant/dequant of INTRADC */
4757 /* note: block[0] is assumed to be positive */
4758 block[0] = (block[0] + (q >> 1)) / q;
4761 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4762 bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4764 scantable= s->inter_scantable.scantable;
4767 qmat = s->q_inter_matrix[qscale];
4768 bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4770 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4771 threshold2= (threshold1<<1);
4772 for(i=63;i>=start_i;i--) {
4774 level = block[j] * qmat[j];
4776 if(((unsigned)(level+threshold1))>threshold2){
4783 for(i=start_i; i<=last_non_zero; i++) {
4785 level = block[j] * qmat[j];
4787 // if( bias+level >= (1<<QMAT_SHIFT)
4788 // || bias-level >= (1<<QMAT_SHIFT)){
4789 if(((unsigned)(level+threshold1))>threshold2){
4791 level= (bias + level)>>QMAT_SHIFT;
4794 level= (bias - level)>>QMAT_SHIFT;
4802 *overflow= s->max_qcoeff < max; //overflow might have happened
4804 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4805 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4806 ff_block_permute(block, s->idsp.idct_permutation,
4807 scantable, last_non_zero);
4809 return last_non_zero;
4812 #define OFFSET(x) offsetof(MpegEncContext, x)
4813 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4814 static const AVOption h263_options[] = {
4815 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4816 { "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 },
4821 static const AVClass h263_class = {
4822 .class_name = "H.263 encoder",
4823 .item_name = av_default_item_name,
4824 .option = h263_options,
4825 .version = LIBAVUTIL_VERSION_INT,
4828 AVCodec ff_h263_encoder = {
4830 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4831 .type = AVMEDIA_TYPE_VIDEO,
4832 .id = AV_CODEC_ID_H263,
4833 .priv_data_size = sizeof(MpegEncContext),
4834 .init = ff_mpv_encode_init,
4835 .encode2 = ff_mpv_encode_picture,
4836 .close = ff_mpv_encode_end,
4837 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4838 .priv_class = &h263_class,
4841 static const AVOption h263p_options[] = {
4842 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4843 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4844 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4845 { "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},
4849 static const AVClass h263p_class = {
4850 .class_name = "H.263p encoder",
4851 .item_name = av_default_item_name,
4852 .option = h263p_options,
4853 .version = LIBAVUTIL_VERSION_INT,
4856 AVCodec ff_h263p_encoder = {
4858 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4859 .type = AVMEDIA_TYPE_VIDEO,
4860 .id = AV_CODEC_ID_H263P,
4861 .priv_data_size = sizeof(MpegEncContext),
4862 .init = ff_mpv_encode_init,
4863 .encode2 = ff_mpv_encode_picture,
4864 .close = ff_mpv_encode_end,
4865 .capabilities = AV_CODEC_CAP_SLICE_THREADS,
4866 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4867 .priv_class = &h263p_class,
4870 static const AVClass msmpeg4v2_class = {
4871 .class_name = "msmpeg4v2 encoder",
4872 .item_name = av_default_item_name,
4873 .option = ff_mpv_generic_options,
4874 .version = LIBAVUTIL_VERSION_INT,
4877 AVCodec ff_msmpeg4v2_encoder = {
4878 .name = "msmpeg4v2",
4879 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4880 .type = AVMEDIA_TYPE_VIDEO,
4881 .id = AV_CODEC_ID_MSMPEG4V2,
4882 .priv_data_size = sizeof(MpegEncContext),
4883 .init = ff_mpv_encode_init,
4884 .encode2 = ff_mpv_encode_picture,
4885 .close = ff_mpv_encode_end,
4886 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4887 .priv_class = &msmpeg4v2_class,
4890 static const AVClass msmpeg4v3_class = {
4891 .class_name = "msmpeg4v3 encoder",
4892 .item_name = av_default_item_name,
4893 .option = ff_mpv_generic_options,
4894 .version = LIBAVUTIL_VERSION_INT,
4897 AVCodec ff_msmpeg4v3_encoder = {
4899 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4900 .type = AVMEDIA_TYPE_VIDEO,
4901 .id = AV_CODEC_ID_MSMPEG4V3,
4902 .priv_data_size = sizeof(MpegEncContext),
4903 .init = ff_mpv_encode_init,
4904 .encode2 = ff_mpv_encode_picture,
4905 .close = ff_mpv_encode_end,
4906 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4907 .priv_class = &msmpeg4v3_class,
4910 static const AVClass wmv1_class = {
4911 .class_name = "wmv1 encoder",
4912 .item_name = av_default_item_name,
4913 .option = ff_mpv_generic_options,
4914 .version = LIBAVUTIL_VERSION_INT,
4917 AVCodec ff_wmv1_encoder = {
4919 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4920 .type = AVMEDIA_TYPE_VIDEO,
4921 .id = AV_CODEC_ID_WMV1,
4922 .priv_data_size = sizeof(MpegEncContext),
4923 .init = ff_mpv_encode_init,
4924 .encode2 = ff_mpv_encode_picture,
4925 .close = ff_mpv_encode_end,
4926 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4927 .priv_class = &wmv1_class,