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)
835 if (!s->dct_quantize)
836 s->dct_quantize = ff_dct_quantize_c;
838 s->denoise_dct = denoise_dct_c;
839 s->fast_dct_quantize = s->dct_quantize;
841 s->dct_quantize = dct_quantize_trellis_c;
843 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
844 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
846 s->quant_precision = 5;
848 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
849 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
851 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
852 ff_h261_encode_init(s);
853 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
854 ff_h263_encode_init(s);
855 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
856 ff_msmpeg4_encode_init(s);
857 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
858 && s->out_format == FMT_MPEG1)
859 ff_mpeg1_encode_init(s);
862 for (i = 0; i < 64; i++) {
863 int j = s->dsp.idct_permutation[i];
864 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
866 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
867 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
868 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
870 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
873 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
874 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
876 if (s->avctx->intra_matrix)
877 s->intra_matrix[j] = s->avctx->intra_matrix[i];
878 if (s->avctx->inter_matrix)
879 s->inter_matrix[j] = s->avctx->inter_matrix[i];
882 /* precompute matrix */
883 /* for mjpeg, we do include qscale in the matrix */
884 if (s->out_format != FMT_MJPEG) {
885 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
886 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
888 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
889 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
893 if (ff_rate_control_init(s) < 0)
899 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
901 MpegEncContext *s = avctx->priv_data;
903 ff_rate_control_uninit(s);
905 ff_MPV_common_end(s);
906 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
907 s->out_format == FMT_MJPEG)
908 ff_mjpeg_encode_close(s);
910 av_freep(&avctx->extradata);
915 static int get_sae(uint8_t *src, int ref, int stride)
920 for (y = 0; y < 16; y++) {
921 for (x = 0; x < 16; x++) {
922 acc += FFABS(src[x + y * stride] - ref);
929 static int get_intra_count(MpegEncContext *s, uint8_t *src,
930 uint8_t *ref, int stride)
938 for (y = 0; y < h; y += 16) {
939 for (x = 0; x < w; x += 16) {
940 int offset = x + y * stride;
941 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
943 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
944 int sae = get_sae(src + offset, mean, stride);
946 acc += sae + 500 < sad;
953 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
958 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
959 (s->low_delay ? 0 : 1);
964 pic_arg->display_picture_number = s->input_picture_number++;
966 if (pts != AV_NOPTS_VALUE) {
967 if (s->user_specified_pts != AV_NOPTS_VALUE) {
969 int64_t last = s->user_specified_pts;
972 av_log(s->avctx, AV_LOG_ERROR,
973 "Error, Invalid timestamp=%"PRId64", "
974 "last=%"PRId64"\n", pts, s->user_specified_pts);
978 if (!s->low_delay && pic_arg->display_picture_number == 1)
979 s->dts_delta = time - last;
981 s->user_specified_pts = pts;
983 if (s->user_specified_pts != AV_NOPTS_VALUE) {
984 s->user_specified_pts =
985 pts = s->user_specified_pts + 1;
986 av_log(s->avctx, AV_LOG_INFO,
987 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
990 pts = pic_arg->display_picture_number;
996 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
998 if (pic_arg->linesize[0] != s->linesize)
1000 if (pic_arg->linesize[1] != s->uvlinesize)
1002 if (pic_arg->linesize[2] != s->uvlinesize)
1005 //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
1006 // pic_arg->linesize[1], s->linesize, s->uvlinesize);
1009 i = ff_find_unused_picture(s, 1);
1013 pic = &s->picture[i].f;
1016 for (i = 0; i < 4; i++) {
1017 pic->data[i] = pic_arg->data[i];
1018 pic->linesize[i] = pic_arg->linesize[i];
1020 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1024 i = ff_find_unused_picture(s, 0);
1028 pic = &s->picture[i].f;
1031 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1035 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1036 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1037 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1040 int h_chroma_shift, v_chroma_shift;
1041 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1044 for (i = 0; i < 3; i++) {
1045 int src_stride = pic_arg->linesize[i];
1046 int dst_stride = i ? s->uvlinesize : s->linesize;
1047 int h_shift = i ? h_chroma_shift : 0;
1048 int v_shift = i ? v_chroma_shift : 0;
1049 int w = s->width >> h_shift;
1050 int h = s->height >> v_shift;
1051 uint8_t *src = pic_arg->data[i];
1052 uint8_t *dst = pic->data[i];
1054 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1055 h= ((s->height+15)/16*16)>>v_shift;
1058 if (!s->avctx->rc_buffer_size)
1059 dst += INPLACE_OFFSET;
1061 if (src_stride == dst_stride)
1062 memcpy(dst, src, src_stride * h);
1065 memcpy(dst, src, w);
1073 copy_picture_attributes(s, pic, pic_arg);
1074 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1077 /* shift buffer entries */
1078 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1079 s->input_picture[i - 1] = s->input_picture[i];
1081 s->input_picture[encoding_delay] = (Picture*) pic;
1086 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1090 int64_t score64 = 0;
1092 for (plane = 0; plane < 3; plane++) {
1093 const int stride = p->f.linesize[plane];
1094 const int bw = plane ? 1 : 2;
1095 for (y = 0; y < s->mb_height * bw; y++) {
1096 for (x = 0; x < s->mb_width * bw; x++) {
1097 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1098 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1099 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1100 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1102 switch (s->avctx->frame_skip_exp) {
1103 case 0: score = FFMAX(score, v); break;
1104 case 1: score += FFABS(v); break;
1105 case 2: score += v * v; break;
1106 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1107 case 4: score64 += v * v * (int64_t)(v * v); break;
1116 if (score64 < s->avctx->frame_skip_threshold)
1118 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1123 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1125 AVPacket pkt = { 0 };
1126 int ret, got_output;
1128 av_init_packet(&pkt);
1129 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1134 av_free_packet(&pkt);
1138 static int estimate_best_b_count(MpegEncContext *s)
1140 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1141 AVCodecContext *c = avcodec_alloc_context3(NULL);
1142 AVFrame input[FF_MAX_B_FRAMES + 2];
1143 const int scale = s->avctx->brd_scale;
1144 int i, j, out_size, p_lambda, b_lambda, lambda2;
1145 int64_t best_rd = INT64_MAX;
1146 int best_b_count = -1;
1148 av_assert0(scale >= 0 && scale <= 3);
1151 //s->next_picture_ptr->quality;
1152 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1153 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1154 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1155 if (!b_lambda) // FIXME we should do this somewhere else
1156 b_lambda = p_lambda;
1157 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1160 c->width = s->width >> scale;
1161 c->height = s->height >> scale;
1162 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1163 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1164 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1165 c->mb_decision = s->avctx->mb_decision;
1166 c->me_cmp = s->avctx->me_cmp;
1167 c->mb_cmp = s->avctx->mb_cmp;
1168 c->me_sub_cmp = s->avctx->me_sub_cmp;
1169 c->pix_fmt = PIX_FMT_YUV420P;
1170 c->time_base = s->avctx->time_base;
1171 c->max_b_frames = s->max_b_frames;
1173 if (avcodec_open2(c, codec, NULL) < 0)
1176 for (i = 0; i < s->max_b_frames + 2; i++) {
1177 int ysize = c->width * c->height;
1178 int csize = (c->width / 2) * (c->height / 2);
1179 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1180 s->next_picture_ptr;
1182 avcodec_get_frame_defaults(&input[i]);
1183 input[i].data[0] = av_malloc(ysize + 2 * csize);
1184 input[i].data[1] = input[i].data[0] + ysize;
1185 input[i].data[2] = input[i].data[1] + csize;
1186 input[i].linesize[0] = c->width;
1187 input[i].linesize[1] =
1188 input[i].linesize[2] = c->width / 2;
1190 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1191 pre_input = *pre_input_ptr;
1193 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1194 pre_input.f.data[0] += INPLACE_OFFSET;
1195 pre_input.f.data[1] += INPLACE_OFFSET;
1196 pre_input.f.data[2] += INPLACE_OFFSET;
1199 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1200 pre_input.f.data[0], pre_input.f.linesize[0],
1201 c->width, c->height);
1202 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1203 pre_input.f.data[1], pre_input.f.linesize[1],
1204 c->width >> 1, c->height >> 1);
1205 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1206 pre_input.f.data[2], pre_input.f.linesize[2],
1207 c->width >> 1, c->height >> 1);
1211 for (j = 0; j < s->max_b_frames + 1; j++) {
1214 if (!s->input_picture[j])
1217 c->error[0] = c->error[1] = c->error[2] = 0;
1219 input[0].pict_type = AV_PICTURE_TYPE_I;
1220 input[0].quality = 1 * FF_QP2LAMBDA;
1222 out_size = encode_frame(c, &input[0]);
1224 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1226 for (i = 0; i < s->max_b_frames + 1; i++) {
1227 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1229 input[i + 1].pict_type = is_p ?
1230 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1231 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1233 out_size = encode_frame(c, &input[i + 1]);
1235 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1238 /* get the delayed frames */
1240 out_size = encode_frame(c, NULL);
1241 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1244 rd += c->error[0] + c->error[1] + c->error[2];
1255 for (i = 0; i < s->max_b_frames + 2; i++) {
1256 av_freep(&input[i].data[0]);
1259 return best_b_count;
1262 static int select_input_picture(MpegEncContext *s)
1266 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1267 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1268 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1270 /* set next picture type & ordering */
1271 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1272 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1273 s->next_picture_ptr == NULL || s->intra_only) {
1274 s->reordered_input_picture[0] = s->input_picture[0];
1275 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1276 s->reordered_input_picture[0]->f.coded_picture_number =
1277 s->coded_picture_number++;
1281 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1282 if (s->picture_in_gop_number < s->gop_size &&
1283 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1284 // FIXME check that te gop check above is +-1 correct
1285 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1286 // s->input_picture[0]->f.data[0],
1287 // s->input_picture[0]->pts);
1289 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1290 for (i = 0; i < 4; i++)
1291 s->input_picture[0]->f.data[i] = NULL;
1292 s->input_picture[0]->f.type = 0;
1294 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1295 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1297 s->avctx->release_buffer(s->avctx,
1298 &s->input_picture[0]->f);
1302 ff_vbv_update(s, 0);
1308 if (s->flags & CODEC_FLAG_PASS2) {
1309 for (i = 0; i < s->max_b_frames + 1; i++) {
1310 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1312 if (pict_num >= s->rc_context.num_entries)
1314 if (!s->input_picture[i]) {
1315 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1319 s->input_picture[i]->f.pict_type =
1320 s->rc_context.entry[pict_num].new_pict_type;
1324 if (s->avctx->b_frame_strategy == 0) {
1325 b_frames = s->max_b_frames;
1326 while (b_frames && !s->input_picture[b_frames])
1328 } else if (s->avctx->b_frame_strategy == 1) {
1329 for (i = 1; i < s->max_b_frames + 1; i++) {
1330 if (s->input_picture[i] &&
1331 s->input_picture[i]->b_frame_score == 0) {
1332 s->input_picture[i]->b_frame_score =
1334 s->input_picture[i ]->f.data[0],
1335 s->input_picture[i - 1]->f.data[0],
1339 for (i = 0; i < s->max_b_frames + 1; i++) {
1340 if (s->input_picture[i] == NULL ||
1341 s->input_picture[i]->b_frame_score - 1 >
1342 s->mb_num / s->avctx->b_sensitivity)
1346 b_frames = FFMAX(0, i - 1);
1349 for (i = 0; i < b_frames + 1; i++) {
1350 s->input_picture[i]->b_frame_score = 0;
1352 } else if (s->avctx->b_frame_strategy == 2) {
1353 b_frames = estimate_best_b_count(s);
1355 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1360 //static int b_count = 0;
1361 //b_count += b_frames;
1362 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1364 for (i = b_frames - 1; i >= 0; i--) {
1365 int type = s->input_picture[i]->f.pict_type;
1366 if (type && type != AV_PICTURE_TYPE_B)
1369 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1370 b_frames == s->max_b_frames) {
1371 av_log(s->avctx, AV_LOG_ERROR,
1372 "warning, too many b frames in a row\n");
1375 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1376 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1377 s->gop_size > s->picture_in_gop_number) {
1378 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1380 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1382 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1386 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1387 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1390 s->reordered_input_picture[0] = s->input_picture[b_frames];
1391 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1392 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1393 s->reordered_input_picture[0]->f.coded_picture_number =
1394 s->coded_picture_number++;
1395 for (i = 0; i < b_frames; i++) {
1396 s->reordered_input_picture[i + 1] = s->input_picture[i];
1397 s->reordered_input_picture[i + 1]->f.pict_type =
1399 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1400 s->coded_picture_number++;
1405 if (s->reordered_input_picture[0]) {
1406 s->reordered_input_picture[0]->f.reference =
1407 s->reordered_input_picture[0]->f.pict_type !=
1408 AV_PICTURE_TYPE_B ? 3 : 0;
1410 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1412 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1413 s->avctx->rc_buffer_size) {
1414 // input is a shared pix, so we can't modifiy it -> alloc a new
1415 // one & ensure that the shared one is reuseable
1418 int i = ff_find_unused_picture(s, 0);
1421 pic = &s->picture[i];
1423 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1424 if (ff_alloc_picture(s, pic, 0) < 0) {
1428 /* mark us unused / free shared pic */
1429 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1430 s->avctx->release_buffer(s->avctx,
1431 &s->reordered_input_picture[0]->f);
1432 for (i = 0; i < 4; i++)
1433 s->reordered_input_picture[0]->f.data[i] = NULL;
1434 s->reordered_input_picture[0]->f.type = 0;
1436 copy_picture_attributes(s, &pic->f,
1437 &s->reordered_input_picture[0]->f);
1439 s->current_picture_ptr = pic;
1441 // input is not a shared pix -> reuse buffer for current_pix
1443 assert(s->reordered_input_picture[0]->f.type ==
1444 FF_BUFFER_TYPE_USER ||
1445 s->reordered_input_picture[0]->f.type ==
1446 FF_BUFFER_TYPE_INTERNAL);
1448 s->current_picture_ptr = s->reordered_input_picture[0];
1449 for (i = 0; i < 4; i++) {
1450 s->new_picture.f.data[i] += INPLACE_OFFSET;
1453 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1455 s->picture_number = s->new_picture.f.display_picture_number;
1456 //printf("dpn:%d\n", s->picture_number);
1458 memset(&s->new_picture, 0, sizeof(Picture));
1463 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1464 AVFrame *pic_arg, int *got_packet)
1466 MpegEncContext *s = avctx->priv_data;
1467 int i, stuffing_count, ret;
1468 int context_count = s->slice_context_count;
1470 s->picture_in_gop_number++;
1472 if (load_input_picture(s, pic_arg) < 0)
1475 if (select_input_picture(s) < 0) {
1480 if (s->new_picture.f.data[0]) {
1481 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1484 s->mb_info_ptr = av_packet_new_side_data(pkt,
1485 AV_PKT_DATA_H263_MB_INFO,
1486 s->mb_width*s->mb_height*12);
1487 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1490 for (i = 0; i < context_count; i++) {
1491 int start_y = s->thread_context[i]->start_mb_y;
1492 int end_y = s->thread_context[i]-> end_mb_y;
1493 int h = s->mb_height;
1494 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1495 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1497 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1500 s->pict_type = s->new_picture.f.pict_type;
1502 //printf("qs:%f %f %d\n", s->new_picture.quality,
1503 // s->current_picture.quality, s->qscale);
1504 ff_MPV_frame_start(s, avctx);
1506 if (encode_picture(s, s->picture_number) < 0)
1509 avctx->header_bits = s->header_bits;
1510 avctx->mv_bits = s->mv_bits;
1511 avctx->misc_bits = s->misc_bits;
1512 avctx->i_tex_bits = s->i_tex_bits;
1513 avctx->p_tex_bits = s->p_tex_bits;
1514 avctx->i_count = s->i_count;
1515 // FIXME f/b_count in avctx
1516 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1517 avctx->skip_count = s->skip_count;
1519 ff_MPV_frame_end(s);
1521 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1522 ff_mjpeg_encode_picture_trailer(s);
1524 if (avctx->rc_buffer_size) {
1525 RateControlContext *rcc = &s->rc_context;
1526 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1528 if (put_bits_count(&s->pb) > max_size &&
1529 s->lambda < s->avctx->lmax) {
1530 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1531 (s->qscale + 1) / s->qscale);
1532 if (s->adaptive_quant) {
1534 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1535 s->lambda_table[i] =
1536 FFMAX(s->lambda_table[i] + 1,
1537 s->lambda_table[i] * (s->qscale + 1) /
1540 s->mb_skipped = 0; // done in MPV_frame_start()
1541 // done in encode_picture() so we must undo it
1542 if (s->pict_type == AV_PICTURE_TYPE_P) {
1543 if (s->flipflop_rounding ||
1544 s->codec_id == AV_CODEC_ID_H263P ||
1545 s->codec_id == AV_CODEC_ID_MPEG4)
1546 s->no_rounding ^= 1;
1548 if (s->pict_type != AV_PICTURE_TYPE_B) {
1549 s->time_base = s->last_time_base;
1550 s->last_non_b_time = s->time - s->pp_time;
1552 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1553 for (i = 0; i < context_count; i++) {
1554 PutBitContext *pb = &s->thread_context[i]->pb;
1555 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1560 assert(s->avctx->rc_max_rate);
1563 if (s->flags & CODEC_FLAG_PASS1)
1564 ff_write_pass1_stats(s);
1566 for (i = 0; i < 4; i++) {
1567 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1568 avctx->error[i] += s->current_picture_ptr->f.error[i];
1571 if (s->flags & CODEC_FLAG_PASS1)
1572 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1573 avctx->i_tex_bits + avctx->p_tex_bits ==
1574 put_bits_count(&s->pb));
1575 flush_put_bits(&s->pb);
1576 s->frame_bits = put_bits_count(&s->pb);
1578 stuffing_count = ff_vbv_update(s, s->frame_bits);
1579 if (stuffing_count) {
1580 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1581 stuffing_count + 50) {
1582 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1586 switch (s->codec_id) {
1587 case AV_CODEC_ID_MPEG1VIDEO:
1588 case AV_CODEC_ID_MPEG2VIDEO:
1589 while (stuffing_count--) {
1590 put_bits(&s->pb, 8, 0);
1593 case AV_CODEC_ID_MPEG4:
1594 put_bits(&s->pb, 16, 0);
1595 put_bits(&s->pb, 16, 0x1C3);
1596 stuffing_count -= 4;
1597 while (stuffing_count--) {
1598 put_bits(&s->pb, 8, 0xFF);
1602 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1604 flush_put_bits(&s->pb);
1605 s->frame_bits = put_bits_count(&s->pb);
1608 /* update mpeg1/2 vbv_delay for CBR */
1609 if (s->avctx->rc_max_rate &&
1610 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1611 s->out_format == FMT_MPEG1 &&
1612 90000LL * (avctx->rc_buffer_size - 1) <=
1613 s->avctx->rc_max_rate * 0xFFFFLL) {
1614 int vbv_delay, min_delay;
1615 double inbits = s->avctx->rc_max_rate *
1616 av_q2d(s->avctx->time_base);
1617 int minbits = s->frame_bits - 8 *
1618 (s->vbv_delay_ptr - s->pb.buf - 1);
1619 double bits = s->rc_context.buffer_index + minbits - inbits;
1622 av_log(s->avctx, AV_LOG_ERROR,
1623 "Internal error, negative bits\n");
1625 assert(s->repeat_first_field == 0);
1627 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1628 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1629 s->avctx->rc_max_rate;
1631 vbv_delay = FFMAX(vbv_delay, min_delay);
1633 av_assert0(vbv_delay < 0xFFFF);
1635 s->vbv_delay_ptr[0] &= 0xF8;
1636 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1637 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1638 s->vbv_delay_ptr[2] &= 0x07;
1639 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1640 avctx->vbv_delay = vbv_delay * 300;
1642 s->total_bits += s->frame_bits;
1643 avctx->frame_bits = s->frame_bits;
1645 pkt->pts = s->current_picture.f.pts;
1646 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1647 if (!s->current_picture.f.coded_picture_number)
1648 pkt->dts = pkt->pts - s->dts_delta;
1650 pkt->dts = s->reordered_pts;
1651 s->reordered_pts = pkt->pts;
1653 pkt->dts = pkt->pts;
1654 if (s->current_picture.f.key_frame)
1655 pkt->flags |= AV_PKT_FLAG_KEY;
1657 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1661 assert((s->frame_bits & 7) == 0);
1663 pkt->size = s->frame_bits / 8;
1664 *got_packet = !!pkt->size;
1668 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1669 int n, int threshold)
1671 static const char tab[64] = {
1672 3, 2, 2, 1, 1, 1, 1, 1,
1673 1, 1, 1, 1, 1, 1, 1, 1,
1674 1, 1, 1, 1, 1, 1, 1, 1,
1675 0, 0, 0, 0, 0, 0, 0, 0,
1676 0, 0, 0, 0, 0, 0, 0, 0,
1677 0, 0, 0, 0, 0, 0, 0, 0,
1678 0, 0, 0, 0, 0, 0, 0, 0,
1679 0, 0, 0, 0, 0, 0, 0, 0
1684 DCTELEM *block = s->block[n];
1685 const int last_index = s->block_last_index[n];
1688 if (threshold < 0) {
1690 threshold = -threshold;
1694 /* Are all we could set to zero already zero? */
1695 if (last_index <= skip_dc - 1)
1698 for (i = 0; i <= last_index; i++) {
1699 const int j = s->intra_scantable.permutated[i];
1700 const int level = FFABS(block[j]);
1702 if (skip_dc && i == 0)
1706 } else if (level > 1) {
1712 if (score >= threshold)
1714 for (i = skip_dc; i <= last_index; i++) {
1715 const int j = s->intra_scantable.permutated[i];
1719 s->block_last_index[n] = 0;
1721 s->block_last_index[n] = -1;
1724 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1728 const int maxlevel = s->max_qcoeff;
1729 const int minlevel = s->min_qcoeff;
1733 i = 1; // skip clipping of intra dc
1737 for (; i <= last_index; i++) {
1738 const int j = s->intra_scantable.permutated[i];
1739 int level = block[j];
1741 if (level > maxlevel) {
1744 } else if (level < minlevel) {
1752 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1753 av_log(s->avctx, AV_LOG_INFO,
1754 "warning, clipping %d dct coefficients to %d..%d\n",
1755 overflow, minlevel, maxlevel);
1758 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1762 for (y = 0; y < 8; y++) {
1763 for (x = 0; x < 8; x++) {
1769 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1770 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1771 int v = ptr[x2 + y2 * stride];
1777 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1782 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1783 int motion_x, int motion_y,
1784 int mb_block_height,
1787 int16_t weight[8][64];
1788 DCTELEM orig[8][64];
1789 const int mb_x = s->mb_x;
1790 const int mb_y = s->mb_y;
1793 int dct_offset = s->linesize * 8; // default for progressive frames
1794 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1797 for (i = 0; i < mb_block_count; i++)
1798 skip_dct[i] = s->skipdct;
1800 if (s->adaptive_quant) {
1801 const int last_qp = s->qscale;
1802 const int mb_xy = mb_x + mb_y * s->mb_stride;
1804 s->lambda = s->lambda_table[mb_xy];
1807 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1808 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1809 s->dquant = s->qscale - last_qp;
1811 if (s->out_format == FMT_H263) {
1812 s->dquant = av_clip(s->dquant, -2, 2);
1814 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1816 if (s->pict_type == AV_PICTURE_TYPE_B) {
1817 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1820 if (s->mv_type == MV_TYPE_8X8)
1826 ff_set_qscale(s, last_qp + s->dquant);
1827 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1828 ff_set_qscale(s, s->qscale + s->dquant);
1830 wrap_y = s->linesize;
1831 wrap_c = s->uvlinesize;
1832 ptr_y = s->new_picture.f.data[0] +
1833 (mb_y * 16 * wrap_y) + mb_x * 16;
1834 ptr_cb = s->new_picture.f.data[1] +
1835 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1836 ptr_cr = s->new_picture.f.data[2] +
1837 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1839 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1840 uint8_t *ebuf = s->edge_emu_buffer + 32;
1841 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1842 mb_y * 16, s->width, s->height);
1844 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1845 mb_block_height, mb_x * 8, mb_y * 8,
1846 (s->width+1) >> 1, (s->height+1) >> 1);
1847 ptr_cb = ebuf + 18 * wrap_y;
1848 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1849 mb_block_height, mb_x * 8, mb_y * 8,
1850 (s->width+1) >> 1, (s->height+1) >> 1);
1851 ptr_cr = ebuf + 18 * wrap_y + 8;
1855 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1856 int progressive_score, interlaced_score;
1858 s->interlaced_dct = 0;
1859 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1861 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1862 NULL, wrap_y, 8) - 400;
1864 if (progressive_score > 0) {
1865 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1866 NULL, wrap_y * 2, 8) +
1867 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1868 NULL, wrap_y * 2, 8);
1869 if (progressive_score > interlaced_score) {
1870 s->interlaced_dct = 1;
1872 dct_offset = wrap_y;
1874 if (s->chroma_format == CHROMA_422)
1880 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1881 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1882 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1883 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1885 if (s->flags & CODEC_FLAG_GRAY) {
1889 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1890 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1891 if (!s->chroma_y_shift) { /* 422 */
1892 s->dsp.get_pixels(s->block[6],
1893 ptr_cb + (dct_offset >> 1), wrap_c);
1894 s->dsp.get_pixels(s->block[7],
1895 ptr_cr + (dct_offset >> 1), wrap_c);
1899 op_pixels_func (*op_pix)[4];
1900 qpel_mc_func (*op_qpix)[16];
1901 uint8_t *dest_y, *dest_cb, *dest_cr;
1903 dest_y = s->dest[0];
1904 dest_cb = s->dest[1];
1905 dest_cr = s->dest[2];
1907 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1908 op_pix = s->dsp.put_pixels_tab;
1909 op_qpix = s->dsp.put_qpel_pixels_tab;
1911 op_pix = s->dsp.put_no_rnd_pixels_tab;
1912 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1915 if (s->mv_dir & MV_DIR_FORWARD) {
1916 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1917 s->last_picture.f.data,
1919 op_pix = s->dsp.avg_pixels_tab;
1920 op_qpix = s->dsp.avg_qpel_pixels_tab;
1922 if (s->mv_dir & MV_DIR_BACKWARD) {
1923 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1924 s->next_picture.f.data,
1928 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1929 int progressive_score, interlaced_score;
1931 s->interlaced_dct = 0;
1932 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1935 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1936 ptr_y + wrap_y * 8, wrap_y,
1939 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1940 progressive_score -= 400;
1942 if (progressive_score > 0) {
1943 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1946 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1950 if (progressive_score > interlaced_score) {
1951 s->interlaced_dct = 1;
1953 dct_offset = wrap_y;
1955 if (s->chroma_format == CHROMA_422)
1961 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1962 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1963 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1964 dest_y + dct_offset, wrap_y);
1965 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1966 dest_y + dct_offset + 8, wrap_y);
1968 if (s->flags & CODEC_FLAG_GRAY) {
1972 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1973 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1974 if (!s->chroma_y_shift) { /* 422 */
1975 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1976 dest_cb + (dct_offset >> 1), wrap_c);
1977 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1978 dest_cr + (dct_offset >> 1), wrap_c);
1981 /* pre quantization */
1982 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1983 2 * s->qscale * s->qscale) {
1985 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1986 wrap_y, 8) < 20 * s->qscale)
1988 if (s->dsp.sad[1](NULL, ptr_y + 8,
1989 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1991 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1992 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1994 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1995 dest_y + dct_offset + 8,
1996 wrap_y, 8) < 20 * s->qscale)
1998 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1999 wrap_c, 8) < 20 * s->qscale)
2001 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2002 wrap_c, 8) < 20 * s->qscale)
2004 if (!s->chroma_y_shift) { /* 422 */
2005 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2006 dest_cb + (dct_offset >> 1),
2007 wrap_c, 8) < 20 * s->qscale)
2009 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2010 dest_cr + (dct_offset >> 1),
2011 wrap_c, 8) < 20 * s->qscale)
2017 if (s->quantizer_noise_shaping) {
2019 get_visual_weight(weight[0], ptr_y , wrap_y);
2021 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2023 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2025 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2027 get_visual_weight(weight[4], ptr_cb , wrap_c);
2029 get_visual_weight(weight[5], ptr_cr , wrap_c);
2030 if (!s->chroma_y_shift) { /* 422 */
2032 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2035 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2038 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2041 /* DCT & quantize */
2042 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2044 for (i = 0; i < mb_block_count; i++) {
2047 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2048 // FIXME we could decide to change to quantizer instead of
2050 // JS: I don't think that would be a good idea it could lower
2051 // quality instead of improve it. Just INTRADC clipping
2052 // deserves changes in quantizer
2054 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2056 s->block_last_index[i] = -1;
2058 if (s->quantizer_noise_shaping) {
2059 for (i = 0; i < mb_block_count; i++) {
2061 s->block_last_index[i] =
2062 dct_quantize_refine(s, s->block[i], weight[i],
2063 orig[i], i, s->qscale);
2068 if (s->luma_elim_threshold && !s->mb_intra)
2069 for (i = 0; i < 4; i++)
2070 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2071 if (s->chroma_elim_threshold && !s->mb_intra)
2072 for (i = 4; i < mb_block_count; i++)
2073 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2075 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2076 for (i = 0; i < mb_block_count; i++) {
2077 if (s->block_last_index[i] == -1)
2078 s->coded_score[i] = INT_MAX / 256;
2083 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2084 s->block_last_index[4] =
2085 s->block_last_index[5] = 0;
2087 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2090 // non c quantize code returns incorrect block_last_index FIXME
2091 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2092 for (i = 0; i < mb_block_count; i++) {
2094 if (s->block_last_index[i] > 0) {
2095 for (j = 63; j > 0; j--) {
2096 if (s->block[i][s->intra_scantable.permutated[j]])
2099 s->block_last_index[i] = j;
2104 /* huffman encode */
2105 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2106 case AV_CODEC_ID_MPEG1VIDEO:
2107 case AV_CODEC_ID_MPEG2VIDEO:
2108 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2109 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2111 case AV_CODEC_ID_MPEG4:
2112 if (CONFIG_MPEG4_ENCODER)
2113 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2115 case AV_CODEC_ID_MSMPEG4V2:
2116 case AV_CODEC_ID_MSMPEG4V3:
2117 case AV_CODEC_ID_WMV1:
2118 if (CONFIG_MSMPEG4_ENCODER)
2119 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2121 case AV_CODEC_ID_WMV2:
2122 if (CONFIG_WMV2_ENCODER)
2123 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2125 case AV_CODEC_ID_H261:
2126 if (CONFIG_H261_ENCODER)
2127 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2129 case AV_CODEC_ID_H263:
2130 case AV_CODEC_ID_H263P:
2131 case AV_CODEC_ID_FLV1:
2132 case AV_CODEC_ID_RV10:
2133 case AV_CODEC_ID_RV20:
2134 if (CONFIG_H263_ENCODER)
2135 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2137 case AV_CODEC_ID_MJPEG:
2138 case AV_CODEC_ID_AMV:
2139 if (CONFIG_MJPEG_ENCODER)
2140 ff_mjpeg_encode_mb(s, s->block);
2147 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2149 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2150 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2153 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2156 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2159 d->mb_skip_run= s->mb_skip_run;
2161 d->last_dc[i] = s->last_dc[i];
2164 d->mv_bits= s->mv_bits;
2165 d->i_tex_bits= s->i_tex_bits;
2166 d->p_tex_bits= s->p_tex_bits;
2167 d->i_count= s->i_count;
2168 d->f_count= s->f_count;
2169 d->b_count= s->b_count;
2170 d->skip_count= s->skip_count;
2171 d->misc_bits= s->misc_bits;
2175 d->qscale= s->qscale;
2176 d->dquant= s->dquant;
2178 d->esc3_level_length= s->esc3_level_length;
2181 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2184 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2185 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2188 d->mb_skip_run= s->mb_skip_run;
2190 d->last_dc[i] = s->last_dc[i];
2193 d->mv_bits= s->mv_bits;
2194 d->i_tex_bits= s->i_tex_bits;
2195 d->p_tex_bits= s->p_tex_bits;
2196 d->i_count= s->i_count;
2197 d->f_count= s->f_count;
2198 d->b_count= s->b_count;
2199 d->skip_count= s->skip_count;
2200 d->misc_bits= s->misc_bits;
2202 d->mb_intra= s->mb_intra;
2203 d->mb_skipped= s->mb_skipped;
2204 d->mv_type= s->mv_type;
2205 d->mv_dir= s->mv_dir;
2207 if(s->data_partitioning){
2209 d->tex_pb= s->tex_pb;
2213 d->block_last_index[i]= s->block_last_index[i];
2214 d->interlaced_dct= s->interlaced_dct;
2215 d->qscale= s->qscale;
2217 d->esc3_level_length= s->esc3_level_length;
2220 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2221 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2222 int *dmin, int *next_block, int motion_x, int motion_y)
2225 uint8_t *dest_backup[3];
2227 copy_context_before_encode(s, backup, type);
2229 s->block= s->blocks[*next_block];
2230 s->pb= pb[*next_block];
2231 if(s->data_partitioning){
2232 s->pb2 = pb2 [*next_block];
2233 s->tex_pb= tex_pb[*next_block];
2237 memcpy(dest_backup, s->dest, sizeof(s->dest));
2238 s->dest[0] = s->rd_scratchpad;
2239 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2240 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2241 assert(s->linesize >= 32); //FIXME
2244 encode_mb(s, motion_x, motion_y);
2246 score= put_bits_count(&s->pb);
2247 if(s->data_partitioning){
2248 score+= put_bits_count(&s->pb2);
2249 score+= put_bits_count(&s->tex_pb);
2252 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2253 ff_MPV_decode_mb(s, s->block);
2255 score *= s->lambda2;
2256 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2260 memcpy(s->dest, dest_backup, sizeof(s->dest));
2267 copy_context_after_encode(best, s, type);
2271 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2272 uint32_t *sq = ff_squareTbl + 256;
2277 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2278 else if(w==8 && h==8)
2279 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2283 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2292 static int sse_mb(MpegEncContext *s){
2296 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2297 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2300 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2301 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)
2302 +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)
2303 +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);
2305 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)
2306 +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)
2307 +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);
2310 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)
2311 +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)
2312 +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);
2315 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2316 MpegEncContext *s= *(void**)arg;
2320 s->me.dia_size= s->avctx->pre_dia_size;
2321 s->first_slice_line=1;
2322 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2323 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2324 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2326 s->first_slice_line=0;
2334 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2335 MpegEncContext *s= *(void**)arg;
2337 ff_check_alignment();
2339 s->me.dia_size= s->avctx->dia_size;
2340 s->first_slice_line=1;
2341 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2342 s->mb_x=0; //for block init below
2343 ff_init_block_index(s);
2344 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2345 s->block_index[0]+=2;
2346 s->block_index[1]+=2;
2347 s->block_index[2]+=2;
2348 s->block_index[3]+=2;
2350 /* compute motion vector & mb_type and store in context */
2351 if(s->pict_type==AV_PICTURE_TYPE_B)
2352 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2354 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2356 s->first_slice_line=0;
2361 static int mb_var_thread(AVCodecContext *c, void *arg){
2362 MpegEncContext *s= *(void**)arg;
2365 ff_check_alignment();
2367 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2368 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2371 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2373 int sum = s->dsp.pix_sum(pix, s->linesize);
2375 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2377 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2378 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2379 s->me.mb_var_sum_temp += varc;
2385 static void write_slice_end(MpegEncContext *s){
2386 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2387 if(s->partitioned_frame){
2388 ff_mpeg4_merge_partitions(s);
2391 ff_mpeg4_stuffing(&s->pb);
2392 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2393 ff_mjpeg_encode_stuffing(s);
2396 avpriv_align_put_bits(&s->pb);
2397 flush_put_bits(&s->pb);
2399 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2400 s->misc_bits+= get_bits_diff(s);
2403 static void write_mb_info(MpegEncContext *s)
2405 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2406 int offset = put_bits_count(&s->pb);
2407 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2408 int gobn = s->mb_y / s->gob_index;
2410 if (CONFIG_H263_ENCODER)
2411 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2412 bytestream_put_le32(&ptr, offset);
2413 bytestream_put_byte(&ptr, s->qscale);
2414 bytestream_put_byte(&ptr, gobn);
2415 bytestream_put_le16(&ptr, mba);
2416 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2417 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2418 /* 4MV not implemented */
2419 bytestream_put_byte(&ptr, 0); /* hmv2 */
2420 bytestream_put_byte(&ptr, 0); /* vmv2 */
2423 static void update_mb_info(MpegEncContext *s, int startcode)
2427 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2428 s->mb_info_size += 12;
2429 s->prev_mb_info = s->last_mb_info;
2432 s->prev_mb_info = put_bits_count(&s->pb)/8;
2433 /* This might have incremented mb_info_size above, and we return without
2434 * actually writing any info into that slot yet. But in that case,
2435 * this will be called again at the start of the after writing the
2436 * start code, actually writing the mb info. */
2440 s->last_mb_info = put_bits_count(&s->pb)/8;
2441 if (!s->mb_info_size)
2442 s->mb_info_size += 12;
2446 static int encode_thread(AVCodecContext *c, void *arg){
2447 MpegEncContext *s= *(void**)arg;
2448 int mb_x, mb_y, pdif = 0;
2449 int chr_h= 16>>s->chroma_y_shift;
2451 MpegEncContext best_s, backup_s;
2452 uint8_t bit_buf[2][MAX_MB_BYTES];
2453 uint8_t bit_buf2[2][MAX_MB_BYTES];
2454 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2455 PutBitContext pb[2], pb2[2], tex_pb[2];
2456 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2458 ff_check_alignment();
2461 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2462 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2463 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2466 s->last_bits= put_bits_count(&s->pb);
2477 /* init last dc values */
2478 /* note: quant matrix value (8) is implied here */
2479 s->last_dc[i] = 128 << s->intra_dc_precision;
2481 s->current_picture.f.error[i] = 0;
2483 if(s->codec_id==AV_CODEC_ID_AMV){
2484 s->last_dc[0] = 128*8/13;
2485 s->last_dc[1] = 128*8/14;
2486 s->last_dc[2] = 128*8/14;
2489 memset(s->last_mv, 0, sizeof(s->last_mv));
2493 switch(s->codec_id){
2494 case AV_CODEC_ID_H263:
2495 case AV_CODEC_ID_H263P:
2496 case AV_CODEC_ID_FLV1:
2497 if (CONFIG_H263_ENCODER)
2498 s->gob_index = ff_h263_get_gob_height(s);
2500 case AV_CODEC_ID_MPEG4:
2501 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2502 ff_mpeg4_init_partitions(s);
2508 s->first_slice_line = 1;
2509 s->ptr_lastgob = s->pb.buf;
2510 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2511 // printf("row %d at %X\n", s->mb_y, (int)s);
2515 ff_set_qscale(s, s->qscale);
2516 ff_init_block_index(s);
2518 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2519 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2520 int mb_type= s->mb_type[xy];
2525 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2526 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2529 if(s->data_partitioning){
2530 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2531 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2532 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2538 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2539 ff_update_block_index(s);
2541 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2542 ff_h261_reorder_mb_index(s);
2543 xy= s->mb_y*s->mb_stride + s->mb_x;
2544 mb_type= s->mb_type[xy];
2547 /* write gob / video packet header */
2549 int current_packet_size, is_gob_start;
2551 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2553 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2555 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2557 switch(s->codec_id){
2558 case AV_CODEC_ID_H263:
2559 case AV_CODEC_ID_H263P:
2560 if(!s->h263_slice_structured)
2561 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2563 case AV_CODEC_ID_MPEG2VIDEO:
2564 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2565 case AV_CODEC_ID_MPEG1VIDEO:
2566 if(s->mb_skip_run) is_gob_start=0;
2568 case AV_CODEC_ID_MJPEG:
2569 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2574 if(s->start_mb_y != mb_y || mb_x!=0){
2576 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2577 ff_mpeg4_init_partitions(s);
2581 av_assert2((put_bits_count(&s->pb)&7) == 0);
2582 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2584 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2585 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2586 int d= 100 / s->avctx->error_rate;
2588 current_packet_size=0;
2589 s->pb.buf_ptr= s->ptr_lastgob;
2590 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2594 if (s->avctx->rtp_callback){
2595 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2596 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2598 update_mb_info(s, 1);
2600 switch(s->codec_id){
2601 case AV_CODEC_ID_MPEG4:
2602 if (CONFIG_MPEG4_ENCODER) {
2603 ff_mpeg4_encode_video_packet_header(s);
2604 ff_mpeg4_clean_buffers(s);
2607 case AV_CODEC_ID_MPEG1VIDEO:
2608 case AV_CODEC_ID_MPEG2VIDEO:
2609 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2610 ff_mpeg1_encode_slice_header(s);
2611 ff_mpeg1_clean_buffers(s);
2614 case AV_CODEC_ID_H263:
2615 case AV_CODEC_ID_H263P:
2616 if (CONFIG_H263_ENCODER)
2617 ff_h263_encode_gob_header(s, mb_y);
2621 if(s->flags&CODEC_FLAG_PASS1){
2622 int bits= put_bits_count(&s->pb);
2623 s->misc_bits+= bits - s->last_bits;
2627 s->ptr_lastgob += current_packet_size;
2628 s->first_slice_line=1;
2629 s->resync_mb_x=mb_x;
2630 s->resync_mb_y=mb_y;
2634 if( (s->resync_mb_x == s->mb_x)
2635 && s->resync_mb_y+1 == s->mb_y){
2636 s->first_slice_line=0;
2640 s->dquant=0; //only for QP_RD
2642 update_mb_info(s, 0);
2644 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
2646 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2648 copy_context_before_encode(&backup_s, s, -1);
2650 best_s.data_partitioning= s->data_partitioning;
2651 best_s.partitioned_frame= s->partitioned_frame;
2652 if(s->data_partitioning){
2653 backup_s.pb2= s->pb2;
2654 backup_s.tex_pb= s->tex_pb;
2657 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2658 s->mv_dir = MV_DIR_FORWARD;
2659 s->mv_type = MV_TYPE_16X16;
2661 s->mv[0][0][0] = s->p_mv_table[xy][0];
2662 s->mv[0][0][1] = s->p_mv_table[xy][1];
2663 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2664 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2666 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2667 s->mv_dir = MV_DIR_FORWARD;
2668 s->mv_type = MV_TYPE_FIELD;
2671 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2672 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2673 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2675 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2676 &dmin, &next_block, 0, 0);
2678 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2679 s->mv_dir = MV_DIR_FORWARD;
2680 s->mv_type = MV_TYPE_16X16;
2684 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2685 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2687 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2688 s->mv_dir = MV_DIR_FORWARD;
2689 s->mv_type = MV_TYPE_8X8;
2692 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2693 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2695 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2696 &dmin, &next_block, 0, 0);
2698 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2699 s->mv_dir = MV_DIR_FORWARD;
2700 s->mv_type = MV_TYPE_16X16;
2702 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2703 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2704 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2705 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2707 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2708 s->mv_dir = MV_DIR_BACKWARD;
2709 s->mv_type = MV_TYPE_16X16;
2711 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2712 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2713 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2714 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2716 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2717 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2718 s->mv_type = MV_TYPE_16X16;
2720 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2721 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2722 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2723 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2724 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2725 &dmin, &next_block, 0, 0);
2727 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2728 s->mv_dir = MV_DIR_FORWARD;
2729 s->mv_type = MV_TYPE_FIELD;
2732 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2733 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2734 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2736 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2737 &dmin, &next_block, 0, 0);
2739 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2740 s->mv_dir = MV_DIR_BACKWARD;
2741 s->mv_type = MV_TYPE_FIELD;
2744 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2745 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2746 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2748 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2749 &dmin, &next_block, 0, 0);
2751 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2752 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2753 s->mv_type = MV_TYPE_FIELD;
2755 for(dir=0; dir<2; dir++){
2757 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2758 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2759 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2762 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2763 &dmin, &next_block, 0, 0);
2765 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2767 s->mv_type = MV_TYPE_16X16;
2771 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2772 &dmin, &next_block, 0, 0);
2773 if(s->h263_pred || s->h263_aic){
2775 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2777 ff_clean_intra_table_entries(s); //old mode?
2781 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2782 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2783 const int last_qp= backup_s.qscale;
2786 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2787 static const int dquant_tab[4]={-1,1,-2,2};
2789 av_assert2(backup_s.dquant == 0);
2792 s->mv_dir= best_s.mv_dir;
2793 s->mv_type = MV_TYPE_16X16;
2794 s->mb_intra= best_s.mb_intra;
2795 s->mv[0][0][0] = best_s.mv[0][0][0];
2796 s->mv[0][0][1] = best_s.mv[0][0][1];
2797 s->mv[1][0][0] = best_s.mv[1][0][0];
2798 s->mv[1][0][1] = best_s.mv[1][0][1];
2800 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2801 for(; qpi<4; qpi++){
2802 int dquant= dquant_tab[qpi];
2803 qp= last_qp + dquant;
2804 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2806 backup_s.dquant= dquant;
2807 if(s->mb_intra && s->dc_val[0]){
2809 dc[i]= s->dc_val[0][ s->block_index[i] ];
2810 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2814 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2815 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2816 if(best_s.qscale != qp){
2817 if(s->mb_intra && s->dc_val[0]){
2819 s->dc_val[0][ s->block_index[i] ]= dc[i];
2820 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2827 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2828 int mx= s->b_direct_mv_table[xy][0];
2829 int my= s->b_direct_mv_table[xy][1];
2831 backup_s.dquant = 0;
2832 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2834 ff_mpeg4_set_direct_mv(s, mx, my);
2835 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2836 &dmin, &next_block, mx, my);
2838 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2839 backup_s.dquant = 0;
2840 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2842 ff_mpeg4_set_direct_mv(s, 0, 0);
2843 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2844 &dmin, &next_block, 0, 0);
2846 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2849 coded |= s->block_last_index[i];
2852 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2853 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2854 mx=my=0; //FIXME find the one we actually used
2855 ff_mpeg4_set_direct_mv(s, mx, my);
2856 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2864 s->mv_dir= best_s.mv_dir;
2865 s->mv_type = best_s.mv_type;
2867 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2868 s->mv[0][0][1] = best_s.mv[0][0][1];
2869 s->mv[1][0][0] = best_s.mv[1][0][0];
2870 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2873 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2874 &dmin, &next_block, mx, my);
2879 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2881 copy_context_after_encode(s, &best_s, -1);
2883 pb_bits_count= put_bits_count(&s->pb);
2884 flush_put_bits(&s->pb);
2885 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2888 if(s->data_partitioning){
2889 pb2_bits_count= put_bits_count(&s->pb2);
2890 flush_put_bits(&s->pb2);
2891 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2892 s->pb2= backup_s.pb2;
2894 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2895 flush_put_bits(&s->tex_pb);
2896 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2897 s->tex_pb= backup_s.tex_pb;
2899 s->last_bits= put_bits_count(&s->pb);
2901 if (CONFIG_H263_ENCODER &&
2902 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2903 ff_h263_update_motion_val(s);
2905 if(next_block==0){ //FIXME 16 vs linesize16
2906 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2907 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2908 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2911 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2912 ff_MPV_decode_mb(s, s->block);
2914 int motion_x = 0, motion_y = 0;
2915 s->mv_type=MV_TYPE_16X16;
2916 // only one MB-Type possible
2919 case CANDIDATE_MB_TYPE_INTRA:
2922 motion_x= s->mv[0][0][0] = 0;
2923 motion_y= s->mv[0][0][1] = 0;
2925 case CANDIDATE_MB_TYPE_INTER:
2926 s->mv_dir = MV_DIR_FORWARD;
2928 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2929 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2931 case CANDIDATE_MB_TYPE_INTER_I:
2932 s->mv_dir = MV_DIR_FORWARD;
2933 s->mv_type = MV_TYPE_FIELD;
2936 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2937 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2938 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2941 case CANDIDATE_MB_TYPE_INTER4V:
2942 s->mv_dir = MV_DIR_FORWARD;
2943 s->mv_type = MV_TYPE_8X8;
2946 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2947 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2950 case CANDIDATE_MB_TYPE_DIRECT:
2951 if (CONFIG_MPEG4_ENCODER) {
2952 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2954 motion_x=s->b_direct_mv_table[xy][0];
2955 motion_y=s->b_direct_mv_table[xy][1];
2956 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2959 case CANDIDATE_MB_TYPE_DIRECT0:
2960 if (CONFIG_MPEG4_ENCODER) {
2961 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2963 ff_mpeg4_set_direct_mv(s, 0, 0);
2966 case CANDIDATE_MB_TYPE_BIDIR:
2967 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2969 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2970 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2971 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2972 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2974 case CANDIDATE_MB_TYPE_BACKWARD:
2975 s->mv_dir = MV_DIR_BACKWARD;
2977 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2978 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2980 case CANDIDATE_MB_TYPE_FORWARD:
2981 s->mv_dir = MV_DIR_FORWARD;
2983 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2984 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2985 // printf(" %d %d ", motion_x, motion_y);
2987 case CANDIDATE_MB_TYPE_FORWARD_I:
2988 s->mv_dir = MV_DIR_FORWARD;
2989 s->mv_type = MV_TYPE_FIELD;
2992 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2993 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2994 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2997 case CANDIDATE_MB_TYPE_BACKWARD_I:
2998 s->mv_dir = MV_DIR_BACKWARD;
2999 s->mv_type = MV_TYPE_FIELD;
3002 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3003 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3004 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3007 case CANDIDATE_MB_TYPE_BIDIR_I:
3008 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3009 s->mv_type = MV_TYPE_FIELD;
3011 for(dir=0; dir<2; dir++){
3013 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3014 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3015 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3020 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3023 encode_mb(s, motion_x, motion_y);
3025 // RAL: Update last macroblock type
3026 s->last_mv_dir = s->mv_dir;
3028 if (CONFIG_H263_ENCODER &&
3029 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3030 ff_h263_update_motion_val(s);
3032 ff_MPV_decode_mb(s, s->block);
3035 /* clean the MV table in IPS frames for direct mode in B frames */
3036 if(s->mb_intra /* && I,P,S_TYPE */){
3037 s->p_mv_table[xy][0]=0;
3038 s->p_mv_table[xy][1]=0;
3041 if(s->flags&CODEC_FLAG_PSNR){
3045 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3046 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3048 s->current_picture.f.error[0] += sse(
3049 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3050 s->dest[0], w, h, s->linesize);
3051 s->current_picture.f.error[1] += sse(
3052 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3053 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3054 s->current_picture.f.error[2] += sse(
3055 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3056 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3059 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3060 ff_h263_loop_filter(s);
3062 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
3066 //not beautiful here but we must write it before flushing so it has to be here
3067 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3068 ff_msmpeg4_encode_ext_header(s);
3072 /* Send the last GOB if RTP */
3073 if (s->avctx->rtp_callback) {
3074 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3075 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3076 /* Call the RTP callback to send the last GOB */
3078 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3084 #define MERGE(field) dst->field += src->field; src->field=0
3085 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3086 MERGE(me.scene_change_score);
3087 MERGE(me.mc_mb_var_sum_temp);
3088 MERGE(me.mb_var_sum_temp);
3091 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3094 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3095 MERGE(dct_count[1]);
3105 MERGE(padding_bug_score);
3106 MERGE(current_picture.f.error[0]);
3107 MERGE(current_picture.f.error[1]);
3108 MERGE(current_picture.f.error[2]);
3110 if(dst->avctx->noise_reduction){
3111 for(i=0; i<64; i++){
3112 MERGE(dct_error_sum[0][i]);
3113 MERGE(dct_error_sum[1][i]);
3117 assert(put_bits_count(&src->pb) % 8 ==0);
3118 assert(put_bits_count(&dst->pb) % 8 ==0);
3119 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3120 flush_put_bits(&dst->pb);
3123 static int estimate_qp(MpegEncContext *s, int dry_run){
3124 if (s->next_lambda){
3125 s->current_picture_ptr->f.quality =
3126 s->current_picture.f.quality = s->next_lambda;
3127 if(!dry_run) s->next_lambda= 0;
3128 } else if (!s->fixed_qscale) {
3129 s->current_picture_ptr->f.quality =
3130 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3131 if (s->current_picture.f.quality < 0)
3135 if(s->adaptive_quant){
3136 switch(s->codec_id){
3137 case AV_CODEC_ID_MPEG4:
3138 if (CONFIG_MPEG4_ENCODER)
3139 ff_clean_mpeg4_qscales(s);
3141 case AV_CODEC_ID_H263:
3142 case AV_CODEC_ID_H263P:
3143 case AV_CODEC_ID_FLV1:
3144 if (CONFIG_H263_ENCODER)
3145 ff_clean_h263_qscales(s);
3148 ff_init_qscale_tab(s);
3151 s->lambda= s->lambda_table[0];
3154 s->lambda = s->current_picture.f.quality;
3155 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3160 /* must be called before writing the header */
3161 static void set_frame_distances(MpegEncContext * s){
3162 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3163 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3165 if(s->pict_type==AV_PICTURE_TYPE_B){
3166 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3167 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3169 s->pp_time= s->time - s->last_non_b_time;
3170 s->last_non_b_time= s->time;
3171 assert(s->picture_number==0 || s->pp_time > 0);
3175 static int encode_picture(MpegEncContext *s, int picture_number)
3179 int context_count = s->slice_context_count;
3181 s->picture_number = picture_number;
3183 /* Reset the average MB variance */
3184 s->me.mb_var_sum_temp =
3185 s->me.mc_mb_var_sum_temp = 0;
3187 /* we need to initialize some time vars before we can encode b-frames */
3188 // RAL: Condition added for MPEG1VIDEO
3189 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3190 set_frame_distances(s);
3191 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3192 ff_set_mpeg4_time(s);
3194 s->me.scene_change_score=0;
3196 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3198 if(s->pict_type==AV_PICTURE_TYPE_I){
3199 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3200 else s->no_rounding=0;
3201 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3202 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3203 s->no_rounding ^= 1;
3206 if(s->flags & CODEC_FLAG_PASS2){
3207 if (estimate_qp(s,1) < 0)
3209 ff_get_2pass_fcode(s);
3210 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3211 if(s->pict_type==AV_PICTURE_TYPE_B)
3212 s->lambda= s->last_lambda_for[s->pict_type];
3214 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3218 if(s->codec_id != AV_CODEC_ID_AMV){
3219 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3220 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3221 s->q_chroma_intra_matrix = s->q_intra_matrix;
3222 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3225 s->mb_intra=0; //for the rate distortion & bit compare functions
3226 for(i=1; i<context_count; i++){
3227 ff_update_duplicate_context(s->thread_context[i], s);
3233 /* Estimate motion for every MB */
3234 if(s->pict_type != AV_PICTURE_TYPE_I){
3235 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3236 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3237 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3238 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3239 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3243 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3244 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3246 for(i=0; i<s->mb_stride*s->mb_height; i++)
3247 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3249 if(!s->fixed_qscale){
3250 /* finding spatial complexity for I-frame rate control */
3251 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3254 for(i=1; i<context_count; i++){
3255 merge_context_after_me(s, s->thread_context[i]);
3257 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3258 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3261 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3262 s->pict_type= AV_PICTURE_TYPE_I;
3263 for(i=0; i<s->mb_stride*s->mb_height; i++)
3264 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3265 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3266 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3270 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3271 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3273 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3275 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3276 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3277 s->f_code= FFMAX3(s->f_code, a, b);
3280 ff_fix_long_p_mvs(s);
3281 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3282 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3286 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3287 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3292 if(s->pict_type==AV_PICTURE_TYPE_B){
3295 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3296 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3297 s->f_code = FFMAX(a, b);
3299 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3300 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3301 s->b_code = FFMAX(a, b);
3303 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3304 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3305 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3306 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3307 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3309 for(dir=0; dir<2; dir++){
3312 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3313 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3314 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3315 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3323 if (estimate_qp(s, 0) < 0)
3326 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3327 s->qscale= 3; //reduce clipping problems
3329 if (s->out_format == FMT_MJPEG) {
3330 /* for mjpeg, we do include qscale in the matrix */
3332 int j= s->dsp.idct_permutation[i];
3334 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3336 s->y_dc_scale_table=
3337 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3338 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3339 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3340 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3343 if(s->codec_id == AV_CODEC_ID_AMV){
3344 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};
3345 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};
3347 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3349 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3350 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3352 s->y_dc_scale_table= y;
3353 s->c_dc_scale_table= c;
3354 s->intra_matrix[0] = 13;
3355 s->chroma_intra_matrix[0] = 14;
3356 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3357 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3358 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3359 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3363 //FIXME var duplication
3364 s->current_picture_ptr->f.key_frame =
3365 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3366 s->current_picture_ptr->f.pict_type =
3367 s->current_picture.f.pict_type = s->pict_type;
3369 if (s->current_picture.f.key_frame)
3370 s->picture_in_gop_number=0;
3372 s->mb_x = s->mb_y = 0;
3373 s->last_bits= put_bits_count(&s->pb);
3374 switch(s->out_format) {
3376 if (CONFIG_MJPEG_ENCODER)
3377 ff_mjpeg_encode_picture_header(s);
3380 if (CONFIG_H261_ENCODER)
3381 ff_h261_encode_picture_header(s, picture_number);
3384 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3385 ff_wmv2_encode_picture_header(s, picture_number);
3386 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3387 ff_msmpeg4_encode_picture_header(s, picture_number);
3388 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3389 ff_mpeg4_encode_picture_header(s, picture_number);
3390 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3391 ff_rv10_encode_picture_header(s, picture_number);
3392 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3393 ff_rv20_encode_picture_header(s, picture_number);
3394 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3395 ff_flv_encode_picture_header(s, picture_number);
3396 else if (CONFIG_H263_ENCODER)
3397 ff_h263_encode_picture_header(s, picture_number);
3400 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3401 ff_mpeg1_encode_picture_header(s, picture_number);
3408 bits= put_bits_count(&s->pb);
3409 s->header_bits= bits - s->last_bits;
3411 for(i=1; i<context_count; i++){
3412 update_duplicate_context_after_me(s->thread_context[i], s);
3414 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3415 for(i=1; i<context_count; i++){
3416 merge_context_after_encode(s, s->thread_context[i]);
3422 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3423 const int intra= s->mb_intra;
3426 s->dct_count[intra]++;
3428 for(i=0; i<64; i++){
3429 int level= block[i];
3433 s->dct_error_sum[intra][i] += level;
3434 level -= s->dct_offset[intra][i];
3435 if(level<0) level=0;
3437 s->dct_error_sum[intra][i] -= level;
3438 level += s->dct_offset[intra][i];
3439 if(level>0) level=0;
3446 static int dct_quantize_trellis_c(MpegEncContext *s,
3447 DCTELEM *block, int n,
3448 int qscale, int *overflow){
3450 const uint8_t *scantable= s->intra_scantable.scantable;
3451 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3453 unsigned int threshold1, threshold2;
3465 int coeff_count[64];
3466 int qmul, qadd, start_i, last_non_zero, i, dc;
3467 const int esc_length= s->ac_esc_length;
3469 uint8_t * last_length;
3470 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3472 s->dsp.fdct (block);
3474 if(s->dct_error_sum)
3475 s->denoise_dct(s, block);
3477 qadd= ((qscale-1)|1)*8;
3488 /* For AIC we skip quant/dequant of INTRADC */
3493 /* note: block[0] is assumed to be positive */
3494 block[0] = (block[0] + (q >> 1)) / q;
3497 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3498 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3499 bias= 1<<(QMAT_SHIFT-1);
3500 length = s->intra_ac_vlc_length;
3501 last_length= s->intra_ac_vlc_last_length;
3505 qmat = s->q_inter_matrix[qscale];
3506 length = s->inter_ac_vlc_length;
3507 last_length= s->inter_ac_vlc_last_length;
3511 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3512 threshold2= (threshold1<<1);
3514 for(i=63; i>=start_i; i--) {
3515 const int j = scantable[i];
3516 int level = block[j] * qmat[j];
3518 if(((unsigned)(level+threshold1))>threshold2){
3524 for(i=start_i; i<=last_non_zero; i++) {
3525 const int j = scantable[i];
3526 int level = block[j] * qmat[j];
3528 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3529 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3530 if(((unsigned)(level+threshold1))>threshold2){
3532 level= (bias + level)>>QMAT_SHIFT;
3534 coeff[1][i]= level-1;
3535 // coeff[2][k]= level-2;
3537 level= (bias - level)>>QMAT_SHIFT;
3538 coeff[0][i]= -level;
3539 coeff[1][i]= -level+1;
3540 // coeff[2][k]= -level+2;
3542 coeff_count[i]= FFMIN(level, 2);
3543 av_assert2(coeff_count[i]);
3546 coeff[0][i]= (level>>31)|1;
3551 *overflow= s->max_qcoeff < max; //overflow might have happened
3553 if(last_non_zero < start_i){
3554 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3555 return last_non_zero;
3558 score_tab[start_i]= 0;
3559 survivor[0]= start_i;
3562 for(i=start_i; i<=last_non_zero; i++){
3563 int level_index, j, zero_distortion;
3564 int dct_coeff= FFABS(block[ scantable[i] ]);
3565 int best_score=256*256*256*120;
3567 if (s->dsp.fdct == ff_fdct_ifast)
3568 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3569 zero_distortion= dct_coeff*dct_coeff;
3571 for(level_index=0; level_index < coeff_count[i]; level_index++){
3573 int level= coeff[level_index][i];
3574 const int alevel= FFABS(level);
3579 if(s->out_format == FMT_H263){
3580 unquant_coeff= alevel*qmul + qadd;
3582 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3584 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3585 unquant_coeff = (unquant_coeff - 1) | 1;
3587 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3588 unquant_coeff = (unquant_coeff - 1) | 1;
3593 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3595 if((level&(~127)) == 0){
3596 for(j=survivor_count-1; j>=0; j--){
3597 int run= i - survivor[j];
3598 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3599 score += score_tab[i-run];
3601 if(score < best_score){
3604 level_tab[i+1]= level-64;
3608 if(s->out_format == FMT_H263){
3609 for(j=survivor_count-1; j>=0; j--){
3610 int run= i - survivor[j];
3611 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3612 score += score_tab[i-run];
3613 if(score < last_score){
3616 last_level= level-64;
3622 distortion += esc_length*lambda;
3623 for(j=survivor_count-1; j>=0; j--){
3624 int run= i - survivor[j];
3625 int score= distortion + score_tab[i-run];
3627 if(score < best_score){
3630 level_tab[i+1]= level-64;
3634 if(s->out_format == FMT_H263){
3635 for(j=survivor_count-1; j>=0; j--){
3636 int run= i - survivor[j];
3637 int score= distortion + score_tab[i-run];
3638 if(score < last_score){
3641 last_level= level-64;
3649 score_tab[i+1]= best_score;
3651 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3652 if(last_non_zero <= 27){
3653 for(; survivor_count; survivor_count--){
3654 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3658 for(; survivor_count; survivor_count--){
3659 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3664 survivor[ survivor_count++ ]= i+1;
3667 if(s->out_format != FMT_H263){
3668 last_score= 256*256*256*120;
3669 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3670 int score= score_tab[i];
3671 if(i) score += lambda*2; //FIXME exacter?
3673 if(score < last_score){
3676 last_level= level_tab[i];
3677 last_run= run_tab[i];
3682 s->coded_score[n] = last_score;
3684 dc= FFABS(block[0]);
3685 last_non_zero= last_i - 1;
3686 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3688 if(last_non_zero < start_i)
3689 return last_non_zero;
3691 if(last_non_zero == 0 && start_i == 0){
3693 int best_score= dc * dc;
3695 for(i=0; i<coeff_count[0]; i++){
3696 int level= coeff[i][0];
3697 int alevel= FFABS(level);
3698 int unquant_coeff, score, distortion;
3700 if(s->out_format == FMT_H263){
3701 unquant_coeff= (alevel*qmul + qadd)>>3;
3703 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3704 unquant_coeff = (unquant_coeff - 1) | 1;
3706 unquant_coeff = (unquant_coeff + 4) >> 3;
3707 unquant_coeff<<= 3 + 3;
3709 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3711 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3712 else score= distortion + esc_length*lambda;
3714 if(score < best_score){
3716 best_level= level - 64;
3719 block[0]= best_level;
3720 s->coded_score[n] = best_score - dc*dc;
3721 if(best_level == 0) return -1;
3722 else return last_non_zero;
3726 av_assert2(last_level);
3728 block[ perm_scantable[last_non_zero] ]= last_level;
3731 for(; i>start_i; i -= run_tab[i] + 1){
3732 block[ perm_scantable[i-1] ]= level_tab[i];
3735 return last_non_zero;
3738 //#define REFINE_STATS 1
3739 static int16_t basis[64][64];
3741 static void build_basis(uint8_t *perm){
3748 double s= 0.25*(1<<BASIS_SHIFT);
3750 int perm_index= perm[index];
3751 if(i==0) s*= sqrt(0.5);
3752 if(j==0) s*= sqrt(0.5);
3753 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)));
3760 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3761 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3764 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3765 const uint8_t *scantable= s->intra_scantable.scantable;
3766 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3767 // unsigned int threshold1, threshold2;
3772 int qmul, qadd, start_i, last_non_zero, i, dc;
3774 uint8_t * last_length;
3776 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3779 static int after_last=0;
3780 static int to_zero=0;
3781 static int from_zero=0;
3784 static int messed_sign=0;
3787 if(basis[0][0] == 0)
3788 build_basis(s->dsp.idct_permutation);
3799 /* For AIC we skip quant/dequant of INTRADC */
3803 q <<= RECON_SHIFT-3;
3804 /* note: block[0] is assumed to be positive */
3806 // block[0] = (block[0] + (q >> 1)) / q;
3808 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3809 // bias= 1<<(QMAT_SHIFT-1);
3810 length = s->intra_ac_vlc_length;
3811 last_length= s->intra_ac_vlc_last_length;
3815 length = s->inter_ac_vlc_length;
3816 last_length= s->inter_ac_vlc_last_length;
3818 last_non_zero = s->block_last_index[n];
3823 dc += (1<<(RECON_SHIFT-1));
3824 for(i=0; i<64; i++){
3825 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3828 STOP_TIMER("memset rem[]")}
3831 for(i=0; i<64; i++){
3836 w= FFABS(weight[i]) + qns*one;
3837 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3840 // w=weight[i] = (63*qns + (w/2)) / w;
3843 av_assert2(w<(1<<6));
3846 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3852 for(i=start_i; i<=last_non_zero; i++){
3853 int j= perm_scantable[i];
3854 const int level= block[j];
3858 if(level<0) coeff= qmul*level - qadd;
3859 else coeff= qmul*level + qadd;
3860 run_tab[rle_index++]=run;
3863 s->dsp.add_8x8basis(rem, basis[j], coeff);
3869 if(last_non_zero>0){
3870 STOP_TIMER("init rem[]")
3877 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3880 int run2, best_unquant_change=0, analyze_gradient;
3884 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3886 if(analyze_gradient){
3890 for(i=0; i<64; i++){
3893 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3896 STOP_TIMER("rem*w*w")}
3906 const int level= block[0];
3907 int change, old_coeff;
3909 av_assert2(s->mb_intra);
3913 for(change=-1; change<=1; change+=2){
3914 int new_level= level + change;
3915 int score, new_coeff;
3917 new_coeff= q*new_level;
3918 if(new_coeff >= 2048 || new_coeff < 0)
3921 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3922 if(score<best_score){
3925 best_change= change;
3926 best_unquant_change= new_coeff - old_coeff;
3933 run2= run_tab[rle_index++];
3937 for(i=start_i; i<64; i++){
3938 int j= perm_scantable[i];
3939 const int level= block[j];
3940 int change, old_coeff;
3942 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3946 if(level<0) old_coeff= qmul*level - qadd;
3947 else old_coeff= qmul*level + qadd;
3948 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3952 av_assert2(run2>=0 || i >= last_non_zero );
3955 for(change=-1; change<=1; change+=2){
3956 int new_level= level + change;
3957 int score, new_coeff, unquant_change;
3960 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3964 if(new_level<0) new_coeff= qmul*new_level - qadd;
3965 else new_coeff= qmul*new_level + qadd;
3966 if(new_coeff >= 2048 || new_coeff <= -2048)
3968 //FIXME check for overflow
3971 if(level < 63 && level > -63){
3972 if(i < last_non_zero)
3973 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3974 - length[UNI_AC_ENC_INDEX(run, level+64)];
3976 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3977 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3980 av_assert2(FFABS(new_level)==1);
3982 if(analyze_gradient){
3983 int g= d1[ scantable[i] ];
3984 if(g && (g^new_level) >= 0)
3988 if(i < last_non_zero){
3989 int next_i= i + run2 + 1;
3990 int next_level= block[ perm_scantable[next_i] ] + 64;
3992 if(next_level&(~127))
3995 if(next_i < last_non_zero)
3996 score += length[UNI_AC_ENC_INDEX(run, 65)]
3997 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3998 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4000 score += length[UNI_AC_ENC_INDEX(run, 65)]
4001 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4002 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4004 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4006 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4007 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4013 av_assert2(FFABS(level)==1);
4015 if(i < last_non_zero){
4016 int next_i= i + run2 + 1;
4017 int next_level= block[ perm_scantable[next_i] ] + 64;
4019 if(next_level&(~127))
4022 if(next_i < last_non_zero)
4023 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4024 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4025 - length[UNI_AC_ENC_INDEX(run, 65)];
4027 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4028 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4029 - length[UNI_AC_ENC_INDEX(run, 65)];
4031 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4033 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4034 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4041 unquant_change= new_coeff - old_coeff;
4042 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4044 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4045 if(score<best_score){
4048 best_change= change;
4049 best_unquant_change= unquant_change;
4053 prev_level= level + 64;
4054 if(prev_level&(~127))
4063 STOP_TIMER("iterative step")}
4067 int j= perm_scantable[ best_coeff ];
4069 block[j] += best_change;
4071 if(best_coeff > last_non_zero){
4072 last_non_zero= best_coeff;
4073 av_assert2(block[j]);
4080 if(block[j] - best_change){
4081 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4093 for(; last_non_zero>=start_i; last_non_zero--){
4094 if(block[perm_scantable[last_non_zero]])
4100 if(256*256*256*64 % count == 0){
4101 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);
4106 for(i=start_i; i<=last_non_zero; i++){
4107 int j= perm_scantable[i];
4108 const int level= block[j];
4111 run_tab[rle_index++]=run;
4118 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4124 if(last_non_zero>0){
4125 STOP_TIMER("iterative search")
4130 return last_non_zero;
4133 int ff_dct_quantize_c(MpegEncContext *s,
4134 DCTELEM *block, int n,
4135 int qscale, int *overflow)
4137 int i, j, level, last_non_zero, q, start_i;
4139 const uint8_t *scantable= s->intra_scantable.scantable;
4142 unsigned int threshold1, threshold2;
4144 s->dsp.fdct (block);
4146 if(s->dct_error_sum)
4147 s->denoise_dct(s, block);
4157 /* For AIC we skip quant/dequant of INTRADC */
4160 /* note: block[0] is assumed to be positive */
4161 block[0] = (block[0] + (q >> 1)) / q;
4164 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4165 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4169 qmat = s->q_inter_matrix[qscale];
4170 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4172 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4173 threshold2= (threshold1<<1);
4174 for(i=63;i>=start_i;i--) {
4176 level = block[j] * qmat[j];
4178 if(((unsigned)(level+threshold1))>threshold2){
4185 for(i=start_i; i<=last_non_zero; i++) {
4187 level = block[j] * qmat[j];
4189 // if( bias+level >= (1<<QMAT_SHIFT)
4190 // || bias-level >= (1<<QMAT_SHIFT)){
4191 if(((unsigned)(level+threshold1))>threshold2){
4193 level= (bias + level)>>QMAT_SHIFT;
4196 level= (bias - level)>>QMAT_SHIFT;
4204 *overflow= s->max_qcoeff < max; //overflow might have happened
4206 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4207 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4208 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4210 return last_non_zero;
4213 #define OFFSET(x) offsetof(MpegEncContext, x)
4214 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4215 static const AVOption h263_options[] = {
4216 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4217 { "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},
4218 { "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 },
4223 static const AVClass h263_class = {
4224 .class_name = "H.263 encoder",
4225 .item_name = av_default_item_name,
4226 .option = h263_options,
4227 .version = LIBAVUTIL_VERSION_INT,
4230 AVCodec ff_h263_encoder = {
4232 .type = AVMEDIA_TYPE_VIDEO,
4233 .id = AV_CODEC_ID_H263,
4234 .priv_data_size = sizeof(MpegEncContext),
4235 .init = ff_MPV_encode_init,
4236 .encode2 = ff_MPV_encode_picture,
4237 .close = ff_MPV_encode_end,
4238 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4239 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4240 .priv_class = &h263_class,
4243 static const AVOption h263p_options[] = {
4244 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4245 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4246 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4247 { "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},
4251 static const AVClass h263p_class = {
4252 .class_name = "H.263p encoder",
4253 .item_name = av_default_item_name,
4254 .option = h263p_options,
4255 .version = LIBAVUTIL_VERSION_INT,
4258 AVCodec ff_h263p_encoder = {
4260 .type = AVMEDIA_TYPE_VIDEO,
4261 .id = AV_CODEC_ID_H263P,
4262 .priv_data_size = sizeof(MpegEncContext),
4263 .init = ff_MPV_encode_init,
4264 .encode2 = ff_MPV_encode_picture,
4265 .close = ff_MPV_encode_end,
4266 .capabilities = CODEC_CAP_SLICE_THREADS,
4267 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4268 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4269 .priv_class = &h263p_class,
4272 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4274 AVCodec ff_msmpeg4v2_encoder = {
4275 .name = "msmpeg4v2",
4276 .type = AVMEDIA_TYPE_VIDEO,
4277 .id = AV_CODEC_ID_MSMPEG4V2,
4278 .priv_data_size = sizeof(MpegEncContext),
4279 .init = ff_MPV_encode_init,
4280 .encode2 = ff_MPV_encode_picture,
4281 .close = ff_MPV_encode_end,
4282 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4283 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4284 .priv_class = &msmpeg4v2_class,
4287 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4289 AVCodec ff_msmpeg4v3_encoder = {
4291 .type = AVMEDIA_TYPE_VIDEO,
4292 .id = AV_CODEC_ID_MSMPEG4V3,
4293 .priv_data_size = sizeof(MpegEncContext),
4294 .init = ff_MPV_encode_init,
4295 .encode2 = ff_MPV_encode_picture,
4296 .close = ff_MPV_encode_end,
4297 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4298 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4299 .priv_class = &msmpeg4v3_class,
4302 FF_MPV_GENERIC_CLASS(wmv1)
4304 AVCodec ff_wmv1_encoder = {
4306 .type = AVMEDIA_TYPE_VIDEO,
4307 .id = AV_CODEC_ID_WMV1,
4308 .priv_data_size = sizeof(MpegEncContext),
4309 .init = ff_MPV_encode_init,
4310 .encode2 = ff_MPV_encode_picture,
4311 .close = ff_MPV_encode_end,
4312 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4313 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4314 .priv_class = &wmv1_class,