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"
41 #include "aandcttab.h"
43 #include "mpeg4video.h"
45 #include "bytestream.h"
52 static int encode_picture(MpegEncContext *s, int picture_number);
53 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
54 static int sse_mb(MpegEncContext *s);
55 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
56 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
58 /* enable all paranoid tests for rounding, overflows, etc... */
63 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
64 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
66 const AVOption ff_mpv_generic_options[] = {
71 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
72 uint16_t (*qmat16)[2][64],
73 const uint16_t *quant_matrix,
74 int bias, int qmin, int qmax, int intra)
79 for (qscale = qmin; qscale <= qmax; qscale++) {
81 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
82 dsp->fdct == ff_jpeg_fdct_islow_10 ||
83 dsp->fdct == ff_faandct) {
84 for (i = 0; i < 64; i++) {
85 const int j = dsp->idct_permutation[i];
86 /* 16 <= qscale * quant_matrix[i] <= 7905
87 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
88 * 19952 <= x <= 249205026
89 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
90 * 3444240 >= (1 << 36) / (x) >= 275 */
92 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
93 (qscale * quant_matrix[j]));
95 } else if (dsp->fdct == ff_fdct_ifast) {
96 for (i = 0; i < 64; i++) {
97 const int j = dsp->idct_permutation[i];
98 /* 16 <= qscale * quant_matrix[i] <= 7905
99 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
100 * 19952 <= x <= 249205026
101 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
102 * 3444240 >= (1 << 36) / (x) >= 275 */
104 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
105 (ff_aanscales[i] * qscale * quant_matrix[j]));
108 for (i = 0; i < 64; i++) {
109 const int j = dsp->idct_permutation[i];
110 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
111 * Assume x = qscale * quant_matrix[i]
113 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
114 * so 32768 >= (1 << 19) / (x) >= 67 */
115 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
116 (qscale * quant_matrix[j]));
117 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
118 // (qscale * quant_matrix[i]);
119 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
120 (qscale * quant_matrix[j]);
122 if (qmat16[qscale][0][i] == 0 ||
123 qmat16[qscale][0][i] == 128 * 256)
124 qmat16[qscale][0][i] = 128 * 256 - 1;
125 qmat16[qscale][1][i] =
126 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
127 qmat16[qscale][0][i]);
131 for (i = intra; i < 64; i++) {
133 if (dsp->fdct == ff_fdct_ifast) {
134 max = (8191LL * ff_aanscales[i]) >> 14;
136 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
142 av_log(NULL, AV_LOG_INFO,
143 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
148 static inline void update_qscale(MpegEncContext *s)
150 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
151 (FF_LAMBDA_SHIFT + 7);
152 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
154 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
158 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
164 for (i = 0; i < 64; i++) {
165 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
172 * init s->current_picture.qscale_table from s->lambda_table
174 void ff_init_qscale_tab(MpegEncContext *s)
176 int8_t * const qscale_table = s->current_picture.f.qscale_table;
179 for (i = 0; i < s->mb_num; i++) {
180 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
181 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
182 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
187 static void copy_picture_attributes(MpegEncContext *s,
193 dst->pict_type = src->pict_type;
194 dst->quality = src->quality;
195 dst->coded_picture_number = src->coded_picture_number;
196 dst->display_picture_number = src->display_picture_number;
197 //dst->reference = src->reference;
199 dst->interlaced_frame = src->interlaced_frame;
200 dst->top_field_first = src->top_field_first;
202 if (s->avctx->me_threshold) {
203 if (!src->motion_val[0])
204 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
206 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
207 if (!src->ref_index[0])
208 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
209 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
210 av_log(s->avctx, AV_LOG_ERROR,
211 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
212 src->motion_subsample_log2, dst->motion_subsample_log2);
214 memcpy(dst->mb_type, src->mb_type,
215 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
217 for (i = 0; i < 2; i++) {
218 int stride = ((16 * s->mb_width ) >>
219 src->motion_subsample_log2) + 1;
220 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
222 if (src->motion_val[i] &&
223 src->motion_val[i] != dst->motion_val[i]) {
224 memcpy(dst->motion_val[i], src->motion_val[i],
225 2 * stride * height * sizeof(int16_t));
227 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
228 memcpy(dst->ref_index[i], src->ref_index[i],
229 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
235 static void update_duplicate_context_after_me(MpegEncContext *dst,
238 #define COPY(a) dst->a= src->a
240 COPY(current_picture);
246 COPY(picture_in_gop_number);
247 COPY(gop_picture_number);
248 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
249 COPY(progressive_frame); // FIXME don't set in encode_header
250 COPY(partitioned_frame); // FIXME don't set in encode_header
255 * Set the given MpegEncContext to defaults for encoding.
256 * the changed fields will not depend upon the prior state of the MpegEncContext.
258 static void MPV_encode_defaults(MpegEncContext *s)
261 ff_MPV_common_defaults(s);
263 for (i = -16; i < 16; i++) {
264 default_fcode_tab[i + MAX_MV] = 1;
266 s->me.mv_penalty = default_mv_penalty;
267 s->fcode_tab = default_fcode_tab;
270 /* init video encoder */
271 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
273 MpegEncContext *s = avctx->priv_data;
275 int chroma_h_shift, chroma_v_shift;
277 MPV_encode_defaults(s);
279 switch (avctx->codec_id) {
280 case AV_CODEC_ID_MPEG2VIDEO:
281 if (avctx->pix_fmt != PIX_FMT_YUV420P &&
282 avctx->pix_fmt != PIX_FMT_YUV422P) {
283 av_log(avctx, AV_LOG_ERROR,
284 "only YUV420 and YUV422 are supported\n");
288 case AV_CODEC_ID_LJPEG:
289 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
290 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
291 avctx->pix_fmt != PIX_FMT_YUVJ444P &&
292 avctx->pix_fmt != PIX_FMT_BGR0 &&
293 avctx->pix_fmt != PIX_FMT_BGRA &&
294 avctx->pix_fmt != PIX_FMT_BGR24 &&
295 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
296 avctx->pix_fmt != PIX_FMT_YUV422P &&
297 avctx->pix_fmt != PIX_FMT_YUV444P) ||
298 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
299 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
303 case AV_CODEC_ID_MJPEG:
304 case AV_CODEC_ID_AMV:
305 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
306 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
307 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
308 avctx->pix_fmt != PIX_FMT_YUV422P) ||
309 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
310 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
315 if (avctx->pix_fmt != PIX_FMT_YUV420P) {
316 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
321 switch (avctx->pix_fmt) {
322 case PIX_FMT_YUVJ422P:
323 case PIX_FMT_YUV422P:
324 s->chroma_format = CHROMA_422;
326 case PIX_FMT_YUVJ420P:
327 case PIX_FMT_YUV420P:
329 s->chroma_format = CHROMA_420;
333 s->bit_rate = avctx->bit_rate;
334 s->width = avctx->width;
335 s->height = avctx->height;
336 if (avctx->gop_size > 600 &&
337 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
338 av_log(avctx, AV_LOG_WARNING,
339 "keyframe interval too large!, reducing it from %d to %d\n",
340 avctx->gop_size, 600);
341 avctx->gop_size = 600;
343 s->gop_size = avctx->gop_size;
345 s->flags = avctx->flags;
346 s->flags2 = avctx->flags2;
347 s->max_b_frames = avctx->max_b_frames;
348 s->codec_id = avctx->codec->id;
349 #if FF_API_MPV_GLOBAL_OPTS
350 if (avctx->luma_elim_threshold)
351 s->luma_elim_threshold = avctx->luma_elim_threshold;
352 if (avctx->chroma_elim_threshold)
353 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
355 s->strict_std_compliance = avctx->strict_std_compliance;
356 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
357 s->mpeg_quant = avctx->mpeg_quant;
358 s->rtp_mode = !!avctx->rtp_payload_size;
359 s->intra_dc_precision = avctx->intra_dc_precision;
360 s->user_specified_pts = AV_NOPTS_VALUE;
362 if (s->gop_size <= 1) {
369 s->me_method = avctx->me_method;
372 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
374 #if FF_API_MPV_GLOBAL_OPTS
375 if (s->flags & CODEC_FLAG_QP_RD)
376 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
379 s->adaptive_quant = (s->avctx->lumi_masking ||
380 s->avctx->dark_masking ||
381 s->avctx->temporal_cplx_masking ||
382 s->avctx->spatial_cplx_masking ||
383 s->avctx->p_masking ||
384 s->avctx->border_masking ||
385 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
388 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
390 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
391 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
392 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
396 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
397 av_log(avctx, AV_LOG_INFO,
398 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
401 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
402 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
406 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
407 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
411 if (avctx->rc_max_rate &&
412 avctx->rc_max_rate == avctx->bit_rate &&
413 avctx->rc_max_rate != avctx->rc_min_rate) {
414 av_log(avctx, AV_LOG_INFO,
415 "impossible bitrate constraints, this will fail\n");
418 if (avctx->rc_buffer_size &&
419 avctx->bit_rate * (int64_t)avctx->time_base.num >
420 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
421 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
425 if (!s->fixed_qscale &&
426 avctx->bit_rate * av_q2d(avctx->time_base) >
427 avctx->bit_rate_tolerance) {
428 av_log(avctx, AV_LOG_ERROR,
429 "bitrate tolerance too small for bitrate\n");
433 if (s->avctx->rc_max_rate &&
434 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
435 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
436 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
437 90000LL * (avctx->rc_buffer_size - 1) >
438 s->avctx->rc_max_rate * 0xFFFFLL) {
439 av_log(avctx, AV_LOG_INFO,
440 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
441 "specified vbv buffer is too large for the given bitrate!\n");
444 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
445 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
446 s->codec_id != AV_CODEC_ID_FLV1) {
447 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
451 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
452 av_log(avctx, AV_LOG_ERROR,
453 "OBMC is only supported with simple mb decision\n");
457 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
458 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
462 if (s->max_b_frames &&
463 s->codec_id != AV_CODEC_ID_MPEG4 &&
464 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
465 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
466 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
470 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
471 s->codec_id == AV_CODEC_ID_H263 ||
472 s->codec_id == AV_CODEC_ID_H263P) &&
473 (avctx->sample_aspect_ratio.num > 255 ||
474 avctx->sample_aspect_ratio.den > 255)) {
475 av_log(avctx, AV_LOG_WARNING,
476 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
477 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
478 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
479 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
482 if ((s->codec_id == AV_CODEC_ID_H263 ||
483 s->codec_id == AV_CODEC_ID_H263P) &&
484 (avctx->width > 2048 ||
485 avctx->height > 1152 )) {
486 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
489 if ((s->codec_id == AV_CODEC_ID_H263 ||
490 s->codec_id == AV_CODEC_ID_H263P) &&
491 ((avctx->width &3) ||
492 (avctx->height&3) )) {
493 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
497 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
498 (avctx->width > 4095 ||
499 avctx->height > 4095 )) {
500 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
504 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
505 (avctx->width > 16383 ||
506 avctx->height > 16383 )) {
507 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
511 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
512 s->codec_id == AV_CODEC_ID_WMV2) &&
514 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
518 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
519 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
520 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
524 // FIXME mpeg2 uses that too
525 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
526 av_log(avctx, AV_LOG_ERROR,
527 "mpeg2 style quantization not supported by codec\n");
531 #if FF_API_MPV_GLOBAL_OPTS
532 if (s->flags & CODEC_FLAG_CBP_RD)
533 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
536 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
537 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
541 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
542 s->avctx->mb_decision != FF_MB_DECISION_RD) {
543 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
547 if (s->avctx->scenechange_threshold < 1000000000 &&
548 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
549 av_log(avctx, AV_LOG_ERROR,
550 "closed gop with scene change detection are not supported yet, "
551 "set threshold to 1000000000\n");
555 if (s->flags & CODEC_FLAG_LOW_DELAY) {
556 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
557 av_log(avctx, AV_LOG_ERROR,
558 "low delay forcing is only available for mpeg2\n");
561 if (s->max_b_frames != 0) {
562 av_log(avctx, AV_LOG_ERROR,
563 "b frames cannot be used with low delay\n");
568 if (s->q_scale_type == 1) {
569 if (avctx->qmax > 12) {
570 av_log(avctx, AV_LOG_ERROR,
571 "non linear quant only supports qmax <= 12 currently\n");
576 if (s->avctx->thread_count > 1 &&
577 s->codec_id != AV_CODEC_ID_MPEG4 &&
578 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
579 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
580 s->codec_id != AV_CODEC_ID_MJPEG &&
581 (s->codec_id != AV_CODEC_ID_H263P)) {
582 av_log(avctx, AV_LOG_ERROR,
583 "multi threaded encoding not supported by codec\n");
587 if (s->avctx->thread_count < 1) {
588 av_log(avctx, AV_LOG_ERROR,
589 "automatic thread number detection not supported by codec, "
594 if (s->avctx->thread_count > 1)
597 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
598 s->h263_slice_structured = 1;
600 if (!avctx->time_base.den || !avctx->time_base.num) {
601 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
605 i = (INT_MAX / 2 + 128) >> 8;
606 if (avctx->me_threshold >= i) {
607 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
611 if (avctx->mb_threshold >= i) {
612 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
617 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
618 av_log(avctx, AV_LOG_INFO,
619 "notice: b_frame_strategy only affects the first pass\n");
620 avctx->b_frame_strategy = 0;
623 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
625 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
626 avctx->time_base.den /= i;
627 avctx->time_base.num /= i;
631 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
632 // (a + x * 3 / 8) / x
633 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
634 s->inter_quant_bias = 0;
636 s->intra_quant_bias = 0;
638 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
641 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
642 s->intra_quant_bias = avctx->intra_quant_bias;
643 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
644 s->inter_quant_bias = avctx->inter_quant_bias;
646 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
648 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
651 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
652 s->avctx->time_base.den > (1 << 16) - 1) {
653 av_log(avctx, AV_LOG_ERROR,
654 "timebase %d/%d not supported by MPEG 4 standard, "
655 "the maximum admitted value for the timebase denominator "
656 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
660 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
662 #if FF_API_MPV_GLOBAL_OPTS
663 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
664 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
665 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
666 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
667 if (avctx->quantizer_noise_shaping)
668 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
671 switch (avctx->codec->id) {
672 case AV_CODEC_ID_MPEG1VIDEO:
673 s->out_format = FMT_MPEG1;
674 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
675 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
677 case AV_CODEC_ID_MPEG2VIDEO:
678 s->out_format = FMT_MPEG1;
679 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
680 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
683 case AV_CODEC_ID_LJPEG:
684 case AV_CODEC_ID_MJPEG:
685 case AV_CODEC_ID_AMV:
686 s->out_format = FMT_MJPEG;
687 s->intra_only = 1; /* force intra only for jpeg */
688 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
689 (avctx->pix_fmt == PIX_FMT_BGR0
690 || s->avctx->pix_fmt == PIX_FMT_BGRA
691 || s->avctx->pix_fmt == PIX_FMT_BGR24)) {
692 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
693 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
694 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
696 s->mjpeg_vsample[0] = 2;
697 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
698 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
699 s->mjpeg_hsample[0] = 2;
700 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
701 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
703 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
704 ff_mjpeg_encode_init(s) < 0)
709 case AV_CODEC_ID_H261:
710 if (!CONFIG_H261_ENCODER)
712 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
713 av_log(avctx, AV_LOG_ERROR,
714 "The specified picture size of %dx%d is not valid for the "
715 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
716 s->width, s->height);
719 s->out_format = FMT_H261;
723 case AV_CODEC_ID_H263:
724 if (!CONFIG_H263_ENCODER)
726 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
727 s->width, s->height) == 8) {
728 av_log(avctx, AV_LOG_ERROR,
729 "The specified picture size of %dx%d is not valid for "
730 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
731 "352x288, 704x576, and 1408x1152. "
732 "Try H.263+.\n", s->width, s->height);
735 s->out_format = FMT_H263;
739 case AV_CODEC_ID_H263P:
740 s->out_format = FMT_H263;
743 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
744 s->modified_quant = s->h263_aic;
745 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
746 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
749 /* These are just to be sure */
753 case AV_CODEC_ID_FLV1:
754 s->out_format = FMT_H263;
755 s->h263_flv = 2; /* format = 1; 11-bit codes */
756 s->unrestricted_mv = 1;
757 s->rtp_mode = 0; /* don't allow GOB */
761 case AV_CODEC_ID_RV10:
762 s->out_format = FMT_H263;
766 case AV_CODEC_ID_RV20:
767 s->out_format = FMT_H263;
770 s->modified_quant = 1;
774 s->unrestricted_mv = 0;
776 case AV_CODEC_ID_MPEG4:
777 s->out_format = FMT_H263;
779 s->unrestricted_mv = 1;
780 s->low_delay = s->max_b_frames ? 0 : 1;
781 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
783 case AV_CODEC_ID_MSMPEG4V2:
784 s->out_format = FMT_H263;
786 s->unrestricted_mv = 1;
787 s->msmpeg4_version = 2;
791 case AV_CODEC_ID_MSMPEG4V3:
792 s->out_format = FMT_H263;
794 s->unrestricted_mv = 1;
795 s->msmpeg4_version = 3;
796 s->flipflop_rounding = 1;
800 case AV_CODEC_ID_WMV1:
801 s->out_format = FMT_H263;
803 s->unrestricted_mv = 1;
804 s->msmpeg4_version = 4;
805 s->flipflop_rounding = 1;
809 case AV_CODEC_ID_WMV2:
810 s->out_format = FMT_H263;
812 s->unrestricted_mv = 1;
813 s->msmpeg4_version = 5;
814 s->flipflop_rounding = 1;
822 avctx->has_b_frames = !s->low_delay;
826 s->progressive_frame =
827 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
828 CODEC_FLAG_INTERLACED_ME) ||
832 if (ff_MPV_common_init(s) < 0)
836 ff_MPV_encode_init_x86(s);
838 if (!s->dct_quantize)
839 s->dct_quantize = ff_dct_quantize_c;
841 s->denoise_dct = denoise_dct_c;
842 s->fast_dct_quantize = s->dct_quantize;
844 s->dct_quantize = dct_quantize_trellis_c;
846 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
847 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
849 s->quant_precision = 5;
851 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
852 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
854 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
855 ff_h261_encode_init(s);
856 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
857 ff_h263_encode_init(s);
858 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
859 ff_msmpeg4_encode_init(s);
860 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
861 && s->out_format == FMT_MPEG1)
862 ff_mpeg1_encode_init(s);
865 for (i = 0; i < 64; i++) {
866 int j = s->dsp.idct_permutation[i];
867 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
869 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
870 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
871 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
873 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
876 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
877 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
879 if (s->avctx->intra_matrix)
880 s->intra_matrix[j] = s->avctx->intra_matrix[i];
881 if (s->avctx->inter_matrix)
882 s->inter_matrix[j] = s->avctx->inter_matrix[i];
885 /* precompute matrix */
886 /* for mjpeg, we do include qscale in the matrix */
887 if (s->out_format != FMT_MJPEG) {
888 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
889 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
891 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
892 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
896 if (ff_rate_control_init(s) < 0)
902 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
904 MpegEncContext *s = avctx->priv_data;
906 ff_rate_control_uninit(s);
908 ff_MPV_common_end(s);
909 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
910 s->out_format == FMT_MJPEG)
911 ff_mjpeg_encode_close(s);
913 av_freep(&avctx->extradata);
918 static int get_sae(uint8_t *src, int ref, int stride)
923 for (y = 0; y < 16; y++) {
924 for (x = 0; x < 16; x++) {
925 acc += FFABS(src[x + y * stride] - ref);
932 static int get_intra_count(MpegEncContext *s, uint8_t *src,
933 uint8_t *ref, int stride)
941 for (y = 0; y < h; y += 16) {
942 for (x = 0; x < w; x += 16) {
943 int offset = x + y * stride;
944 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
946 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
947 int sae = get_sae(src + offset, mean, stride);
949 acc += sae + 500 < sad;
956 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
961 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
962 (s->low_delay ? 0 : 1);
967 pic_arg->display_picture_number = s->input_picture_number++;
969 if (pts != AV_NOPTS_VALUE) {
970 if (s->user_specified_pts != AV_NOPTS_VALUE) {
972 int64_t last = s->user_specified_pts;
975 av_log(s->avctx, AV_LOG_ERROR,
976 "Error, Invalid timestamp=%"PRId64", "
977 "last=%"PRId64"\n", pts, s->user_specified_pts);
981 if (!s->low_delay && pic_arg->display_picture_number == 1)
982 s->dts_delta = time - last;
984 s->user_specified_pts = pts;
986 if (s->user_specified_pts != AV_NOPTS_VALUE) {
987 s->user_specified_pts =
988 pts = s->user_specified_pts + 1;
989 av_log(s->avctx, AV_LOG_INFO,
990 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
993 pts = pic_arg->display_picture_number;
999 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
1001 if (pic_arg->linesize[0] != s->linesize)
1003 if (pic_arg->linesize[1] != s->uvlinesize)
1005 if (pic_arg->linesize[2] != s->uvlinesize)
1008 //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
1009 // pic_arg->linesize[1], s->linesize, s->uvlinesize);
1012 i = ff_find_unused_picture(s, 1);
1016 pic = &s->picture[i].f;
1019 for (i = 0; i < 4; i++) {
1020 pic->data[i] = pic_arg->data[i];
1021 pic->linesize[i] = pic_arg->linesize[i];
1023 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1027 i = ff_find_unused_picture(s, 0);
1031 pic = &s->picture[i].f;
1034 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1038 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1039 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1040 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1043 int h_chroma_shift, v_chroma_shift;
1044 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1047 for (i = 0; i < 3; i++) {
1048 int src_stride = pic_arg->linesize[i];
1049 int dst_stride = i ? s->uvlinesize : s->linesize;
1050 int h_shift = i ? h_chroma_shift : 0;
1051 int v_shift = i ? v_chroma_shift : 0;
1052 int w = s->width >> h_shift;
1053 int h = s->height >> v_shift;
1054 uint8_t *src = pic_arg->data[i];
1055 uint8_t *dst = pic->data[i];
1057 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1058 h= ((s->height+15)/16*16)>>v_shift;
1061 if (!s->avctx->rc_buffer_size)
1062 dst += INPLACE_OFFSET;
1064 if (src_stride == dst_stride)
1065 memcpy(dst, src, src_stride * h);
1068 memcpy(dst, src, w);
1076 copy_picture_attributes(s, pic, pic_arg);
1077 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1080 /* shift buffer entries */
1081 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1082 s->input_picture[i - 1] = s->input_picture[i];
1084 s->input_picture[encoding_delay] = (Picture*) pic;
1089 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1093 int64_t score64 = 0;
1095 for (plane = 0; plane < 3; plane++) {
1096 const int stride = p->f.linesize[plane];
1097 const int bw = plane ? 1 : 2;
1098 for (y = 0; y < s->mb_height * bw; y++) {
1099 for (x = 0; x < s->mb_width * bw; x++) {
1100 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1101 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1102 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1103 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1105 switch (s->avctx->frame_skip_exp) {
1106 case 0: score = FFMAX(score, v); break;
1107 case 1: score += FFABS(v); break;
1108 case 2: score += v * v; break;
1109 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1110 case 4: score64 += v * v * (int64_t)(v * v); break;
1119 if (score64 < s->avctx->frame_skip_threshold)
1121 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1126 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1128 AVPacket pkt = { 0 };
1129 int ret, got_output;
1131 av_init_packet(&pkt);
1132 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1137 av_free_packet(&pkt);
1141 static int estimate_best_b_count(MpegEncContext *s)
1143 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1144 AVCodecContext *c = avcodec_alloc_context3(NULL);
1145 AVFrame input[FF_MAX_B_FRAMES + 2];
1146 const int scale = s->avctx->brd_scale;
1147 int i, j, out_size, p_lambda, b_lambda, lambda2;
1148 int64_t best_rd = INT64_MAX;
1149 int best_b_count = -1;
1151 av_assert0(scale >= 0 && scale <= 3);
1154 //s->next_picture_ptr->quality;
1155 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1156 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1157 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1158 if (!b_lambda) // FIXME we should do this somewhere else
1159 b_lambda = p_lambda;
1160 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1163 c->width = s->width >> scale;
1164 c->height = s->height >> scale;
1165 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1166 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1167 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1168 c->mb_decision = s->avctx->mb_decision;
1169 c->me_cmp = s->avctx->me_cmp;
1170 c->mb_cmp = s->avctx->mb_cmp;
1171 c->me_sub_cmp = s->avctx->me_sub_cmp;
1172 c->pix_fmt = PIX_FMT_YUV420P;
1173 c->time_base = s->avctx->time_base;
1174 c->max_b_frames = s->max_b_frames;
1176 if (avcodec_open2(c, codec, NULL) < 0)
1179 for (i = 0; i < s->max_b_frames + 2; i++) {
1180 int ysize = c->width * c->height;
1181 int csize = (c->width / 2) * (c->height / 2);
1182 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1183 s->next_picture_ptr;
1185 avcodec_get_frame_defaults(&input[i]);
1186 input[i].data[0] = av_malloc(ysize + 2 * csize);
1187 input[i].data[1] = input[i].data[0] + ysize;
1188 input[i].data[2] = input[i].data[1] + csize;
1189 input[i].linesize[0] = c->width;
1190 input[i].linesize[1] =
1191 input[i].linesize[2] = c->width / 2;
1193 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1194 pre_input = *pre_input_ptr;
1196 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1197 pre_input.f.data[0] += INPLACE_OFFSET;
1198 pre_input.f.data[1] += INPLACE_OFFSET;
1199 pre_input.f.data[2] += INPLACE_OFFSET;
1202 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1203 pre_input.f.data[0], pre_input.f.linesize[0],
1204 c->width, c->height);
1205 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1206 pre_input.f.data[1], pre_input.f.linesize[1],
1207 c->width >> 1, c->height >> 1);
1208 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1209 pre_input.f.data[2], pre_input.f.linesize[2],
1210 c->width >> 1, c->height >> 1);
1214 for (j = 0; j < s->max_b_frames + 1; j++) {
1217 if (!s->input_picture[j])
1220 c->error[0] = c->error[1] = c->error[2] = 0;
1222 input[0].pict_type = AV_PICTURE_TYPE_I;
1223 input[0].quality = 1 * FF_QP2LAMBDA;
1225 out_size = encode_frame(c, &input[0]);
1227 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1229 for (i = 0; i < s->max_b_frames + 1; i++) {
1230 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1232 input[i + 1].pict_type = is_p ?
1233 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1234 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1236 out_size = encode_frame(c, &input[i + 1]);
1238 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1241 /* get the delayed frames */
1243 out_size = encode_frame(c, NULL);
1244 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1247 rd += c->error[0] + c->error[1] + c->error[2];
1258 for (i = 0; i < s->max_b_frames + 2; i++) {
1259 av_freep(&input[i].data[0]);
1262 return best_b_count;
1265 static int select_input_picture(MpegEncContext *s)
1269 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1270 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1271 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1273 /* set next picture type & ordering */
1274 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1275 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1276 s->next_picture_ptr == NULL || s->intra_only) {
1277 s->reordered_input_picture[0] = s->input_picture[0];
1278 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1279 s->reordered_input_picture[0]->f.coded_picture_number =
1280 s->coded_picture_number++;
1284 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1285 if (s->picture_in_gop_number < s->gop_size &&
1286 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1287 // FIXME check that te gop check above is +-1 correct
1288 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1289 // s->input_picture[0]->f.data[0],
1290 // s->input_picture[0]->pts);
1292 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1293 for (i = 0; i < 4; i++)
1294 s->input_picture[0]->f.data[i] = NULL;
1295 s->input_picture[0]->f.type = 0;
1297 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1298 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1300 s->avctx->release_buffer(s->avctx,
1301 &s->input_picture[0]->f);
1305 ff_vbv_update(s, 0);
1311 if (s->flags & CODEC_FLAG_PASS2) {
1312 for (i = 0; i < s->max_b_frames + 1; i++) {
1313 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1315 if (pict_num >= s->rc_context.num_entries)
1317 if (!s->input_picture[i]) {
1318 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1322 s->input_picture[i]->f.pict_type =
1323 s->rc_context.entry[pict_num].new_pict_type;
1327 if (s->avctx->b_frame_strategy == 0) {
1328 b_frames = s->max_b_frames;
1329 while (b_frames && !s->input_picture[b_frames])
1331 } else if (s->avctx->b_frame_strategy == 1) {
1332 for (i = 1; i < s->max_b_frames + 1; i++) {
1333 if (s->input_picture[i] &&
1334 s->input_picture[i]->b_frame_score == 0) {
1335 s->input_picture[i]->b_frame_score =
1337 s->input_picture[i ]->f.data[0],
1338 s->input_picture[i - 1]->f.data[0],
1342 for (i = 0; i < s->max_b_frames + 1; i++) {
1343 if (s->input_picture[i] == NULL ||
1344 s->input_picture[i]->b_frame_score - 1 >
1345 s->mb_num / s->avctx->b_sensitivity)
1349 b_frames = FFMAX(0, i - 1);
1352 for (i = 0; i < b_frames + 1; i++) {
1353 s->input_picture[i]->b_frame_score = 0;
1355 } else if (s->avctx->b_frame_strategy == 2) {
1356 b_frames = estimate_best_b_count(s);
1358 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1363 //static int b_count = 0;
1364 //b_count += b_frames;
1365 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1367 for (i = b_frames - 1; i >= 0; i--) {
1368 int type = s->input_picture[i]->f.pict_type;
1369 if (type && type != AV_PICTURE_TYPE_B)
1372 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1373 b_frames == s->max_b_frames) {
1374 av_log(s->avctx, AV_LOG_ERROR,
1375 "warning, too many b frames in a row\n");
1378 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1379 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1380 s->gop_size > s->picture_in_gop_number) {
1381 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1383 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1385 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1389 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1390 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1393 s->reordered_input_picture[0] = s->input_picture[b_frames];
1394 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1395 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1396 s->reordered_input_picture[0]->f.coded_picture_number =
1397 s->coded_picture_number++;
1398 for (i = 0; i < b_frames; i++) {
1399 s->reordered_input_picture[i + 1] = s->input_picture[i];
1400 s->reordered_input_picture[i + 1]->f.pict_type =
1402 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1403 s->coded_picture_number++;
1408 if (s->reordered_input_picture[0]) {
1409 s->reordered_input_picture[0]->f.reference =
1410 s->reordered_input_picture[0]->f.pict_type !=
1411 AV_PICTURE_TYPE_B ? 3 : 0;
1413 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1415 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1416 s->avctx->rc_buffer_size) {
1417 // input is a shared pix, so we can't modifiy it -> alloc a new
1418 // one & ensure that the shared one is reuseable
1421 int i = ff_find_unused_picture(s, 0);
1424 pic = &s->picture[i];
1426 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1427 if (ff_alloc_picture(s, pic, 0) < 0) {
1431 /* mark us unused / free shared pic */
1432 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1433 s->avctx->release_buffer(s->avctx,
1434 &s->reordered_input_picture[0]->f);
1435 for (i = 0; i < 4; i++)
1436 s->reordered_input_picture[0]->f.data[i] = NULL;
1437 s->reordered_input_picture[0]->f.type = 0;
1439 copy_picture_attributes(s, &pic->f,
1440 &s->reordered_input_picture[0]->f);
1442 s->current_picture_ptr = pic;
1444 // input is not a shared pix -> reuse buffer for current_pix
1446 assert(s->reordered_input_picture[0]->f.type ==
1447 FF_BUFFER_TYPE_USER ||
1448 s->reordered_input_picture[0]->f.type ==
1449 FF_BUFFER_TYPE_INTERNAL);
1451 s->current_picture_ptr = s->reordered_input_picture[0];
1452 for (i = 0; i < 4; i++) {
1453 s->new_picture.f.data[i] += INPLACE_OFFSET;
1456 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1458 s->picture_number = s->new_picture.f.display_picture_number;
1459 //printf("dpn:%d\n", s->picture_number);
1461 memset(&s->new_picture, 0, sizeof(Picture));
1466 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1467 AVFrame *pic_arg, int *got_packet)
1469 MpegEncContext *s = avctx->priv_data;
1470 int i, stuffing_count, ret;
1471 int context_count = s->slice_context_count;
1473 s->picture_in_gop_number++;
1475 if (load_input_picture(s, pic_arg) < 0)
1478 if (select_input_picture(s) < 0) {
1483 if (s->new_picture.f.data[0]) {
1484 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1487 s->mb_info_ptr = av_packet_new_side_data(pkt,
1488 AV_PKT_DATA_H263_MB_INFO,
1489 s->mb_width*s->mb_height*12);
1490 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1493 for (i = 0; i < context_count; i++) {
1494 int start_y = s->thread_context[i]->start_mb_y;
1495 int end_y = s->thread_context[i]-> end_mb_y;
1496 int h = s->mb_height;
1497 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1498 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1500 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1503 s->pict_type = s->new_picture.f.pict_type;
1505 //printf("qs:%f %f %d\n", s->new_picture.quality,
1506 // s->current_picture.quality, s->qscale);
1507 ff_MPV_frame_start(s, avctx);
1509 if (encode_picture(s, s->picture_number) < 0)
1512 avctx->header_bits = s->header_bits;
1513 avctx->mv_bits = s->mv_bits;
1514 avctx->misc_bits = s->misc_bits;
1515 avctx->i_tex_bits = s->i_tex_bits;
1516 avctx->p_tex_bits = s->p_tex_bits;
1517 avctx->i_count = s->i_count;
1518 // FIXME f/b_count in avctx
1519 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1520 avctx->skip_count = s->skip_count;
1522 ff_MPV_frame_end(s);
1524 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1525 ff_mjpeg_encode_picture_trailer(s);
1527 if (avctx->rc_buffer_size) {
1528 RateControlContext *rcc = &s->rc_context;
1529 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1531 if (put_bits_count(&s->pb) > max_size &&
1532 s->lambda < s->avctx->lmax) {
1533 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1534 (s->qscale + 1) / s->qscale);
1535 if (s->adaptive_quant) {
1537 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1538 s->lambda_table[i] =
1539 FFMAX(s->lambda_table[i] + 1,
1540 s->lambda_table[i] * (s->qscale + 1) /
1543 s->mb_skipped = 0; // done in MPV_frame_start()
1544 // done in encode_picture() so we must undo it
1545 if (s->pict_type == AV_PICTURE_TYPE_P) {
1546 if (s->flipflop_rounding ||
1547 s->codec_id == AV_CODEC_ID_H263P ||
1548 s->codec_id == AV_CODEC_ID_MPEG4)
1549 s->no_rounding ^= 1;
1551 if (s->pict_type != AV_PICTURE_TYPE_B) {
1552 s->time_base = s->last_time_base;
1553 s->last_non_b_time = s->time - s->pp_time;
1555 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1556 for (i = 0; i < context_count; i++) {
1557 PutBitContext *pb = &s->thread_context[i]->pb;
1558 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1563 assert(s->avctx->rc_max_rate);
1566 if (s->flags & CODEC_FLAG_PASS1)
1567 ff_write_pass1_stats(s);
1569 for (i = 0; i < 4; i++) {
1570 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1571 avctx->error[i] += s->current_picture_ptr->f.error[i];
1574 if (s->flags & CODEC_FLAG_PASS1)
1575 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1576 avctx->i_tex_bits + avctx->p_tex_bits ==
1577 put_bits_count(&s->pb));
1578 flush_put_bits(&s->pb);
1579 s->frame_bits = put_bits_count(&s->pb);
1581 stuffing_count = ff_vbv_update(s, s->frame_bits);
1582 if (stuffing_count) {
1583 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1584 stuffing_count + 50) {
1585 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1589 switch (s->codec_id) {
1590 case AV_CODEC_ID_MPEG1VIDEO:
1591 case AV_CODEC_ID_MPEG2VIDEO:
1592 while (stuffing_count--) {
1593 put_bits(&s->pb, 8, 0);
1596 case AV_CODEC_ID_MPEG4:
1597 put_bits(&s->pb, 16, 0);
1598 put_bits(&s->pb, 16, 0x1C3);
1599 stuffing_count -= 4;
1600 while (stuffing_count--) {
1601 put_bits(&s->pb, 8, 0xFF);
1605 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1607 flush_put_bits(&s->pb);
1608 s->frame_bits = put_bits_count(&s->pb);
1611 /* update mpeg1/2 vbv_delay for CBR */
1612 if (s->avctx->rc_max_rate &&
1613 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1614 s->out_format == FMT_MPEG1 &&
1615 90000LL * (avctx->rc_buffer_size - 1) <=
1616 s->avctx->rc_max_rate * 0xFFFFLL) {
1617 int vbv_delay, min_delay;
1618 double inbits = s->avctx->rc_max_rate *
1619 av_q2d(s->avctx->time_base);
1620 int minbits = s->frame_bits - 8 *
1621 (s->vbv_delay_ptr - s->pb.buf - 1);
1622 double bits = s->rc_context.buffer_index + minbits - inbits;
1625 av_log(s->avctx, AV_LOG_ERROR,
1626 "Internal error, negative bits\n");
1628 assert(s->repeat_first_field == 0);
1630 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1631 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1632 s->avctx->rc_max_rate;
1634 vbv_delay = FFMAX(vbv_delay, min_delay);
1636 av_assert0(vbv_delay < 0xFFFF);
1638 s->vbv_delay_ptr[0] &= 0xF8;
1639 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1640 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1641 s->vbv_delay_ptr[2] &= 0x07;
1642 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1643 avctx->vbv_delay = vbv_delay * 300;
1645 s->total_bits += s->frame_bits;
1646 avctx->frame_bits = s->frame_bits;
1648 pkt->pts = s->current_picture.f.pts;
1649 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1650 if (!s->current_picture.f.coded_picture_number)
1651 pkt->dts = pkt->pts - s->dts_delta;
1653 pkt->dts = s->reordered_pts;
1654 s->reordered_pts = pkt->pts;
1656 pkt->dts = pkt->pts;
1657 if (s->current_picture.f.key_frame)
1658 pkt->flags |= AV_PKT_FLAG_KEY;
1660 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1664 assert((s->frame_bits & 7) == 0);
1666 pkt->size = s->frame_bits / 8;
1667 *got_packet = !!pkt->size;
1671 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1672 int n, int threshold)
1674 static const char tab[64] = {
1675 3, 2, 2, 1, 1, 1, 1, 1,
1676 1, 1, 1, 1, 1, 1, 1, 1,
1677 1, 1, 1, 1, 1, 1, 1, 1,
1678 0, 0, 0, 0, 0, 0, 0, 0,
1679 0, 0, 0, 0, 0, 0, 0, 0,
1680 0, 0, 0, 0, 0, 0, 0, 0,
1681 0, 0, 0, 0, 0, 0, 0, 0,
1682 0, 0, 0, 0, 0, 0, 0, 0
1687 DCTELEM *block = s->block[n];
1688 const int last_index = s->block_last_index[n];
1691 if (threshold < 0) {
1693 threshold = -threshold;
1697 /* Are all we could set to zero already zero? */
1698 if (last_index <= skip_dc - 1)
1701 for (i = 0; i <= last_index; i++) {
1702 const int j = s->intra_scantable.permutated[i];
1703 const int level = FFABS(block[j]);
1705 if (skip_dc && i == 0)
1709 } else if (level > 1) {
1715 if (score >= threshold)
1717 for (i = skip_dc; i <= last_index; i++) {
1718 const int j = s->intra_scantable.permutated[i];
1722 s->block_last_index[n] = 0;
1724 s->block_last_index[n] = -1;
1727 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1731 const int maxlevel = s->max_qcoeff;
1732 const int minlevel = s->min_qcoeff;
1736 i = 1; // skip clipping of intra dc
1740 for (; i <= last_index; i++) {
1741 const int j = s->intra_scantable.permutated[i];
1742 int level = block[j];
1744 if (level > maxlevel) {
1747 } else if (level < minlevel) {
1755 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1756 av_log(s->avctx, AV_LOG_INFO,
1757 "warning, clipping %d dct coefficients to %d..%d\n",
1758 overflow, minlevel, maxlevel);
1761 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1765 for (y = 0; y < 8; y++) {
1766 for (x = 0; x < 8; x++) {
1772 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1773 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1774 int v = ptr[x2 + y2 * stride];
1780 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1785 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1786 int motion_x, int motion_y,
1787 int mb_block_height,
1790 int16_t weight[8][64];
1791 DCTELEM orig[8][64];
1792 const int mb_x = s->mb_x;
1793 const int mb_y = s->mb_y;
1796 int dct_offset = s->linesize * 8; // default for progressive frames
1797 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1800 for (i = 0; i < mb_block_count; i++)
1801 skip_dct[i] = s->skipdct;
1803 if (s->adaptive_quant) {
1804 const int last_qp = s->qscale;
1805 const int mb_xy = mb_x + mb_y * s->mb_stride;
1807 s->lambda = s->lambda_table[mb_xy];
1810 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1811 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1812 s->dquant = s->qscale - last_qp;
1814 if (s->out_format == FMT_H263) {
1815 s->dquant = av_clip(s->dquant, -2, 2);
1817 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1819 if (s->pict_type == AV_PICTURE_TYPE_B) {
1820 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1823 if (s->mv_type == MV_TYPE_8X8)
1829 ff_set_qscale(s, last_qp + s->dquant);
1830 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1831 ff_set_qscale(s, s->qscale + s->dquant);
1833 wrap_y = s->linesize;
1834 wrap_c = s->uvlinesize;
1835 ptr_y = s->new_picture.f.data[0] +
1836 (mb_y * 16 * wrap_y) + mb_x * 16;
1837 ptr_cb = s->new_picture.f.data[1] +
1838 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1839 ptr_cr = s->new_picture.f.data[2] +
1840 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1842 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1843 uint8_t *ebuf = s->edge_emu_buffer + 32;
1844 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1845 mb_y * 16, s->width, s->height);
1847 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1848 mb_block_height, mb_x * 8, mb_y * 8,
1849 (s->width+1) >> 1, (s->height+1) >> 1);
1850 ptr_cb = ebuf + 18 * wrap_y;
1851 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1852 mb_block_height, mb_x * 8, mb_y * 8,
1853 (s->width+1) >> 1, (s->height+1) >> 1);
1854 ptr_cr = ebuf + 18 * wrap_y + 8;
1858 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1859 int progressive_score, interlaced_score;
1861 s->interlaced_dct = 0;
1862 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1864 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1865 NULL, wrap_y, 8) - 400;
1867 if (progressive_score > 0) {
1868 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1869 NULL, wrap_y * 2, 8) +
1870 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1871 NULL, wrap_y * 2, 8);
1872 if (progressive_score > interlaced_score) {
1873 s->interlaced_dct = 1;
1875 dct_offset = wrap_y;
1877 if (s->chroma_format == CHROMA_422)
1883 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1884 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1885 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1886 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1888 if (s->flags & CODEC_FLAG_GRAY) {
1892 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1893 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1894 if (!s->chroma_y_shift) { /* 422 */
1895 s->dsp.get_pixels(s->block[6],
1896 ptr_cb + (dct_offset >> 1), wrap_c);
1897 s->dsp.get_pixels(s->block[7],
1898 ptr_cr + (dct_offset >> 1), wrap_c);
1902 op_pixels_func (*op_pix)[4];
1903 qpel_mc_func (*op_qpix)[16];
1904 uint8_t *dest_y, *dest_cb, *dest_cr;
1906 dest_y = s->dest[0];
1907 dest_cb = s->dest[1];
1908 dest_cr = s->dest[2];
1910 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1911 op_pix = s->dsp.put_pixels_tab;
1912 op_qpix = s->dsp.put_qpel_pixels_tab;
1914 op_pix = s->dsp.put_no_rnd_pixels_tab;
1915 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1918 if (s->mv_dir & MV_DIR_FORWARD) {
1919 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1920 s->last_picture.f.data,
1922 op_pix = s->dsp.avg_pixels_tab;
1923 op_qpix = s->dsp.avg_qpel_pixels_tab;
1925 if (s->mv_dir & MV_DIR_BACKWARD) {
1926 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1927 s->next_picture.f.data,
1931 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1932 int progressive_score, interlaced_score;
1934 s->interlaced_dct = 0;
1935 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1938 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1939 ptr_y + wrap_y * 8, wrap_y,
1942 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1943 progressive_score -= 400;
1945 if (progressive_score > 0) {
1946 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1949 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1953 if (progressive_score > interlaced_score) {
1954 s->interlaced_dct = 1;
1956 dct_offset = wrap_y;
1958 if (s->chroma_format == CHROMA_422)
1964 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1965 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1966 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1967 dest_y + dct_offset, wrap_y);
1968 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1969 dest_y + dct_offset + 8, wrap_y);
1971 if (s->flags & CODEC_FLAG_GRAY) {
1975 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1976 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1977 if (!s->chroma_y_shift) { /* 422 */
1978 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1979 dest_cb + (dct_offset >> 1), wrap_c);
1980 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1981 dest_cr + (dct_offset >> 1), wrap_c);
1984 /* pre quantization */
1985 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1986 2 * s->qscale * s->qscale) {
1988 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1989 wrap_y, 8) < 20 * s->qscale)
1991 if (s->dsp.sad[1](NULL, ptr_y + 8,
1992 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1994 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1995 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1997 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1998 dest_y + dct_offset + 8,
1999 wrap_y, 8) < 20 * s->qscale)
2001 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2002 wrap_c, 8) < 20 * s->qscale)
2004 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2005 wrap_c, 8) < 20 * s->qscale)
2007 if (!s->chroma_y_shift) { /* 422 */
2008 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2009 dest_cb + (dct_offset >> 1),
2010 wrap_c, 8) < 20 * s->qscale)
2012 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2013 dest_cr + (dct_offset >> 1),
2014 wrap_c, 8) < 20 * s->qscale)
2020 if (s->quantizer_noise_shaping) {
2022 get_visual_weight(weight[0], ptr_y , wrap_y);
2024 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2026 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2028 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2030 get_visual_weight(weight[4], ptr_cb , wrap_c);
2032 get_visual_weight(weight[5], ptr_cr , wrap_c);
2033 if (!s->chroma_y_shift) { /* 422 */
2035 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2038 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2041 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2044 /* DCT & quantize */
2045 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2047 for (i = 0; i < mb_block_count; i++) {
2050 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2051 // FIXME we could decide to change to quantizer instead of
2053 // JS: I don't think that would be a good idea it could lower
2054 // quality instead of improve it. Just INTRADC clipping
2055 // deserves changes in quantizer
2057 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2059 s->block_last_index[i] = -1;
2061 if (s->quantizer_noise_shaping) {
2062 for (i = 0; i < mb_block_count; i++) {
2064 s->block_last_index[i] =
2065 dct_quantize_refine(s, s->block[i], weight[i],
2066 orig[i], i, s->qscale);
2071 if (s->luma_elim_threshold && !s->mb_intra)
2072 for (i = 0; i < 4; i++)
2073 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2074 if (s->chroma_elim_threshold && !s->mb_intra)
2075 for (i = 4; i < mb_block_count; i++)
2076 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2078 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2079 for (i = 0; i < mb_block_count; i++) {
2080 if (s->block_last_index[i] == -1)
2081 s->coded_score[i] = INT_MAX / 256;
2086 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2087 s->block_last_index[4] =
2088 s->block_last_index[5] = 0;
2090 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2093 // non c quantize code returns incorrect block_last_index FIXME
2094 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2095 for (i = 0; i < mb_block_count; i++) {
2097 if (s->block_last_index[i] > 0) {
2098 for (j = 63; j > 0; j--) {
2099 if (s->block[i][s->intra_scantable.permutated[j]])
2102 s->block_last_index[i] = j;
2107 /* huffman encode */
2108 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2109 case AV_CODEC_ID_MPEG1VIDEO:
2110 case AV_CODEC_ID_MPEG2VIDEO:
2111 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2112 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2114 case AV_CODEC_ID_MPEG4:
2115 if (CONFIG_MPEG4_ENCODER)
2116 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2118 case AV_CODEC_ID_MSMPEG4V2:
2119 case AV_CODEC_ID_MSMPEG4V3:
2120 case AV_CODEC_ID_WMV1:
2121 if (CONFIG_MSMPEG4_ENCODER)
2122 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2124 case AV_CODEC_ID_WMV2:
2125 if (CONFIG_WMV2_ENCODER)
2126 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2128 case AV_CODEC_ID_H261:
2129 if (CONFIG_H261_ENCODER)
2130 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2132 case AV_CODEC_ID_H263:
2133 case AV_CODEC_ID_H263P:
2134 case AV_CODEC_ID_FLV1:
2135 case AV_CODEC_ID_RV10:
2136 case AV_CODEC_ID_RV20:
2137 if (CONFIG_H263_ENCODER)
2138 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2140 case AV_CODEC_ID_MJPEG:
2141 case AV_CODEC_ID_AMV:
2142 if (CONFIG_MJPEG_ENCODER)
2143 ff_mjpeg_encode_mb(s, s->block);
2150 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2152 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2153 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2156 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2159 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2162 d->mb_skip_run= s->mb_skip_run;
2164 d->last_dc[i] = s->last_dc[i];
2167 d->mv_bits= s->mv_bits;
2168 d->i_tex_bits= s->i_tex_bits;
2169 d->p_tex_bits= s->p_tex_bits;
2170 d->i_count= s->i_count;
2171 d->f_count= s->f_count;
2172 d->b_count= s->b_count;
2173 d->skip_count= s->skip_count;
2174 d->misc_bits= s->misc_bits;
2178 d->qscale= s->qscale;
2179 d->dquant= s->dquant;
2181 d->esc3_level_length= s->esc3_level_length;
2184 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2187 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2188 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2191 d->mb_skip_run= s->mb_skip_run;
2193 d->last_dc[i] = s->last_dc[i];
2196 d->mv_bits= s->mv_bits;
2197 d->i_tex_bits= s->i_tex_bits;
2198 d->p_tex_bits= s->p_tex_bits;
2199 d->i_count= s->i_count;
2200 d->f_count= s->f_count;
2201 d->b_count= s->b_count;
2202 d->skip_count= s->skip_count;
2203 d->misc_bits= s->misc_bits;
2205 d->mb_intra= s->mb_intra;
2206 d->mb_skipped= s->mb_skipped;
2207 d->mv_type= s->mv_type;
2208 d->mv_dir= s->mv_dir;
2210 if(s->data_partitioning){
2212 d->tex_pb= s->tex_pb;
2216 d->block_last_index[i]= s->block_last_index[i];
2217 d->interlaced_dct= s->interlaced_dct;
2218 d->qscale= s->qscale;
2220 d->esc3_level_length= s->esc3_level_length;
2223 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2224 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2225 int *dmin, int *next_block, int motion_x, int motion_y)
2228 uint8_t *dest_backup[3];
2230 copy_context_before_encode(s, backup, type);
2232 s->block= s->blocks[*next_block];
2233 s->pb= pb[*next_block];
2234 if(s->data_partitioning){
2235 s->pb2 = pb2 [*next_block];
2236 s->tex_pb= tex_pb[*next_block];
2240 memcpy(dest_backup, s->dest, sizeof(s->dest));
2241 s->dest[0] = s->rd_scratchpad;
2242 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2243 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2244 assert(s->linesize >= 32); //FIXME
2247 encode_mb(s, motion_x, motion_y);
2249 score= put_bits_count(&s->pb);
2250 if(s->data_partitioning){
2251 score+= put_bits_count(&s->pb2);
2252 score+= put_bits_count(&s->tex_pb);
2255 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2256 ff_MPV_decode_mb(s, s->block);
2258 score *= s->lambda2;
2259 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2263 memcpy(s->dest, dest_backup, sizeof(s->dest));
2270 copy_context_after_encode(best, s, type);
2274 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2275 uint32_t *sq = ff_squareTbl + 256;
2280 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2281 else if(w==8 && h==8)
2282 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2286 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2295 static int sse_mb(MpegEncContext *s){
2299 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2300 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2303 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2304 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)
2305 +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)
2306 +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);
2308 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)
2309 +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)
2310 +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);
2313 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)
2314 +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)
2315 +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);
2318 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2319 MpegEncContext *s= *(void**)arg;
2323 s->me.dia_size= s->avctx->pre_dia_size;
2324 s->first_slice_line=1;
2325 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2326 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2327 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2329 s->first_slice_line=0;
2337 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2338 MpegEncContext *s= *(void**)arg;
2340 ff_check_alignment();
2342 s->me.dia_size= s->avctx->dia_size;
2343 s->first_slice_line=1;
2344 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2345 s->mb_x=0; //for block init below
2346 ff_init_block_index(s);
2347 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2348 s->block_index[0]+=2;
2349 s->block_index[1]+=2;
2350 s->block_index[2]+=2;
2351 s->block_index[3]+=2;
2353 /* compute motion vector & mb_type and store in context */
2354 if(s->pict_type==AV_PICTURE_TYPE_B)
2355 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2357 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2359 s->first_slice_line=0;
2364 static int mb_var_thread(AVCodecContext *c, void *arg){
2365 MpegEncContext *s= *(void**)arg;
2368 ff_check_alignment();
2370 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2371 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2374 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2376 int sum = s->dsp.pix_sum(pix, s->linesize);
2378 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2380 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2381 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2382 s->me.mb_var_sum_temp += varc;
2388 static void write_slice_end(MpegEncContext *s){
2389 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2390 if(s->partitioned_frame){
2391 ff_mpeg4_merge_partitions(s);
2394 ff_mpeg4_stuffing(&s->pb);
2395 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2396 ff_mjpeg_encode_stuffing(s);
2399 avpriv_align_put_bits(&s->pb);
2400 flush_put_bits(&s->pb);
2402 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2403 s->misc_bits+= get_bits_diff(s);
2406 static void write_mb_info(MpegEncContext *s)
2408 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2409 int offset = put_bits_count(&s->pb);
2410 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2411 int gobn = s->mb_y / s->gob_index;
2413 if (CONFIG_H263_ENCODER)
2414 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2415 bytestream_put_le32(&ptr, offset);
2416 bytestream_put_byte(&ptr, s->qscale);
2417 bytestream_put_byte(&ptr, gobn);
2418 bytestream_put_le16(&ptr, mba);
2419 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2420 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2421 /* 4MV not implemented */
2422 bytestream_put_byte(&ptr, 0); /* hmv2 */
2423 bytestream_put_byte(&ptr, 0); /* vmv2 */
2426 static void update_mb_info(MpegEncContext *s, int startcode)
2430 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2431 s->mb_info_size += 12;
2432 s->prev_mb_info = s->last_mb_info;
2435 s->prev_mb_info = put_bits_count(&s->pb)/8;
2436 /* This might have incremented mb_info_size above, and we return without
2437 * actually writing any info into that slot yet. But in that case,
2438 * this will be called again at the start of the after writing the
2439 * start code, actually writing the mb info. */
2443 s->last_mb_info = put_bits_count(&s->pb)/8;
2444 if (!s->mb_info_size)
2445 s->mb_info_size += 12;
2449 static int encode_thread(AVCodecContext *c, void *arg){
2450 MpegEncContext *s= *(void**)arg;
2451 int mb_x, mb_y, pdif = 0;
2452 int chr_h= 16>>s->chroma_y_shift;
2454 MpegEncContext best_s, backup_s;
2455 uint8_t bit_buf[2][MAX_MB_BYTES];
2456 uint8_t bit_buf2[2][MAX_MB_BYTES];
2457 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2458 PutBitContext pb[2], pb2[2], tex_pb[2];
2459 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2461 ff_check_alignment();
2464 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2465 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2466 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2469 s->last_bits= put_bits_count(&s->pb);
2480 /* init last dc values */
2481 /* note: quant matrix value (8) is implied here */
2482 s->last_dc[i] = 128 << s->intra_dc_precision;
2484 s->current_picture.f.error[i] = 0;
2486 if(s->codec_id==AV_CODEC_ID_AMV){
2487 s->last_dc[0] = 128*8/13;
2488 s->last_dc[1] = 128*8/14;
2489 s->last_dc[2] = 128*8/14;
2492 memset(s->last_mv, 0, sizeof(s->last_mv));
2496 switch(s->codec_id){
2497 case AV_CODEC_ID_H263:
2498 case AV_CODEC_ID_H263P:
2499 case AV_CODEC_ID_FLV1:
2500 if (CONFIG_H263_ENCODER)
2501 s->gob_index = ff_h263_get_gob_height(s);
2503 case AV_CODEC_ID_MPEG4:
2504 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2505 ff_mpeg4_init_partitions(s);
2511 s->first_slice_line = 1;
2512 s->ptr_lastgob = s->pb.buf;
2513 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2514 // printf("row %d at %X\n", s->mb_y, (int)s);
2518 ff_set_qscale(s, s->qscale);
2519 ff_init_block_index(s);
2521 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2522 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2523 int mb_type= s->mb_type[xy];
2528 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2529 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2532 if(s->data_partitioning){
2533 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2534 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2535 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2541 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2542 ff_update_block_index(s);
2544 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2545 ff_h261_reorder_mb_index(s);
2546 xy= s->mb_y*s->mb_stride + s->mb_x;
2547 mb_type= s->mb_type[xy];
2550 /* write gob / video packet header */
2552 int current_packet_size, is_gob_start;
2554 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2556 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2558 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2560 switch(s->codec_id){
2561 case AV_CODEC_ID_H263:
2562 case AV_CODEC_ID_H263P:
2563 if(!s->h263_slice_structured)
2564 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2566 case AV_CODEC_ID_MPEG2VIDEO:
2567 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2568 case AV_CODEC_ID_MPEG1VIDEO:
2569 if(s->mb_skip_run) is_gob_start=0;
2571 case AV_CODEC_ID_MJPEG:
2572 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2577 if(s->start_mb_y != mb_y || mb_x!=0){
2579 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2580 ff_mpeg4_init_partitions(s);
2584 av_assert2((put_bits_count(&s->pb)&7) == 0);
2585 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2587 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2588 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2589 int d= 100 / s->avctx->error_rate;
2591 current_packet_size=0;
2592 s->pb.buf_ptr= s->ptr_lastgob;
2593 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2597 if (s->avctx->rtp_callback){
2598 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2599 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2601 update_mb_info(s, 1);
2603 switch(s->codec_id){
2604 case AV_CODEC_ID_MPEG4:
2605 if (CONFIG_MPEG4_ENCODER) {
2606 ff_mpeg4_encode_video_packet_header(s);
2607 ff_mpeg4_clean_buffers(s);
2610 case AV_CODEC_ID_MPEG1VIDEO:
2611 case AV_CODEC_ID_MPEG2VIDEO:
2612 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2613 ff_mpeg1_encode_slice_header(s);
2614 ff_mpeg1_clean_buffers(s);
2617 case AV_CODEC_ID_H263:
2618 case AV_CODEC_ID_H263P:
2619 if (CONFIG_H263_ENCODER)
2620 ff_h263_encode_gob_header(s, mb_y);
2624 if(s->flags&CODEC_FLAG_PASS1){
2625 int bits= put_bits_count(&s->pb);
2626 s->misc_bits+= bits - s->last_bits;
2630 s->ptr_lastgob += current_packet_size;
2631 s->first_slice_line=1;
2632 s->resync_mb_x=mb_x;
2633 s->resync_mb_y=mb_y;
2637 if( (s->resync_mb_x == s->mb_x)
2638 && s->resync_mb_y+1 == s->mb_y){
2639 s->first_slice_line=0;
2643 s->dquant=0; //only for QP_RD
2645 update_mb_info(s, 0);
2647 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
2649 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2651 copy_context_before_encode(&backup_s, s, -1);
2653 best_s.data_partitioning= s->data_partitioning;
2654 best_s.partitioned_frame= s->partitioned_frame;
2655 if(s->data_partitioning){
2656 backup_s.pb2= s->pb2;
2657 backup_s.tex_pb= s->tex_pb;
2660 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2661 s->mv_dir = MV_DIR_FORWARD;
2662 s->mv_type = MV_TYPE_16X16;
2664 s->mv[0][0][0] = s->p_mv_table[xy][0];
2665 s->mv[0][0][1] = s->p_mv_table[xy][1];
2666 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2667 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2669 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2670 s->mv_dir = MV_DIR_FORWARD;
2671 s->mv_type = MV_TYPE_FIELD;
2674 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2675 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2676 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2678 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2679 &dmin, &next_block, 0, 0);
2681 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2682 s->mv_dir = MV_DIR_FORWARD;
2683 s->mv_type = MV_TYPE_16X16;
2687 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, 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_INTER4V){
2691 s->mv_dir = MV_DIR_FORWARD;
2692 s->mv_type = MV_TYPE_8X8;
2695 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2696 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2698 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2699 &dmin, &next_block, 0, 0);
2701 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2702 s->mv_dir = MV_DIR_FORWARD;
2703 s->mv_type = MV_TYPE_16X16;
2705 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2706 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2707 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2708 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2710 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2711 s->mv_dir = MV_DIR_BACKWARD;
2712 s->mv_type = MV_TYPE_16X16;
2714 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2715 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2716 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2717 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2719 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2720 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2721 s->mv_type = MV_TYPE_16X16;
2723 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2724 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2725 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2726 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2727 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2728 &dmin, &next_block, 0, 0);
2730 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2731 s->mv_dir = MV_DIR_FORWARD;
2732 s->mv_type = MV_TYPE_FIELD;
2735 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2736 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2737 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2739 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2740 &dmin, &next_block, 0, 0);
2742 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2743 s->mv_dir = MV_DIR_BACKWARD;
2744 s->mv_type = MV_TYPE_FIELD;
2747 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2748 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2749 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2751 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2752 &dmin, &next_block, 0, 0);
2754 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2755 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2756 s->mv_type = MV_TYPE_FIELD;
2758 for(dir=0; dir<2; dir++){
2760 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2761 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2762 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2765 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2766 &dmin, &next_block, 0, 0);
2768 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2770 s->mv_type = MV_TYPE_16X16;
2774 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2775 &dmin, &next_block, 0, 0);
2776 if(s->h263_pred || s->h263_aic){
2778 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2780 ff_clean_intra_table_entries(s); //old mode?
2784 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2785 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2786 const int last_qp= backup_s.qscale;
2789 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2790 static const int dquant_tab[4]={-1,1,-2,2};
2792 av_assert2(backup_s.dquant == 0);
2795 s->mv_dir= best_s.mv_dir;
2796 s->mv_type = MV_TYPE_16X16;
2797 s->mb_intra= best_s.mb_intra;
2798 s->mv[0][0][0] = best_s.mv[0][0][0];
2799 s->mv[0][0][1] = best_s.mv[0][0][1];
2800 s->mv[1][0][0] = best_s.mv[1][0][0];
2801 s->mv[1][0][1] = best_s.mv[1][0][1];
2803 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2804 for(; qpi<4; qpi++){
2805 int dquant= dquant_tab[qpi];
2806 qp= last_qp + dquant;
2807 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2809 backup_s.dquant= dquant;
2810 if(s->mb_intra && s->dc_val[0]){
2812 dc[i]= s->dc_val[0][ s->block_index[i] ];
2813 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2817 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2818 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2819 if(best_s.qscale != qp){
2820 if(s->mb_intra && s->dc_val[0]){
2822 s->dc_val[0][ s->block_index[i] ]= dc[i];
2823 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2830 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2831 int mx= s->b_direct_mv_table[xy][0];
2832 int my= s->b_direct_mv_table[xy][1];
2834 backup_s.dquant = 0;
2835 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2837 ff_mpeg4_set_direct_mv(s, mx, my);
2838 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2839 &dmin, &next_block, mx, my);
2841 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2842 backup_s.dquant = 0;
2843 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2845 ff_mpeg4_set_direct_mv(s, 0, 0);
2846 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2847 &dmin, &next_block, 0, 0);
2849 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2852 coded |= s->block_last_index[i];
2855 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2856 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2857 mx=my=0; //FIXME find the one we actually used
2858 ff_mpeg4_set_direct_mv(s, mx, my);
2859 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2867 s->mv_dir= best_s.mv_dir;
2868 s->mv_type = best_s.mv_type;
2870 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2871 s->mv[0][0][1] = best_s.mv[0][0][1];
2872 s->mv[1][0][0] = best_s.mv[1][0][0];
2873 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2876 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2877 &dmin, &next_block, mx, my);
2882 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2884 copy_context_after_encode(s, &best_s, -1);
2886 pb_bits_count= put_bits_count(&s->pb);
2887 flush_put_bits(&s->pb);
2888 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2891 if(s->data_partitioning){
2892 pb2_bits_count= put_bits_count(&s->pb2);
2893 flush_put_bits(&s->pb2);
2894 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2895 s->pb2= backup_s.pb2;
2897 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2898 flush_put_bits(&s->tex_pb);
2899 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2900 s->tex_pb= backup_s.tex_pb;
2902 s->last_bits= put_bits_count(&s->pb);
2904 if (CONFIG_H263_ENCODER &&
2905 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2906 ff_h263_update_motion_val(s);
2908 if(next_block==0){ //FIXME 16 vs linesize16
2909 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2910 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2911 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2914 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2915 ff_MPV_decode_mb(s, s->block);
2917 int motion_x = 0, motion_y = 0;
2918 s->mv_type=MV_TYPE_16X16;
2919 // only one MB-Type possible
2922 case CANDIDATE_MB_TYPE_INTRA:
2925 motion_x= s->mv[0][0][0] = 0;
2926 motion_y= s->mv[0][0][1] = 0;
2928 case CANDIDATE_MB_TYPE_INTER:
2929 s->mv_dir = MV_DIR_FORWARD;
2931 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2932 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2934 case CANDIDATE_MB_TYPE_INTER_I:
2935 s->mv_dir = MV_DIR_FORWARD;
2936 s->mv_type = MV_TYPE_FIELD;
2939 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2940 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2941 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2944 case CANDIDATE_MB_TYPE_INTER4V:
2945 s->mv_dir = MV_DIR_FORWARD;
2946 s->mv_type = MV_TYPE_8X8;
2949 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2950 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2953 case CANDIDATE_MB_TYPE_DIRECT:
2954 if (CONFIG_MPEG4_ENCODER) {
2955 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2957 motion_x=s->b_direct_mv_table[xy][0];
2958 motion_y=s->b_direct_mv_table[xy][1];
2959 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2962 case CANDIDATE_MB_TYPE_DIRECT0:
2963 if (CONFIG_MPEG4_ENCODER) {
2964 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2966 ff_mpeg4_set_direct_mv(s, 0, 0);
2969 case CANDIDATE_MB_TYPE_BIDIR:
2970 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2972 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2973 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2974 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2975 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2977 case CANDIDATE_MB_TYPE_BACKWARD:
2978 s->mv_dir = MV_DIR_BACKWARD;
2980 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2981 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2983 case CANDIDATE_MB_TYPE_FORWARD:
2984 s->mv_dir = MV_DIR_FORWARD;
2986 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2987 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2988 // printf(" %d %d ", motion_x, motion_y);
2990 case CANDIDATE_MB_TYPE_FORWARD_I:
2991 s->mv_dir = MV_DIR_FORWARD;
2992 s->mv_type = MV_TYPE_FIELD;
2995 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2996 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2997 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3000 case CANDIDATE_MB_TYPE_BACKWARD_I:
3001 s->mv_dir = MV_DIR_BACKWARD;
3002 s->mv_type = MV_TYPE_FIELD;
3005 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3006 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3007 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3010 case CANDIDATE_MB_TYPE_BIDIR_I:
3011 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3012 s->mv_type = MV_TYPE_FIELD;
3014 for(dir=0; dir<2; dir++){
3016 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3017 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3018 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3023 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3026 encode_mb(s, motion_x, motion_y);
3028 // RAL: Update last macroblock type
3029 s->last_mv_dir = s->mv_dir;
3031 if (CONFIG_H263_ENCODER &&
3032 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3033 ff_h263_update_motion_val(s);
3035 ff_MPV_decode_mb(s, s->block);
3038 /* clean the MV table in IPS frames for direct mode in B frames */
3039 if(s->mb_intra /* && I,P,S_TYPE */){
3040 s->p_mv_table[xy][0]=0;
3041 s->p_mv_table[xy][1]=0;
3044 if(s->flags&CODEC_FLAG_PSNR){
3048 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3049 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3051 s->current_picture.f.error[0] += sse(
3052 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3053 s->dest[0], w, h, s->linesize);
3054 s->current_picture.f.error[1] += sse(
3055 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3056 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3057 s->current_picture.f.error[2] += sse(
3058 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3059 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3062 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3063 ff_h263_loop_filter(s);
3065 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
3069 //not beautiful here but we must write it before flushing so it has to be here
3070 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3071 ff_msmpeg4_encode_ext_header(s);
3075 /* Send the last GOB if RTP */
3076 if (s->avctx->rtp_callback) {
3077 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3078 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3079 /* Call the RTP callback to send the last GOB */
3081 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3087 #define MERGE(field) dst->field += src->field; src->field=0
3088 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3089 MERGE(me.scene_change_score);
3090 MERGE(me.mc_mb_var_sum_temp);
3091 MERGE(me.mb_var_sum_temp);
3094 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3097 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3098 MERGE(dct_count[1]);
3108 MERGE(padding_bug_score);
3109 MERGE(current_picture.f.error[0]);
3110 MERGE(current_picture.f.error[1]);
3111 MERGE(current_picture.f.error[2]);
3113 if(dst->avctx->noise_reduction){
3114 for(i=0; i<64; i++){
3115 MERGE(dct_error_sum[0][i]);
3116 MERGE(dct_error_sum[1][i]);
3120 assert(put_bits_count(&src->pb) % 8 ==0);
3121 assert(put_bits_count(&dst->pb) % 8 ==0);
3122 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3123 flush_put_bits(&dst->pb);
3126 static int estimate_qp(MpegEncContext *s, int dry_run){
3127 if (s->next_lambda){
3128 s->current_picture_ptr->f.quality =
3129 s->current_picture.f.quality = s->next_lambda;
3130 if(!dry_run) s->next_lambda= 0;
3131 } else if (!s->fixed_qscale) {
3132 s->current_picture_ptr->f.quality =
3133 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3134 if (s->current_picture.f.quality < 0)
3138 if(s->adaptive_quant){
3139 switch(s->codec_id){
3140 case AV_CODEC_ID_MPEG4:
3141 if (CONFIG_MPEG4_ENCODER)
3142 ff_clean_mpeg4_qscales(s);
3144 case AV_CODEC_ID_H263:
3145 case AV_CODEC_ID_H263P:
3146 case AV_CODEC_ID_FLV1:
3147 if (CONFIG_H263_ENCODER)
3148 ff_clean_h263_qscales(s);
3151 ff_init_qscale_tab(s);
3154 s->lambda= s->lambda_table[0];
3157 s->lambda = s->current_picture.f.quality;
3158 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3163 /* must be called before writing the header */
3164 static void set_frame_distances(MpegEncContext * s){
3165 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3166 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3168 if(s->pict_type==AV_PICTURE_TYPE_B){
3169 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3170 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3172 s->pp_time= s->time - s->last_non_b_time;
3173 s->last_non_b_time= s->time;
3174 assert(s->picture_number==0 || s->pp_time > 0);
3178 static int encode_picture(MpegEncContext *s, int picture_number)
3182 int context_count = s->slice_context_count;
3184 s->picture_number = picture_number;
3186 /* Reset the average MB variance */
3187 s->me.mb_var_sum_temp =
3188 s->me.mc_mb_var_sum_temp = 0;
3190 /* we need to initialize some time vars before we can encode b-frames */
3191 // RAL: Condition added for MPEG1VIDEO
3192 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3193 set_frame_distances(s);
3194 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3195 ff_set_mpeg4_time(s);
3197 s->me.scene_change_score=0;
3199 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3201 if(s->pict_type==AV_PICTURE_TYPE_I){
3202 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3203 else s->no_rounding=0;
3204 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3205 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3206 s->no_rounding ^= 1;
3209 if(s->flags & CODEC_FLAG_PASS2){
3210 if (estimate_qp(s,1) < 0)
3212 ff_get_2pass_fcode(s);
3213 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3214 if(s->pict_type==AV_PICTURE_TYPE_B)
3215 s->lambda= s->last_lambda_for[s->pict_type];
3217 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3221 if(s->codec_id != AV_CODEC_ID_AMV){
3222 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3223 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3224 s->q_chroma_intra_matrix = s->q_intra_matrix;
3225 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3228 s->mb_intra=0; //for the rate distortion & bit compare functions
3229 for(i=1; i<context_count; i++){
3230 ff_update_duplicate_context(s->thread_context[i], s);
3236 /* Estimate motion for every MB */
3237 if(s->pict_type != AV_PICTURE_TYPE_I){
3238 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3239 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3240 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3241 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3242 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3246 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3247 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3249 for(i=0; i<s->mb_stride*s->mb_height; i++)
3250 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3252 if(!s->fixed_qscale){
3253 /* finding spatial complexity for I-frame rate control */
3254 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3257 for(i=1; i<context_count; i++){
3258 merge_context_after_me(s, s->thread_context[i]);
3260 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3261 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3264 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3265 s->pict_type= AV_PICTURE_TYPE_I;
3266 for(i=0; i<s->mb_stride*s->mb_height; i++)
3267 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3268 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3269 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3273 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3274 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3276 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3278 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3279 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3280 s->f_code= FFMAX3(s->f_code, a, b);
3283 ff_fix_long_p_mvs(s);
3284 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3285 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3289 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3290 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3295 if(s->pict_type==AV_PICTURE_TYPE_B){
3298 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3299 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3300 s->f_code = FFMAX(a, b);
3302 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3303 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3304 s->b_code = FFMAX(a, b);
3306 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3307 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3308 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3309 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3310 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3312 for(dir=0; dir<2; dir++){
3315 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3316 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3317 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3318 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3326 if (estimate_qp(s, 0) < 0)
3329 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3330 s->qscale= 3; //reduce clipping problems
3332 if (s->out_format == FMT_MJPEG) {
3333 /* for mjpeg, we do include qscale in the matrix */
3335 int j= s->dsp.idct_permutation[i];
3337 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3339 s->y_dc_scale_table=
3340 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3341 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3342 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3343 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3346 if(s->codec_id == AV_CODEC_ID_AMV){
3347 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};
3348 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};
3350 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3352 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3353 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3355 s->y_dc_scale_table= y;
3356 s->c_dc_scale_table= c;
3357 s->intra_matrix[0] = 13;
3358 s->chroma_intra_matrix[0] = 14;
3359 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3360 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3361 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3362 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3366 //FIXME var duplication
3367 s->current_picture_ptr->f.key_frame =
3368 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3369 s->current_picture_ptr->f.pict_type =
3370 s->current_picture.f.pict_type = s->pict_type;
3372 if (s->current_picture.f.key_frame)
3373 s->picture_in_gop_number=0;
3375 s->mb_x = s->mb_y = 0;
3376 s->last_bits= put_bits_count(&s->pb);
3377 switch(s->out_format) {
3379 if (CONFIG_MJPEG_ENCODER)
3380 ff_mjpeg_encode_picture_header(s);
3383 if (CONFIG_H261_ENCODER)
3384 ff_h261_encode_picture_header(s, picture_number);
3387 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3388 ff_wmv2_encode_picture_header(s, picture_number);
3389 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3390 ff_msmpeg4_encode_picture_header(s, picture_number);
3391 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3392 ff_mpeg4_encode_picture_header(s, picture_number);
3393 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3394 ff_rv10_encode_picture_header(s, picture_number);
3395 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3396 ff_rv20_encode_picture_header(s, picture_number);
3397 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3398 ff_flv_encode_picture_header(s, picture_number);
3399 else if (CONFIG_H263_ENCODER)
3400 ff_h263_encode_picture_header(s, picture_number);
3403 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3404 ff_mpeg1_encode_picture_header(s, picture_number);
3411 bits= put_bits_count(&s->pb);
3412 s->header_bits= bits - s->last_bits;
3414 for(i=1; i<context_count; i++){
3415 update_duplicate_context_after_me(s->thread_context[i], s);
3417 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3418 for(i=1; i<context_count; i++){
3419 merge_context_after_encode(s, s->thread_context[i]);
3425 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3426 const int intra= s->mb_intra;
3429 s->dct_count[intra]++;
3431 for(i=0; i<64; i++){
3432 int level= block[i];
3436 s->dct_error_sum[intra][i] += level;
3437 level -= s->dct_offset[intra][i];
3438 if(level<0) level=0;
3440 s->dct_error_sum[intra][i] -= level;
3441 level += s->dct_offset[intra][i];
3442 if(level>0) level=0;
3449 static int dct_quantize_trellis_c(MpegEncContext *s,
3450 DCTELEM *block, int n,
3451 int qscale, int *overflow){
3453 const uint8_t *scantable= s->intra_scantable.scantable;
3454 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3456 unsigned int threshold1, threshold2;
3468 int coeff_count[64];
3469 int qmul, qadd, start_i, last_non_zero, i, dc;
3470 const int esc_length= s->ac_esc_length;
3472 uint8_t * last_length;
3473 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3475 s->dsp.fdct (block);
3477 if(s->dct_error_sum)
3478 s->denoise_dct(s, block);
3480 qadd= ((qscale-1)|1)*8;
3491 /* For AIC we skip quant/dequant of INTRADC */
3496 /* note: block[0] is assumed to be positive */
3497 block[0] = (block[0] + (q >> 1)) / q;
3500 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3501 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3502 bias= 1<<(QMAT_SHIFT-1);
3503 length = s->intra_ac_vlc_length;
3504 last_length= s->intra_ac_vlc_last_length;
3508 qmat = s->q_inter_matrix[qscale];
3509 length = s->inter_ac_vlc_length;
3510 last_length= s->inter_ac_vlc_last_length;
3514 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3515 threshold2= (threshold1<<1);
3517 for(i=63; i>=start_i; i--) {
3518 const int j = scantable[i];
3519 int level = block[j] * qmat[j];
3521 if(((unsigned)(level+threshold1))>threshold2){
3527 for(i=start_i; i<=last_non_zero; i++) {
3528 const int j = scantable[i];
3529 int level = block[j] * qmat[j];
3531 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3532 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3533 if(((unsigned)(level+threshold1))>threshold2){
3535 level= (bias + level)>>QMAT_SHIFT;
3537 coeff[1][i]= level-1;
3538 // coeff[2][k]= level-2;
3540 level= (bias - level)>>QMAT_SHIFT;
3541 coeff[0][i]= -level;
3542 coeff[1][i]= -level+1;
3543 // coeff[2][k]= -level+2;
3545 coeff_count[i]= FFMIN(level, 2);
3546 av_assert2(coeff_count[i]);
3549 coeff[0][i]= (level>>31)|1;
3554 *overflow= s->max_qcoeff < max; //overflow might have happened
3556 if(last_non_zero < start_i){
3557 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3558 return last_non_zero;
3561 score_tab[start_i]= 0;
3562 survivor[0]= start_i;
3565 for(i=start_i; i<=last_non_zero; i++){
3566 int level_index, j, zero_distortion;
3567 int dct_coeff= FFABS(block[ scantable[i] ]);
3568 int best_score=256*256*256*120;
3570 if (s->dsp.fdct == ff_fdct_ifast)
3571 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3572 zero_distortion= dct_coeff*dct_coeff;
3574 for(level_index=0; level_index < coeff_count[i]; level_index++){
3576 int level= coeff[level_index][i];
3577 const int alevel= FFABS(level);
3582 if(s->out_format == FMT_H263){
3583 unquant_coeff= alevel*qmul + qadd;
3585 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3587 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3588 unquant_coeff = (unquant_coeff - 1) | 1;
3590 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3591 unquant_coeff = (unquant_coeff - 1) | 1;
3596 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3598 if((level&(~127)) == 0){
3599 for(j=survivor_count-1; j>=0; j--){
3600 int run= i - survivor[j];
3601 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3602 score += score_tab[i-run];
3604 if(score < best_score){
3607 level_tab[i+1]= level-64;
3611 if(s->out_format == FMT_H263){
3612 for(j=survivor_count-1; j>=0; j--){
3613 int run= i - survivor[j];
3614 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3615 score += score_tab[i-run];
3616 if(score < last_score){
3619 last_level= level-64;
3625 distortion += esc_length*lambda;
3626 for(j=survivor_count-1; j>=0; j--){
3627 int run= i - survivor[j];
3628 int score= distortion + score_tab[i-run];
3630 if(score < best_score){
3633 level_tab[i+1]= level-64;
3637 if(s->out_format == FMT_H263){
3638 for(j=survivor_count-1; j>=0; j--){
3639 int run= i - survivor[j];
3640 int score= distortion + score_tab[i-run];
3641 if(score < last_score){
3644 last_level= level-64;
3652 score_tab[i+1]= best_score;
3654 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3655 if(last_non_zero <= 27){
3656 for(; survivor_count; survivor_count--){
3657 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3661 for(; survivor_count; survivor_count--){
3662 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3667 survivor[ survivor_count++ ]= i+1;
3670 if(s->out_format != FMT_H263){
3671 last_score= 256*256*256*120;
3672 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3673 int score= score_tab[i];
3674 if(i) score += lambda*2; //FIXME exacter?
3676 if(score < last_score){
3679 last_level= level_tab[i];
3680 last_run= run_tab[i];
3685 s->coded_score[n] = last_score;
3687 dc= FFABS(block[0]);
3688 last_non_zero= last_i - 1;
3689 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3691 if(last_non_zero < start_i)
3692 return last_non_zero;
3694 if(last_non_zero == 0 && start_i == 0){
3696 int best_score= dc * dc;
3698 for(i=0; i<coeff_count[0]; i++){
3699 int level= coeff[i][0];
3700 int alevel= FFABS(level);
3701 int unquant_coeff, score, distortion;
3703 if(s->out_format == FMT_H263){
3704 unquant_coeff= (alevel*qmul + qadd)>>3;
3706 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3707 unquant_coeff = (unquant_coeff - 1) | 1;
3709 unquant_coeff = (unquant_coeff + 4) >> 3;
3710 unquant_coeff<<= 3 + 3;
3712 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3714 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3715 else score= distortion + esc_length*lambda;
3717 if(score < best_score){
3719 best_level= level - 64;
3722 block[0]= best_level;
3723 s->coded_score[n] = best_score - dc*dc;
3724 if(best_level == 0) return -1;
3725 else return last_non_zero;
3729 av_assert2(last_level);
3731 block[ perm_scantable[last_non_zero] ]= last_level;
3734 for(; i>start_i; i -= run_tab[i] + 1){
3735 block[ perm_scantable[i-1] ]= level_tab[i];
3738 return last_non_zero;
3741 //#define REFINE_STATS 1
3742 static int16_t basis[64][64];
3744 static void build_basis(uint8_t *perm){
3751 double s= 0.25*(1<<BASIS_SHIFT);
3753 int perm_index= perm[index];
3754 if(i==0) s*= sqrt(0.5);
3755 if(j==0) s*= sqrt(0.5);
3756 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)));
3763 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3764 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3767 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3768 const uint8_t *scantable= s->intra_scantable.scantable;
3769 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3770 // unsigned int threshold1, threshold2;
3775 int qmul, qadd, start_i, last_non_zero, i, dc;
3777 uint8_t * last_length;
3779 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3782 static int after_last=0;
3783 static int to_zero=0;
3784 static int from_zero=0;
3787 static int messed_sign=0;
3790 if(basis[0][0] == 0)
3791 build_basis(s->dsp.idct_permutation);
3802 /* For AIC we skip quant/dequant of INTRADC */
3806 q <<= RECON_SHIFT-3;
3807 /* note: block[0] is assumed to be positive */
3809 // block[0] = (block[0] + (q >> 1)) / q;
3811 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3812 // bias= 1<<(QMAT_SHIFT-1);
3813 length = s->intra_ac_vlc_length;
3814 last_length= s->intra_ac_vlc_last_length;
3818 length = s->inter_ac_vlc_length;
3819 last_length= s->inter_ac_vlc_last_length;
3821 last_non_zero = s->block_last_index[n];
3826 dc += (1<<(RECON_SHIFT-1));
3827 for(i=0; i<64; i++){
3828 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3831 STOP_TIMER("memset rem[]")}
3834 for(i=0; i<64; i++){
3839 w= FFABS(weight[i]) + qns*one;
3840 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3843 // w=weight[i] = (63*qns + (w/2)) / w;
3846 av_assert2(w<(1<<6));
3849 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3855 for(i=start_i; i<=last_non_zero; i++){
3856 int j= perm_scantable[i];
3857 const int level= block[j];
3861 if(level<0) coeff= qmul*level - qadd;
3862 else coeff= qmul*level + qadd;
3863 run_tab[rle_index++]=run;
3866 s->dsp.add_8x8basis(rem, basis[j], coeff);
3872 if(last_non_zero>0){
3873 STOP_TIMER("init rem[]")
3880 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3883 int run2, best_unquant_change=0, analyze_gradient;
3887 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3889 if(analyze_gradient){
3893 for(i=0; i<64; i++){
3896 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3899 STOP_TIMER("rem*w*w")}
3909 const int level= block[0];
3910 int change, old_coeff;
3912 av_assert2(s->mb_intra);
3916 for(change=-1; change<=1; change+=2){
3917 int new_level= level + change;
3918 int score, new_coeff;
3920 new_coeff= q*new_level;
3921 if(new_coeff >= 2048 || new_coeff < 0)
3924 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3925 if(score<best_score){
3928 best_change= change;
3929 best_unquant_change= new_coeff - old_coeff;
3936 run2= run_tab[rle_index++];
3940 for(i=start_i; i<64; i++){
3941 int j= perm_scantable[i];
3942 const int level= block[j];
3943 int change, old_coeff;
3945 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3949 if(level<0) old_coeff= qmul*level - qadd;
3950 else old_coeff= qmul*level + qadd;
3951 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3955 av_assert2(run2>=0 || i >= last_non_zero );
3958 for(change=-1; change<=1; change+=2){
3959 int new_level= level + change;
3960 int score, new_coeff, unquant_change;
3963 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3967 if(new_level<0) new_coeff= qmul*new_level - qadd;
3968 else new_coeff= qmul*new_level + qadd;
3969 if(new_coeff >= 2048 || new_coeff <= -2048)
3971 //FIXME check for overflow
3974 if(level < 63 && level > -63){
3975 if(i < last_non_zero)
3976 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3977 - length[UNI_AC_ENC_INDEX(run, level+64)];
3979 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3980 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3983 av_assert2(FFABS(new_level)==1);
3985 if(analyze_gradient){
3986 int g= d1[ scantable[i] ];
3987 if(g && (g^new_level) >= 0)
3991 if(i < last_non_zero){
3992 int next_i= i + run2 + 1;
3993 int next_level= block[ perm_scantable[next_i] ] + 64;
3995 if(next_level&(~127))
3998 if(next_i < last_non_zero)
3999 score += length[UNI_AC_ENC_INDEX(run, 65)]
4000 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4001 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4003 score += length[UNI_AC_ENC_INDEX(run, 65)]
4004 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4005 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4007 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4009 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4010 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4016 av_assert2(FFABS(level)==1);
4018 if(i < last_non_zero){
4019 int next_i= i + run2 + 1;
4020 int next_level= block[ perm_scantable[next_i] ] + 64;
4022 if(next_level&(~127))
4025 if(next_i < last_non_zero)
4026 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4027 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4028 - length[UNI_AC_ENC_INDEX(run, 65)];
4030 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4031 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4032 - length[UNI_AC_ENC_INDEX(run, 65)];
4034 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4036 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4037 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4044 unquant_change= new_coeff - old_coeff;
4045 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4047 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4048 if(score<best_score){
4051 best_change= change;
4052 best_unquant_change= unquant_change;
4056 prev_level= level + 64;
4057 if(prev_level&(~127))
4066 STOP_TIMER("iterative step")}
4070 int j= perm_scantable[ best_coeff ];
4072 block[j] += best_change;
4074 if(best_coeff > last_non_zero){
4075 last_non_zero= best_coeff;
4076 av_assert2(block[j]);
4083 if(block[j] - best_change){
4084 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4096 for(; last_non_zero>=start_i; last_non_zero--){
4097 if(block[perm_scantable[last_non_zero]])
4103 if(256*256*256*64 % count == 0){
4104 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);
4109 for(i=start_i; i<=last_non_zero; i++){
4110 int j= perm_scantable[i];
4111 const int level= block[j];
4114 run_tab[rle_index++]=run;
4121 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4127 if(last_non_zero>0){
4128 STOP_TIMER("iterative search")
4133 return last_non_zero;
4136 int ff_dct_quantize_c(MpegEncContext *s,
4137 DCTELEM *block, int n,
4138 int qscale, int *overflow)
4140 int i, j, level, last_non_zero, q, start_i;
4142 const uint8_t *scantable= s->intra_scantable.scantable;
4145 unsigned int threshold1, threshold2;
4147 s->dsp.fdct (block);
4149 if(s->dct_error_sum)
4150 s->denoise_dct(s, block);
4160 /* For AIC we skip quant/dequant of INTRADC */
4163 /* note: block[0] is assumed to be positive */
4164 block[0] = (block[0] + (q >> 1)) / q;
4167 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4168 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4172 qmat = s->q_inter_matrix[qscale];
4173 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4175 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4176 threshold2= (threshold1<<1);
4177 for(i=63;i>=start_i;i--) {
4179 level = block[j] * qmat[j];
4181 if(((unsigned)(level+threshold1))>threshold2){
4188 for(i=start_i; i<=last_non_zero; i++) {
4190 level = block[j] * qmat[j];
4192 // if( bias+level >= (1<<QMAT_SHIFT)
4193 // || bias-level >= (1<<QMAT_SHIFT)){
4194 if(((unsigned)(level+threshold1))>threshold2){
4196 level= (bias + level)>>QMAT_SHIFT;
4199 level= (bias - level)>>QMAT_SHIFT;
4207 *overflow= s->max_qcoeff < max; //overflow might have happened
4209 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4210 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4211 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4213 return last_non_zero;
4216 #define OFFSET(x) offsetof(MpegEncContext, x)
4217 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4218 static const AVOption h263_options[] = {
4219 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4220 { "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},
4221 { "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 },
4226 static const AVClass h263_class = {
4227 .class_name = "H.263 encoder",
4228 .item_name = av_default_item_name,
4229 .option = h263_options,
4230 .version = LIBAVUTIL_VERSION_INT,
4233 AVCodec ff_h263_encoder = {
4235 .type = AVMEDIA_TYPE_VIDEO,
4236 .id = AV_CODEC_ID_H263,
4237 .priv_data_size = sizeof(MpegEncContext),
4238 .init = ff_MPV_encode_init,
4239 .encode2 = ff_MPV_encode_picture,
4240 .close = ff_MPV_encode_end,
4241 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4242 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4243 .priv_class = &h263_class,
4246 static const AVOption h263p_options[] = {
4247 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4248 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4249 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4250 { "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},
4254 static const AVClass h263p_class = {
4255 .class_name = "H.263p encoder",
4256 .item_name = av_default_item_name,
4257 .option = h263p_options,
4258 .version = LIBAVUTIL_VERSION_INT,
4261 AVCodec ff_h263p_encoder = {
4263 .type = AVMEDIA_TYPE_VIDEO,
4264 .id = AV_CODEC_ID_H263P,
4265 .priv_data_size = sizeof(MpegEncContext),
4266 .init = ff_MPV_encode_init,
4267 .encode2 = ff_MPV_encode_picture,
4268 .close = ff_MPV_encode_end,
4269 .capabilities = CODEC_CAP_SLICE_THREADS,
4270 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4271 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4272 .priv_class = &h263p_class,
4275 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4277 AVCodec ff_msmpeg4v2_encoder = {
4278 .name = "msmpeg4v2",
4279 .type = AVMEDIA_TYPE_VIDEO,
4280 .id = AV_CODEC_ID_MSMPEG4V2,
4281 .priv_data_size = sizeof(MpegEncContext),
4282 .init = ff_MPV_encode_init,
4283 .encode2 = ff_MPV_encode_picture,
4284 .close = ff_MPV_encode_end,
4285 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4286 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4287 .priv_class = &msmpeg4v2_class,
4290 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4292 AVCodec ff_msmpeg4v3_encoder = {
4294 .type = AVMEDIA_TYPE_VIDEO,
4295 .id = AV_CODEC_ID_MSMPEG4V3,
4296 .priv_data_size = sizeof(MpegEncContext),
4297 .init = ff_MPV_encode_init,
4298 .encode2 = ff_MPV_encode_picture,
4299 .close = ff_MPV_encode_end,
4300 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4301 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4302 .priv_class = &msmpeg4v3_class,
4305 FF_MPV_GENERIC_CLASS(wmv1)
4307 AVCodec ff_wmv1_encoder = {
4309 .type = AVMEDIA_TYPE_VIDEO,
4310 .id = AV_CODEC_ID_WMV1,
4311 .priv_data_size = sizeof(MpegEncContext),
4312 .init = ff_MPV_encode_init,
4313 .encode2 = ff_MPV_encode_picture,
4314 .close = ff_MPV_encode_end,
4315 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4316 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4317 .priv_class = &wmv1_class,