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
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/internal.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/opt.h"
39 #include "mpegvideo.h"
47 #include "aandcttab.h"
49 #include "mpeg4video.h"
51 #include "bytestream.h"
55 static int encode_picture(MpegEncContext *s, int picture_number);
56 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
57 static int sse_mb(MpegEncContext *s);
58 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
59 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
61 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
62 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
64 const AVOption ff_mpv_generic_options[] = {
69 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
70 uint16_t (*qmat16)[2][64],
71 const uint16_t *quant_matrix,
72 int bias, int qmin, int qmax, int intra)
77 for (qscale = qmin; qscale <= qmax; qscale++) {
79 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
80 dsp->fdct == ff_jpeg_fdct_islow_10 ||
81 dsp->fdct == ff_faandct) {
82 for (i = 0; i < 64; i++) {
83 const int j = dsp->idct_permutation[i];
84 /* 16 <= qscale * quant_matrix[i] <= 7905
85 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
86 * 19952 <= x <= 249205026
87 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
88 * 3444240 >= (1 << 36) / (x) >= 275 */
90 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
91 (qscale * quant_matrix[j]));
93 } else if (dsp->fdct == ff_fdct_ifast) {
94 for (i = 0; i < 64; i++) {
95 const int j = dsp->idct_permutation[i];
96 /* 16 <= qscale * quant_matrix[i] <= 7905
97 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
98 * 19952 <= x <= 249205026
99 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
100 * 3444240 >= (1 << 36) / (x) >= 275 */
102 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
103 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
106 for (i = 0; i < 64; i++) {
107 const int j = dsp->idct_permutation[i];
108 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
109 * Assume x = qscale * quant_matrix[i]
111 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
112 * so 32768 >= (1 << 19) / (x) >= 67 */
113 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
114 (qscale * quant_matrix[j]));
115 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
116 // (qscale * quant_matrix[i]);
117 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
118 (qscale * quant_matrix[j]);
120 if (qmat16[qscale][0][i] == 0 ||
121 qmat16[qscale][0][i] == 128 * 256)
122 qmat16[qscale][0][i] = 128 * 256 - 1;
123 qmat16[qscale][1][i] =
124 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
125 qmat16[qscale][0][i]);
129 for (i = intra; i < 64; i++) {
131 if (dsp->fdct == ff_fdct_ifast) {
132 max = (8191LL * ff_aanscales[i]) >> 14;
134 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
140 av_log(NULL, AV_LOG_INFO,
141 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
146 static inline void update_qscale(MpegEncContext *s)
148 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
149 (FF_LAMBDA_SHIFT + 7);
150 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
152 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
156 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
162 for (i = 0; i < 64; i++) {
163 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
170 * init s->current_picture.qscale_table from s->lambda_table
172 void ff_init_qscale_tab(MpegEncContext *s)
174 int8_t * const qscale_table = s->current_picture.qscale_table;
177 for (i = 0; i < s->mb_num; i++) {
178 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
179 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
180 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
185 static void update_duplicate_context_after_me(MpegEncContext *dst,
188 #define COPY(a) dst->a= src->a
190 COPY(current_picture);
196 COPY(picture_in_gop_number);
197 COPY(gop_picture_number);
198 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
199 COPY(progressive_frame); // FIXME don't set in encode_header
200 COPY(partitioned_frame); // FIXME don't set in encode_header
205 * Set the given MpegEncContext to defaults for encoding.
206 * the changed fields will not depend upon the prior state of the MpegEncContext.
208 static void MPV_encode_defaults(MpegEncContext *s)
211 ff_MPV_common_defaults(s);
213 for (i = -16; i < 16; i++) {
214 default_fcode_tab[i + MAX_MV] = 1;
216 s->me.mv_penalty = default_mv_penalty;
217 s->fcode_tab = default_fcode_tab;
220 av_cold int ff_dct_encode_init(MpegEncContext *s) {
222 ff_dct_encode_init_x86(s);
224 if (!s->dct_quantize)
225 s->dct_quantize = ff_dct_quantize_c;
227 s->denoise_dct = denoise_dct_c;
228 s->fast_dct_quantize = s->dct_quantize;
229 if (s->avctx->trellis)
230 s->dct_quantize = dct_quantize_trellis_c;
235 /* init video encoder */
236 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
238 MpegEncContext *s = avctx->priv_data;
240 int chroma_h_shift, chroma_v_shift;
242 MPV_encode_defaults(s);
244 switch (avctx->codec_id) {
245 case AV_CODEC_ID_MPEG2VIDEO:
246 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
247 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
248 av_log(avctx, AV_LOG_ERROR,
249 "only YUV420 and YUV422 are supported\n");
253 case AV_CODEC_ID_LJPEG:
254 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
255 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
256 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
257 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
258 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
259 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
260 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
261 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
262 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
263 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
264 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
268 case AV_CODEC_ID_MJPEG:
269 case AV_CODEC_ID_AMV:
270 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
271 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
272 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
273 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
274 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
275 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
276 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
277 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
282 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
283 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
288 switch (avctx->pix_fmt) {
289 case AV_PIX_FMT_YUVJ444P:
290 case AV_PIX_FMT_YUV444P:
291 s->chroma_format = CHROMA_444;
293 case AV_PIX_FMT_YUVJ422P:
294 case AV_PIX_FMT_YUV422P:
295 s->chroma_format = CHROMA_422;
297 case AV_PIX_FMT_YUVJ420P:
298 case AV_PIX_FMT_YUV420P:
300 s->chroma_format = CHROMA_420;
304 s->bit_rate = avctx->bit_rate;
305 s->width = avctx->width;
306 s->height = avctx->height;
307 if (avctx->gop_size > 600 &&
308 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
309 av_log(avctx, AV_LOG_WARNING,
310 "keyframe interval too large!, reducing it from %d to %d\n",
311 avctx->gop_size, 600);
312 avctx->gop_size = 600;
314 s->gop_size = avctx->gop_size;
316 s->flags = avctx->flags;
317 s->flags2 = avctx->flags2;
318 s->max_b_frames = avctx->max_b_frames;
319 s->codec_id = avctx->codec->id;
320 s->strict_std_compliance = avctx->strict_std_compliance;
321 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
322 s->mpeg_quant = avctx->mpeg_quant;
323 s->rtp_mode = !!avctx->rtp_payload_size;
324 s->intra_dc_precision = avctx->intra_dc_precision;
325 s->user_specified_pts = AV_NOPTS_VALUE;
327 if (s->gop_size <= 1) {
334 s->me_method = avctx->me_method;
337 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
339 s->adaptive_quant = (s->avctx->lumi_masking ||
340 s->avctx->dark_masking ||
341 s->avctx->temporal_cplx_masking ||
342 s->avctx->spatial_cplx_masking ||
343 s->avctx->p_masking ||
344 s->avctx->border_masking ||
345 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
348 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
350 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
351 switch(avctx->codec_id) {
352 case AV_CODEC_ID_MPEG1VIDEO:
353 case AV_CODEC_ID_MPEG2VIDEO:
354 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
356 case AV_CODEC_ID_MPEG4:
357 case AV_CODEC_ID_MSMPEG4V1:
358 case AV_CODEC_ID_MSMPEG4V2:
359 case AV_CODEC_ID_MSMPEG4V3:
360 if (avctx->rc_max_rate >= 15000000) {
361 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
362 } else if(avctx->rc_max_rate >= 2000000) {
363 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
364 } else if(avctx->rc_max_rate >= 384000) {
365 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
367 avctx->rc_buffer_size = 40;
368 avctx->rc_buffer_size *= 16384;
371 if (avctx->rc_buffer_size) {
372 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
376 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
377 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
378 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
382 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
383 av_log(avctx, AV_LOG_INFO,
384 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
387 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
388 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
392 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
393 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
397 if (avctx->rc_max_rate &&
398 avctx->rc_max_rate == avctx->bit_rate &&
399 avctx->rc_max_rate != avctx->rc_min_rate) {
400 av_log(avctx, AV_LOG_INFO,
401 "impossible bitrate constraints, this will fail\n");
404 if (avctx->rc_buffer_size &&
405 avctx->bit_rate * (int64_t)avctx->time_base.num >
406 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
407 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
411 if (!s->fixed_qscale &&
412 avctx->bit_rate * av_q2d(avctx->time_base) >
413 avctx->bit_rate_tolerance) {
414 av_log(avctx, AV_LOG_ERROR,
415 "bitrate tolerance too small for bitrate\n");
419 if (s->avctx->rc_max_rate &&
420 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
421 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
422 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
423 90000LL * (avctx->rc_buffer_size - 1) >
424 s->avctx->rc_max_rate * 0xFFFFLL) {
425 av_log(avctx, AV_LOG_INFO,
426 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
427 "specified vbv buffer is too large for the given bitrate!\n");
430 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
431 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
432 s->codec_id != AV_CODEC_ID_FLV1) {
433 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
437 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
438 av_log(avctx, AV_LOG_ERROR,
439 "OBMC is only supported with simple mb decision\n");
443 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
444 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
448 if (s->max_b_frames &&
449 s->codec_id != AV_CODEC_ID_MPEG4 &&
450 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
451 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
452 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
456 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
457 s->codec_id == AV_CODEC_ID_H263 ||
458 s->codec_id == AV_CODEC_ID_H263P) &&
459 (avctx->sample_aspect_ratio.num > 255 ||
460 avctx->sample_aspect_ratio.den > 255)) {
461 av_log(avctx, AV_LOG_WARNING,
462 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
463 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
464 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
465 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
468 if ((s->codec_id == AV_CODEC_ID_H263 ||
469 s->codec_id == AV_CODEC_ID_H263P) &&
470 (avctx->width > 2048 ||
471 avctx->height > 1152 )) {
472 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
475 if ((s->codec_id == AV_CODEC_ID_H263 ||
476 s->codec_id == AV_CODEC_ID_H263P) &&
477 ((avctx->width &3) ||
478 (avctx->height&3) )) {
479 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
483 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
484 (avctx->width > 4095 ||
485 avctx->height > 4095 )) {
486 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
490 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
491 (avctx->width > 16383 ||
492 avctx->height > 16383 )) {
493 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
497 if (s->codec_id == AV_CODEC_ID_RV10 &&
499 avctx->height&15 )) {
500 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
501 return AVERROR(EINVAL);
504 if (s->codec_id == AV_CODEC_ID_RV20 &&
507 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
508 return AVERROR(EINVAL);
511 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
512 s->codec_id == AV_CODEC_ID_WMV2) &&
514 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
518 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
519 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
520 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
524 // FIXME mpeg2 uses that too
525 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
526 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
527 av_log(avctx, AV_LOG_ERROR,
528 "mpeg2 style quantization not supported by codec\n");
532 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
533 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
537 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
538 s->avctx->mb_decision != FF_MB_DECISION_RD) {
539 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
543 if (s->avctx->scenechange_threshold < 1000000000 &&
544 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
545 av_log(avctx, AV_LOG_ERROR,
546 "closed gop with scene change detection are not supported yet, "
547 "set threshold to 1000000000\n");
551 if (s->flags & CODEC_FLAG_LOW_DELAY) {
552 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
553 av_log(avctx, AV_LOG_ERROR,
554 "low delay forcing is only available for mpeg2\n");
557 if (s->max_b_frames != 0) {
558 av_log(avctx, AV_LOG_ERROR,
559 "b frames cannot be used with low delay\n");
564 if (s->q_scale_type == 1) {
565 if (avctx->qmax > 12) {
566 av_log(avctx, AV_LOG_ERROR,
567 "non linear quant only supports qmax <= 12 currently\n");
572 if (s->avctx->thread_count > 1 &&
573 s->codec_id != AV_CODEC_ID_MPEG4 &&
574 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
575 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
576 s->codec_id != AV_CODEC_ID_MJPEG &&
577 (s->codec_id != AV_CODEC_ID_H263P)) {
578 av_log(avctx, AV_LOG_ERROR,
579 "multi threaded encoding not supported by codec\n");
583 if (s->avctx->thread_count < 1) {
584 av_log(avctx, AV_LOG_ERROR,
585 "automatic thread number detection not supported by codec, "
590 if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
593 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
594 s->h263_slice_structured = 1;
596 if (!avctx->time_base.den || !avctx->time_base.num) {
597 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
601 i = (INT_MAX / 2 + 128) >> 8;
602 if (avctx->mb_threshold >= i) {
603 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
608 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
609 av_log(avctx, AV_LOG_INFO,
610 "notice: b_frame_strategy only affects the first pass\n");
611 avctx->b_frame_strategy = 0;
614 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
616 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
617 avctx->time_base.den /= i;
618 avctx->time_base.num /= i;
622 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) {
623 // (a + x * 3 / 8) / x
624 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
625 s->inter_quant_bias = 0;
627 s->intra_quant_bias = 0;
629 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
632 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
633 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
634 return AVERROR(EINVAL);
637 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
638 s->intra_quant_bias = avctx->intra_quant_bias;
639 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
640 s->inter_quant_bias = avctx->inter_quant_bias;
642 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
644 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
646 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
647 s->avctx->time_base.den > (1 << 16) - 1) {
648 av_log(avctx, AV_LOG_ERROR,
649 "timebase %d/%d not supported by MPEG 4 standard, "
650 "the maximum admitted value for the timebase denominator "
651 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
655 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
657 switch (avctx->codec->id) {
658 case AV_CODEC_ID_MPEG1VIDEO:
659 s->out_format = FMT_MPEG1;
660 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
661 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
663 case AV_CODEC_ID_MPEG2VIDEO:
664 s->out_format = FMT_MPEG1;
665 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
666 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
669 case AV_CODEC_ID_LJPEG:
670 case AV_CODEC_ID_MJPEG:
671 case AV_CODEC_ID_AMV:
672 s->out_format = FMT_MJPEG;
673 s->intra_only = 1; /* force intra only for jpeg */
674 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
675 (avctx->pix_fmt == AV_PIX_FMT_BGR0
676 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
677 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
678 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
679 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
680 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
681 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
682 s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
683 s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
685 s->mjpeg_vsample[0] = 2;
686 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
687 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
688 s->mjpeg_hsample[0] = 2;
689 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
690 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
692 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
693 ff_mjpeg_encode_init(s) < 0)
698 case AV_CODEC_ID_H261:
699 if (!CONFIG_H261_ENCODER)
701 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
702 av_log(avctx, AV_LOG_ERROR,
703 "The specified picture size of %dx%d is not valid for the "
704 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
705 s->width, s->height);
708 s->out_format = FMT_H261;
712 case AV_CODEC_ID_H263:
713 if (!CONFIG_H263_ENCODER)
715 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
716 s->width, s->height) == 8) {
717 av_log(avctx, AV_LOG_ERROR,
718 "The specified picture size of %dx%d is not valid for "
719 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
720 "352x288, 704x576, and 1408x1152. "
721 "Try H.263+.\n", s->width, s->height);
724 s->out_format = FMT_H263;
728 case AV_CODEC_ID_H263P:
729 s->out_format = FMT_H263;
732 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
733 s->modified_quant = s->h263_aic;
734 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
735 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
738 /* These are just to be sure */
742 case AV_CODEC_ID_FLV1:
743 s->out_format = FMT_H263;
744 s->h263_flv = 2; /* format = 1; 11-bit codes */
745 s->unrestricted_mv = 1;
746 s->rtp_mode = 0; /* don't allow GOB */
750 case AV_CODEC_ID_RV10:
751 s->out_format = FMT_H263;
755 case AV_CODEC_ID_RV20:
756 s->out_format = FMT_H263;
759 s->modified_quant = 1;
763 s->unrestricted_mv = 0;
765 case AV_CODEC_ID_MPEG4:
766 s->out_format = FMT_H263;
768 s->unrestricted_mv = 1;
769 s->low_delay = s->max_b_frames ? 0 : 1;
770 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
772 case AV_CODEC_ID_MSMPEG4V2:
773 s->out_format = FMT_H263;
775 s->unrestricted_mv = 1;
776 s->msmpeg4_version = 2;
780 case AV_CODEC_ID_MSMPEG4V3:
781 s->out_format = FMT_H263;
783 s->unrestricted_mv = 1;
784 s->msmpeg4_version = 3;
785 s->flipflop_rounding = 1;
789 case AV_CODEC_ID_WMV1:
790 s->out_format = FMT_H263;
792 s->unrestricted_mv = 1;
793 s->msmpeg4_version = 4;
794 s->flipflop_rounding = 1;
798 case AV_CODEC_ID_WMV2:
799 s->out_format = FMT_H263;
801 s->unrestricted_mv = 1;
802 s->msmpeg4_version = 5;
803 s->flipflop_rounding = 1;
811 avctx->has_b_frames = !s->low_delay;
815 s->progressive_frame =
816 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
817 CODEC_FLAG_INTERLACED_ME) ||
821 if (ff_MPV_common_init(s) < 0)
824 ff_dct_encode_init(s);
826 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
827 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
829 s->quant_precision = 5;
831 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
832 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
834 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
835 ff_h261_encode_init(s);
836 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
837 ff_h263_encode_init(s);
838 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
839 ff_msmpeg4_encode_init(s);
840 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
841 && s->out_format == FMT_MPEG1)
842 ff_mpeg1_encode_init(s);
845 for (i = 0; i < 64; i++) {
846 int j = s->dsp.idct_permutation[i];
847 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
849 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
850 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
851 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
853 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
856 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
857 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
859 if (s->avctx->intra_matrix)
860 s->intra_matrix[j] = s->avctx->intra_matrix[i];
861 if (s->avctx->inter_matrix)
862 s->inter_matrix[j] = s->avctx->inter_matrix[i];
865 /* precompute matrix */
866 /* for mjpeg, we do include qscale in the matrix */
867 if (s->out_format != FMT_MJPEG) {
868 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
869 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
871 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
872 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
876 if (ff_rate_control_init(s) < 0)
882 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
884 MpegEncContext *s = avctx->priv_data;
886 ff_rate_control_uninit(s);
888 ff_MPV_common_end(s);
889 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
890 s->out_format == FMT_MJPEG)
891 ff_mjpeg_encode_close(s);
893 av_freep(&avctx->extradata);
898 static int get_sae(uint8_t *src, int ref, int stride)
903 for (y = 0; y < 16; y++) {
904 for (x = 0; x < 16; x++) {
905 acc += FFABS(src[x + y * stride] - ref);
912 static int get_intra_count(MpegEncContext *s, uint8_t *src,
913 uint8_t *ref, int stride)
921 for (y = 0; y < h; y += 16) {
922 for (x = 0; x < w; x += 16) {
923 int offset = x + y * stride;
924 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
926 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
927 int sae = get_sae(src + offset, mean, stride);
929 acc += sae + 500 < sad;
936 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
940 int i, display_picture_number = 0, ret;
941 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
942 (s->low_delay ? 0 : 1);
947 display_picture_number = s->input_picture_number++;
949 if (pts != AV_NOPTS_VALUE) {
950 if (s->user_specified_pts != AV_NOPTS_VALUE) {
951 int64_t last = s->user_specified_pts;
954 av_log(s->avctx, AV_LOG_ERROR,
955 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
957 return AVERROR(EINVAL);
960 if (!s->low_delay && display_picture_number == 1)
961 s->dts_delta = pts - last;
963 s->user_specified_pts = pts;
965 if (s->user_specified_pts != AV_NOPTS_VALUE) {
966 s->user_specified_pts =
967 pts = s->user_specified_pts + 1;
968 av_log(s->avctx, AV_LOG_INFO,
969 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
972 pts = display_picture_number;
978 if (!pic_arg->buf[0])
980 if (pic_arg->linesize[0] != s->linesize)
982 if (pic_arg->linesize[1] != s->uvlinesize)
984 if (pic_arg->linesize[2] != s->uvlinesize)
987 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
988 pic_arg->linesize[1], (int) s->linesize, (int) s->uvlinesize);
991 i = ff_find_unused_picture(s, 1);
995 pic = &s->picture[i];
998 if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
1000 if (ff_alloc_picture(s, pic, 1) < 0) {
1004 i = ff_find_unused_picture(s, 0);
1008 pic = &s->picture[i];
1011 if (ff_alloc_picture(s, pic, 0) < 0) {
1015 if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1016 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1017 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1020 int h_chroma_shift, v_chroma_shift;
1021 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1025 for (i = 0; i < 3; i++) {
1026 int src_stride = pic_arg->linesize[i];
1027 int dst_stride = i ? s->uvlinesize : s->linesize;
1028 int h_shift = i ? h_chroma_shift : 0;
1029 int v_shift = i ? v_chroma_shift : 0;
1030 int w = s->width >> h_shift;
1031 int h = s->height >> v_shift;
1032 uint8_t *src = pic_arg->data[i];
1033 uint8_t *dst = pic->f.data[i];
1035 if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1036 h = ((s->height + 15)/16*16) >> v_shift;
1039 if (!s->avctx->rc_buffer_size)
1040 dst += INPLACE_OFFSET;
1042 if (src_stride == dst_stride)
1043 memcpy(dst, src, src_stride * h);
1046 uint8_t *dst2 = dst;
1048 memcpy(dst2, src, w);
1053 if ((s->width & 15) || (s->height & 15)) {
1054 s->dsp.draw_edges(dst, dst_stride,
1063 ret = av_frame_copy_props(&pic->f, pic_arg);
1067 pic->f.display_picture_number = display_picture_number;
1068 pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
1071 /* shift buffer entries */
1072 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1073 s->input_picture[i - 1] = s->input_picture[i];
1075 s->input_picture[encoding_delay] = (Picture*) pic;
1080 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1084 int64_t score64 = 0;
1086 for (plane = 0; plane < 3; plane++) {
1087 const int stride = p->f.linesize[plane];
1088 const int bw = plane ? 1 : 2;
1089 for (y = 0; y < s->mb_height * bw; y++) {
1090 for (x = 0; x < s->mb_width * bw; x++) {
1091 int off = p->shared ? 0 : 16;
1092 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1093 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1094 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1096 switch (s->avctx->frame_skip_exp) {
1097 case 0: score = FFMAX(score, v); break;
1098 case 1: score += FFABS(v); break;
1099 case 2: score += v * v; break;
1100 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1101 case 4: score64 += v * v * (int64_t)(v * v); break;
1110 if (score64 < s->avctx->frame_skip_threshold)
1112 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1117 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1119 AVPacket pkt = { 0 };
1120 int ret, got_output;
1122 av_init_packet(&pkt);
1123 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1128 av_free_packet(&pkt);
1132 static int estimate_best_b_count(MpegEncContext *s)
1134 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1135 AVCodecContext *c = avcodec_alloc_context3(NULL);
1136 AVFrame input[FF_MAX_B_FRAMES + 2];
1137 const int scale = s->avctx->brd_scale;
1138 int i, j, out_size, p_lambda, b_lambda, lambda2;
1139 int64_t best_rd = INT64_MAX;
1140 int best_b_count = -1;
1142 av_assert0(scale >= 0 && scale <= 3);
1145 //s->next_picture_ptr->quality;
1146 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1147 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1148 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1149 if (!b_lambda) // FIXME we should do this somewhere else
1150 b_lambda = p_lambda;
1151 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1154 c->width = s->width >> scale;
1155 c->height = s->height >> scale;
1156 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1157 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1158 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1159 c->mb_decision = s->avctx->mb_decision;
1160 c->me_cmp = s->avctx->me_cmp;
1161 c->mb_cmp = s->avctx->mb_cmp;
1162 c->me_sub_cmp = s->avctx->me_sub_cmp;
1163 c->pix_fmt = AV_PIX_FMT_YUV420P;
1164 c->time_base = s->avctx->time_base;
1165 c->max_b_frames = s->max_b_frames;
1167 if (avcodec_open2(c, codec, NULL) < 0)
1170 for (i = 0; i < s->max_b_frames + 2; i++) {
1171 int ysize = c->width * c->height;
1172 int csize = (c->width / 2) * (c->height / 2);
1173 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1174 s->next_picture_ptr;
1176 avcodec_get_frame_defaults(&input[i]);
1177 input[i].data[0] = av_malloc(ysize + 2 * csize);
1178 input[i].data[1] = input[i].data[0] + ysize;
1179 input[i].data[2] = input[i].data[1] + csize;
1180 input[i].linesize[0] = c->width;
1181 input[i].linesize[1] =
1182 input[i].linesize[2] = c->width / 2;
1184 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1185 pre_input = *pre_input_ptr;
1187 if (!pre_input.shared && i) {
1188 pre_input.f.data[0] += INPLACE_OFFSET;
1189 pre_input.f.data[1] += INPLACE_OFFSET;
1190 pre_input.f.data[2] += INPLACE_OFFSET;
1193 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1194 pre_input.f.data[0], pre_input.f.linesize[0],
1195 c->width, c->height);
1196 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1197 pre_input.f.data[1], pre_input.f.linesize[1],
1198 c->width >> 1, c->height >> 1);
1199 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1200 pre_input.f.data[2], pre_input.f.linesize[2],
1201 c->width >> 1, c->height >> 1);
1205 for (j = 0; j < s->max_b_frames + 1; j++) {
1208 if (!s->input_picture[j])
1211 c->error[0] = c->error[1] = c->error[2] = 0;
1213 input[0].pict_type = AV_PICTURE_TYPE_I;
1214 input[0].quality = 1 * FF_QP2LAMBDA;
1216 out_size = encode_frame(c, &input[0]);
1218 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1220 for (i = 0; i < s->max_b_frames + 1; i++) {
1221 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1223 input[i + 1].pict_type = is_p ?
1224 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1225 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1227 out_size = encode_frame(c, &input[i + 1]);
1229 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1232 /* get the delayed frames */
1234 out_size = encode_frame(c, NULL);
1235 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1238 rd += c->error[0] + c->error[1] + c->error[2];
1249 for (i = 0; i < s->max_b_frames + 2; i++) {
1250 av_freep(&input[i].data[0]);
1253 return best_b_count;
1256 static int select_input_picture(MpegEncContext *s)
1260 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1261 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1262 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1264 /* set next picture type & ordering */
1265 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1266 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1267 s->next_picture_ptr == NULL || s->intra_only) {
1268 s->reordered_input_picture[0] = s->input_picture[0];
1269 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1270 s->reordered_input_picture[0]->f.coded_picture_number =
1271 s->coded_picture_number++;
1275 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1276 if (s->picture_in_gop_number < s->gop_size &&
1277 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1278 // FIXME check that te gop check above is +-1 correct
1279 av_frame_unref(&s->input_picture[0]->f);
1282 ff_vbv_update(s, 0);
1288 if (s->flags & CODEC_FLAG_PASS2) {
1289 for (i = 0; i < s->max_b_frames + 1; i++) {
1290 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1292 if (pict_num >= s->rc_context.num_entries)
1294 if (!s->input_picture[i]) {
1295 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1299 s->input_picture[i]->f.pict_type =
1300 s->rc_context.entry[pict_num].new_pict_type;
1304 if (s->avctx->b_frame_strategy == 0) {
1305 b_frames = s->max_b_frames;
1306 while (b_frames && !s->input_picture[b_frames])
1308 } else if (s->avctx->b_frame_strategy == 1) {
1309 for (i = 1; i < s->max_b_frames + 1; i++) {
1310 if (s->input_picture[i] &&
1311 s->input_picture[i]->b_frame_score == 0) {
1312 s->input_picture[i]->b_frame_score =
1314 s->input_picture[i ]->f.data[0],
1315 s->input_picture[i - 1]->f.data[0],
1319 for (i = 0; i < s->max_b_frames + 1; i++) {
1320 if (s->input_picture[i] == NULL ||
1321 s->input_picture[i]->b_frame_score - 1 >
1322 s->mb_num / s->avctx->b_sensitivity)
1326 b_frames = FFMAX(0, i - 1);
1329 for (i = 0; i < b_frames + 1; i++) {
1330 s->input_picture[i]->b_frame_score = 0;
1332 } else if (s->avctx->b_frame_strategy == 2) {
1333 b_frames = estimate_best_b_count(s);
1335 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1341 for (i = b_frames - 1; i >= 0; i--) {
1342 int type = s->input_picture[i]->f.pict_type;
1343 if (type && type != AV_PICTURE_TYPE_B)
1346 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1347 b_frames == s->max_b_frames) {
1348 av_log(s->avctx, AV_LOG_ERROR,
1349 "warning, too many b frames in a row\n");
1352 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1353 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1354 s->gop_size > s->picture_in_gop_number) {
1355 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1357 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1359 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1363 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1364 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1367 s->reordered_input_picture[0] = s->input_picture[b_frames];
1368 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1369 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1370 s->reordered_input_picture[0]->f.coded_picture_number =
1371 s->coded_picture_number++;
1372 for (i = 0; i < b_frames; i++) {
1373 s->reordered_input_picture[i + 1] = s->input_picture[i];
1374 s->reordered_input_picture[i + 1]->f.pict_type =
1376 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1377 s->coded_picture_number++;
1382 if (s->reordered_input_picture[0]) {
1383 s->reordered_input_picture[0]->reference =
1384 s->reordered_input_picture[0]->f.pict_type !=
1385 AV_PICTURE_TYPE_B ? 3 : 0;
1387 ff_mpeg_unref_picture(s, &s->new_picture);
1388 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1391 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1392 // input is a shared pix, so we can't modifiy it -> alloc a new
1393 // one & ensure that the shared one is reuseable
1396 int i = ff_find_unused_picture(s, 0);
1399 pic = &s->picture[i];
1401 pic->reference = s->reordered_input_picture[0]->reference;
1402 if (ff_alloc_picture(s, pic, 0) < 0) {
1406 ret = av_frame_copy_props(&pic->f, &s->reordered_input_picture[0]->f);
1410 /* mark us unused / free shared pic */
1411 av_frame_unref(&s->reordered_input_picture[0]->f);
1412 s->reordered_input_picture[0]->shared = 0;
1414 s->current_picture_ptr = pic;
1416 // input is not a shared pix -> reuse buffer for current_pix
1417 s->current_picture_ptr = s->reordered_input_picture[0];
1418 for (i = 0; i < 4; i++) {
1419 s->new_picture.f.data[i] += INPLACE_OFFSET;
1422 ff_mpeg_unref_picture(s, &s->current_picture);
1423 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1424 s->current_picture_ptr)) < 0)
1427 s->picture_number = s->new_picture.f.display_picture_number;
1429 ff_mpeg_unref_picture(s, &s->new_picture);
1434 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1435 AVFrame *pic_arg, int *got_packet)
1437 MpegEncContext *s = avctx->priv_data;
1438 int i, stuffing_count, ret;
1439 int context_count = s->slice_context_count;
1441 s->picture_in_gop_number++;
1443 if (load_input_picture(s, pic_arg) < 0)
1446 if (select_input_picture(s) < 0) {
1451 if (s->new_picture.f.data[0]) {
1452 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1455 s->mb_info_ptr = av_packet_new_side_data(pkt,
1456 AV_PKT_DATA_H263_MB_INFO,
1457 s->mb_width*s->mb_height*12);
1458 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1461 for (i = 0; i < context_count; i++) {
1462 int start_y = s->thread_context[i]->start_mb_y;
1463 int end_y = s->thread_context[i]-> end_mb_y;
1464 int h = s->mb_height;
1465 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1466 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1468 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1471 s->pict_type = s->new_picture.f.pict_type;
1473 if (ff_MPV_frame_start(s, avctx) < 0)
1476 if (encode_picture(s, s->picture_number) < 0)
1479 avctx->header_bits = s->header_bits;
1480 avctx->mv_bits = s->mv_bits;
1481 avctx->misc_bits = s->misc_bits;
1482 avctx->i_tex_bits = s->i_tex_bits;
1483 avctx->p_tex_bits = s->p_tex_bits;
1484 avctx->i_count = s->i_count;
1485 // FIXME f/b_count in avctx
1486 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1487 avctx->skip_count = s->skip_count;
1489 ff_MPV_frame_end(s);
1491 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1492 ff_mjpeg_encode_picture_trailer(s);
1494 if (avctx->rc_buffer_size) {
1495 RateControlContext *rcc = &s->rc_context;
1496 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1498 if (put_bits_count(&s->pb) > max_size &&
1499 s->lambda < s->avctx->lmax) {
1500 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1501 (s->qscale + 1) / s->qscale);
1502 if (s->adaptive_quant) {
1504 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1505 s->lambda_table[i] =
1506 FFMAX(s->lambda_table[i] + 1,
1507 s->lambda_table[i] * (s->qscale + 1) /
1510 s->mb_skipped = 0; // done in MPV_frame_start()
1511 // done in encode_picture() so we must undo it
1512 if (s->pict_type == AV_PICTURE_TYPE_P) {
1513 if (s->flipflop_rounding ||
1514 s->codec_id == AV_CODEC_ID_H263P ||
1515 s->codec_id == AV_CODEC_ID_MPEG4)
1516 s->no_rounding ^= 1;
1518 if (s->pict_type != AV_PICTURE_TYPE_B) {
1519 s->time_base = s->last_time_base;
1520 s->last_non_b_time = s->time - s->pp_time;
1522 for (i = 0; i < context_count; i++) {
1523 PutBitContext *pb = &s->thread_context[i]->pb;
1524 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1529 assert(s->avctx->rc_max_rate);
1532 if (s->flags & CODEC_FLAG_PASS1)
1533 ff_write_pass1_stats(s);
1535 for (i = 0; i < 4; i++) {
1536 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1537 avctx->error[i] += s->current_picture_ptr->f.error[i];
1540 if (s->flags & CODEC_FLAG_PASS1)
1541 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1542 avctx->i_tex_bits + avctx->p_tex_bits ==
1543 put_bits_count(&s->pb));
1544 flush_put_bits(&s->pb);
1545 s->frame_bits = put_bits_count(&s->pb);
1547 stuffing_count = ff_vbv_update(s, s->frame_bits);
1548 s->stuffing_bits = 8*stuffing_count;
1549 if (stuffing_count) {
1550 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1551 stuffing_count + 50) {
1552 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1556 switch (s->codec_id) {
1557 case AV_CODEC_ID_MPEG1VIDEO:
1558 case AV_CODEC_ID_MPEG2VIDEO:
1559 while (stuffing_count--) {
1560 put_bits(&s->pb, 8, 0);
1563 case AV_CODEC_ID_MPEG4:
1564 put_bits(&s->pb, 16, 0);
1565 put_bits(&s->pb, 16, 0x1C3);
1566 stuffing_count -= 4;
1567 while (stuffing_count--) {
1568 put_bits(&s->pb, 8, 0xFF);
1572 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1574 flush_put_bits(&s->pb);
1575 s->frame_bits = put_bits_count(&s->pb);
1578 /* update mpeg1/2 vbv_delay for CBR */
1579 if (s->avctx->rc_max_rate &&
1580 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1581 s->out_format == FMT_MPEG1 &&
1582 90000LL * (avctx->rc_buffer_size - 1) <=
1583 s->avctx->rc_max_rate * 0xFFFFLL) {
1584 int vbv_delay, min_delay;
1585 double inbits = s->avctx->rc_max_rate *
1586 av_q2d(s->avctx->time_base);
1587 int minbits = s->frame_bits - 8 *
1588 (s->vbv_delay_ptr - s->pb.buf - 1);
1589 double bits = s->rc_context.buffer_index + minbits - inbits;
1592 av_log(s->avctx, AV_LOG_ERROR,
1593 "Internal error, negative bits\n");
1595 assert(s->repeat_first_field == 0);
1597 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1598 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1599 s->avctx->rc_max_rate;
1601 vbv_delay = FFMAX(vbv_delay, min_delay);
1603 av_assert0(vbv_delay < 0xFFFF);
1605 s->vbv_delay_ptr[0] &= 0xF8;
1606 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1607 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1608 s->vbv_delay_ptr[2] &= 0x07;
1609 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1610 avctx->vbv_delay = vbv_delay * 300;
1612 s->total_bits += s->frame_bits;
1613 avctx->frame_bits = s->frame_bits;
1615 pkt->pts = s->current_picture.f.pts;
1616 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1617 if (!s->current_picture.f.coded_picture_number)
1618 pkt->dts = pkt->pts - s->dts_delta;
1620 pkt->dts = s->reordered_pts;
1621 s->reordered_pts = pkt->pts;
1623 pkt->dts = pkt->pts;
1624 if (s->current_picture.f.key_frame)
1625 pkt->flags |= AV_PKT_FLAG_KEY;
1627 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1632 /* release non-reference frames */
1633 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1634 if (!s->picture[i].reference)
1635 ff_mpeg_unref_picture(s, &s->picture[i]);
1638 assert((s->frame_bits & 7) == 0);
1640 pkt->size = s->frame_bits / 8;
1641 *got_packet = !!pkt->size;
1645 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1646 int n, int threshold)
1648 static const char tab[64] = {
1649 3, 2, 2, 1, 1, 1, 1, 1,
1650 1, 1, 1, 1, 1, 1, 1, 1,
1651 1, 1, 1, 1, 1, 1, 1, 1,
1652 0, 0, 0, 0, 0, 0, 0, 0,
1653 0, 0, 0, 0, 0, 0, 0, 0,
1654 0, 0, 0, 0, 0, 0, 0, 0,
1655 0, 0, 0, 0, 0, 0, 0, 0,
1656 0, 0, 0, 0, 0, 0, 0, 0
1661 int16_t *block = s->block[n];
1662 const int last_index = s->block_last_index[n];
1665 if (threshold < 0) {
1667 threshold = -threshold;
1671 /* Are all we could set to zero already zero? */
1672 if (last_index <= skip_dc - 1)
1675 for (i = 0; i <= last_index; i++) {
1676 const int j = s->intra_scantable.permutated[i];
1677 const int level = FFABS(block[j]);
1679 if (skip_dc && i == 0)
1683 } else if (level > 1) {
1689 if (score >= threshold)
1691 for (i = skip_dc; i <= last_index; i++) {
1692 const int j = s->intra_scantable.permutated[i];
1696 s->block_last_index[n] = 0;
1698 s->block_last_index[n] = -1;
1701 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1705 const int maxlevel = s->max_qcoeff;
1706 const int minlevel = s->min_qcoeff;
1710 i = 1; // skip clipping of intra dc
1714 for (; i <= last_index; i++) {
1715 const int j = s->intra_scantable.permutated[i];
1716 int level = block[j];
1718 if (level > maxlevel) {
1721 } else if (level < minlevel) {
1729 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1730 av_log(s->avctx, AV_LOG_INFO,
1731 "warning, clipping %d dct coefficients to %d..%d\n",
1732 overflow, minlevel, maxlevel);
1735 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1739 for (y = 0; y < 8; y++) {
1740 for (x = 0; x < 8; x++) {
1746 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1747 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1748 int v = ptr[x2 + y2 * stride];
1754 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1759 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1760 int motion_x, int motion_y,
1761 int mb_block_height,
1765 int16_t weight[12][64];
1766 int16_t orig[12][64];
1767 const int mb_x = s->mb_x;
1768 const int mb_y = s->mb_y;
1771 int dct_offset = s->linesize * 8; // default for progressive frames
1772 int uv_dct_offset = s->uvlinesize * 8;
1773 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1774 ptrdiff_t wrap_y, wrap_c;
1776 for (i = 0; i < mb_block_count; i++)
1777 skip_dct[i] = s->skipdct;
1779 if (s->adaptive_quant) {
1780 const int last_qp = s->qscale;
1781 const int mb_xy = mb_x + mb_y * s->mb_stride;
1783 s->lambda = s->lambda_table[mb_xy];
1786 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1787 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1788 s->dquant = s->qscale - last_qp;
1790 if (s->out_format == FMT_H263) {
1791 s->dquant = av_clip(s->dquant, -2, 2);
1793 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1795 if (s->pict_type == AV_PICTURE_TYPE_B) {
1796 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1799 if (s->mv_type == MV_TYPE_8X8)
1805 ff_set_qscale(s, last_qp + s->dquant);
1806 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1807 ff_set_qscale(s, s->qscale + s->dquant);
1809 wrap_y = s->linesize;
1810 wrap_c = s->uvlinesize;
1811 ptr_y = s->new_picture.f.data[0] +
1812 (mb_y * 16 * wrap_y) + mb_x * 16;
1813 ptr_cb = s->new_picture.f.data[1] +
1814 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1815 ptr_cr = s->new_picture.f.data[2] +
1816 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1818 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1819 uint8_t *ebuf = s->edge_emu_buffer + 32;
1820 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1821 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1822 s->vdsp.emulated_edge_mc(ebuf, wrap_y, ptr_y, wrap_y, 16, 16, mb_x * 16,
1823 mb_y * 16, s->width, s->height);
1825 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, wrap_c, ptr_cb, wrap_c, mb_block_width,
1826 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1828 ptr_cb = ebuf + 18 * wrap_y;
1829 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, wrap_c, ptr_cr, wrap_c, mb_block_width,
1830 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1832 ptr_cr = ebuf + 18 * wrap_y + 16;
1836 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1837 int progressive_score, interlaced_score;
1839 s->interlaced_dct = 0;
1840 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1842 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1843 NULL, wrap_y, 8) - 400;
1845 if (progressive_score > 0) {
1846 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1847 NULL, wrap_y * 2, 8) +
1848 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1849 NULL, wrap_y * 2, 8);
1850 if (progressive_score > interlaced_score) {
1851 s->interlaced_dct = 1;
1853 dct_offset = wrap_y;
1854 uv_dct_offset = wrap_c;
1856 if (s->chroma_format == CHROMA_422 ||
1857 s->chroma_format == CHROMA_444)
1863 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1864 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1865 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1866 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1868 if (s->flags & CODEC_FLAG_GRAY) {
1872 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1873 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1874 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1875 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1876 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1877 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1878 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1879 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1880 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1881 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1882 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1883 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1887 op_pixels_func (*op_pix)[4];
1888 qpel_mc_func (*op_qpix)[16];
1889 uint8_t *dest_y, *dest_cb, *dest_cr;
1891 dest_y = s->dest[0];
1892 dest_cb = s->dest[1];
1893 dest_cr = s->dest[2];
1895 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1896 op_pix = s->hdsp.put_pixels_tab;
1897 op_qpix = s->dsp.put_qpel_pixels_tab;
1899 op_pix = s->hdsp.put_no_rnd_pixels_tab;
1900 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1903 if (s->mv_dir & MV_DIR_FORWARD) {
1904 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1905 s->last_picture.f.data,
1907 op_pix = s->hdsp.avg_pixels_tab;
1908 op_qpix = s->dsp.avg_qpel_pixels_tab;
1910 if (s->mv_dir & MV_DIR_BACKWARD) {
1911 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1912 s->next_picture.f.data,
1916 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1917 int progressive_score, interlaced_score;
1919 s->interlaced_dct = 0;
1920 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1923 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1924 ptr_y + wrap_y * 8, wrap_y,
1927 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1928 progressive_score -= 400;
1930 if (progressive_score > 0) {
1931 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1934 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1938 if (progressive_score > interlaced_score) {
1939 s->interlaced_dct = 1;
1941 dct_offset = wrap_y;
1942 uv_dct_offset = wrap_c;
1944 if (s->chroma_format == CHROMA_422)
1950 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1951 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1952 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1953 dest_y + dct_offset, wrap_y);
1954 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1955 dest_y + dct_offset + 8, wrap_y);
1957 if (s->flags & CODEC_FLAG_GRAY) {
1961 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1962 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1963 if (!s->chroma_y_shift) { /* 422 */
1964 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
1965 dest_cb + uv_dct_offset, wrap_c);
1966 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
1967 dest_cr + uv_dct_offset, wrap_c);
1970 /* pre quantization */
1971 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1972 2 * s->qscale * s->qscale) {
1974 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1975 wrap_y, 8) < 20 * s->qscale)
1977 if (s->dsp.sad[1](NULL, ptr_y + 8,
1978 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1980 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1981 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1983 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1984 dest_y + dct_offset + 8,
1985 wrap_y, 8) < 20 * s->qscale)
1987 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1988 wrap_c, 8) < 20 * s->qscale)
1990 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1991 wrap_c, 8) < 20 * s->qscale)
1993 if (!s->chroma_y_shift) { /* 422 */
1994 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
1995 dest_cb + uv_dct_offset,
1996 wrap_c, 8) < 20 * s->qscale)
1998 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
1999 dest_cr + uv_dct_offset,
2000 wrap_c, 8) < 20 * s->qscale)
2006 if (s->quantizer_noise_shaping) {
2008 get_visual_weight(weight[0], ptr_y , wrap_y);
2010 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2012 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2014 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2016 get_visual_weight(weight[4], ptr_cb , wrap_c);
2018 get_visual_weight(weight[5], ptr_cr , wrap_c);
2019 if (!s->chroma_y_shift) { /* 422 */
2021 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2024 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2027 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2030 /* DCT & quantize */
2031 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2033 for (i = 0; i < mb_block_count; i++) {
2036 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2037 // FIXME we could decide to change to quantizer instead of
2039 // JS: I don't think that would be a good idea it could lower
2040 // quality instead of improve it. Just INTRADC clipping
2041 // deserves changes in quantizer
2043 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2045 s->block_last_index[i] = -1;
2047 if (s->quantizer_noise_shaping) {
2048 for (i = 0; i < mb_block_count; i++) {
2050 s->block_last_index[i] =
2051 dct_quantize_refine(s, s->block[i], weight[i],
2052 orig[i], i, s->qscale);
2057 if (s->luma_elim_threshold && !s->mb_intra)
2058 for (i = 0; i < 4; i++)
2059 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2060 if (s->chroma_elim_threshold && !s->mb_intra)
2061 for (i = 4; i < mb_block_count; i++)
2062 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2064 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2065 for (i = 0; i < mb_block_count; i++) {
2066 if (s->block_last_index[i] == -1)
2067 s->coded_score[i] = INT_MAX / 256;
2072 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2073 s->block_last_index[4] =
2074 s->block_last_index[5] = 0;
2076 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2077 if (!s->chroma_y_shift) { /* 422 / 444 */
2078 for (i=6; i<12; i++) {
2079 s->block_last_index[i] = 0;
2080 s->block[i][0] = s->block[4][0];
2085 // non c quantize code returns incorrect block_last_index FIXME
2086 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2087 for (i = 0; i < mb_block_count; i++) {
2089 if (s->block_last_index[i] > 0) {
2090 for (j = 63; j > 0; j--) {
2091 if (s->block[i][s->intra_scantable.permutated[j]])
2094 s->block_last_index[i] = j;
2099 /* huffman encode */
2100 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2101 case AV_CODEC_ID_MPEG1VIDEO:
2102 case AV_CODEC_ID_MPEG2VIDEO:
2103 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2104 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2106 case AV_CODEC_ID_MPEG4:
2107 if (CONFIG_MPEG4_ENCODER)
2108 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2110 case AV_CODEC_ID_MSMPEG4V2:
2111 case AV_CODEC_ID_MSMPEG4V3:
2112 case AV_CODEC_ID_WMV1:
2113 if (CONFIG_MSMPEG4_ENCODER)
2114 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2116 case AV_CODEC_ID_WMV2:
2117 if (CONFIG_WMV2_ENCODER)
2118 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2120 case AV_CODEC_ID_H261:
2121 if (CONFIG_H261_ENCODER)
2122 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2124 case AV_CODEC_ID_H263:
2125 case AV_CODEC_ID_H263P:
2126 case AV_CODEC_ID_FLV1:
2127 case AV_CODEC_ID_RV10:
2128 case AV_CODEC_ID_RV20:
2129 if (CONFIG_H263_ENCODER)
2130 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2132 case AV_CODEC_ID_MJPEG:
2133 case AV_CODEC_ID_AMV:
2134 if (CONFIG_MJPEG_ENCODER)
2135 ff_mjpeg_encode_mb(s, s->block);
2142 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2144 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2145 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2146 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2149 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2152 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2155 d->mb_skip_run= s->mb_skip_run;
2157 d->last_dc[i] = s->last_dc[i];
2160 d->mv_bits= s->mv_bits;
2161 d->i_tex_bits= s->i_tex_bits;
2162 d->p_tex_bits= s->p_tex_bits;
2163 d->i_count= s->i_count;
2164 d->f_count= s->f_count;
2165 d->b_count= s->b_count;
2166 d->skip_count= s->skip_count;
2167 d->misc_bits= s->misc_bits;
2171 d->qscale= s->qscale;
2172 d->dquant= s->dquant;
2174 d->esc3_level_length= s->esc3_level_length;
2177 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2180 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2181 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2184 d->mb_skip_run= s->mb_skip_run;
2186 d->last_dc[i] = s->last_dc[i];
2189 d->mv_bits= s->mv_bits;
2190 d->i_tex_bits= s->i_tex_bits;
2191 d->p_tex_bits= s->p_tex_bits;
2192 d->i_count= s->i_count;
2193 d->f_count= s->f_count;
2194 d->b_count= s->b_count;
2195 d->skip_count= s->skip_count;
2196 d->misc_bits= s->misc_bits;
2198 d->mb_intra= s->mb_intra;
2199 d->mb_skipped= s->mb_skipped;
2200 d->mv_type= s->mv_type;
2201 d->mv_dir= s->mv_dir;
2203 if(s->data_partitioning){
2205 d->tex_pb= s->tex_pb;
2209 d->block_last_index[i]= s->block_last_index[i];
2210 d->interlaced_dct= s->interlaced_dct;
2211 d->qscale= s->qscale;
2213 d->esc3_level_length= s->esc3_level_length;
2216 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2217 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2218 int *dmin, int *next_block, int motion_x, int motion_y)
2221 uint8_t *dest_backup[3];
2223 copy_context_before_encode(s, backup, type);
2225 s->block= s->blocks[*next_block];
2226 s->pb= pb[*next_block];
2227 if(s->data_partitioning){
2228 s->pb2 = pb2 [*next_block];
2229 s->tex_pb= tex_pb[*next_block];
2233 memcpy(dest_backup, s->dest, sizeof(s->dest));
2234 s->dest[0] = s->rd_scratchpad;
2235 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2236 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2237 assert(s->linesize >= 32); //FIXME
2240 encode_mb(s, motion_x, motion_y);
2242 score= put_bits_count(&s->pb);
2243 if(s->data_partitioning){
2244 score+= put_bits_count(&s->pb2);
2245 score+= put_bits_count(&s->tex_pb);
2248 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2249 ff_MPV_decode_mb(s, s->block);
2251 score *= s->lambda2;
2252 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2256 memcpy(s->dest, dest_backup, sizeof(s->dest));
2263 copy_context_after_encode(best, s, type);
2267 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2268 uint32_t *sq = ff_squareTbl + 256;
2273 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2274 else if(w==8 && h==8)
2275 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2279 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2288 static int sse_mb(MpegEncContext *s){
2292 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2293 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2296 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2297 return s->dsp.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)
2298 +s->dsp.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)
2299 +s->dsp.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);
2301 return s->dsp.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)
2302 +s->dsp.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)
2303 +s->dsp.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);
2306 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)
2307 +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)
2308 +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);
2311 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2312 MpegEncContext *s= *(void**)arg;
2316 s->me.dia_size= s->avctx->pre_dia_size;
2317 s->first_slice_line=1;
2318 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2319 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2320 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2322 s->first_slice_line=0;
2330 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2331 MpegEncContext *s= *(void**)arg;
2333 ff_check_alignment();
2335 s->me.dia_size= s->avctx->dia_size;
2336 s->first_slice_line=1;
2337 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2338 s->mb_x=0; //for block init below
2339 ff_init_block_index(s);
2340 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2341 s->block_index[0]+=2;
2342 s->block_index[1]+=2;
2343 s->block_index[2]+=2;
2344 s->block_index[3]+=2;
2346 /* compute motion vector & mb_type and store in context */
2347 if(s->pict_type==AV_PICTURE_TYPE_B)
2348 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2350 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2352 s->first_slice_line=0;
2357 static int mb_var_thread(AVCodecContext *c, void *arg){
2358 MpegEncContext *s= *(void**)arg;
2361 ff_check_alignment();
2363 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2364 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2367 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2369 int sum = s->dsp.pix_sum(pix, s->linesize);
2371 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2373 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2374 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2375 s->me.mb_var_sum_temp += varc;
2381 static void write_slice_end(MpegEncContext *s){
2382 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2383 if(s->partitioned_frame){
2384 ff_mpeg4_merge_partitions(s);
2387 ff_mpeg4_stuffing(&s->pb);
2388 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2389 ff_mjpeg_encode_stuffing(s);
2392 avpriv_align_put_bits(&s->pb);
2393 flush_put_bits(&s->pb);
2395 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2396 s->misc_bits+= get_bits_diff(s);
2399 static void write_mb_info(MpegEncContext *s)
2401 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2402 int offset = put_bits_count(&s->pb);
2403 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2404 int gobn = s->mb_y / s->gob_index;
2406 if (CONFIG_H263_ENCODER)
2407 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2408 bytestream_put_le32(&ptr, offset);
2409 bytestream_put_byte(&ptr, s->qscale);
2410 bytestream_put_byte(&ptr, gobn);
2411 bytestream_put_le16(&ptr, mba);
2412 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2413 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2414 /* 4MV not implemented */
2415 bytestream_put_byte(&ptr, 0); /* hmv2 */
2416 bytestream_put_byte(&ptr, 0); /* vmv2 */
2419 static void update_mb_info(MpegEncContext *s, int startcode)
2423 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2424 s->mb_info_size += 12;
2425 s->prev_mb_info = s->last_mb_info;
2428 s->prev_mb_info = put_bits_count(&s->pb)/8;
2429 /* This might have incremented mb_info_size above, and we return without
2430 * actually writing any info into that slot yet. But in that case,
2431 * this will be called again at the start of the after writing the
2432 * start code, actually writing the mb info. */
2436 s->last_mb_info = put_bits_count(&s->pb)/8;
2437 if (!s->mb_info_size)
2438 s->mb_info_size += 12;
2442 static int encode_thread(AVCodecContext *c, void *arg){
2443 MpegEncContext *s= *(void**)arg;
2444 int mb_x, mb_y, pdif = 0;
2445 int chr_h= 16>>s->chroma_y_shift;
2447 MpegEncContext best_s, backup_s;
2448 uint8_t bit_buf[2][MAX_MB_BYTES];
2449 uint8_t bit_buf2[2][MAX_MB_BYTES];
2450 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2451 PutBitContext pb[2], pb2[2], tex_pb[2];
2453 ff_check_alignment();
2456 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2457 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2458 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2461 s->last_bits= put_bits_count(&s->pb);
2472 /* init last dc values */
2473 /* note: quant matrix value (8) is implied here */
2474 s->last_dc[i] = 128 << s->intra_dc_precision;
2476 s->current_picture.f.error[i] = 0;
2478 if(s->codec_id==AV_CODEC_ID_AMV){
2479 s->last_dc[0] = 128*8/13;
2480 s->last_dc[1] = 128*8/14;
2481 s->last_dc[2] = 128*8/14;
2484 memset(s->last_mv, 0, sizeof(s->last_mv));
2488 switch(s->codec_id){
2489 case AV_CODEC_ID_H263:
2490 case AV_CODEC_ID_H263P:
2491 case AV_CODEC_ID_FLV1:
2492 if (CONFIG_H263_ENCODER)
2493 s->gob_index = ff_h263_get_gob_height(s);
2495 case AV_CODEC_ID_MPEG4:
2496 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2497 ff_mpeg4_init_partitions(s);
2503 s->first_slice_line = 1;
2504 s->ptr_lastgob = s->pb.buf;
2505 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2509 ff_set_qscale(s, s->qscale);
2510 ff_init_block_index(s);
2512 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2513 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2514 int mb_type= s->mb_type[xy];
2519 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2520 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2523 if(s->data_partitioning){
2524 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2525 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2526 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2532 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2533 ff_update_block_index(s);
2535 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2536 ff_h261_reorder_mb_index(s);
2537 xy= s->mb_y*s->mb_stride + s->mb_x;
2538 mb_type= s->mb_type[xy];
2541 /* write gob / video packet header */
2543 int current_packet_size, is_gob_start;
2545 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2547 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2549 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2551 switch(s->codec_id){
2552 case AV_CODEC_ID_H263:
2553 case AV_CODEC_ID_H263P:
2554 if(!s->h263_slice_structured)
2555 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2557 case AV_CODEC_ID_MPEG2VIDEO:
2558 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2559 case AV_CODEC_ID_MPEG1VIDEO:
2560 if(s->mb_skip_run) is_gob_start=0;
2562 case AV_CODEC_ID_MJPEG:
2563 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2568 if(s->start_mb_y != mb_y || mb_x!=0){
2570 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2571 ff_mpeg4_init_partitions(s);
2575 av_assert2((put_bits_count(&s->pb)&7) == 0);
2576 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2578 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2579 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2580 int d= 100 / s->avctx->error_rate;
2582 current_packet_size=0;
2583 s->pb.buf_ptr= s->ptr_lastgob;
2584 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2588 if (s->avctx->rtp_callback){
2589 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2590 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2592 update_mb_info(s, 1);
2594 switch(s->codec_id){
2595 case AV_CODEC_ID_MPEG4:
2596 if (CONFIG_MPEG4_ENCODER) {
2597 ff_mpeg4_encode_video_packet_header(s);
2598 ff_mpeg4_clean_buffers(s);
2601 case AV_CODEC_ID_MPEG1VIDEO:
2602 case AV_CODEC_ID_MPEG2VIDEO:
2603 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2604 ff_mpeg1_encode_slice_header(s);
2605 ff_mpeg1_clean_buffers(s);
2608 case AV_CODEC_ID_H263:
2609 case AV_CODEC_ID_H263P:
2610 if (CONFIG_H263_ENCODER)
2611 ff_h263_encode_gob_header(s, mb_y);
2615 if(s->flags&CODEC_FLAG_PASS1){
2616 int bits= put_bits_count(&s->pb);
2617 s->misc_bits+= bits - s->last_bits;
2621 s->ptr_lastgob += current_packet_size;
2622 s->first_slice_line=1;
2623 s->resync_mb_x=mb_x;
2624 s->resync_mb_y=mb_y;
2628 if( (s->resync_mb_x == s->mb_x)
2629 && s->resync_mb_y+1 == s->mb_y){
2630 s->first_slice_line=0;
2634 s->dquant=0; //only for QP_RD
2636 update_mb_info(s, 0);
2638 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
2640 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2642 copy_context_before_encode(&backup_s, s, -1);
2644 best_s.data_partitioning= s->data_partitioning;
2645 best_s.partitioned_frame= s->partitioned_frame;
2646 if(s->data_partitioning){
2647 backup_s.pb2= s->pb2;
2648 backup_s.tex_pb= s->tex_pb;
2651 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2652 s->mv_dir = MV_DIR_FORWARD;
2653 s->mv_type = MV_TYPE_16X16;
2655 s->mv[0][0][0] = s->p_mv_table[xy][0];
2656 s->mv[0][0][1] = s->p_mv_table[xy][1];
2657 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2658 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2660 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2661 s->mv_dir = MV_DIR_FORWARD;
2662 s->mv_type = MV_TYPE_FIELD;
2665 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2666 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2667 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2669 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2670 &dmin, &next_block, 0, 0);
2672 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2673 s->mv_dir = MV_DIR_FORWARD;
2674 s->mv_type = MV_TYPE_16X16;
2678 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2679 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2681 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2682 s->mv_dir = MV_DIR_FORWARD;
2683 s->mv_type = MV_TYPE_8X8;
2686 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2687 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2689 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2690 &dmin, &next_block, 0, 0);
2692 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2693 s->mv_dir = MV_DIR_FORWARD;
2694 s->mv_type = MV_TYPE_16X16;
2696 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2697 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2698 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2699 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2701 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2702 s->mv_dir = MV_DIR_BACKWARD;
2703 s->mv_type = MV_TYPE_16X16;
2705 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2706 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2707 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2708 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2710 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2711 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2712 s->mv_type = MV_TYPE_16X16;
2714 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2715 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2716 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2717 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2718 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2719 &dmin, &next_block, 0, 0);
2721 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2722 s->mv_dir = MV_DIR_FORWARD;
2723 s->mv_type = MV_TYPE_FIELD;
2726 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2727 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2728 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2730 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2731 &dmin, &next_block, 0, 0);
2733 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2734 s->mv_dir = MV_DIR_BACKWARD;
2735 s->mv_type = MV_TYPE_FIELD;
2738 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2739 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2740 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2742 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2743 &dmin, &next_block, 0, 0);
2745 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2746 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2747 s->mv_type = MV_TYPE_FIELD;
2749 for(dir=0; dir<2; dir++){
2751 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2752 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2753 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2756 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2757 &dmin, &next_block, 0, 0);
2759 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2761 s->mv_type = MV_TYPE_16X16;
2765 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2766 &dmin, &next_block, 0, 0);
2767 if(s->h263_pred || s->h263_aic){
2769 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2771 ff_clean_intra_table_entries(s); //old mode?
2775 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2776 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2777 const int last_qp= backup_s.qscale;
2780 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2781 static const int dquant_tab[4]={-1,1,-2,2};
2782 int storecoefs = s->mb_intra && s->dc_val[0];
2784 av_assert2(backup_s.dquant == 0);
2787 s->mv_dir= best_s.mv_dir;
2788 s->mv_type = MV_TYPE_16X16;
2789 s->mb_intra= best_s.mb_intra;
2790 s->mv[0][0][0] = best_s.mv[0][0][0];
2791 s->mv[0][0][1] = best_s.mv[0][0][1];
2792 s->mv[1][0][0] = best_s.mv[1][0][0];
2793 s->mv[1][0][1] = best_s.mv[1][0][1];
2795 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2796 for(; qpi<4; qpi++){
2797 int dquant= dquant_tab[qpi];
2798 qp= last_qp + dquant;
2799 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2801 backup_s.dquant= dquant;
2804 dc[i]= s->dc_val[0][ s->block_index[i] ];
2805 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2809 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2810 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2811 if(best_s.qscale != qp){
2814 s->dc_val[0][ s->block_index[i] ]= dc[i];
2815 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2822 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2823 int mx= s->b_direct_mv_table[xy][0];
2824 int my= s->b_direct_mv_table[xy][1];
2826 backup_s.dquant = 0;
2827 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2829 ff_mpeg4_set_direct_mv(s, mx, my);
2830 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2831 &dmin, &next_block, mx, my);
2833 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2834 backup_s.dquant = 0;
2835 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2837 ff_mpeg4_set_direct_mv(s, 0, 0);
2838 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2839 &dmin, &next_block, 0, 0);
2841 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2844 coded |= s->block_last_index[i];
2847 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2848 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2849 mx=my=0; //FIXME find the one we actually used
2850 ff_mpeg4_set_direct_mv(s, mx, my);
2851 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2859 s->mv_dir= best_s.mv_dir;
2860 s->mv_type = best_s.mv_type;
2862 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2863 s->mv[0][0][1] = best_s.mv[0][0][1];
2864 s->mv[1][0][0] = best_s.mv[1][0][0];
2865 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2868 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2869 &dmin, &next_block, mx, my);
2874 s->current_picture.qscale_table[xy] = best_s.qscale;
2876 copy_context_after_encode(s, &best_s, -1);
2878 pb_bits_count= put_bits_count(&s->pb);
2879 flush_put_bits(&s->pb);
2880 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2883 if(s->data_partitioning){
2884 pb2_bits_count= put_bits_count(&s->pb2);
2885 flush_put_bits(&s->pb2);
2886 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2887 s->pb2= backup_s.pb2;
2889 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2890 flush_put_bits(&s->tex_pb);
2891 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2892 s->tex_pb= backup_s.tex_pb;
2894 s->last_bits= put_bits_count(&s->pb);
2896 if (CONFIG_H263_ENCODER &&
2897 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2898 ff_h263_update_motion_val(s);
2900 if(next_block==0){ //FIXME 16 vs linesize16
2901 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2902 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2903 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2906 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2907 ff_MPV_decode_mb(s, s->block);
2909 int motion_x = 0, motion_y = 0;
2910 s->mv_type=MV_TYPE_16X16;
2911 // only one MB-Type possible
2914 case CANDIDATE_MB_TYPE_INTRA:
2917 motion_x= s->mv[0][0][0] = 0;
2918 motion_y= s->mv[0][0][1] = 0;
2920 case CANDIDATE_MB_TYPE_INTER:
2921 s->mv_dir = MV_DIR_FORWARD;
2923 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2924 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2926 case CANDIDATE_MB_TYPE_INTER_I:
2927 s->mv_dir = MV_DIR_FORWARD;
2928 s->mv_type = MV_TYPE_FIELD;
2931 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2932 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2933 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2936 case CANDIDATE_MB_TYPE_INTER4V:
2937 s->mv_dir = MV_DIR_FORWARD;
2938 s->mv_type = MV_TYPE_8X8;
2941 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2942 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2945 case CANDIDATE_MB_TYPE_DIRECT:
2946 if (CONFIG_MPEG4_ENCODER) {
2947 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2949 motion_x=s->b_direct_mv_table[xy][0];
2950 motion_y=s->b_direct_mv_table[xy][1];
2951 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2954 case CANDIDATE_MB_TYPE_DIRECT0:
2955 if (CONFIG_MPEG4_ENCODER) {
2956 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2958 ff_mpeg4_set_direct_mv(s, 0, 0);
2961 case CANDIDATE_MB_TYPE_BIDIR:
2962 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2964 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2965 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2966 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2967 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2969 case CANDIDATE_MB_TYPE_BACKWARD:
2970 s->mv_dir = MV_DIR_BACKWARD;
2972 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2973 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2975 case CANDIDATE_MB_TYPE_FORWARD:
2976 s->mv_dir = MV_DIR_FORWARD;
2978 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2979 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2981 case CANDIDATE_MB_TYPE_FORWARD_I:
2982 s->mv_dir = MV_DIR_FORWARD;
2983 s->mv_type = MV_TYPE_FIELD;
2986 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2987 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2988 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2991 case CANDIDATE_MB_TYPE_BACKWARD_I:
2992 s->mv_dir = MV_DIR_BACKWARD;
2993 s->mv_type = MV_TYPE_FIELD;
2996 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2997 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2998 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3001 case CANDIDATE_MB_TYPE_BIDIR_I:
3002 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3003 s->mv_type = MV_TYPE_FIELD;
3005 for(dir=0; dir<2; dir++){
3007 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3008 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3009 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3014 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3017 encode_mb(s, motion_x, motion_y);
3019 // RAL: Update last macroblock type
3020 s->last_mv_dir = s->mv_dir;
3022 if (CONFIG_H263_ENCODER &&
3023 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3024 ff_h263_update_motion_val(s);
3026 ff_MPV_decode_mb(s, s->block);
3029 /* clean the MV table in IPS frames for direct mode in B frames */
3030 if(s->mb_intra /* && I,P,S_TYPE */){
3031 s->p_mv_table[xy][0]=0;
3032 s->p_mv_table[xy][1]=0;
3035 if(s->flags&CODEC_FLAG_PSNR){
3039 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3040 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3042 s->current_picture.f.error[0] += sse(
3043 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3044 s->dest[0], w, h, s->linesize);
3045 s->current_picture.f.error[1] += sse(
3046 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3047 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3048 s->current_picture.f.error[2] += sse(
3049 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3050 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3053 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3054 ff_h263_loop_filter(s);
3056 av_dlog(s->avctx, "MB %d %d bits\n",
3057 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3061 //not beautiful here but we must write it before flushing so it has to be here
3062 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3063 ff_msmpeg4_encode_ext_header(s);
3067 /* Send the last GOB if RTP */
3068 if (s->avctx->rtp_callback) {
3069 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3070 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3071 /* Call the RTP callback to send the last GOB */
3073 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3079 #define MERGE(field) dst->field += src->field; src->field=0
3080 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3081 MERGE(me.scene_change_score);
3082 MERGE(me.mc_mb_var_sum_temp);
3083 MERGE(me.mb_var_sum_temp);
3086 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3089 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3090 MERGE(dct_count[1]);
3099 MERGE(er.error_count);
3100 MERGE(padding_bug_score);
3101 MERGE(current_picture.f.error[0]);
3102 MERGE(current_picture.f.error[1]);
3103 MERGE(current_picture.f.error[2]);
3105 if(dst->avctx->noise_reduction){
3106 for(i=0; i<64; i++){
3107 MERGE(dct_error_sum[0][i]);
3108 MERGE(dct_error_sum[1][i]);
3112 assert(put_bits_count(&src->pb) % 8 ==0);
3113 assert(put_bits_count(&dst->pb) % 8 ==0);
3114 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3115 flush_put_bits(&dst->pb);
3118 static int estimate_qp(MpegEncContext *s, int dry_run){
3119 if (s->next_lambda){
3120 s->current_picture_ptr->f.quality =
3121 s->current_picture.f.quality = s->next_lambda;
3122 if(!dry_run) s->next_lambda= 0;
3123 } else if (!s->fixed_qscale) {
3124 s->current_picture_ptr->f.quality =
3125 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3126 if (s->current_picture.f.quality < 0)
3130 if(s->adaptive_quant){
3131 switch(s->codec_id){
3132 case AV_CODEC_ID_MPEG4:
3133 if (CONFIG_MPEG4_ENCODER)
3134 ff_clean_mpeg4_qscales(s);
3136 case AV_CODEC_ID_H263:
3137 case AV_CODEC_ID_H263P:
3138 case AV_CODEC_ID_FLV1:
3139 if (CONFIG_H263_ENCODER)
3140 ff_clean_h263_qscales(s);
3143 ff_init_qscale_tab(s);
3146 s->lambda= s->lambda_table[0];
3149 s->lambda = s->current_picture.f.quality;
3154 /* must be called before writing the header */
3155 static void set_frame_distances(MpegEncContext * s){
3156 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3157 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3159 if(s->pict_type==AV_PICTURE_TYPE_B){
3160 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3161 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3163 s->pp_time= s->time - s->last_non_b_time;
3164 s->last_non_b_time= s->time;
3165 assert(s->picture_number==0 || s->pp_time > 0);
3169 static int encode_picture(MpegEncContext *s, int picture_number)
3173 int context_count = s->slice_context_count;
3175 s->picture_number = picture_number;
3177 /* Reset the average MB variance */
3178 s->me.mb_var_sum_temp =
3179 s->me.mc_mb_var_sum_temp = 0;
3181 /* we need to initialize some time vars before we can encode b-frames */
3182 // RAL: Condition added for MPEG1VIDEO
3183 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3184 set_frame_distances(s);
3185 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3186 ff_set_mpeg4_time(s);
3188 s->me.scene_change_score=0;
3190 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3192 if(s->pict_type==AV_PICTURE_TYPE_I){
3193 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3194 else s->no_rounding=0;
3195 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3196 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3197 s->no_rounding ^= 1;
3200 if(s->flags & CODEC_FLAG_PASS2){
3201 if (estimate_qp(s,1) < 0)
3203 ff_get_2pass_fcode(s);
3204 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3205 if(s->pict_type==AV_PICTURE_TYPE_B)
3206 s->lambda= s->last_lambda_for[s->pict_type];
3208 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3212 if(s->codec_id != AV_CODEC_ID_AMV){
3213 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3214 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3215 s->q_chroma_intra_matrix = s->q_intra_matrix;
3216 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3219 s->mb_intra=0; //for the rate distortion & bit compare functions
3220 for(i=1; i<context_count; i++){
3221 ret = ff_update_duplicate_context(s->thread_context[i], s);
3229 /* Estimate motion for every MB */
3230 if(s->pict_type != AV_PICTURE_TYPE_I){
3231 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3232 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3233 if (s->pict_type != AV_PICTURE_TYPE_B) {
3234 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3235 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3239 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3240 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3242 for(i=0; i<s->mb_stride*s->mb_height; i++)
3243 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3245 if(!s->fixed_qscale){
3246 /* finding spatial complexity for I-frame rate control */
3247 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3250 for(i=1; i<context_count; i++){
3251 merge_context_after_me(s, s->thread_context[i]);
3253 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3254 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3257 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3258 s->pict_type= AV_PICTURE_TYPE_I;
3259 for(i=0; i<s->mb_stride*s->mb_height; i++)
3260 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3261 if(s->msmpeg4_version >= 3)
3263 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3264 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3268 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3269 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3271 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3273 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3274 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3275 s->f_code= FFMAX3(s->f_code, a, b);
3278 ff_fix_long_p_mvs(s);
3279 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3280 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3284 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3285 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3290 if(s->pict_type==AV_PICTURE_TYPE_B){
3293 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3294 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3295 s->f_code = FFMAX(a, b);
3297 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3298 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3299 s->b_code = FFMAX(a, b);
3301 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3302 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3303 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3304 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3305 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3307 for(dir=0; dir<2; dir++){
3310 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3311 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3312 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3313 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3321 if (estimate_qp(s, 0) < 0)
3324 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3325 s->qscale= 3; //reduce clipping problems
3327 if (s->out_format == FMT_MJPEG) {
3328 /* for mjpeg, we do include qscale in the matrix */
3330 int j= s->dsp.idct_permutation[i];
3332 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3334 s->y_dc_scale_table=
3335 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3336 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3337 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3338 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3341 if(s->codec_id == AV_CODEC_ID_AMV){
3342 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};
3343 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};
3345 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3347 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3348 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3350 s->y_dc_scale_table= y;
3351 s->c_dc_scale_table= c;
3352 s->intra_matrix[0] = 13;
3353 s->chroma_intra_matrix[0] = 14;
3354 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3355 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3356 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3357 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3361 //FIXME var duplication
3362 s->current_picture_ptr->f.key_frame =
3363 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3364 s->current_picture_ptr->f.pict_type =
3365 s->current_picture.f.pict_type = s->pict_type;
3367 if (s->current_picture.f.key_frame)
3368 s->picture_in_gop_number=0;
3370 s->mb_x = s->mb_y = 0;
3371 s->last_bits= put_bits_count(&s->pb);
3372 switch(s->out_format) {
3374 if (CONFIG_MJPEG_ENCODER)
3375 ff_mjpeg_encode_picture_header(s);
3378 if (CONFIG_H261_ENCODER)
3379 ff_h261_encode_picture_header(s, picture_number);
3382 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3383 ff_wmv2_encode_picture_header(s, picture_number);
3384 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3385 ff_msmpeg4_encode_picture_header(s, picture_number);
3386 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3387 ff_mpeg4_encode_picture_header(s, picture_number);
3388 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3389 ff_rv10_encode_picture_header(s, picture_number);
3390 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3391 ff_rv20_encode_picture_header(s, picture_number);
3392 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3393 ff_flv_encode_picture_header(s, picture_number);
3394 else if (CONFIG_H263_ENCODER)
3395 ff_h263_encode_picture_header(s, picture_number);
3398 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3399 ff_mpeg1_encode_picture_header(s, picture_number);
3404 bits= put_bits_count(&s->pb);
3405 s->header_bits= bits - s->last_bits;
3407 for(i=1; i<context_count; i++){
3408 update_duplicate_context_after_me(s->thread_context[i], s);
3410 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3411 for(i=1; i<context_count; i++){
3412 merge_context_after_encode(s, s->thread_context[i]);
3418 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3419 const int intra= s->mb_intra;
3422 s->dct_count[intra]++;
3424 for(i=0; i<64; i++){
3425 int level= block[i];
3429 s->dct_error_sum[intra][i] += level;
3430 level -= s->dct_offset[intra][i];
3431 if(level<0) level=0;
3433 s->dct_error_sum[intra][i] -= level;
3434 level += s->dct_offset[intra][i];
3435 if(level>0) level=0;
3442 static int dct_quantize_trellis_c(MpegEncContext *s,
3443 int16_t *block, int n,
3444 int qscale, int *overflow){
3446 const uint8_t *scantable= s->intra_scantable.scantable;
3447 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3449 unsigned int threshold1, threshold2;
3461 int coeff_count[64];
3462 int qmul, qadd, start_i, last_non_zero, i, dc;
3463 const int esc_length= s->ac_esc_length;
3465 uint8_t * last_length;
3466 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3468 s->dsp.fdct (block);
3470 if(s->dct_error_sum)
3471 s->denoise_dct(s, block);
3473 qadd= ((qscale-1)|1)*8;
3484 /* For AIC we skip quant/dequant of INTRADC */
3489 /* note: block[0] is assumed to be positive */
3490 block[0] = (block[0] + (q >> 1)) / q;
3493 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3494 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3495 bias= 1<<(QMAT_SHIFT-1);
3496 length = s->intra_ac_vlc_length;
3497 last_length= s->intra_ac_vlc_last_length;
3501 qmat = s->q_inter_matrix[qscale];
3502 length = s->inter_ac_vlc_length;
3503 last_length= s->inter_ac_vlc_last_length;
3507 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3508 threshold2= (threshold1<<1);
3510 for(i=63; i>=start_i; i--) {
3511 const int j = scantable[i];
3512 int level = block[j] * qmat[j];
3514 if(((unsigned)(level+threshold1))>threshold2){
3520 for(i=start_i; i<=last_non_zero; i++) {
3521 const int j = scantable[i];
3522 int level = block[j] * qmat[j];
3524 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3525 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3526 if(((unsigned)(level+threshold1))>threshold2){
3528 level= (bias + level)>>QMAT_SHIFT;
3530 coeff[1][i]= level-1;
3531 // coeff[2][k]= level-2;
3533 level= (bias - level)>>QMAT_SHIFT;
3534 coeff[0][i]= -level;
3535 coeff[1][i]= -level+1;
3536 // coeff[2][k]= -level+2;
3538 coeff_count[i]= FFMIN(level, 2);
3539 av_assert2(coeff_count[i]);
3542 coeff[0][i]= (level>>31)|1;
3547 *overflow= s->max_qcoeff < max; //overflow might have happened
3549 if(last_non_zero < start_i){
3550 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3551 return last_non_zero;
3554 score_tab[start_i]= 0;
3555 survivor[0]= start_i;
3558 for(i=start_i; i<=last_non_zero; i++){
3559 int level_index, j, zero_distortion;
3560 int dct_coeff= FFABS(block[ scantable[i] ]);
3561 int best_score=256*256*256*120;
3563 if (s->dsp.fdct == ff_fdct_ifast)
3564 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3565 zero_distortion= dct_coeff*dct_coeff;
3567 for(level_index=0; level_index < coeff_count[i]; level_index++){
3569 int level= coeff[level_index][i];
3570 const int alevel= FFABS(level);
3575 if(s->out_format == FMT_H263){
3576 unquant_coeff= alevel*qmul + qadd;
3578 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3580 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3581 unquant_coeff = (unquant_coeff - 1) | 1;
3583 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3584 unquant_coeff = (unquant_coeff - 1) | 1;
3589 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3591 if((level&(~127)) == 0){
3592 for(j=survivor_count-1; j>=0; j--){
3593 int run= i - survivor[j];
3594 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3595 score += score_tab[i-run];
3597 if(score < best_score){
3600 level_tab[i+1]= level-64;
3604 if(s->out_format == FMT_H263){
3605 for(j=survivor_count-1; j>=0; j--){
3606 int run= i - survivor[j];
3607 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3608 score += score_tab[i-run];
3609 if(score < last_score){
3612 last_level= level-64;
3618 distortion += esc_length*lambda;
3619 for(j=survivor_count-1; j>=0; j--){
3620 int run= i - survivor[j];
3621 int score= distortion + score_tab[i-run];
3623 if(score < best_score){
3626 level_tab[i+1]= level-64;
3630 if(s->out_format == FMT_H263){
3631 for(j=survivor_count-1; j>=0; j--){
3632 int run= i - survivor[j];
3633 int score= distortion + score_tab[i-run];
3634 if(score < last_score){
3637 last_level= level-64;
3645 score_tab[i+1]= best_score;
3647 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3648 if(last_non_zero <= 27){
3649 for(; survivor_count; survivor_count--){
3650 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3654 for(; survivor_count; survivor_count--){
3655 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3660 survivor[ survivor_count++ ]= i+1;
3663 if(s->out_format != FMT_H263){
3664 last_score= 256*256*256*120;
3665 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3666 int score= score_tab[i];
3667 if(i) score += lambda*2; //FIXME exacter?
3669 if(score < last_score){
3672 last_level= level_tab[i];
3673 last_run= run_tab[i];
3678 s->coded_score[n] = last_score;
3680 dc= FFABS(block[0]);
3681 last_non_zero= last_i - 1;
3682 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3684 if(last_non_zero < start_i)
3685 return last_non_zero;
3687 if(last_non_zero == 0 && start_i == 0){
3689 int best_score= dc * dc;
3691 for(i=0; i<coeff_count[0]; i++){
3692 int level= coeff[i][0];
3693 int alevel= FFABS(level);
3694 int unquant_coeff, score, distortion;
3696 if(s->out_format == FMT_H263){
3697 unquant_coeff= (alevel*qmul + qadd)>>3;
3699 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3700 unquant_coeff = (unquant_coeff - 1) | 1;
3702 unquant_coeff = (unquant_coeff + 4) >> 3;
3703 unquant_coeff<<= 3 + 3;
3705 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3707 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3708 else score= distortion + esc_length*lambda;
3710 if(score < best_score){
3712 best_level= level - 64;
3715 block[0]= best_level;
3716 s->coded_score[n] = best_score - dc*dc;
3717 if(best_level == 0) return -1;
3718 else return last_non_zero;
3722 av_assert2(last_level);
3724 block[ perm_scantable[last_non_zero] ]= last_level;
3727 for(; i>start_i; i -= run_tab[i] + 1){
3728 block[ perm_scantable[i-1] ]= level_tab[i];
3731 return last_non_zero;
3734 //#define REFINE_STATS 1
3735 static int16_t basis[64][64];
3737 static void build_basis(uint8_t *perm){
3744 double s= 0.25*(1<<BASIS_SHIFT);
3746 int perm_index= perm[index];
3747 if(i==0) s*= sqrt(0.5);
3748 if(j==0) s*= sqrt(0.5);
3749 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)));
3756 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3757 int16_t *block, int16_t *weight, int16_t *orig,
3760 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3761 const uint8_t *scantable= s->intra_scantable.scantable;
3762 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3763 // unsigned int threshold1, threshold2;
3768 int qmul, qadd, start_i, last_non_zero, i, dc;
3770 uint8_t * last_length;
3772 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3775 static int after_last=0;
3776 static int to_zero=0;
3777 static int from_zero=0;
3780 static int messed_sign=0;
3783 if(basis[0][0] == 0)
3784 build_basis(s->dsp.idct_permutation);
3795 /* For AIC we skip quant/dequant of INTRADC */
3799 q <<= RECON_SHIFT-3;
3800 /* note: block[0] is assumed to be positive */
3802 // block[0] = (block[0] + (q >> 1)) / q;
3804 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3805 // bias= 1<<(QMAT_SHIFT-1);
3806 length = s->intra_ac_vlc_length;
3807 last_length= s->intra_ac_vlc_last_length;
3811 length = s->inter_ac_vlc_length;
3812 last_length= s->inter_ac_vlc_last_length;
3814 last_non_zero = s->block_last_index[n];
3819 dc += (1<<(RECON_SHIFT-1));
3820 for(i=0; i<64; i++){
3821 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3824 STOP_TIMER("memset rem[]")}
3827 for(i=0; i<64; i++){
3832 w= FFABS(weight[i]) + qns*one;
3833 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3836 // w=weight[i] = (63*qns + (w/2)) / w;
3839 av_assert2(w<(1<<6));
3842 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3848 for(i=start_i; i<=last_non_zero; i++){
3849 int j= perm_scantable[i];
3850 const int level= block[j];
3854 if(level<0) coeff= qmul*level - qadd;
3855 else coeff= qmul*level + qadd;
3856 run_tab[rle_index++]=run;
3859 s->dsp.add_8x8basis(rem, basis[j], coeff);
3865 if(last_non_zero>0){
3866 STOP_TIMER("init rem[]")
3873 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3876 int run2, best_unquant_change=0, analyze_gradient;
3880 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3882 if(analyze_gradient){
3886 for(i=0; i<64; i++){
3889 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3892 STOP_TIMER("rem*w*w")}
3902 const int level= block[0];
3903 int change, old_coeff;
3905 av_assert2(s->mb_intra);
3909 for(change=-1; change<=1; change+=2){
3910 int new_level= level + change;
3911 int score, new_coeff;
3913 new_coeff= q*new_level;
3914 if(new_coeff >= 2048 || new_coeff < 0)
3917 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3918 if(score<best_score){
3921 best_change= change;
3922 best_unquant_change= new_coeff - old_coeff;
3929 run2= run_tab[rle_index++];
3933 for(i=start_i; i<64; i++){
3934 int j= perm_scantable[i];
3935 const int level= block[j];
3936 int change, old_coeff;
3938 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3942 if(level<0) old_coeff= qmul*level - qadd;
3943 else old_coeff= qmul*level + qadd;
3944 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3948 av_assert2(run2>=0 || i >= last_non_zero );
3951 for(change=-1; change<=1; change+=2){
3952 int new_level= level + change;
3953 int score, new_coeff, unquant_change;
3956 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3960 if(new_level<0) new_coeff= qmul*new_level - qadd;
3961 else new_coeff= qmul*new_level + qadd;
3962 if(new_coeff >= 2048 || new_coeff <= -2048)
3964 //FIXME check for overflow
3967 if(level < 63 && level > -63){
3968 if(i < last_non_zero)
3969 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3970 - length[UNI_AC_ENC_INDEX(run, level+64)];
3972 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3973 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3976 av_assert2(FFABS(new_level)==1);
3978 if(analyze_gradient){
3979 int g= d1[ scantable[i] ];
3980 if(g && (g^new_level) >= 0)
3984 if(i < last_non_zero){
3985 int next_i= i + run2 + 1;
3986 int next_level= block[ perm_scantable[next_i] ] + 64;
3988 if(next_level&(~127))
3991 if(next_i < last_non_zero)
3992 score += length[UNI_AC_ENC_INDEX(run, 65)]
3993 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3994 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3996 score += length[UNI_AC_ENC_INDEX(run, 65)]
3997 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3998 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4000 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4002 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4003 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4009 av_assert2(FFABS(level)==1);
4011 if(i < last_non_zero){
4012 int next_i= i + run2 + 1;
4013 int next_level= block[ perm_scantable[next_i] ] + 64;
4015 if(next_level&(~127))
4018 if(next_i < last_non_zero)
4019 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4020 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4021 - length[UNI_AC_ENC_INDEX(run, 65)];
4023 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4024 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4025 - length[UNI_AC_ENC_INDEX(run, 65)];
4027 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4029 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4030 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4037 unquant_change= new_coeff - old_coeff;
4038 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4040 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4041 if(score<best_score){
4044 best_change= change;
4045 best_unquant_change= unquant_change;
4049 prev_level= level + 64;
4050 if(prev_level&(~127))
4059 STOP_TIMER("iterative step")}
4063 int j= perm_scantable[ best_coeff ];
4065 block[j] += best_change;
4067 if(best_coeff > last_non_zero){
4068 last_non_zero= best_coeff;
4069 av_assert2(block[j]);
4076 if(block[j] - best_change){
4077 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4089 for(; last_non_zero>=start_i; last_non_zero--){
4090 if(block[perm_scantable[last_non_zero]])
4096 if(256*256*256*64 % count == 0){
4097 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);
4102 for(i=start_i; i<=last_non_zero; i++){
4103 int j= perm_scantable[i];
4104 const int level= block[j];
4107 run_tab[rle_index++]=run;
4114 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4120 if(last_non_zero>0){
4121 STOP_TIMER("iterative search")
4126 return last_non_zero;
4129 int ff_dct_quantize_c(MpegEncContext *s,
4130 int16_t *block, int n,
4131 int qscale, int *overflow)
4133 int i, j, level, last_non_zero, q, start_i;
4135 const uint8_t *scantable= s->intra_scantable.scantable;
4138 unsigned int threshold1, threshold2;
4140 s->dsp.fdct (block);
4142 if(s->dct_error_sum)
4143 s->denoise_dct(s, block);
4153 /* For AIC we skip quant/dequant of INTRADC */
4156 /* note: block[0] is assumed to be positive */
4157 block[0] = (block[0] + (q >> 1)) / q;
4160 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4161 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4165 qmat = s->q_inter_matrix[qscale];
4166 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4168 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4169 threshold2= (threshold1<<1);
4170 for(i=63;i>=start_i;i--) {
4172 level = block[j] * qmat[j];
4174 if(((unsigned)(level+threshold1))>threshold2){
4181 for(i=start_i; i<=last_non_zero; i++) {
4183 level = block[j] * qmat[j];
4185 // if( bias+level >= (1<<QMAT_SHIFT)
4186 // || bias-level >= (1<<QMAT_SHIFT)){
4187 if(((unsigned)(level+threshold1))>threshold2){
4189 level= (bias + level)>>QMAT_SHIFT;
4192 level= (bias - level)>>QMAT_SHIFT;
4200 *overflow= s->max_qcoeff < max; //overflow might have happened
4202 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4203 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4204 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4206 return last_non_zero;
4209 #define OFFSET(x) offsetof(MpegEncContext, x)
4210 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4211 static const AVOption h263_options[] = {
4212 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4213 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4214 { "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 },
4219 static const AVClass h263_class = {
4220 .class_name = "H.263 encoder",
4221 .item_name = av_default_item_name,
4222 .option = h263_options,
4223 .version = LIBAVUTIL_VERSION_INT,
4226 AVCodec ff_h263_encoder = {
4228 .type = AVMEDIA_TYPE_VIDEO,
4229 .id = AV_CODEC_ID_H263,
4230 .priv_data_size = sizeof(MpegEncContext),
4231 .init = ff_MPV_encode_init,
4232 .encode2 = ff_MPV_encode_picture,
4233 .close = ff_MPV_encode_end,
4234 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4235 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4236 .priv_class = &h263_class,
4239 static const AVOption h263p_options[] = {
4240 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4241 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4242 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4243 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4247 static const AVClass h263p_class = {
4248 .class_name = "H.263p encoder",
4249 .item_name = av_default_item_name,
4250 .option = h263p_options,
4251 .version = LIBAVUTIL_VERSION_INT,
4254 AVCodec ff_h263p_encoder = {
4256 .type = AVMEDIA_TYPE_VIDEO,
4257 .id = AV_CODEC_ID_H263P,
4258 .priv_data_size = sizeof(MpegEncContext),
4259 .init = ff_MPV_encode_init,
4260 .encode2 = ff_MPV_encode_picture,
4261 .close = ff_MPV_encode_end,
4262 .capabilities = CODEC_CAP_SLICE_THREADS,
4263 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4264 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4265 .priv_class = &h263p_class,
4268 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4270 AVCodec ff_msmpeg4v2_encoder = {
4271 .name = "msmpeg4v2",
4272 .type = AVMEDIA_TYPE_VIDEO,
4273 .id = AV_CODEC_ID_MSMPEG4V2,
4274 .priv_data_size = sizeof(MpegEncContext),
4275 .init = ff_MPV_encode_init,
4276 .encode2 = ff_MPV_encode_picture,
4277 .close = ff_MPV_encode_end,
4278 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4279 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4280 .priv_class = &msmpeg4v2_class,
4283 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4285 AVCodec ff_msmpeg4v3_encoder = {
4287 .type = AVMEDIA_TYPE_VIDEO,
4288 .id = AV_CODEC_ID_MSMPEG4V3,
4289 .priv_data_size = sizeof(MpegEncContext),
4290 .init = ff_MPV_encode_init,
4291 .encode2 = ff_MPV_encode_picture,
4292 .close = ff_MPV_encode_end,
4293 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4294 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4295 .priv_class = &msmpeg4v3_class,
4298 FF_MPV_GENERIC_CLASS(wmv1)
4300 AVCodec ff_wmv1_encoder = {
4302 .type = AVMEDIA_TYPE_VIDEO,
4303 .id = AV_CODEC_ID_WMV1,
4304 .priv_data_size = sizeof(MpegEncContext),
4305 .init = ff_MPV_encode_init,
4306 .encode2 = ff_MPV_encode_picture,
4307 .close = ff_MPV_encode_end,
4308 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4309 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4310 .priv_class = &wmv1_class,