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/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
42 #include "aandcttab.h"
44 #include "mpeg4video.h"
46 #include "bytestream.h"
53 static int encode_picture(MpegEncContext *s, int picture_number);
54 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
55 static int sse_mb(MpegEncContext *s);
56 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
57 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 /* enable all paranoid tests for rounding, overflows, etc... */
64 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
65 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
67 const AVOption ff_mpv_generic_options[] = {
72 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
73 uint16_t (*qmat16)[2][64],
74 const uint16_t *quant_matrix,
75 int bias, int qmin, int qmax, int intra)
80 for (qscale = qmin; qscale <= qmax; qscale++) {
82 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
83 dsp->fdct == ff_jpeg_fdct_islow_10 ||
84 dsp->fdct == ff_faandct) {
85 for (i = 0; i < 64; i++) {
86 const int j = dsp->idct_permutation[i];
87 /* 16 <= qscale * quant_matrix[i] <= 7905
88 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
89 * 19952 <= x <= 249205026
90 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
91 * 3444240 >= (1 << 36) / (x) >= 275 */
93 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
94 (qscale * quant_matrix[j]));
96 } else if (dsp->fdct == ff_fdct_ifast) {
97 for (i = 0; i < 64; i++) {
98 const int j = dsp->idct_permutation[i];
99 /* 16 <= qscale * quant_matrix[i] <= 7905
100 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101 * 19952 <= x <= 249205026
102 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103 * 3444240 >= (1 << 36) / (x) >= 275 */
105 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
106 (ff_aanscales[i] * qscale * quant_matrix[j]));
109 for (i = 0; i < 64; i++) {
110 const int j = dsp->idct_permutation[i];
111 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
112 * Assume x = qscale * quant_matrix[i]
114 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
115 * so 32768 >= (1 << 19) / (x) >= 67 */
116 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
117 (qscale * quant_matrix[j]));
118 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
119 // (qscale * quant_matrix[i]);
120 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
121 (qscale * quant_matrix[j]);
123 if (qmat16[qscale][0][i] == 0 ||
124 qmat16[qscale][0][i] == 128 * 256)
125 qmat16[qscale][0][i] = 128 * 256 - 1;
126 qmat16[qscale][1][i] =
127 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
128 qmat16[qscale][0][i]);
132 for (i = intra; i < 64; i++) {
134 if (dsp->fdct == ff_fdct_ifast) {
135 max = (8191LL * ff_aanscales[i]) >> 14;
137 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
143 av_log(NULL, AV_LOG_INFO,
144 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
149 static inline void update_qscale(MpegEncContext *s)
151 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
152 (FF_LAMBDA_SHIFT + 7);
153 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
155 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
159 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165 for (i = 0; i < 64; i++) {
166 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
173 * init s->current_picture.qscale_table from s->lambda_table
175 void ff_init_qscale_tab(MpegEncContext *s)
177 int8_t * const qscale_table = s->current_picture.f.qscale_table;
180 for (i = 0; i < s->mb_num; i++) {
181 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
182 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
183 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
188 static void copy_picture_attributes(MpegEncContext *s,
194 dst->pict_type = src->pict_type;
195 dst->quality = src->quality;
196 dst->coded_picture_number = src->coded_picture_number;
197 dst->display_picture_number = src->display_picture_number;
198 //dst->reference = src->reference;
200 dst->interlaced_frame = src->interlaced_frame;
201 dst->top_field_first = src->top_field_first;
203 if (s->avctx->me_threshold) {
204 if (!src->motion_val[0])
205 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
207 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
208 if (!src->ref_index[0])
209 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
210 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
211 av_log(s->avctx, AV_LOG_ERROR,
212 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
213 src->motion_subsample_log2, dst->motion_subsample_log2);
215 memcpy(dst->mb_type, src->mb_type,
216 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
218 for (i = 0; i < 2; i++) {
219 int stride = ((16 * s->mb_width ) >>
220 src->motion_subsample_log2) + 1;
221 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
223 if (src->motion_val[i] &&
224 src->motion_val[i] != dst->motion_val[i]) {
225 memcpy(dst->motion_val[i], src->motion_val[i],
226 2 * stride * height * sizeof(int16_t));
228 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
229 memcpy(dst->ref_index[i], src->ref_index[i],
230 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
236 static void update_duplicate_context_after_me(MpegEncContext *dst,
239 #define COPY(a) dst->a= src->a
241 COPY(current_picture);
247 COPY(picture_in_gop_number);
248 COPY(gop_picture_number);
249 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
250 COPY(progressive_frame); // FIXME don't set in encode_header
251 COPY(partitioned_frame); // FIXME don't set in encode_header
256 * Set the given MpegEncContext to defaults for encoding.
257 * the changed fields will not depend upon the prior state of the MpegEncContext.
259 static void MPV_encode_defaults(MpegEncContext *s)
262 ff_MPV_common_defaults(s);
264 for (i = -16; i < 16; i++) {
265 default_fcode_tab[i + MAX_MV] = 1;
267 s->me.mv_penalty = default_mv_penalty;
268 s->fcode_tab = default_fcode_tab;
271 /* init video encoder */
272 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
274 MpegEncContext *s = avctx->priv_data;
276 int chroma_h_shift, chroma_v_shift;
278 MPV_encode_defaults(s);
280 switch (avctx->codec_id) {
281 case CODEC_ID_MPEG2VIDEO:
282 if (avctx->pix_fmt != PIX_FMT_YUV420P &&
283 avctx->pix_fmt != PIX_FMT_YUV422P) {
284 av_log(avctx, AV_LOG_ERROR,
285 "only YUV420 and YUV422 are supported\n");
290 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
291 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
292 avctx->pix_fmt != PIX_FMT_YUVJ444P &&
293 avctx->pix_fmt != PIX_FMT_BGR0 &&
294 avctx->pix_fmt != PIX_FMT_BGRA &&
295 avctx->pix_fmt != PIX_FMT_BGR24 &&
296 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
297 avctx->pix_fmt != PIX_FMT_YUV422P &&
298 avctx->pix_fmt != PIX_FMT_YUV444P) ||
299 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
300 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
306 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
307 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
308 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
309 avctx->pix_fmt != PIX_FMT_YUV422P) ||
310 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
311 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
316 if (avctx->pix_fmt != PIX_FMT_YUV420P) {
317 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
322 switch (avctx->pix_fmt) {
323 case PIX_FMT_YUVJ422P:
324 case PIX_FMT_YUV422P:
325 s->chroma_format = CHROMA_422;
327 case PIX_FMT_YUVJ420P:
328 case PIX_FMT_YUV420P:
330 s->chroma_format = CHROMA_420;
334 s->bit_rate = avctx->bit_rate;
335 s->width = avctx->width;
336 s->height = avctx->height;
337 if (avctx->gop_size > 600 &&
338 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
339 av_log(avctx, AV_LOG_WARNING,
340 "keyframe interval too large!, reducing it from %d to %d\n",
341 avctx->gop_size, 600);
342 avctx->gop_size = 600;
344 s->gop_size = avctx->gop_size;
346 s->flags = avctx->flags;
347 s->flags2 = avctx->flags2;
348 s->max_b_frames = avctx->max_b_frames;
349 s->codec_id = avctx->codec->id;
350 #if FF_API_MPV_GLOBAL_OPTS
351 if (avctx->luma_elim_threshold)
352 s->luma_elim_threshold = avctx->luma_elim_threshold;
353 if (avctx->chroma_elim_threshold)
354 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
356 s->strict_std_compliance = avctx->strict_std_compliance;
357 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
358 s->mpeg_quant = avctx->mpeg_quant;
359 s->rtp_mode = !!avctx->rtp_payload_size;
360 s->intra_dc_precision = avctx->intra_dc_precision;
361 s->user_specified_pts = AV_NOPTS_VALUE;
363 if (s->gop_size <= 1) {
370 s->me_method = avctx->me_method;
373 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
375 #if FF_API_MPV_GLOBAL_OPTS
376 if (s->flags & CODEC_FLAG_QP_RD)
377 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
380 s->adaptive_quant = (s->avctx->lumi_masking ||
381 s->avctx->dark_masking ||
382 s->avctx->temporal_cplx_masking ||
383 s->avctx->spatial_cplx_masking ||
384 s->avctx->p_masking ||
385 s->avctx->border_masking ||
386 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
389 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
391 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
392 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
393 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
397 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
398 av_log(avctx, AV_LOG_INFO,
399 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
402 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
403 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
407 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
408 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
412 if (avctx->rc_max_rate &&
413 avctx->rc_max_rate == avctx->bit_rate &&
414 avctx->rc_max_rate != avctx->rc_min_rate) {
415 av_log(avctx, AV_LOG_INFO,
416 "impossible bitrate constraints, this will fail\n");
419 if (avctx->rc_buffer_size &&
420 avctx->bit_rate * (int64_t)avctx->time_base.num >
421 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
422 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
426 if (!s->fixed_qscale &&
427 avctx->bit_rate * av_q2d(avctx->time_base) >
428 avctx->bit_rate_tolerance) {
429 av_log(avctx, AV_LOG_ERROR,
430 "bitrate tolerance too small for bitrate\n");
434 if (s->avctx->rc_max_rate &&
435 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
436 (s->codec_id == CODEC_ID_MPEG1VIDEO ||
437 s->codec_id == CODEC_ID_MPEG2VIDEO) &&
438 90000LL * (avctx->rc_buffer_size - 1) >
439 s->avctx->rc_max_rate * 0xFFFFLL) {
440 av_log(avctx, AV_LOG_INFO,
441 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
442 "specified vbv buffer is too large for the given bitrate!\n");
445 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 &&
446 s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P &&
447 s->codec_id != CODEC_ID_FLV1) {
448 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
452 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
453 av_log(avctx, AV_LOG_ERROR,
454 "OBMC is only supported with simple mb decision\n");
458 if (s->quarter_sample && s->codec_id != CODEC_ID_MPEG4) {
459 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
463 if (s->max_b_frames &&
464 s->codec_id != CODEC_ID_MPEG4 &&
465 s->codec_id != CODEC_ID_MPEG1VIDEO &&
466 s->codec_id != CODEC_ID_MPEG2VIDEO) {
467 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
471 if ((s->codec_id == CODEC_ID_MPEG4 ||
472 s->codec_id == CODEC_ID_H263 ||
473 s->codec_id == CODEC_ID_H263P) &&
474 (avctx->sample_aspect_ratio.num > 255 ||
475 avctx->sample_aspect_ratio.den > 255)) {
476 av_log(avctx, AV_LOG_WARNING,
477 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
478 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
479 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
480 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
483 if ((s->codec_id == CODEC_ID_H263 ||
484 s->codec_id == CODEC_ID_H263P) &&
485 (avctx->width > 2048 ||
486 avctx->height > 1152 )) {
487 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
490 if ((s->codec_id == CODEC_ID_H263 ||
491 s->codec_id == CODEC_ID_H263P) &&
492 ((avctx->width &3) ||
493 (avctx->height&3) )) {
494 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
498 if (s->codec_id == CODEC_ID_MPEG1VIDEO &&
499 (avctx->width > 4095 ||
500 avctx->height > 4095 )) {
501 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
505 if (s->codec_id == CODEC_ID_MPEG2VIDEO &&
506 (avctx->width > 16383 ||
507 avctx->height > 16383 )) {
508 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
512 if ((s->codec_id == CODEC_ID_WMV1 ||
513 s->codec_id == CODEC_ID_WMV2) &&
515 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
519 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
520 s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO) {
521 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
525 // FIXME mpeg2 uses that too
526 if (s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4) {
527 av_log(avctx, AV_LOG_ERROR,
528 "mpeg2 style quantization not supported by codec\n");
532 #if FF_API_MPV_GLOBAL_OPTS
533 if (s->flags & CODEC_FLAG_CBP_RD)
534 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
537 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
538 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
542 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
543 s->avctx->mb_decision != FF_MB_DECISION_RD) {
544 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
548 if (s->avctx->scenechange_threshold < 1000000000 &&
549 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
550 av_log(avctx, AV_LOG_ERROR,
551 "closed gop with scene change detection are not supported yet, "
552 "set threshold to 1000000000\n");
556 if (s->flags & CODEC_FLAG_LOW_DELAY) {
557 if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
558 av_log(avctx, AV_LOG_ERROR,
559 "low delay forcing is only available for mpeg2\n");
562 if (s->max_b_frames != 0) {
563 av_log(avctx, AV_LOG_ERROR,
564 "b frames cannot be used with low delay\n");
569 if (s->q_scale_type == 1) {
570 if (avctx->qmax > 12) {
571 av_log(avctx, AV_LOG_ERROR,
572 "non linear quant only supports qmax <= 12 currently\n");
577 if (s->avctx->thread_count > 1 &&
578 s->codec_id != CODEC_ID_MPEG4 &&
579 s->codec_id != CODEC_ID_MPEG1VIDEO &&
580 s->codec_id != CODEC_ID_MPEG2VIDEO &&
581 s->codec_id != CODEC_ID_MJPEG &&
582 (s->codec_id != CODEC_ID_H263P)) {
583 av_log(avctx, AV_LOG_ERROR,
584 "multi threaded encoding not supported by codec\n");
588 if (s->avctx->thread_count < 1) {
589 av_log(avctx, AV_LOG_ERROR,
590 "automatic thread number detection not supported by codec, "
595 if (s->avctx->thread_count > 1)
598 if (!avctx->time_base.den || !avctx->time_base.num) {
599 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
603 i = (INT_MAX / 2 + 128) >> 8;
604 if (avctx->me_threshold >= i) {
605 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
609 if (avctx->mb_threshold >= i) {
610 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
615 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
616 av_log(avctx, AV_LOG_INFO,
617 "notice: b_frame_strategy only affects the first pass\n");
618 avctx->b_frame_strategy = 0;
621 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
623 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
624 avctx->time_base.den /= i;
625 avctx->time_base.num /= i;
629 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id==CODEC_ID_AMV) {
630 // (a + x * 3 / 8) / x
631 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
632 s->inter_quant_bias = 0;
634 s->intra_quant_bias = 0;
636 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
639 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
640 s->intra_quant_bias = avctx->intra_quant_bias;
641 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
642 s->inter_quant_bias = avctx->inter_quant_bias;
644 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
646 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
649 if (avctx->codec_id == CODEC_ID_MPEG4 &&
650 s->avctx->time_base.den > (1 << 16) - 1) {
651 av_log(avctx, AV_LOG_ERROR,
652 "timebase %d/%d not supported by MPEG 4 standard, "
653 "the maximum admitted value for the timebase denominator "
654 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
658 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
660 #if FF_API_MPV_GLOBAL_OPTS
661 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
662 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
663 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
664 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
665 if (avctx->quantizer_noise_shaping)
666 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
669 switch (avctx->codec->id) {
670 case CODEC_ID_MPEG1VIDEO:
671 s->out_format = FMT_MPEG1;
672 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
673 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
675 case CODEC_ID_MPEG2VIDEO:
676 s->out_format = FMT_MPEG1;
677 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
678 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
684 s->out_format = FMT_MJPEG;
685 s->intra_only = 1; /* force intra only for jpeg */
686 if (avctx->codec->id == CODEC_ID_LJPEG &&
687 (avctx->pix_fmt == PIX_FMT_BGR0
688 || s->avctx->pix_fmt == PIX_FMT_BGRA
689 || s->avctx->pix_fmt == PIX_FMT_BGR24)) {
690 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
691 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
692 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
694 s->mjpeg_vsample[0] = 2;
695 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
696 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
697 s->mjpeg_hsample[0] = 2;
698 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
699 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
701 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
702 ff_mjpeg_encode_init(s) < 0)
708 if (!CONFIG_H261_ENCODER)
710 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
711 av_log(avctx, AV_LOG_ERROR,
712 "The specified picture size of %dx%d is not valid for the "
713 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
714 s->width, s->height);
717 s->out_format = FMT_H261;
722 if (!CONFIG_H263_ENCODER)
724 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
725 s->width, s->height) == 8) {
726 av_log(avctx, AV_LOG_ERROR,
727 "The specified picture size of %dx%d is not valid for "
728 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
729 "352x288, 704x576, and 1408x1152. "
730 "Try H.263+.\n", s->width, s->height);
733 s->out_format = FMT_H263;
738 s->out_format = FMT_H263;
741 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
742 s->modified_quant = s->h263_aic;
743 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
744 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
747 /* These are just to be sure */
752 s->out_format = FMT_H263;
753 s->h263_flv = 2; /* format = 1; 11-bit codes */
754 s->unrestricted_mv = 1;
755 s->rtp_mode = 0; /* don't allow GOB */
760 s->out_format = FMT_H263;
765 s->out_format = FMT_H263;
768 s->modified_quant = 1;
772 s->unrestricted_mv = 0;
775 s->out_format = FMT_H263;
777 s->unrestricted_mv = 1;
778 s->low_delay = s->max_b_frames ? 0 : 1;
779 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
781 case CODEC_ID_MSMPEG4V2:
782 s->out_format = FMT_H263;
784 s->unrestricted_mv = 1;
785 s->msmpeg4_version = 2;
789 case CODEC_ID_MSMPEG4V3:
790 s->out_format = FMT_H263;
792 s->unrestricted_mv = 1;
793 s->msmpeg4_version = 3;
794 s->flipflop_rounding = 1;
799 s->out_format = FMT_H263;
801 s->unrestricted_mv = 1;
802 s->msmpeg4_version = 4;
803 s->flipflop_rounding = 1;
808 s->out_format = FMT_H263;
810 s->unrestricted_mv = 1;
811 s->msmpeg4_version = 5;
812 s->flipflop_rounding = 1;
820 avctx->has_b_frames = !s->low_delay;
824 s->progressive_frame =
825 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
826 CODEC_FLAG_INTERLACED_ME) ||
830 if (ff_MPV_common_init(s) < 0)
833 if (!s->dct_quantize)
834 s->dct_quantize = ff_dct_quantize_c;
836 s->denoise_dct = denoise_dct_c;
837 s->fast_dct_quantize = s->dct_quantize;
839 s->dct_quantize = dct_quantize_trellis_c;
841 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
842 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
844 s->quant_precision = 5;
846 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
847 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
849 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
850 ff_h261_encode_init(s);
851 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
852 ff_h263_encode_init(s);
853 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
854 ff_msmpeg4_encode_init(s);
855 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
856 && s->out_format == FMT_MPEG1)
857 ff_mpeg1_encode_init(s);
860 for (i = 0; i < 64; i++) {
861 int j = s->dsp.idct_permutation[i];
862 if (CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4 &&
864 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
865 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
866 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
868 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
871 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
872 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
874 if (s->avctx->intra_matrix)
875 s->intra_matrix[j] = s->avctx->intra_matrix[i];
876 if (s->avctx->inter_matrix)
877 s->inter_matrix[j] = s->avctx->inter_matrix[i];
880 /* precompute matrix */
881 /* for mjpeg, we do include qscale in the matrix */
882 if (s->out_format != FMT_MJPEG) {
883 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
884 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
886 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
887 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
891 if (ff_rate_control_init(s) < 0)
897 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
899 MpegEncContext *s = avctx->priv_data;
901 ff_rate_control_uninit(s);
903 ff_MPV_common_end(s);
904 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
905 s->out_format == FMT_MJPEG)
906 ff_mjpeg_encode_close(s);
908 av_freep(&avctx->extradata);
913 static int get_sae(uint8_t *src, int ref, int stride)
918 for (y = 0; y < 16; y++) {
919 for (x = 0; x < 16; x++) {
920 acc += FFABS(src[x + y * stride] - ref);
927 static int get_intra_count(MpegEncContext *s, uint8_t *src,
928 uint8_t *ref, int stride)
936 for (y = 0; y < h; y += 16) {
937 for (x = 0; x < w; x += 16) {
938 int offset = x + y * stride;
939 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
941 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
942 int sae = get_sae(src + offset, mean, stride);
944 acc += sae + 500 < sad;
951 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
956 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
957 (s->low_delay ? 0 : 1);
962 pic_arg->display_picture_number = s->input_picture_number++;
964 if (pts != AV_NOPTS_VALUE) {
965 if (s->user_specified_pts != AV_NOPTS_VALUE) {
967 int64_t last = s->user_specified_pts;
970 av_log(s->avctx, AV_LOG_ERROR,
971 "Error, Invalid timestamp=%"PRId64", "
972 "last=%"PRId64"\n", pts, s->user_specified_pts);
976 if (!s->low_delay && pic_arg->display_picture_number == 1)
977 s->dts_delta = time - last;
979 s->user_specified_pts = pts;
981 if (s->user_specified_pts != AV_NOPTS_VALUE) {
982 s->user_specified_pts =
983 pts = s->user_specified_pts + 1;
984 av_log(s->avctx, AV_LOG_INFO,
985 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
988 pts = pic_arg->display_picture_number;
994 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
996 if (pic_arg->linesize[0] != s->linesize)
998 if (pic_arg->linesize[1] != s->uvlinesize)
1000 if (pic_arg->linesize[2] != s->uvlinesize)
1003 //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
1004 // pic_arg->linesize[1], s->linesize, s->uvlinesize);
1007 i = ff_find_unused_picture(s, 1);
1011 pic = &s->picture[i].f;
1014 for (i = 0; i < 4; i++) {
1015 pic->data[i] = pic_arg->data[i];
1016 pic->linesize[i] = pic_arg->linesize[i];
1018 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1022 i = ff_find_unused_picture(s, 0);
1026 pic = &s->picture[i].f;
1029 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1033 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1034 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1035 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1038 int h_chroma_shift, v_chroma_shift;
1039 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1042 for (i = 0; i < 3; i++) {
1043 int src_stride = pic_arg->linesize[i];
1044 int dst_stride = i ? s->uvlinesize : s->linesize;
1045 int h_shift = i ? h_chroma_shift : 0;
1046 int v_shift = i ? v_chroma_shift : 0;
1047 int w = s->width >> h_shift;
1048 int h = s->height >> v_shift;
1049 uint8_t *src = pic_arg->data[i];
1050 uint8_t *dst = pic->data[i];
1052 if(s->codec_id == CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1053 h= ((s->height+15)/16*16)>>v_shift;
1056 if (!s->avctx->rc_buffer_size)
1057 dst += INPLACE_OFFSET;
1059 if (src_stride == dst_stride)
1060 memcpy(dst, src, src_stride * h);
1063 memcpy(dst, src, w);
1071 copy_picture_attributes(s, pic, pic_arg);
1072 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1075 /* shift buffer entries */
1076 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1077 s->input_picture[i - 1] = s->input_picture[i];
1079 s->input_picture[encoding_delay] = (Picture*) pic;
1084 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1088 int64_t score64 = 0;
1090 for (plane = 0; plane < 3; plane++) {
1091 const int stride = p->f.linesize[plane];
1092 const int bw = plane ? 1 : 2;
1093 for (y = 0; y < s->mb_height * bw; y++) {
1094 for (x = 0; x < s->mb_width * bw; x++) {
1095 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1096 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1097 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1098 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1100 switch (s->avctx->frame_skip_exp) {
1101 case 0: score = FFMAX(score, v); break;
1102 case 1: score += FFABS(v); break;
1103 case 2: score += v * v; break;
1104 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1105 case 4: score64 += v * v * (int64_t)(v * v); break;
1114 if (score64 < s->avctx->frame_skip_threshold)
1116 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1121 static int estimate_best_b_count(MpegEncContext *s)
1123 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1124 AVCodecContext *c = avcodec_alloc_context3(NULL);
1125 AVFrame input[FF_MAX_B_FRAMES + 2];
1126 const int scale = s->avctx->brd_scale;
1127 int i, j, out_size, p_lambda, b_lambda, lambda2;
1128 int outbuf_size = s->width * s->height; // FIXME
1129 uint8_t *outbuf = av_malloc(outbuf_size);
1130 int64_t best_rd = INT64_MAX;
1131 int best_b_count = -1;
1133 assert(scale >= 0 && scale <= 3);
1136 //s->next_picture_ptr->quality;
1137 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1138 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1139 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1140 if (!b_lambda) // FIXME we should do this somewhere else
1141 b_lambda = p_lambda;
1142 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1145 c->width = s->width >> scale;
1146 c->height = s->height >> scale;
1147 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1148 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1149 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1150 c->mb_decision = s->avctx->mb_decision;
1151 c->me_cmp = s->avctx->me_cmp;
1152 c->mb_cmp = s->avctx->mb_cmp;
1153 c->me_sub_cmp = s->avctx->me_sub_cmp;
1154 c->pix_fmt = PIX_FMT_YUV420P;
1155 c->time_base = s->avctx->time_base;
1156 c->max_b_frames = s->max_b_frames;
1158 if (avcodec_open2(c, codec, NULL) < 0)
1161 for (i = 0; i < s->max_b_frames + 2; i++) {
1162 int ysize = c->width * c->height;
1163 int csize = (c->width / 2) * (c->height / 2);
1164 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1165 s->next_picture_ptr;
1167 avcodec_get_frame_defaults(&input[i]);
1168 input[i].data[0] = av_malloc(ysize + 2 * csize);
1169 input[i].data[1] = input[i].data[0] + ysize;
1170 input[i].data[2] = input[i].data[1] + csize;
1171 input[i].linesize[0] = c->width;
1172 input[i].linesize[1] =
1173 input[i].linesize[2] = c->width / 2;
1175 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1176 pre_input = *pre_input_ptr;
1178 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1179 pre_input.f.data[0] += INPLACE_OFFSET;
1180 pre_input.f.data[1] += INPLACE_OFFSET;
1181 pre_input.f.data[2] += INPLACE_OFFSET;
1184 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1185 pre_input.f.data[0], pre_input.f.linesize[0],
1186 c->width, c->height);
1187 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1188 pre_input.f.data[1], pre_input.f.linesize[1],
1189 c->width >> 1, c->height >> 1);
1190 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1191 pre_input.f.data[2], pre_input.f.linesize[2],
1192 c->width >> 1, c->height >> 1);
1196 for (j = 0; j < s->max_b_frames + 1; j++) {
1199 if (!s->input_picture[j])
1202 c->error[0] = c->error[1] = c->error[2] = 0;
1204 input[0].pict_type = AV_PICTURE_TYPE_I;
1205 input[0].quality = 1 * FF_QP2LAMBDA;
1206 out_size = avcodec_encode_video(c, outbuf,
1207 outbuf_size, &input[0]);
1208 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1210 for (i = 0; i < s->max_b_frames + 1; i++) {
1211 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1213 input[i + 1].pict_type = is_p ?
1214 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1215 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1216 out_size = avcodec_encode_video(c, outbuf, outbuf_size,
1218 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1221 /* get the delayed frames */
1223 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
1224 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1227 rd += c->error[0] + c->error[1] + c->error[2];
1239 for (i = 0; i < s->max_b_frames + 2; i++) {
1240 av_freep(&input[i].data[0]);
1243 return best_b_count;
1246 static int select_input_picture(MpegEncContext *s)
1250 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1251 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1252 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1254 /* set next picture type & ordering */
1255 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1256 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1257 s->next_picture_ptr == NULL || s->intra_only) {
1258 s->reordered_input_picture[0] = s->input_picture[0];
1259 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1260 s->reordered_input_picture[0]->f.coded_picture_number =
1261 s->coded_picture_number++;
1265 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1266 if (s->picture_in_gop_number < s->gop_size &&
1267 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1268 // FIXME check that te gop check above is +-1 correct
1269 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1270 // s->input_picture[0]->f.data[0],
1271 // s->input_picture[0]->pts);
1273 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1274 for (i = 0; i < 4; i++)
1275 s->input_picture[0]->f.data[i] = NULL;
1276 s->input_picture[0]->f.type = 0;
1278 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1279 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1281 s->avctx->release_buffer(s->avctx,
1282 &s->input_picture[0]->f);
1286 ff_vbv_update(s, 0);
1292 if (s->flags & CODEC_FLAG_PASS2) {
1293 for (i = 0; i < s->max_b_frames + 1; i++) {
1294 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1296 if (pict_num >= s->rc_context.num_entries)
1298 if (!s->input_picture[i]) {
1299 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1303 s->input_picture[i]->f.pict_type =
1304 s->rc_context.entry[pict_num].new_pict_type;
1308 if (s->avctx->b_frame_strategy == 0) {
1309 b_frames = s->max_b_frames;
1310 while (b_frames && !s->input_picture[b_frames])
1312 } else if (s->avctx->b_frame_strategy == 1) {
1313 for (i = 1; i < s->max_b_frames + 1; i++) {
1314 if (s->input_picture[i] &&
1315 s->input_picture[i]->b_frame_score == 0) {
1316 s->input_picture[i]->b_frame_score =
1318 s->input_picture[i ]->f.data[0],
1319 s->input_picture[i - 1]->f.data[0],
1323 for (i = 0; i < s->max_b_frames + 1; i++) {
1324 if (s->input_picture[i] == NULL ||
1325 s->input_picture[i]->b_frame_score - 1 >
1326 s->mb_num / s->avctx->b_sensitivity)
1330 b_frames = FFMAX(0, i - 1);
1333 for (i = 0; i < b_frames + 1; i++) {
1334 s->input_picture[i]->b_frame_score = 0;
1336 } else if (s->avctx->b_frame_strategy == 2) {
1337 b_frames = estimate_best_b_count(s);
1339 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1344 //static int b_count = 0;
1345 //b_count += b_frames;
1346 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1348 for (i = b_frames - 1; i >= 0; i--) {
1349 int type = s->input_picture[i]->f.pict_type;
1350 if (type && type != AV_PICTURE_TYPE_B)
1353 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1354 b_frames == s->max_b_frames) {
1355 av_log(s->avctx, AV_LOG_ERROR,
1356 "warning, too many b frames in a row\n");
1359 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1360 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1361 s->gop_size > s->picture_in_gop_number) {
1362 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1364 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1366 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1370 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1371 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1374 s->reordered_input_picture[0] = s->input_picture[b_frames];
1375 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1376 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1377 s->reordered_input_picture[0]->f.coded_picture_number =
1378 s->coded_picture_number++;
1379 for (i = 0; i < b_frames; i++) {
1380 s->reordered_input_picture[i + 1] = s->input_picture[i];
1381 s->reordered_input_picture[i + 1]->f.pict_type =
1383 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1384 s->coded_picture_number++;
1389 if (s->reordered_input_picture[0]) {
1390 s->reordered_input_picture[0]->f.reference =
1391 s->reordered_input_picture[0]->f.pict_type !=
1392 AV_PICTURE_TYPE_B ? 3 : 0;
1394 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1396 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1397 s->avctx->rc_buffer_size) {
1398 // input is a shared pix, so we can't modifiy it -> alloc a new
1399 // one & ensure that the shared one is reuseable
1402 int i = ff_find_unused_picture(s, 0);
1405 pic = &s->picture[i];
1407 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1408 if (ff_alloc_picture(s, pic, 0) < 0) {
1412 /* mark us unused / free shared pic */
1413 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1414 s->avctx->release_buffer(s->avctx,
1415 &s->reordered_input_picture[0]->f);
1416 for (i = 0; i < 4; i++)
1417 s->reordered_input_picture[0]->f.data[i] = NULL;
1418 s->reordered_input_picture[0]->f.type = 0;
1420 copy_picture_attributes(s, &pic->f,
1421 &s->reordered_input_picture[0]->f);
1423 s->current_picture_ptr = pic;
1425 // input is not a shared pix -> reuse buffer for current_pix
1427 assert(s->reordered_input_picture[0]->f.type ==
1428 FF_BUFFER_TYPE_USER ||
1429 s->reordered_input_picture[0]->f.type ==
1430 FF_BUFFER_TYPE_INTERNAL);
1432 s->current_picture_ptr = s->reordered_input_picture[0];
1433 for (i = 0; i < 4; i++) {
1434 s->new_picture.f.data[i] += INPLACE_OFFSET;
1437 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1439 s->picture_number = s->new_picture.f.display_picture_number;
1440 //printf("dpn:%d\n", s->picture_number);
1442 memset(&s->new_picture, 0, sizeof(Picture));
1447 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1448 AVFrame *pic_arg, int *got_packet)
1450 MpegEncContext *s = avctx->priv_data;
1451 int i, stuffing_count, ret;
1452 int context_count = s->slice_context_count;
1454 s->picture_in_gop_number++;
1456 if (load_input_picture(s, pic_arg) < 0)
1459 if (select_input_picture(s) < 0) {
1464 if (s->new_picture.f.data[0]) {
1465 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1468 s->mb_info_ptr = av_packet_new_side_data(pkt,
1469 AV_PKT_DATA_H263_MB_INFO,
1470 s->mb_width*s->mb_height*12);
1471 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1474 for (i = 0; i < context_count; i++) {
1475 int start_y = s->thread_context[i]->start_mb_y;
1476 int end_y = s->thread_context[i]-> end_mb_y;
1477 int h = s->mb_height;
1478 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1479 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1481 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1484 s->pict_type = s->new_picture.f.pict_type;
1486 //printf("qs:%f %f %d\n", s->new_picture.quality,
1487 // s->current_picture.quality, s->qscale);
1488 ff_MPV_frame_start(s, avctx);
1490 if (encode_picture(s, s->picture_number) < 0)
1493 avctx->header_bits = s->header_bits;
1494 avctx->mv_bits = s->mv_bits;
1495 avctx->misc_bits = s->misc_bits;
1496 avctx->i_tex_bits = s->i_tex_bits;
1497 avctx->p_tex_bits = s->p_tex_bits;
1498 avctx->i_count = s->i_count;
1499 // FIXME f/b_count in avctx
1500 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1501 avctx->skip_count = s->skip_count;
1503 ff_MPV_frame_end(s);
1505 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1506 ff_mjpeg_encode_picture_trailer(s);
1508 if (avctx->rc_buffer_size) {
1509 RateControlContext *rcc = &s->rc_context;
1510 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1512 if (put_bits_count(&s->pb) > max_size &&
1513 s->lambda < s->avctx->lmax) {
1514 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1515 (s->qscale + 1) / s->qscale);
1516 if (s->adaptive_quant) {
1518 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1519 s->lambda_table[i] =
1520 FFMAX(s->lambda_table[i] + 1,
1521 s->lambda_table[i] * (s->qscale + 1) /
1524 s->mb_skipped = 0; // done in MPV_frame_start()
1525 // done in encode_picture() so we must undo it
1526 if (s->pict_type == AV_PICTURE_TYPE_P) {
1527 if (s->flipflop_rounding ||
1528 s->codec_id == CODEC_ID_H263P ||
1529 s->codec_id == CODEC_ID_MPEG4)
1530 s->no_rounding ^= 1;
1532 if (s->pict_type != AV_PICTURE_TYPE_B) {
1533 s->time_base = s->last_time_base;
1534 s->last_non_b_time = s->time - s->pp_time;
1536 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1537 for (i = 0; i < context_count; i++) {
1538 PutBitContext *pb = &s->thread_context[i]->pb;
1539 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1544 assert(s->avctx->rc_max_rate);
1547 if (s->flags & CODEC_FLAG_PASS1)
1548 ff_write_pass1_stats(s);
1550 for (i = 0; i < 4; i++) {
1551 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1552 avctx->error[i] += s->current_picture_ptr->f.error[i];
1555 if (s->flags & CODEC_FLAG_PASS1)
1556 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1557 avctx->i_tex_bits + avctx->p_tex_bits ==
1558 put_bits_count(&s->pb));
1559 flush_put_bits(&s->pb);
1560 s->frame_bits = put_bits_count(&s->pb);
1562 stuffing_count = ff_vbv_update(s, s->frame_bits);
1563 if (stuffing_count) {
1564 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1565 stuffing_count + 50) {
1566 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1570 switch (s->codec_id) {
1571 case CODEC_ID_MPEG1VIDEO:
1572 case CODEC_ID_MPEG2VIDEO:
1573 while (stuffing_count--) {
1574 put_bits(&s->pb, 8, 0);
1577 case CODEC_ID_MPEG4:
1578 put_bits(&s->pb, 16, 0);
1579 put_bits(&s->pb, 16, 0x1C3);
1580 stuffing_count -= 4;
1581 while (stuffing_count--) {
1582 put_bits(&s->pb, 8, 0xFF);
1586 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1588 flush_put_bits(&s->pb);
1589 s->frame_bits = put_bits_count(&s->pb);
1592 /* update mpeg1/2 vbv_delay for CBR */
1593 if (s->avctx->rc_max_rate &&
1594 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1595 s->out_format == FMT_MPEG1 &&
1596 90000LL * (avctx->rc_buffer_size - 1) <=
1597 s->avctx->rc_max_rate * 0xFFFFLL) {
1598 int vbv_delay, min_delay;
1599 double inbits = s->avctx->rc_max_rate *
1600 av_q2d(s->avctx->time_base);
1601 int minbits = s->frame_bits - 8 *
1602 (s->vbv_delay_ptr - s->pb.buf - 1);
1603 double bits = s->rc_context.buffer_index + minbits - inbits;
1606 av_log(s->avctx, AV_LOG_ERROR,
1607 "Internal error, negative bits\n");
1609 assert(s->repeat_first_field == 0);
1611 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1612 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1613 s->avctx->rc_max_rate;
1615 vbv_delay = FFMAX(vbv_delay, min_delay);
1617 assert(vbv_delay < 0xFFFF);
1619 s->vbv_delay_ptr[0] &= 0xF8;
1620 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1621 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1622 s->vbv_delay_ptr[2] &= 0x07;
1623 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1624 avctx->vbv_delay = vbv_delay * 300;
1626 s->total_bits += s->frame_bits;
1627 avctx->frame_bits = s->frame_bits;
1629 pkt->pts = s->current_picture.f.pts;
1630 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1631 if (!s->current_picture.f.coded_picture_number)
1632 pkt->dts = pkt->pts - s->dts_delta;
1634 pkt->dts = s->reordered_pts;
1635 s->reordered_pts = pkt->pts;
1637 pkt->dts = pkt->pts;
1638 if (s->current_picture.f.key_frame)
1639 pkt->flags |= AV_PKT_FLAG_KEY;
1641 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1643 assert((put_bits_ptr(&s->pb) == s->pb.buf));
1646 assert((s->frame_bits & 7) == 0);
1648 pkt->size = s->frame_bits / 8;
1649 *got_packet = !!pkt->size;
1653 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1654 int n, int threshold)
1656 static const char tab[64] = {
1657 3, 2, 2, 1, 1, 1, 1, 1,
1658 1, 1, 1, 1, 1, 1, 1, 1,
1659 1, 1, 1, 1, 1, 1, 1, 1,
1660 0, 0, 0, 0, 0, 0, 0, 0,
1661 0, 0, 0, 0, 0, 0, 0, 0,
1662 0, 0, 0, 0, 0, 0, 0, 0,
1663 0, 0, 0, 0, 0, 0, 0, 0,
1664 0, 0, 0, 0, 0, 0, 0, 0
1669 DCTELEM *block = s->block[n];
1670 const int last_index = s->block_last_index[n];
1673 if (threshold < 0) {
1675 threshold = -threshold;
1679 /* Are all we could set to zero already zero? */
1680 if (last_index <= skip_dc - 1)
1683 for (i = 0; i <= last_index; i++) {
1684 const int j = s->intra_scantable.permutated[i];
1685 const int level = FFABS(block[j]);
1687 if (skip_dc && i == 0)
1691 } else if (level > 1) {
1697 if (score >= threshold)
1699 for (i = skip_dc; i <= last_index; i++) {
1700 const int j = s->intra_scantable.permutated[i];
1704 s->block_last_index[n] = 0;
1706 s->block_last_index[n] = -1;
1709 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1713 const int maxlevel = s->max_qcoeff;
1714 const int minlevel = s->min_qcoeff;
1718 i = 1; // skip clipping of intra dc
1722 for (; i <= last_index; i++) {
1723 const int j = s->intra_scantable.permutated[i];
1724 int level = block[j];
1726 if (level > maxlevel) {
1729 } else if (level < minlevel) {
1737 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1738 av_log(s->avctx, AV_LOG_INFO,
1739 "warning, clipping %d dct coefficients to %d..%d\n",
1740 overflow, minlevel, maxlevel);
1743 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1747 for (y = 0; y < 8; y++) {
1748 for (x = 0; x < 8; x++) {
1754 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1755 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1756 int v = ptr[x2 + y2 * stride];
1762 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1767 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1768 int motion_x, int motion_y,
1769 int mb_block_height,
1772 int16_t weight[8][64];
1773 DCTELEM orig[8][64];
1774 const int mb_x = s->mb_x;
1775 const int mb_y = s->mb_y;
1778 int dct_offset = s->linesize * 8; // default for progressive frames
1779 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1782 for (i = 0; i < mb_block_count; i++)
1783 skip_dct[i] = s->skipdct;
1785 if (s->adaptive_quant) {
1786 const int last_qp = s->qscale;
1787 const int mb_xy = mb_x + mb_y * s->mb_stride;
1789 s->lambda = s->lambda_table[mb_xy];
1792 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1793 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1794 s->dquant = s->qscale - last_qp;
1796 if (s->out_format == FMT_H263) {
1797 s->dquant = av_clip(s->dquant, -2, 2);
1799 if (s->codec_id == CODEC_ID_MPEG4) {
1801 if (s->pict_type == AV_PICTURE_TYPE_B) {
1802 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1805 if (s->mv_type == MV_TYPE_8X8)
1811 ff_set_qscale(s, last_qp + s->dquant);
1812 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1813 ff_set_qscale(s, s->qscale + s->dquant);
1815 wrap_y = s->linesize;
1816 wrap_c = s->uvlinesize;
1817 ptr_y = s->new_picture.f.data[0] +
1818 (mb_y * 16 * wrap_y) + mb_x * 16;
1819 ptr_cb = s->new_picture.f.data[1] +
1820 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1821 ptr_cr = s->new_picture.f.data[2] +
1822 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1824 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != CODEC_ID_AMV){
1825 uint8_t *ebuf = s->edge_emu_buffer + 32;
1826 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1827 mb_y * 16, s->width, s->height);
1829 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1830 mb_block_height, mb_x * 8, mb_y * 8,
1831 (s->width+1) >> 1, (s->height+1) >> 1);
1832 ptr_cb = ebuf + 18 * wrap_y;
1833 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1834 mb_block_height, mb_x * 8, mb_y * 8,
1835 (s->width+1) >> 1, (s->height+1) >> 1);
1836 ptr_cr = ebuf + 18 * wrap_y + 8;
1840 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1841 int progressive_score, interlaced_score;
1843 s->interlaced_dct = 0;
1844 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1846 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1847 NULL, wrap_y, 8) - 400;
1849 if (progressive_score > 0) {
1850 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1851 NULL, wrap_y * 2, 8) +
1852 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1853 NULL, wrap_y * 2, 8);
1854 if (progressive_score > interlaced_score) {
1855 s->interlaced_dct = 1;
1857 dct_offset = wrap_y;
1859 if (s->chroma_format == CHROMA_422)
1865 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1866 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1867 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1868 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1870 if (s->flags & CODEC_FLAG_GRAY) {
1874 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1875 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1876 if (!s->chroma_y_shift) { /* 422 */
1877 s->dsp.get_pixels(s->block[6],
1878 ptr_cb + (dct_offset >> 1), wrap_c);
1879 s->dsp.get_pixels(s->block[7],
1880 ptr_cr + (dct_offset >> 1), wrap_c);
1884 op_pixels_func (*op_pix)[4];
1885 qpel_mc_func (*op_qpix)[16];
1886 uint8_t *dest_y, *dest_cb, *dest_cr;
1888 dest_y = s->dest[0];
1889 dest_cb = s->dest[1];
1890 dest_cr = s->dest[2];
1892 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1893 op_pix = s->dsp.put_pixels_tab;
1894 op_qpix = s->dsp.put_qpel_pixels_tab;
1896 op_pix = s->dsp.put_no_rnd_pixels_tab;
1897 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1900 if (s->mv_dir & MV_DIR_FORWARD) {
1901 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data,
1903 op_pix = s->dsp.avg_pixels_tab;
1904 op_qpix = s->dsp.avg_qpel_pixels_tab;
1906 if (s->mv_dir & MV_DIR_BACKWARD) {
1907 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data,
1911 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1912 int progressive_score, interlaced_score;
1914 s->interlaced_dct = 0;
1915 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1918 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1919 ptr_y + wrap_y * 8, wrap_y,
1922 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1923 progressive_score -= 400;
1925 if (progressive_score > 0) {
1926 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1929 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1933 if (progressive_score > interlaced_score) {
1934 s->interlaced_dct = 1;
1936 dct_offset = wrap_y;
1938 if (s->chroma_format == CHROMA_422)
1944 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1945 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1946 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1947 dest_y + dct_offset, wrap_y);
1948 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1949 dest_y + dct_offset + 8, wrap_y);
1951 if (s->flags & CODEC_FLAG_GRAY) {
1955 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1956 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1957 if (!s->chroma_y_shift) { /* 422 */
1958 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1959 dest_cb + (dct_offset >> 1), wrap_c);
1960 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1961 dest_cr + (dct_offset >> 1), wrap_c);
1964 /* pre quantization */
1965 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1966 2 * s->qscale * s->qscale) {
1968 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1969 wrap_y, 8) < 20 * s->qscale)
1971 if (s->dsp.sad[1](NULL, ptr_y + 8,
1972 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1974 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1975 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1977 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1978 dest_y + dct_offset + 8,
1979 wrap_y, 8) < 20 * s->qscale)
1981 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1982 wrap_c, 8) < 20 * s->qscale)
1984 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1985 wrap_c, 8) < 20 * s->qscale)
1987 if (!s->chroma_y_shift) { /* 422 */
1988 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1989 dest_cb + (dct_offset >> 1),
1990 wrap_c, 8) < 20 * s->qscale)
1992 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1993 dest_cr + (dct_offset >> 1),
1994 wrap_c, 8) < 20 * s->qscale)
2000 if (s->quantizer_noise_shaping) {
2002 get_visual_weight(weight[0], ptr_y , wrap_y);
2004 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2006 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2008 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2010 get_visual_weight(weight[4], ptr_cb , wrap_c);
2012 get_visual_weight(weight[5], ptr_cr , wrap_c);
2013 if (!s->chroma_y_shift) { /* 422 */
2015 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2018 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2021 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2024 /* DCT & quantize */
2025 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2027 for (i = 0; i < mb_block_count; i++) {
2030 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2031 // FIXME we could decide to change to quantizer instead of
2033 // JS: I don't think that would be a good idea it could lower
2034 // quality instead of improve it. Just INTRADC clipping
2035 // deserves changes in quantizer
2037 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2039 s->block_last_index[i] = -1;
2041 if (s->quantizer_noise_shaping) {
2042 for (i = 0; i < mb_block_count; i++) {
2044 s->block_last_index[i] =
2045 dct_quantize_refine(s, s->block[i], weight[i],
2046 orig[i], i, s->qscale);
2051 if (s->luma_elim_threshold && !s->mb_intra)
2052 for (i = 0; i < 4; i++)
2053 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2054 if (s->chroma_elim_threshold && !s->mb_intra)
2055 for (i = 4; i < mb_block_count; i++)
2056 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2058 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2059 for (i = 0; i < mb_block_count; i++) {
2060 if (s->block_last_index[i] == -1)
2061 s->coded_score[i] = INT_MAX / 256;
2066 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2067 s->block_last_index[4] =
2068 s->block_last_index[5] = 0;
2070 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2073 // non c quantize code returns incorrect block_last_index FIXME
2074 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2075 for (i = 0; i < mb_block_count; i++) {
2077 if (s->block_last_index[i] > 0) {
2078 for (j = 63; j > 0; j--) {
2079 if (s->block[i][s->intra_scantable.permutated[j]])
2082 s->block_last_index[i] = j;
2087 /* huffman encode */
2088 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2089 case CODEC_ID_MPEG1VIDEO:
2090 case CODEC_ID_MPEG2VIDEO:
2091 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2092 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2094 case CODEC_ID_MPEG4:
2095 if (CONFIG_MPEG4_ENCODER)
2096 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2098 case CODEC_ID_MSMPEG4V2:
2099 case CODEC_ID_MSMPEG4V3:
2101 if (CONFIG_MSMPEG4_ENCODER)
2102 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2105 if (CONFIG_WMV2_ENCODER)
2106 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2109 if (CONFIG_H261_ENCODER)
2110 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2113 case CODEC_ID_H263P:
2117 if (CONFIG_H263_ENCODER)
2118 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2120 case CODEC_ID_MJPEG:
2122 if (CONFIG_MJPEG_ENCODER)
2123 ff_mjpeg_encode_mb(s, s->block);
2130 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2132 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2133 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2136 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2139 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2142 d->mb_skip_run= s->mb_skip_run;
2144 d->last_dc[i] = s->last_dc[i];
2147 d->mv_bits= s->mv_bits;
2148 d->i_tex_bits= s->i_tex_bits;
2149 d->p_tex_bits= s->p_tex_bits;
2150 d->i_count= s->i_count;
2151 d->f_count= s->f_count;
2152 d->b_count= s->b_count;
2153 d->skip_count= s->skip_count;
2154 d->misc_bits= s->misc_bits;
2158 d->qscale= s->qscale;
2159 d->dquant= s->dquant;
2161 d->esc3_level_length= s->esc3_level_length;
2164 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2167 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2168 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2171 d->mb_skip_run= s->mb_skip_run;
2173 d->last_dc[i] = s->last_dc[i];
2176 d->mv_bits= s->mv_bits;
2177 d->i_tex_bits= s->i_tex_bits;
2178 d->p_tex_bits= s->p_tex_bits;
2179 d->i_count= s->i_count;
2180 d->f_count= s->f_count;
2181 d->b_count= s->b_count;
2182 d->skip_count= s->skip_count;
2183 d->misc_bits= s->misc_bits;
2185 d->mb_intra= s->mb_intra;
2186 d->mb_skipped= s->mb_skipped;
2187 d->mv_type= s->mv_type;
2188 d->mv_dir= s->mv_dir;
2190 if(s->data_partitioning){
2192 d->tex_pb= s->tex_pb;
2196 d->block_last_index[i]= s->block_last_index[i];
2197 d->interlaced_dct= s->interlaced_dct;
2198 d->qscale= s->qscale;
2200 d->esc3_level_length= s->esc3_level_length;
2203 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2204 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2205 int *dmin, int *next_block, int motion_x, int motion_y)
2208 uint8_t *dest_backup[3];
2210 copy_context_before_encode(s, backup, type);
2212 s->block= s->blocks[*next_block];
2213 s->pb= pb[*next_block];
2214 if(s->data_partitioning){
2215 s->pb2 = pb2 [*next_block];
2216 s->tex_pb= tex_pb[*next_block];
2220 memcpy(dest_backup, s->dest, sizeof(s->dest));
2221 s->dest[0] = s->rd_scratchpad;
2222 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2223 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2224 assert(s->linesize >= 32); //FIXME
2227 encode_mb(s, motion_x, motion_y);
2229 score= put_bits_count(&s->pb);
2230 if(s->data_partitioning){
2231 score+= put_bits_count(&s->pb2);
2232 score+= put_bits_count(&s->tex_pb);
2235 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2236 ff_MPV_decode_mb(s, s->block);
2238 score *= s->lambda2;
2239 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2243 memcpy(s->dest, dest_backup, sizeof(s->dest));
2250 copy_context_after_encode(best, s, type);
2254 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2255 uint32_t *sq = ff_squareTbl + 256;
2260 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2261 else if(w==8 && h==8)
2262 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2266 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2275 static int sse_mb(MpegEncContext *s){
2279 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2280 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2283 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2284 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)
2285 +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)
2286 +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);
2288 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)
2289 +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)
2290 +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);
2293 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)
2294 +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)
2295 +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);
2298 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2299 MpegEncContext *s= *(void**)arg;
2303 s->me.dia_size= s->avctx->pre_dia_size;
2304 s->first_slice_line=1;
2305 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2306 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2307 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2309 s->first_slice_line=0;
2317 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2318 MpegEncContext *s= *(void**)arg;
2320 ff_check_alignment();
2322 s->me.dia_size= s->avctx->dia_size;
2323 s->first_slice_line=1;
2324 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2325 s->mb_x=0; //for block init below
2326 ff_init_block_index(s);
2327 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2328 s->block_index[0]+=2;
2329 s->block_index[1]+=2;
2330 s->block_index[2]+=2;
2331 s->block_index[3]+=2;
2333 /* compute motion vector & mb_type and store in context */
2334 if(s->pict_type==AV_PICTURE_TYPE_B)
2335 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2337 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2339 s->first_slice_line=0;
2344 static int mb_var_thread(AVCodecContext *c, void *arg){
2345 MpegEncContext *s= *(void**)arg;
2348 ff_check_alignment();
2350 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2351 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2354 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2356 int sum = s->dsp.pix_sum(pix, s->linesize);
2358 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2360 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2361 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2362 s->me.mb_var_sum_temp += varc;
2368 static void write_slice_end(MpegEncContext *s){
2369 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
2370 if(s->partitioned_frame){
2371 ff_mpeg4_merge_partitions(s);
2374 ff_mpeg4_stuffing(&s->pb);
2375 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2376 ff_mjpeg_encode_stuffing(s);
2379 avpriv_align_put_bits(&s->pb);
2380 flush_put_bits(&s->pb);
2382 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2383 s->misc_bits+= get_bits_diff(s);
2386 static void write_mb_info(MpegEncContext *s)
2388 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2389 int offset = put_bits_count(&s->pb);
2390 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2391 int gobn = s->mb_y / s->gob_index;
2393 if (CONFIG_H263_ENCODER)
2394 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2395 bytestream_put_le32(&ptr, offset);
2396 bytestream_put_byte(&ptr, s->qscale);
2397 bytestream_put_byte(&ptr, gobn);
2398 bytestream_put_le16(&ptr, mba);
2399 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2400 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2401 /* 4MV not implemented */
2402 bytestream_put_byte(&ptr, 0); /* hmv2 */
2403 bytestream_put_byte(&ptr, 0); /* vmv2 */
2406 static void update_mb_info(MpegEncContext *s, int startcode)
2410 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2411 s->mb_info_size += 12;
2412 s->prev_mb_info = s->last_mb_info;
2415 s->prev_mb_info = put_bits_count(&s->pb)/8;
2416 /* This might have incremented mb_info_size above, and we return without
2417 * actually writing any info into that slot yet. But in that case,
2418 * this will be called again at the start of the after writing the
2419 * start code, actually writing the mb info. */
2423 s->last_mb_info = put_bits_count(&s->pb)/8;
2424 if (!s->mb_info_size)
2425 s->mb_info_size += 12;
2429 static int encode_thread(AVCodecContext *c, void *arg){
2430 MpegEncContext *s= *(void**)arg;
2431 int mb_x, mb_y, pdif = 0;
2432 int chr_h= 16>>s->chroma_y_shift;
2434 MpegEncContext best_s, backup_s;
2435 uint8_t bit_buf[2][MAX_MB_BYTES];
2436 uint8_t bit_buf2[2][MAX_MB_BYTES];
2437 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2438 PutBitContext pb[2], pb2[2], tex_pb[2];
2439 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2441 ff_check_alignment();
2444 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2445 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2446 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2449 s->last_bits= put_bits_count(&s->pb);
2460 /* init last dc values */
2461 /* note: quant matrix value (8) is implied here */
2462 s->last_dc[i] = 128 << s->intra_dc_precision;
2464 s->current_picture.f.error[i] = 0;
2466 if(s->codec_id==CODEC_ID_AMV){
2467 s->last_dc[0] = 128*8/13;
2468 s->last_dc[1] = 128*8/14;
2469 s->last_dc[2] = 128*8/14;
2472 memset(s->last_mv, 0, sizeof(s->last_mv));
2476 switch(s->codec_id){
2478 case CODEC_ID_H263P:
2480 if (CONFIG_H263_ENCODER)
2481 s->gob_index = ff_h263_get_gob_height(s);
2483 case CODEC_ID_MPEG4:
2484 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2485 ff_mpeg4_init_partitions(s);
2491 s->first_slice_line = 1;
2492 s->ptr_lastgob = s->pb.buf;
2493 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2494 // printf("row %d at %X\n", s->mb_y, (int)s);
2498 ff_set_qscale(s, s->qscale);
2499 ff_init_block_index(s);
2501 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2502 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2503 int mb_type= s->mb_type[xy];
2508 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2509 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2512 if(s->data_partitioning){
2513 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2514 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2515 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2521 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2522 ff_update_block_index(s);
2524 if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){
2525 ff_h261_reorder_mb_index(s);
2526 xy= s->mb_y*s->mb_stride + s->mb_x;
2527 mb_type= s->mb_type[xy];
2530 /* write gob / video packet header */
2532 int current_packet_size, is_gob_start;
2534 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2536 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2538 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2540 switch(s->codec_id){
2542 case CODEC_ID_H263P:
2543 if(!s->h263_slice_structured)
2544 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2546 case CODEC_ID_MPEG2VIDEO:
2547 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2548 case CODEC_ID_MPEG1VIDEO:
2549 if(s->mb_skip_run) is_gob_start=0;
2551 case CODEC_ID_MJPEG:
2552 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2557 if(s->start_mb_y != mb_y || mb_x!=0){
2559 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
2560 ff_mpeg4_init_partitions(s);
2564 assert((put_bits_count(&s->pb)&7) == 0);
2565 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2567 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2568 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2569 int d= 100 / s->avctx->error_rate;
2571 current_packet_size=0;
2572 s->pb.buf_ptr= s->ptr_lastgob;
2573 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2577 if (s->avctx->rtp_callback){
2578 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2579 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2581 update_mb_info(s, 1);
2583 switch(s->codec_id){
2584 case CODEC_ID_MPEG4:
2585 if (CONFIG_MPEG4_ENCODER) {
2586 ff_mpeg4_encode_video_packet_header(s);
2587 ff_mpeg4_clean_buffers(s);
2590 case CODEC_ID_MPEG1VIDEO:
2591 case CODEC_ID_MPEG2VIDEO:
2592 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2593 ff_mpeg1_encode_slice_header(s);
2594 ff_mpeg1_clean_buffers(s);
2598 case CODEC_ID_H263P:
2599 if (CONFIG_H263_ENCODER)
2600 ff_h263_encode_gob_header(s, mb_y);
2604 if(s->flags&CODEC_FLAG_PASS1){
2605 int bits= put_bits_count(&s->pb);
2606 s->misc_bits+= bits - s->last_bits;
2610 s->ptr_lastgob += current_packet_size;
2611 s->first_slice_line=1;
2612 s->resync_mb_x=mb_x;
2613 s->resync_mb_y=mb_y;
2617 if( (s->resync_mb_x == s->mb_x)
2618 && s->resync_mb_y+1 == s->mb_y){
2619 s->first_slice_line=0;
2623 s->dquant=0; //only for QP_RD
2625 update_mb_info(s, 0);
2627 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
2629 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2631 copy_context_before_encode(&backup_s, s, -1);
2633 best_s.data_partitioning= s->data_partitioning;
2634 best_s.partitioned_frame= s->partitioned_frame;
2635 if(s->data_partitioning){
2636 backup_s.pb2= s->pb2;
2637 backup_s.tex_pb= s->tex_pb;
2640 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2641 s->mv_dir = MV_DIR_FORWARD;
2642 s->mv_type = MV_TYPE_16X16;
2644 s->mv[0][0][0] = s->p_mv_table[xy][0];
2645 s->mv[0][0][1] = s->p_mv_table[xy][1];
2646 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2647 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2649 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2650 s->mv_dir = MV_DIR_FORWARD;
2651 s->mv_type = MV_TYPE_FIELD;
2654 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2655 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2656 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2658 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2659 &dmin, &next_block, 0, 0);
2661 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2662 s->mv_dir = MV_DIR_FORWARD;
2663 s->mv_type = MV_TYPE_16X16;
2667 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2668 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2670 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2671 s->mv_dir = MV_DIR_FORWARD;
2672 s->mv_type = MV_TYPE_8X8;
2675 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2676 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2678 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2679 &dmin, &next_block, 0, 0);
2681 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2682 s->mv_dir = MV_DIR_FORWARD;
2683 s->mv_type = MV_TYPE_16X16;
2685 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2686 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2687 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2688 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2690 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2691 s->mv_dir = MV_DIR_BACKWARD;
2692 s->mv_type = MV_TYPE_16X16;
2694 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2695 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2696 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2697 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2699 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2700 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2701 s->mv_type = MV_TYPE_16X16;
2703 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2704 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2705 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2706 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2707 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2708 &dmin, &next_block, 0, 0);
2710 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2711 s->mv_dir = MV_DIR_FORWARD;
2712 s->mv_type = MV_TYPE_FIELD;
2715 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2716 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2717 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2719 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2720 &dmin, &next_block, 0, 0);
2722 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2723 s->mv_dir = MV_DIR_BACKWARD;
2724 s->mv_type = MV_TYPE_FIELD;
2727 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2728 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2729 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2731 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2732 &dmin, &next_block, 0, 0);
2734 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2735 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2736 s->mv_type = MV_TYPE_FIELD;
2738 for(dir=0; dir<2; dir++){
2740 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2741 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2742 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2745 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2746 &dmin, &next_block, 0, 0);
2748 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2750 s->mv_type = MV_TYPE_16X16;
2754 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2755 &dmin, &next_block, 0, 0);
2756 if(s->h263_pred || s->h263_aic){
2758 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2760 ff_clean_intra_table_entries(s); //old mode?
2764 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2765 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2766 const int last_qp= backup_s.qscale;
2769 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2770 static const int dquant_tab[4]={-1,1,-2,2};
2772 assert(backup_s.dquant == 0);
2775 s->mv_dir= best_s.mv_dir;
2776 s->mv_type = MV_TYPE_16X16;
2777 s->mb_intra= best_s.mb_intra;
2778 s->mv[0][0][0] = best_s.mv[0][0][0];
2779 s->mv[0][0][1] = best_s.mv[0][0][1];
2780 s->mv[1][0][0] = best_s.mv[1][0][0];
2781 s->mv[1][0][1] = best_s.mv[1][0][1];
2783 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2784 for(; qpi<4; qpi++){
2785 int dquant= dquant_tab[qpi];
2786 qp= last_qp + dquant;
2787 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2789 backup_s.dquant= dquant;
2790 if(s->mb_intra && s->dc_val[0]){
2792 dc[i]= s->dc_val[0][ s->block_index[i] ];
2793 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2797 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2798 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2799 if(best_s.qscale != qp){
2800 if(s->mb_intra && s->dc_val[0]){
2802 s->dc_val[0][ s->block_index[i] ]= dc[i];
2803 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2810 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2811 int mx= s->b_direct_mv_table[xy][0];
2812 int my= s->b_direct_mv_table[xy][1];
2814 backup_s.dquant = 0;
2815 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2817 ff_mpeg4_set_direct_mv(s, mx, my);
2818 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2819 &dmin, &next_block, mx, my);
2821 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2822 backup_s.dquant = 0;
2823 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2825 ff_mpeg4_set_direct_mv(s, 0, 0);
2826 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2827 &dmin, &next_block, 0, 0);
2829 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2832 coded |= s->block_last_index[i];
2835 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2836 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2837 mx=my=0; //FIXME find the one we actually used
2838 ff_mpeg4_set_direct_mv(s, mx, my);
2839 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2847 s->mv_dir= best_s.mv_dir;
2848 s->mv_type = best_s.mv_type;
2850 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2851 s->mv[0][0][1] = best_s.mv[0][0][1];
2852 s->mv[1][0][0] = best_s.mv[1][0][0];
2853 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2856 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2857 &dmin, &next_block, mx, my);
2862 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2864 copy_context_after_encode(s, &best_s, -1);
2866 pb_bits_count= put_bits_count(&s->pb);
2867 flush_put_bits(&s->pb);
2868 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2871 if(s->data_partitioning){
2872 pb2_bits_count= put_bits_count(&s->pb2);
2873 flush_put_bits(&s->pb2);
2874 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2875 s->pb2= backup_s.pb2;
2877 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2878 flush_put_bits(&s->tex_pb);
2879 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2880 s->tex_pb= backup_s.tex_pb;
2882 s->last_bits= put_bits_count(&s->pb);
2884 if (CONFIG_H263_ENCODER &&
2885 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2886 ff_h263_update_motion_val(s);
2888 if(next_block==0){ //FIXME 16 vs linesize16
2889 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2890 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2891 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2894 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2895 ff_MPV_decode_mb(s, s->block);
2897 int motion_x = 0, motion_y = 0;
2898 s->mv_type=MV_TYPE_16X16;
2899 // only one MB-Type possible
2902 case CANDIDATE_MB_TYPE_INTRA:
2905 motion_x= s->mv[0][0][0] = 0;
2906 motion_y= s->mv[0][0][1] = 0;
2908 case CANDIDATE_MB_TYPE_INTER:
2909 s->mv_dir = MV_DIR_FORWARD;
2911 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2912 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2914 case CANDIDATE_MB_TYPE_INTER_I:
2915 s->mv_dir = MV_DIR_FORWARD;
2916 s->mv_type = MV_TYPE_FIELD;
2919 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2920 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2921 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2924 case CANDIDATE_MB_TYPE_INTER4V:
2925 s->mv_dir = MV_DIR_FORWARD;
2926 s->mv_type = MV_TYPE_8X8;
2929 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2930 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2933 case CANDIDATE_MB_TYPE_DIRECT:
2934 if (CONFIG_MPEG4_ENCODER) {
2935 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2937 motion_x=s->b_direct_mv_table[xy][0];
2938 motion_y=s->b_direct_mv_table[xy][1];
2939 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2942 case CANDIDATE_MB_TYPE_DIRECT0:
2943 if (CONFIG_MPEG4_ENCODER) {
2944 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2946 ff_mpeg4_set_direct_mv(s, 0, 0);
2949 case CANDIDATE_MB_TYPE_BIDIR:
2950 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2952 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2953 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2954 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2955 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2957 case CANDIDATE_MB_TYPE_BACKWARD:
2958 s->mv_dir = MV_DIR_BACKWARD;
2960 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2961 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2963 case CANDIDATE_MB_TYPE_FORWARD:
2964 s->mv_dir = MV_DIR_FORWARD;
2966 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2967 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2968 // printf(" %d %d ", motion_x, motion_y);
2970 case CANDIDATE_MB_TYPE_FORWARD_I:
2971 s->mv_dir = MV_DIR_FORWARD;
2972 s->mv_type = MV_TYPE_FIELD;
2975 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2976 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2977 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2980 case CANDIDATE_MB_TYPE_BACKWARD_I:
2981 s->mv_dir = MV_DIR_BACKWARD;
2982 s->mv_type = MV_TYPE_FIELD;
2985 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2986 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2987 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2990 case CANDIDATE_MB_TYPE_BIDIR_I:
2991 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2992 s->mv_type = MV_TYPE_FIELD;
2994 for(dir=0; dir<2; dir++){
2996 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2997 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2998 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3003 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3006 encode_mb(s, motion_x, motion_y);
3008 // RAL: Update last macroblock type
3009 s->last_mv_dir = s->mv_dir;
3011 if (CONFIG_H263_ENCODER &&
3012 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3013 ff_h263_update_motion_val(s);
3015 ff_MPV_decode_mb(s, s->block);
3018 /* clean the MV table in IPS frames for direct mode in B frames */
3019 if(s->mb_intra /* && I,P,S_TYPE */){
3020 s->p_mv_table[xy][0]=0;
3021 s->p_mv_table[xy][1]=0;
3024 if(s->flags&CODEC_FLAG_PSNR){
3028 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3029 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3031 s->current_picture.f.error[0] += sse(
3032 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3033 s->dest[0], w, h, s->linesize);
3034 s->current_picture.f.error[1] += sse(
3035 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3036 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3037 s->current_picture.f.error[2] += sse(
3038 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3039 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3042 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3043 ff_h263_loop_filter(s);
3045 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
3049 //not beautiful here but we must write it before flushing so it has to be here
3050 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3051 ff_msmpeg4_encode_ext_header(s);
3055 /* Send the last GOB if RTP */
3056 if (s->avctx->rtp_callback) {
3057 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3058 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3059 /* Call the RTP callback to send the last GOB */
3061 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3067 #define MERGE(field) dst->field += src->field; src->field=0
3068 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3069 MERGE(me.scene_change_score);
3070 MERGE(me.mc_mb_var_sum_temp);
3071 MERGE(me.mb_var_sum_temp);
3074 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3077 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3078 MERGE(dct_count[1]);
3088 MERGE(padding_bug_score);
3089 MERGE(current_picture.f.error[0]);
3090 MERGE(current_picture.f.error[1]);
3091 MERGE(current_picture.f.error[2]);
3093 if(dst->avctx->noise_reduction){
3094 for(i=0; i<64; i++){
3095 MERGE(dct_error_sum[0][i]);
3096 MERGE(dct_error_sum[1][i]);
3100 assert(put_bits_count(&src->pb) % 8 ==0);
3101 assert(put_bits_count(&dst->pb) % 8 ==0);
3102 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3103 flush_put_bits(&dst->pb);
3106 static int estimate_qp(MpegEncContext *s, int dry_run){
3107 if (s->next_lambda){
3108 s->current_picture_ptr->f.quality =
3109 s->current_picture.f.quality = s->next_lambda;
3110 if(!dry_run) s->next_lambda= 0;
3111 } else if (!s->fixed_qscale) {
3112 s->current_picture_ptr->f.quality =
3113 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3114 if (s->current_picture.f.quality < 0)
3118 if(s->adaptive_quant){
3119 switch(s->codec_id){
3120 case CODEC_ID_MPEG4:
3121 if (CONFIG_MPEG4_ENCODER)
3122 ff_clean_mpeg4_qscales(s);
3125 case CODEC_ID_H263P:
3127 if (CONFIG_H263_ENCODER)
3128 ff_clean_h263_qscales(s);
3131 ff_init_qscale_tab(s);
3134 s->lambda= s->lambda_table[0];
3137 s->lambda = s->current_picture.f.quality;
3138 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3143 /* must be called before writing the header */
3144 static void set_frame_distances(MpegEncContext * s){
3145 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3146 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3148 if(s->pict_type==AV_PICTURE_TYPE_B){
3149 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3150 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3152 s->pp_time= s->time - s->last_non_b_time;
3153 s->last_non_b_time= s->time;
3154 assert(s->picture_number==0 || s->pp_time > 0);
3158 static int encode_picture(MpegEncContext *s, int picture_number)
3162 int context_count = s->slice_context_count;
3164 s->picture_number = picture_number;
3166 /* Reset the average MB variance */
3167 s->me.mb_var_sum_temp =
3168 s->me.mc_mb_var_sum_temp = 0;
3170 /* we need to initialize some time vars before we can encode b-frames */
3171 // RAL: Condition added for MPEG1VIDEO
3172 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3173 set_frame_distances(s);
3174 if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
3175 ff_set_mpeg4_time(s);
3177 s->me.scene_change_score=0;
3179 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3181 if(s->pict_type==AV_PICTURE_TYPE_I){
3182 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3183 else s->no_rounding=0;
3184 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3185 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3186 s->no_rounding ^= 1;
3189 if(s->flags & CODEC_FLAG_PASS2){
3190 if (estimate_qp(s,1) < 0)
3192 ff_get_2pass_fcode(s);
3193 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3194 if(s->pict_type==AV_PICTURE_TYPE_B)
3195 s->lambda= s->last_lambda_for[s->pict_type];
3197 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3201 if(s->codec_id != CODEC_ID_AMV){
3202 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3203 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3204 s->q_chroma_intra_matrix = s->q_intra_matrix;
3205 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3208 s->mb_intra=0; //for the rate distortion & bit compare functions
3209 for(i=1; i<context_count; i++){
3210 ff_update_duplicate_context(s->thread_context[i], s);
3216 /* Estimate motion for every MB */
3217 if(s->pict_type != AV_PICTURE_TYPE_I){
3218 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3219 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3220 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3221 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3222 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3226 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3227 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3229 for(i=0; i<s->mb_stride*s->mb_height; i++)
3230 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3232 if(!s->fixed_qscale){
3233 /* finding spatial complexity for I-frame rate control */
3234 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3237 for(i=1; i<context_count; i++){
3238 merge_context_after_me(s, s->thread_context[i]);
3240 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3241 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3244 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3245 s->pict_type= AV_PICTURE_TYPE_I;
3246 for(i=0; i<s->mb_stride*s->mb_height; i++)
3247 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3248 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3249 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3253 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3254 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3256 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3258 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3259 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3260 s->f_code= FFMAX3(s->f_code, a, b);
3263 ff_fix_long_p_mvs(s);
3264 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3265 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3269 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3270 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3275 if(s->pict_type==AV_PICTURE_TYPE_B){
3278 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3279 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3280 s->f_code = FFMAX(a, b);
3282 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3283 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3284 s->b_code = FFMAX(a, b);
3286 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3287 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3288 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3289 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3290 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3292 for(dir=0; dir<2; dir++){
3295 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3296 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3297 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3298 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3306 if (estimate_qp(s, 0) < 0)
3309 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3310 s->qscale= 3; //reduce clipping problems
3312 if (s->out_format == FMT_MJPEG) {
3313 /* for mjpeg, we do include qscale in the matrix */
3315 int j= s->dsp.idct_permutation[i];
3317 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3319 s->y_dc_scale_table=
3320 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3321 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3322 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3323 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3326 if(s->codec_id == CODEC_ID_AMV){
3327 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};
3328 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};
3330 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3332 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3333 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3335 s->y_dc_scale_table= y;
3336 s->c_dc_scale_table= c;
3337 s->intra_matrix[0] = 13;
3338 s->chroma_intra_matrix[0] = 14;
3339 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3340 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3341 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3342 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3346 //FIXME var duplication
3347 s->current_picture_ptr->f.key_frame =
3348 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3349 s->current_picture_ptr->f.pict_type =
3350 s->current_picture.f.pict_type = s->pict_type;
3352 if (s->current_picture.f.key_frame)
3353 s->picture_in_gop_number=0;
3355 s->last_bits= put_bits_count(&s->pb);
3356 switch(s->out_format) {
3358 if (CONFIG_MJPEG_ENCODER)
3359 ff_mjpeg_encode_picture_header(s);
3362 if (CONFIG_H261_ENCODER)
3363 ff_h261_encode_picture_header(s, picture_number);
3366 if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2)
3367 ff_wmv2_encode_picture_header(s, picture_number);
3368 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3369 ff_msmpeg4_encode_picture_header(s, picture_number);
3370 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3371 ff_mpeg4_encode_picture_header(s, picture_number);
3372 else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
3373 ff_rv10_encode_picture_header(s, picture_number);
3374 else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
3375 ff_rv20_encode_picture_header(s, picture_number);
3376 else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
3377 ff_flv_encode_picture_header(s, picture_number);
3378 else if (CONFIG_H263_ENCODER)
3379 ff_h263_encode_picture_header(s, picture_number);
3382 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3383 ff_mpeg1_encode_picture_header(s, picture_number);
3390 bits= put_bits_count(&s->pb);
3391 s->header_bits= bits - s->last_bits;
3393 for(i=1; i<context_count; i++){
3394 update_duplicate_context_after_me(s->thread_context[i], s);
3396 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3397 for(i=1; i<context_count; i++){
3398 merge_context_after_encode(s, s->thread_context[i]);
3404 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3405 const int intra= s->mb_intra;
3408 s->dct_count[intra]++;
3410 for(i=0; i<64; i++){
3411 int level= block[i];
3415 s->dct_error_sum[intra][i] += level;
3416 level -= s->dct_offset[intra][i];
3417 if(level<0) level=0;
3419 s->dct_error_sum[intra][i] -= level;
3420 level += s->dct_offset[intra][i];
3421 if(level>0) level=0;
3428 static int dct_quantize_trellis_c(MpegEncContext *s,
3429 DCTELEM *block, int n,
3430 int qscale, int *overflow){
3432 const uint8_t *scantable= s->intra_scantable.scantable;
3433 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3435 unsigned int threshold1, threshold2;
3447 int coeff_count[64];
3448 int qmul, qadd, start_i, last_non_zero, i, dc;
3449 const int esc_length= s->ac_esc_length;
3451 uint8_t * last_length;
3452 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3454 s->dsp.fdct (block);
3456 if(s->dct_error_sum)
3457 s->denoise_dct(s, block);
3459 qadd= ((qscale-1)|1)*8;
3470 /* For AIC we skip quant/dequant of INTRADC */
3475 /* note: block[0] is assumed to be positive */
3476 block[0] = (block[0] + (q >> 1)) / q;
3479 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3480 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3481 bias= 1<<(QMAT_SHIFT-1);
3482 length = s->intra_ac_vlc_length;
3483 last_length= s->intra_ac_vlc_last_length;
3487 qmat = s->q_inter_matrix[qscale];
3488 length = s->inter_ac_vlc_length;
3489 last_length= s->inter_ac_vlc_last_length;
3493 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3494 threshold2= (threshold1<<1);
3496 for(i=63; i>=start_i; i--) {
3497 const int j = scantable[i];
3498 int level = block[j] * qmat[j];
3500 if(((unsigned)(level+threshold1))>threshold2){
3506 for(i=start_i; i<=last_non_zero; i++) {
3507 const int j = scantable[i];
3508 int level = block[j] * qmat[j];
3510 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3511 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3512 if(((unsigned)(level+threshold1))>threshold2){
3514 level= (bias + level)>>QMAT_SHIFT;
3516 coeff[1][i]= level-1;
3517 // coeff[2][k]= level-2;
3519 level= (bias - level)>>QMAT_SHIFT;
3520 coeff[0][i]= -level;
3521 coeff[1][i]= -level+1;
3522 // coeff[2][k]= -level+2;
3524 coeff_count[i]= FFMIN(level, 2);
3525 assert(coeff_count[i]);
3528 coeff[0][i]= (level>>31)|1;
3533 *overflow= s->max_qcoeff < max; //overflow might have happened
3535 if(last_non_zero < start_i){
3536 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3537 return last_non_zero;
3540 score_tab[start_i]= 0;
3541 survivor[0]= start_i;
3544 for(i=start_i; i<=last_non_zero; i++){
3545 int level_index, j, zero_distortion;
3546 int dct_coeff= FFABS(block[ scantable[i] ]);
3547 int best_score=256*256*256*120;
3549 if (s->dsp.fdct == ff_fdct_ifast)
3550 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3551 zero_distortion= dct_coeff*dct_coeff;
3553 for(level_index=0; level_index < coeff_count[i]; level_index++){
3555 int level= coeff[level_index][i];
3556 const int alevel= FFABS(level);
3561 if(s->out_format == FMT_H263){
3562 unquant_coeff= alevel*qmul + qadd;
3564 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3566 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3567 unquant_coeff = (unquant_coeff - 1) | 1;
3569 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3570 unquant_coeff = (unquant_coeff - 1) | 1;
3575 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3577 if((level&(~127)) == 0){
3578 for(j=survivor_count-1; j>=0; j--){
3579 int run= i - survivor[j];
3580 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3581 score += score_tab[i-run];
3583 if(score < best_score){
3586 level_tab[i+1]= level-64;
3590 if(s->out_format == FMT_H263){
3591 for(j=survivor_count-1; j>=0; j--){
3592 int run= i - survivor[j];
3593 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3594 score += score_tab[i-run];
3595 if(score < last_score){
3598 last_level= level-64;
3604 distortion += esc_length*lambda;
3605 for(j=survivor_count-1; j>=0; j--){
3606 int run= i - survivor[j];
3607 int score= distortion + score_tab[i-run];
3609 if(score < best_score){
3612 level_tab[i+1]= level-64;
3616 if(s->out_format == FMT_H263){
3617 for(j=survivor_count-1; j>=0; j--){
3618 int run= i - survivor[j];
3619 int score= distortion + score_tab[i-run];
3620 if(score < last_score){
3623 last_level= level-64;
3631 score_tab[i+1]= best_score;
3633 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3634 if(last_non_zero <= 27){
3635 for(; survivor_count; survivor_count--){
3636 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3640 for(; survivor_count; survivor_count--){
3641 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3646 survivor[ survivor_count++ ]= i+1;
3649 if(s->out_format != FMT_H263){
3650 last_score= 256*256*256*120;
3651 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3652 int score= score_tab[i];
3653 if(i) score += lambda*2; //FIXME exacter?
3655 if(score < last_score){
3658 last_level= level_tab[i];
3659 last_run= run_tab[i];
3664 s->coded_score[n] = last_score;
3666 dc= FFABS(block[0]);
3667 last_non_zero= last_i - 1;
3668 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3670 if(last_non_zero < start_i)
3671 return last_non_zero;
3673 if(last_non_zero == 0 && start_i == 0){
3675 int best_score= dc * dc;
3677 for(i=0; i<coeff_count[0]; i++){
3678 int level= coeff[i][0];
3679 int alevel= FFABS(level);
3680 int unquant_coeff, score, distortion;
3682 if(s->out_format == FMT_H263){
3683 unquant_coeff= (alevel*qmul + qadd)>>3;
3685 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3686 unquant_coeff = (unquant_coeff - 1) | 1;
3688 unquant_coeff = (unquant_coeff + 4) >> 3;
3689 unquant_coeff<<= 3 + 3;
3691 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3693 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3694 else score= distortion + esc_length*lambda;
3696 if(score < best_score){
3698 best_level= level - 64;
3701 block[0]= best_level;
3702 s->coded_score[n] = best_score - dc*dc;
3703 if(best_level == 0) return -1;
3704 else return last_non_zero;
3710 block[ perm_scantable[last_non_zero] ]= last_level;
3713 for(; i>start_i; i -= run_tab[i] + 1){
3714 block[ perm_scantable[i-1] ]= level_tab[i];
3717 return last_non_zero;
3720 //#define REFINE_STATS 1
3721 static int16_t basis[64][64];
3723 static void build_basis(uint8_t *perm){
3730 double s= 0.25*(1<<BASIS_SHIFT);
3732 int perm_index= perm[index];
3733 if(i==0) s*= sqrt(0.5);
3734 if(j==0) s*= sqrt(0.5);
3735 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)));
3742 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3743 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3746 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3747 const uint8_t *scantable= s->intra_scantable.scantable;
3748 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3749 // unsigned int threshold1, threshold2;
3754 int qmul, qadd, start_i, last_non_zero, i, dc;
3756 uint8_t * last_length;
3758 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3761 static int after_last=0;
3762 static int to_zero=0;
3763 static int from_zero=0;
3766 static int messed_sign=0;
3769 if(basis[0][0] == 0)
3770 build_basis(s->dsp.idct_permutation);
3781 /* For AIC we skip quant/dequant of INTRADC */
3785 q <<= RECON_SHIFT-3;
3786 /* note: block[0] is assumed to be positive */
3788 // block[0] = (block[0] + (q >> 1)) / q;
3790 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3791 // bias= 1<<(QMAT_SHIFT-1);
3792 length = s->intra_ac_vlc_length;
3793 last_length= s->intra_ac_vlc_last_length;
3797 length = s->inter_ac_vlc_length;
3798 last_length= s->inter_ac_vlc_last_length;
3800 last_non_zero = s->block_last_index[n];
3805 dc += (1<<(RECON_SHIFT-1));
3806 for(i=0; i<64; i++){
3807 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3810 STOP_TIMER("memset rem[]")}
3813 for(i=0; i<64; i++){
3818 w= FFABS(weight[i]) + qns*one;
3819 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3822 // w=weight[i] = (63*qns + (w/2)) / w;
3828 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3834 for(i=start_i; i<=last_non_zero; i++){
3835 int j= perm_scantable[i];
3836 const int level= block[j];
3840 if(level<0) coeff= qmul*level - qadd;
3841 else coeff= qmul*level + qadd;
3842 run_tab[rle_index++]=run;
3845 s->dsp.add_8x8basis(rem, basis[j], coeff);
3851 if(last_non_zero>0){
3852 STOP_TIMER("init rem[]")
3859 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3862 int run2, best_unquant_change=0, analyze_gradient;
3866 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3868 if(analyze_gradient){
3872 for(i=0; i<64; i++){
3875 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3878 STOP_TIMER("rem*w*w")}
3888 const int level= block[0];
3889 int change, old_coeff;
3891 assert(s->mb_intra);
3895 for(change=-1; change<=1; change+=2){
3896 int new_level= level + change;
3897 int score, new_coeff;
3899 new_coeff= q*new_level;
3900 if(new_coeff >= 2048 || new_coeff < 0)
3903 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3904 if(score<best_score){
3907 best_change= change;
3908 best_unquant_change= new_coeff - old_coeff;
3915 run2= run_tab[rle_index++];
3919 for(i=start_i; i<64; i++){
3920 int j= perm_scantable[i];
3921 const int level= block[j];
3922 int change, old_coeff;
3924 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3928 if(level<0) old_coeff= qmul*level - qadd;
3929 else old_coeff= qmul*level + qadd;
3930 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3934 assert(run2>=0 || i >= last_non_zero );
3937 for(change=-1; change<=1; change+=2){
3938 int new_level= level + change;
3939 int score, new_coeff, unquant_change;
3942 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3946 if(new_level<0) new_coeff= qmul*new_level - qadd;
3947 else new_coeff= qmul*new_level + qadd;
3948 if(new_coeff >= 2048 || new_coeff <= -2048)
3950 //FIXME check for overflow
3953 if(level < 63 && level > -63){
3954 if(i < last_non_zero)
3955 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3956 - length[UNI_AC_ENC_INDEX(run, level+64)];
3958 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3959 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3962 assert(FFABS(new_level)==1);
3964 if(analyze_gradient){
3965 int g= d1[ scantable[i] ];
3966 if(g && (g^new_level) >= 0)
3970 if(i < last_non_zero){
3971 int next_i= i + run2 + 1;
3972 int next_level= block[ perm_scantable[next_i] ] + 64;
3974 if(next_level&(~127))
3977 if(next_i < last_non_zero)
3978 score += length[UNI_AC_ENC_INDEX(run, 65)]
3979 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3980 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3982 score += length[UNI_AC_ENC_INDEX(run, 65)]
3983 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3984 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3986 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
3988 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3989 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3995 assert(FFABS(level)==1);
3997 if(i < last_non_zero){
3998 int next_i= i + run2 + 1;
3999 int next_level= block[ perm_scantable[next_i] ] + 64;
4001 if(next_level&(~127))
4004 if(next_i < last_non_zero)
4005 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4006 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4007 - length[UNI_AC_ENC_INDEX(run, 65)];
4009 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4010 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4011 - length[UNI_AC_ENC_INDEX(run, 65)];
4013 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4015 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4016 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4023 unquant_change= new_coeff - old_coeff;
4024 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4026 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4027 if(score<best_score){
4030 best_change= change;
4031 best_unquant_change= unquant_change;
4035 prev_level= level + 64;
4036 if(prev_level&(~127))
4045 STOP_TIMER("iterative step")}
4049 int j= perm_scantable[ best_coeff ];
4051 block[j] += best_change;
4053 if(best_coeff > last_non_zero){
4054 last_non_zero= best_coeff;
4062 if(block[j] - best_change){
4063 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4075 for(; last_non_zero>=start_i; last_non_zero--){
4076 if(block[perm_scantable[last_non_zero]])
4082 if(256*256*256*64 % count == 0){
4083 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4088 for(i=start_i; i<=last_non_zero; i++){
4089 int j= perm_scantable[i];
4090 const int level= block[j];
4093 run_tab[rle_index++]=run;
4100 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4106 if(last_non_zero>0){
4107 STOP_TIMER("iterative search")
4112 return last_non_zero;
4115 int ff_dct_quantize_c(MpegEncContext *s,
4116 DCTELEM *block, int n,
4117 int qscale, int *overflow)
4119 int i, j, level, last_non_zero, q, start_i;
4121 const uint8_t *scantable= s->intra_scantable.scantable;
4124 unsigned int threshold1, threshold2;
4126 s->dsp.fdct (block);
4128 if(s->dct_error_sum)
4129 s->denoise_dct(s, block);
4139 /* For AIC we skip quant/dequant of INTRADC */
4142 /* note: block[0] is assumed to be positive */
4143 block[0] = (block[0] + (q >> 1)) / q;
4146 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4147 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4151 qmat = s->q_inter_matrix[qscale];
4152 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4154 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4155 threshold2= (threshold1<<1);
4156 for(i=63;i>=start_i;i--) {
4158 level = block[j] * qmat[j];
4160 if(((unsigned)(level+threshold1))>threshold2){
4167 for(i=start_i; i<=last_non_zero; i++) {
4169 level = block[j] * qmat[j];
4171 // if( bias+level >= (1<<QMAT_SHIFT)
4172 // || bias-level >= (1<<QMAT_SHIFT)){
4173 if(((unsigned)(level+threshold1))>threshold2){
4175 level= (bias + level)>>QMAT_SHIFT;
4178 level= (bias - level)>>QMAT_SHIFT;
4186 *overflow= s->max_qcoeff < max; //overflow might have happened
4188 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4189 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4190 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4192 return last_non_zero;
4195 #define OFFSET(x) offsetof(MpegEncContext, x)
4196 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4197 static const AVOption h263_options[] = {
4198 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4199 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4200 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { 0 }, 0, INT_MAX, VE },
4205 static const AVClass h263_class = {
4206 .class_name = "H.263 encoder",
4207 .item_name = av_default_item_name,
4208 .option = h263_options,
4209 .version = LIBAVUTIL_VERSION_INT,
4212 AVCodec ff_h263_encoder = {
4214 .type = AVMEDIA_TYPE_VIDEO,
4215 .id = CODEC_ID_H263,
4216 .priv_data_size = sizeof(MpegEncContext),
4217 .init = ff_MPV_encode_init,
4218 .encode2 = ff_MPV_encode_picture,
4219 .close = ff_MPV_encode_end,
4220 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4221 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4222 .priv_class = &h263_class,
4225 static const AVOption h263p_options[] = {
4226 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4227 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4228 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4229 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4233 static const AVClass h263p_class = {
4234 .class_name = "H.263p encoder",
4235 .item_name = av_default_item_name,
4236 .option = h263p_options,
4237 .version = LIBAVUTIL_VERSION_INT,
4240 AVCodec ff_h263p_encoder = {
4242 .type = AVMEDIA_TYPE_VIDEO,
4243 .id = CODEC_ID_H263P,
4244 .priv_data_size = sizeof(MpegEncContext),
4245 .init = ff_MPV_encode_init,
4246 .encode2 = ff_MPV_encode_picture,
4247 .close = ff_MPV_encode_end,
4248 .capabilities = CODEC_CAP_SLICE_THREADS,
4249 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4250 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4251 .priv_class = &h263p_class,
4254 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4256 AVCodec ff_msmpeg4v2_encoder = {
4257 .name = "msmpeg4v2",
4258 .type = AVMEDIA_TYPE_VIDEO,
4259 .id = CODEC_ID_MSMPEG4V2,
4260 .priv_data_size = sizeof(MpegEncContext),
4261 .init = ff_MPV_encode_init,
4262 .encode2 = ff_MPV_encode_picture,
4263 .close = ff_MPV_encode_end,
4264 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4265 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4266 .priv_class = &msmpeg4v2_class,
4269 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4271 AVCodec ff_msmpeg4v3_encoder = {
4273 .type = AVMEDIA_TYPE_VIDEO,
4274 .id = CODEC_ID_MSMPEG4V3,
4275 .priv_data_size = sizeof(MpegEncContext),
4276 .init = ff_MPV_encode_init,
4277 .encode2 = ff_MPV_encode_picture,
4278 .close = ff_MPV_encode_end,
4279 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4280 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4281 .priv_class = &msmpeg4v3_class,
4284 FF_MPV_GENERIC_CLASS(wmv1)
4286 AVCodec ff_wmv1_encoder = {
4288 .type = AVMEDIA_TYPE_VIDEO,
4289 .id = CODEC_ID_WMV1,
4290 .priv_data_size = sizeof(MpegEncContext),
4291 .init = ff_MPV_encode_init,
4292 .encode2 = ff_MPV_encode_picture,
4293 .close = ff_MPV_encode_end,
4294 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4295 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4296 .priv_class = &wmv1_class,