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"
42 #include "aandcttab.h"
44 #include "mpeg4video.h"
46 #include "bytestream.h"
53 static int encode_picture(MpegEncContext *s, int picture_number);
54 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
55 static int sse_mb(MpegEncContext *s);
56 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
57 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 /* enable all paranoid tests for rounding, overflows, etc... */
64 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
65 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
67 const AVOption ff_mpv_generic_options[] = {
72 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
73 uint16_t (*qmat16)[2][64],
74 const uint16_t *quant_matrix,
75 int bias, int qmin, int qmax, int intra)
80 for (qscale = qmin; qscale <= qmax; qscale++) {
82 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
83 dsp->fdct == ff_jpeg_fdct_islow_10 ||
84 dsp->fdct == ff_faandct) {
85 for (i = 0; i < 64; i++) {
86 const int j = dsp->idct_permutation[i];
87 /* 16 <= qscale * quant_matrix[i] <= 7905
88 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
89 * 19952 <= x <= 249205026
90 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
91 * 3444240 >= (1 << 36) / (x) >= 275 */
93 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
94 (qscale * quant_matrix[j]));
96 } else if (dsp->fdct == ff_fdct_ifast) {
97 for (i = 0; i < 64; i++) {
98 const int j = dsp->idct_permutation[i];
99 /* 16 <= qscale * quant_matrix[i] <= 7905
100 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101 * 19952 <= x <= 249205026
102 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103 * 3444240 >= (1 << 36) / (x) >= 275 */
105 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
106 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
109 for (i = 0; i < 64; i++) {
110 const int j = dsp->idct_permutation[i];
111 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
112 * Assume x = qscale * quant_matrix[i]
114 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
115 * so 32768 >= (1 << 19) / (x) >= 67 */
116 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
117 (qscale * quant_matrix[j]));
118 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
119 // (qscale * quant_matrix[i]);
120 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
121 (qscale * quant_matrix[j]);
123 if (qmat16[qscale][0][i] == 0 ||
124 qmat16[qscale][0][i] == 128 * 256)
125 qmat16[qscale][0][i] = 128 * 256 - 1;
126 qmat16[qscale][1][i] =
127 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
128 qmat16[qscale][0][i]);
132 for (i = intra; i < 64; i++) {
134 if (dsp->fdct == ff_fdct_ifast) {
135 max = (8191LL * ff_aanscales[i]) >> 14;
137 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
143 av_log(NULL, AV_LOG_INFO,
144 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
149 static inline void update_qscale(MpegEncContext *s)
151 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
152 (FF_LAMBDA_SHIFT + 7);
153 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
155 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
159 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165 for (i = 0; i < 64; i++) {
166 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
173 * init s->current_picture.qscale_table from s->lambda_table
175 void ff_init_qscale_tab(MpegEncContext *s)
177 int8_t * const qscale_table = s->current_picture.f.qscale_table;
180 for (i = 0; i < s->mb_num; i++) {
181 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
182 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
183 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
188 static void copy_picture_attributes(MpegEncContext *s,
194 dst->pict_type = src->pict_type;
195 dst->quality = src->quality;
196 dst->coded_picture_number = src->coded_picture_number;
197 dst->display_picture_number = src->display_picture_number;
198 //dst->reference = src->reference;
200 dst->interlaced_frame = src->interlaced_frame;
201 dst->top_field_first = src->top_field_first;
203 if (s->avctx->me_threshold) {
204 if (!src->motion_val[0])
205 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
207 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
208 if (!src->ref_index[0])
209 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
210 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
211 av_log(s->avctx, AV_LOG_ERROR,
212 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
213 src->motion_subsample_log2, dst->motion_subsample_log2);
215 memcpy(dst->mb_type, src->mb_type,
216 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
218 for (i = 0; i < 2; i++) {
219 int stride = ((16 * s->mb_width ) >>
220 src->motion_subsample_log2) + 1;
221 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
223 if (src->motion_val[i] &&
224 src->motion_val[i] != dst->motion_val[i]) {
225 memcpy(dst->motion_val[i], src->motion_val[i],
226 2 * stride * height * sizeof(int16_t));
228 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
229 memcpy(dst->ref_index[i], src->ref_index[i],
230 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
236 static void update_duplicate_context_after_me(MpegEncContext *dst,
239 #define COPY(a) dst->a= src->a
241 COPY(current_picture);
247 COPY(picture_in_gop_number);
248 COPY(gop_picture_number);
249 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
250 COPY(progressive_frame); // FIXME don't set in encode_header
251 COPY(partitioned_frame); // FIXME don't set in encode_header
256 * Set the given MpegEncContext to defaults for encoding.
257 * the changed fields will not depend upon the prior state of the MpegEncContext.
259 static void MPV_encode_defaults(MpegEncContext *s)
262 ff_MPV_common_defaults(s);
264 for (i = -16; i < 16; i++) {
265 default_fcode_tab[i + MAX_MV] = 1;
267 s->me.mv_penalty = default_mv_penalty;
268 s->fcode_tab = default_fcode_tab;
271 av_cold int ff_dct_encode_init(MpegEncContext *s) {
273 ff_dct_encode_init_x86(s);
275 if (!s->dct_quantize)
276 s->dct_quantize = ff_dct_quantize_c;
278 s->denoise_dct = denoise_dct_c;
279 s->fast_dct_quantize = s->dct_quantize;
280 if (s->avctx->trellis)
281 s->dct_quantize = dct_quantize_trellis_c;
286 /* init video encoder */
287 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
289 MpegEncContext *s = avctx->priv_data;
291 int chroma_h_shift, chroma_v_shift;
293 MPV_encode_defaults(s);
295 switch (avctx->codec_id) {
296 case AV_CODEC_ID_MPEG2VIDEO:
297 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
298 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
299 av_log(avctx, AV_LOG_ERROR,
300 "only YUV420 and YUV422 are supported\n");
304 case AV_CODEC_ID_LJPEG:
305 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
306 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
307 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
308 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
309 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
310 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
311 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
312 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
313 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
314 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
315 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
319 case AV_CODEC_ID_MJPEG:
320 case AV_CODEC_ID_AMV:
321 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
322 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
323 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
324 avctx->pix_fmt != AV_PIX_FMT_YUV422P) ||
325 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
326 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
331 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
332 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
337 switch (avctx->pix_fmt) {
338 case AV_PIX_FMT_YUVJ422P:
339 case AV_PIX_FMT_YUV422P:
340 s->chroma_format = CHROMA_422;
342 case AV_PIX_FMT_YUVJ420P:
343 case AV_PIX_FMT_YUV420P:
345 s->chroma_format = CHROMA_420;
349 s->bit_rate = avctx->bit_rate;
350 s->width = avctx->width;
351 s->height = avctx->height;
352 if (avctx->gop_size > 600 &&
353 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
354 av_log(avctx, AV_LOG_WARNING,
355 "keyframe interval too large!, reducing it from %d to %d\n",
356 avctx->gop_size, 600);
357 avctx->gop_size = 600;
359 s->gop_size = avctx->gop_size;
361 s->flags = avctx->flags;
362 s->flags2 = avctx->flags2;
363 s->max_b_frames = avctx->max_b_frames;
364 s->codec_id = avctx->codec->id;
365 #if FF_API_MPV_GLOBAL_OPTS
366 if (avctx->luma_elim_threshold)
367 s->luma_elim_threshold = avctx->luma_elim_threshold;
368 if (avctx->chroma_elim_threshold)
369 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
371 s->strict_std_compliance = avctx->strict_std_compliance;
372 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
373 s->mpeg_quant = avctx->mpeg_quant;
374 s->rtp_mode = !!avctx->rtp_payload_size;
375 s->intra_dc_precision = avctx->intra_dc_precision;
376 s->user_specified_pts = AV_NOPTS_VALUE;
378 if (s->gop_size <= 1) {
385 s->me_method = avctx->me_method;
388 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
390 #if FF_API_MPV_GLOBAL_OPTS
391 if (s->flags & CODEC_FLAG_QP_RD)
392 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
395 s->adaptive_quant = (s->avctx->lumi_masking ||
396 s->avctx->dark_masking ||
397 s->avctx->temporal_cplx_masking ||
398 s->avctx->spatial_cplx_masking ||
399 s->avctx->p_masking ||
400 s->avctx->border_masking ||
401 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
404 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
406 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
407 switch(avctx->codec_id) {
408 case AV_CODEC_ID_MPEG1VIDEO:
409 case AV_CODEC_ID_MPEG2VIDEO:
410 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
412 case AV_CODEC_ID_MPEG4:
413 case AV_CODEC_ID_MSMPEG4V1:
414 case AV_CODEC_ID_MSMPEG4V2:
415 case AV_CODEC_ID_MSMPEG4V3:
416 if (avctx->rc_max_rate >= 15000000) {
417 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
418 } else if(avctx->rc_max_rate >= 2000000) {
419 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
420 } else if(avctx->rc_max_rate >= 384000) {
421 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
423 avctx->rc_buffer_size = 40;
424 avctx->rc_buffer_size *= 16384;
427 if (avctx->rc_buffer_size) {
428 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
432 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
433 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
434 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
438 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
439 av_log(avctx, AV_LOG_INFO,
440 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
443 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
444 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
448 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
449 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
453 if (avctx->rc_max_rate &&
454 avctx->rc_max_rate == avctx->bit_rate &&
455 avctx->rc_max_rate != avctx->rc_min_rate) {
456 av_log(avctx, AV_LOG_INFO,
457 "impossible bitrate constraints, this will fail\n");
460 if (avctx->rc_buffer_size &&
461 avctx->bit_rate * (int64_t)avctx->time_base.num >
462 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
463 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
467 if (!s->fixed_qscale &&
468 avctx->bit_rate * av_q2d(avctx->time_base) >
469 avctx->bit_rate_tolerance) {
470 av_log(avctx, AV_LOG_ERROR,
471 "bitrate tolerance too small for bitrate\n");
475 if (s->avctx->rc_max_rate &&
476 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
477 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
478 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
479 90000LL * (avctx->rc_buffer_size - 1) >
480 s->avctx->rc_max_rate * 0xFFFFLL) {
481 av_log(avctx, AV_LOG_INFO,
482 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
483 "specified vbv buffer is too large for the given bitrate!\n");
486 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
487 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
488 s->codec_id != AV_CODEC_ID_FLV1) {
489 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
493 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
494 av_log(avctx, AV_LOG_ERROR,
495 "OBMC is only supported with simple mb decision\n");
499 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
500 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
504 if (s->max_b_frames &&
505 s->codec_id != AV_CODEC_ID_MPEG4 &&
506 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
507 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
508 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
512 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
513 s->codec_id == AV_CODEC_ID_H263 ||
514 s->codec_id == AV_CODEC_ID_H263P) &&
515 (avctx->sample_aspect_ratio.num > 255 ||
516 avctx->sample_aspect_ratio.den > 255)) {
517 av_log(avctx, AV_LOG_WARNING,
518 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
519 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
520 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
521 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
524 if ((s->codec_id == AV_CODEC_ID_H263 ||
525 s->codec_id == AV_CODEC_ID_H263P) &&
526 (avctx->width > 2048 ||
527 avctx->height > 1152 )) {
528 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
531 if ((s->codec_id == AV_CODEC_ID_H263 ||
532 s->codec_id == AV_CODEC_ID_H263P) &&
533 ((avctx->width &3) ||
534 (avctx->height&3) )) {
535 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
539 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
540 (avctx->width > 4095 ||
541 avctx->height > 4095 )) {
542 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
546 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
547 (avctx->width > 16383 ||
548 avctx->height > 16383 )) {
549 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
553 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
554 s->codec_id == AV_CODEC_ID_WMV2) &&
556 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
560 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
561 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
562 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
566 // FIXME mpeg2 uses that too
567 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
568 av_log(avctx, AV_LOG_ERROR,
569 "mpeg2 style quantization not supported by codec\n");
573 #if FF_API_MPV_GLOBAL_OPTS
574 if (s->flags & CODEC_FLAG_CBP_RD)
575 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
578 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
579 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
583 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
584 s->avctx->mb_decision != FF_MB_DECISION_RD) {
585 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
589 if (s->avctx->scenechange_threshold < 1000000000 &&
590 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
591 av_log(avctx, AV_LOG_ERROR,
592 "closed gop with scene change detection are not supported yet, "
593 "set threshold to 1000000000\n");
597 if (s->flags & CODEC_FLAG_LOW_DELAY) {
598 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
599 av_log(avctx, AV_LOG_ERROR,
600 "low delay forcing is only available for mpeg2\n");
603 if (s->max_b_frames != 0) {
604 av_log(avctx, AV_LOG_ERROR,
605 "b frames cannot be used with low delay\n");
610 if (s->q_scale_type == 1) {
611 if (avctx->qmax > 12) {
612 av_log(avctx, AV_LOG_ERROR,
613 "non linear quant only supports qmax <= 12 currently\n");
618 if (s->avctx->thread_count > 1 &&
619 s->codec_id != AV_CODEC_ID_MPEG4 &&
620 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
621 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
622 s->codec_id != AV_CODEC_ID_MJPEG &&
623 (s->codec_id != AV_CODEC_ID_H263P)) {
624 av_log(avctx, AV_LOG_ERROR,
625 "multi threaded encoding not supported by codec\n");
629 if (s->avctx->thread_count < 1) {
630 av_log(avctx, AV_LOG_ERROR,
631 "automatic thread number detection not supported by codec, "
636 if (s->avctx->thread_count > 1)
639 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
640 s->h263_slice_structured = 1;
642 if (!avctx->time_base.den || !avctx->time_base.num) {
643 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
647 i = (INT_MAX / 2 + 128) >> 8;
648 if (avctx->me_threshold >= i) {
649 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
653 if (avctx->mb_threshold >= i) {
654 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
659 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
660 av_log(avctx, AV_LOG_INFO,
661 "notice: b_frame_strategy only affects the first pass\n");
662 avctx->b_frame_strategy = 0;
665 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
667 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
668 avctx->time_base.den /= i;
669 avctx->time_base.num /= i;
673 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) {
674 // (a + x * 3 / 8) / x
675 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
676 s->inter_quant_bias = 0;
678 s->intra_quant_bias = 0;
680 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
683 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
684 s->intra_quant_bias = avctx->intra_quant_bias;
685 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
686 s->inter_quant_bias = avctx->inter_quant_bias;
688 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
690 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
693 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
694 s->avctx->time_base.den > (1 << 16) - 1) {
695 av_log(avctx, AV_LOG_ERROR,
696 "timebase %d/%d not supported by MPEG 4 standard, "
697 "the maximum admitted value for the timebase denominator "
698 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
702 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
704 #if FF_API_MPV_GLOBAL_OPTS
705 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
706 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
707 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
708 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
709 if (avctx->quantizer_noise_shaping)
710 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
713 switch (avctx->codec->id) {
714 case AV_CODEC_ID_MPEG1VIDEO:
715 s->out_format = FMT_MPEG1;
716 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
717 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
719 case AV_CODEC_ID_MPEG2VIDEO:
720 s->out_format = FMT_MPEG1;
721 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
722 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
725 case AV_CODEC_ID_LJPEG:
726 case AV_CODEC_ID_MJPEG:
727 case AV_CODEC_ID_AMV:
728 s->out_format = FMT_MJPEG;
729 s->intra_only = 1; /* force intra only for jpeg */
730 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
731 (avctx->pix_fmt == AV_PIX_FMT_BGR0
732 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
733 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
734 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
735 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
736 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
738 s->mjpeg_vsample[0] = 2;
739 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
740 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
741 s->mjpeg_hsample[0] = 2;
742 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
743 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
745 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
746 ff_mjpeg_encode_init(s) < 0)
751 case AV_CODEC_ID_H261:
752 if (!CONFIG_H261_ENCODER)
754 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
755 av_log(avctx, AV_LOG_ERROR,
756 "The specified picture size of %dx%d is not valid for the "
757 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
758 s->width, s->height);
761 s->out_format = FMT_H261;
765 case AV_CODEC_ID_H263:
766 if (!CONFIG_H263_ENCODER)
768 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
769 s->width, s->height) == 8) {
770 av_log(avctx, AV_LOG_ERROR,
771 "The specified picture size of %dx%d is not valid for "
772 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
773 "352x288, 704x576, and 1408x1152. "
774 "Try H.263+.\n", s->width, s->height);
777 s->out_format = FMT_H263;
781 case AV_CODEC_ID_H263P:
782 s->out_format = FMT_H263;
785 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
786 s->modified_quant = s->h263_aic;
787 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
788 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
791 /* These are just to be sure */
795 case AV_CODEC_ID_FLV1:
796 s->out_format = FMT_H263;
797 s->h263_flv = 2; /* format = 1; 11-bit codes */
798 s->unrestricted_mv = 1;
799 s->rtp_mode = 0; /* don't allow GOB */
803 case AV_CODEC_ID_RV10:
804 s->out_format = FMT_H263;
808 case AV_CODEC_ID_RV20:
809 s->out_format = FMT_H263;
812 s->modified_quant = 1;
816 s->unrestricted_mv = 0;
818 case AV_CODEC_ID_MPEG4:
819 s->out_format = FMT_H263;
821 s->unrestricted_mv = 1;
822 s->low_delay = s->max_b_frames ? 0 : 1;
823 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
825 case AV_CODEC_ID_MSMPEG4V2:
826 s->out_format = FMT_H263;
828 s->unrestricted_mv = 1;
829 s->msmpeg4_version = 2;
833 case AV_CODEC_ID_MSMPEG4V3:
834 s->out_format = FMT_H263;
836 s->unrestricted_mv = 1;
837 s->msmpeg4_version = 3;
838 s->flipflop_rounding = 1;
842 case AV_CODEC_ID_WMV1:
843 s->out_format = FMT_H263;
845 s->unrestricted_mv = 1;
846 s->msmpeg4_version = 4;
847 s->flipflop_rounding = 1;
851 case AV_CODEC_ID_WMV2:
852 s->out_format = FMT_H263;
854 s->unrestricted_mv = 1;
855 s->msmpeg4_version = 5;
856 s->flipflop_rounding = 1;
864 avctx->has_b_frames = !s->low_delay;
868 s->progressive_frame =
869 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
870 CODEC_FLAG_INTERLACED_ME) ||
874 if (ff_MPV_common_init(s) < 0)
877 ff_dct_encode_init(s);
879 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
880 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
882 s->quant_precision = 5;
884 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
885 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
887 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
888 ff_h261_encode_init(s);
889 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
890 ff_h263_encode_init(s);
891 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
892 ff_msmpeg4_encode_init(s);
893 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
894 && s->out_format == FMT_MPEG1)
895 ff_mpeg1_encode_init(s);
898 for (i = 0; i < 64; i++) {
899 int j = s->dsp.idct_permutation[i];
900 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
902 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
903 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
904 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
906 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
909 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
910 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
912 if (s->avctx->intra_matrix)
913 s->intra_matrix[j] = s->avctx->intra_matrix[i];
914 if (s->avctx->inter_matrix)
915 s->inter_matrix[j] = s->avctx->inter_matrix[i];
918 /* precompute matrix */
919 /* for mjpeg, we do include qscale in the matrix */
920 if (s->out_format != FMT_MJPEG) {
921 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
922 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
924 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
925 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
929 if (ff_rate_control_init(s) < 0)
935 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
937 MpegEncContext *s = avctx->priv_data;
939 ff_rate_control_uninit(s);
941 ff_MPV_common_end(s);
942 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
943 s->out_format == FMT_MJPEG)
944 ff_mjpeg_encode_close(s);
946 av_freep(&avctx->extradata);
951 static int get_sae(uint8_t *src, int ref, int stride)
956 for (y = 0; y < 16; y++) {
957 for (x = 0; x < 16; x++) {
958 acc += FFABS(src[x + y * stride] - ref);
965 static int get_intra_count(MpegEncContext *s, uint8_t *src,
966 uint8_t *ref, int stride)
974 for (y = 0; y < h; y += 16) {
975 for (x = 0; x < w; x += 16) {
976 int offset = x + y * stride;
977 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
979 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
980 int sae = get_sae(src + offset, mean, stride);
982 acc += sae + 500 < sad;
989 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
994 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
995 (s->low_delay ? 0 : 1);
1000 pic_arg->display_picture_number = s->input_picture_number++;
1002 if (pts != AV_NOPTS_VALUE) {
1003 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1005 int64_t last = s->user_specified_pts;
1008 av_log(s->avctx, AV_LOG_ERROR,
1009 "Error, Invalid timestamp=%"PRId64", "
1010 "last=%"PRId64"\n", pts, s->user_specified_pts);
1014 if (!s->low_delay && pic_arg->display_picture_number == 1)
1015 s->dts_delta = time - last;
1017 s->user_specified_pts = pts;
1019 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1020 s->user_specified_pts =
1021 pts = s->user_specified_pts + 1;
1022 av_log(s->avctx, AV_LOG_INFO,
1023 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1026 pts = pic_arg->display_picture_number;
1032 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
1034 if (pic_arg->linesize[0] != s->linesize)
1036 if (pic_arg->linesize[1] != s->uvlinesize)
1038 if (pic_arg->linesize[2] != s->uvlinesize)
1041 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
1042 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1045 i = ff_find_unused_picture(s, 1);
1049 pic = &s->picture[i].f;
1052 for (i = 0; i < 4; i++) {
1053 pic->data[i] = pic_arg->data[i];
1054 pic->linesize[i] = pic_arg->linesize[i];
1056 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1060 i = ff_find_unused_picture(s, 0);
1064 pic = &s->picture[i].f;
1067 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1071 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1072 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1073 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1076 int h_chroma_shift, v_chroma_shift;
1077 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1080 for (i = 0; i < 3; i++) {
1081 int src_stride = pic_arg->linesize[i];
1082 int dst_stride = i ? s->uvlinesize : s->linesize;
1083 int h_shift = i ? h_chroma_shift : 0;
1084 int v_shift = i ? v_chroma_shift : 0;
1085 int w = s->width >> h_shift;
1086 int h = s->height >> v_shift;
1087 uint8_t *src = pic_arg->data[i];
1088 uint8_t *dst = pic->data[i];
1090 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1091 h= ((s->height+15)/16*16)>>v_shift;
1094 if (!s->avctx->rc_buffer_size)
1095 dst += INPLACE_OFFSET;
1097 if (src_stride == dst_stride)
1098 memcpy(dst, src, src_stride * h);
1101 memcpy(dst, src, w);
1109 copy_picture_attributes(s, pic, pic_arg);
1110 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1113 /* shift buffer entries */
1114 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1115 s->input_picture[i - 1] = s->input_picture[i];
1117 s->input_picture[encoding_delay] = (Picture*) pic;
1122 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1126 int64_t score64 = 0;
1128 for (plane = 0; plane < 3; plane++) {
1129 const int stride = p->f.linesize[plane];
1130 const int bw = plane ? 1 : 2;
1131 for (y = 0; y < s->mb_height * bw; y++) {
1132 for (x = 0; x < s->mb_width * bw; x++) {
1133 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1134 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1135 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1136 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1138 switch (s->avctx->frame_skip_exp) {
1139 case 0: score = FFMAX(score, v); break;
1140 case 1: score += FFABS(v); break;
1141 case 2: score += v * v; break;
1142 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1143 case 4: score64 += v * v * (int64_t)(v * v); break;
1152 if (score64 < s->avctx->frame_skip_threshold)
1154 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1159 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1161 AVPacket pkt = { 0 };
1162 int ret, got_output;
1164 av_init_packet(&pkt);
1165 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1170 av_free_packet(&pkt);
1174 static int estimate_best_b_count(MpegEncContext *s)
1176 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1177 AVCodecContext *c = avcodec_alloc_context3(NULL);
1178 AVFrame input[FF_MAX_B_FRAMES + 2];
1179 const int scale = s->avctx->brd_scale;
1180 int i, j, out_size, p_lambda, b_lambda, lambda2;
1181 int64_t best_rd = INT64_MAX;
1182 int best_b_count = -1;
1184 av_assert0(scale >= 0 && scale <= 3);
1187 //s->next_picture_ptr->quality;
1188 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1189 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1190 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1191 if (!b_lambda) // FIXME we should do this somewhere else
1192 b_lambda = p_lambda;
1193 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1196 c->width = s->width >> scale;
1197 c->height = s->height >> scale;
1198 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1199 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1200 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1201 c->mb_decision = s->avctx->mb_decision;
1202 c->me_cmp = s->avctx->me_cmp;
1203 c->mb_cmp = s->avctx->mb_cmp;
1204 c->me_sub_cmp = s->avctx->me_sub_cmp;
1205 c->pix_fmt = AV_PIX_FMT_YUV420P;
1206 c->time_base = s->avctx->time_base;
1207 c->max_b_frames = s->max_b_frames;
1209 if (avcodec_open2(c, codec, NULL) < 0)
1212 for (i = 0; i < s->max_b_frames + 2; i++) {
1213 int ysize = c->width * c->height;
1214 int csize = (c->width / 2) * (c->height / 2);
1215 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1216 s->next_picture_ptr;
1218 avcodec_get_frame_defaults(&input[i]);
1219 input[i].data[0] = av_malloc(ysize + 2 * csize);
1220 input[i].data[1] = input[i].data[0] + ysize;
1221 input[i].data[2] = input[i].data[1] + csize;
1222 input[i].linesize[0] = c->width;
1223 input[i].linesize[1] =
1224 input[i].linesize[2] = c->width / 2;
1226 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1227 pre_input = *pre_input_ptr;
1229 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1230 pre_input.f.data[0] += INPLACE_OFFSET;
1231 pre_input.f.data[1] += INPLACE_OFFSET;
1232 pre_input.f.data[2] += INPLACE_OFFSET;
1235 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1236 pre_input.f.data[0], pre_input.f.linesize[0],
1237 c->width, c->height);
1238 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1239 pre_input.f.data[1], pre_input.f.linesize[1],
1240 c->width >> 1, c->height >> 1);
1241 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1242 pre_input.f.data[2], pre_input.f.linesize[2],
1243 c->width >> 1, c->height >> 1);
1247 for (j = 0; j < s->max_b_frames + 1; j++) {
1250 if (!s->input_picture[j])
1253 c->error[0] = c->error[1] = c->error[2] = 0;
1255 input[0].pict_type = AV_PICTURE_TYPE_I;
1256 input[0].quality = 1 * FF_QP2LAMBDA;
1258 out_size = encode_frame(c, &input[0]);
1260 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1262 for (i = 0; i < s->max_b_frames + 1; i++) {
1263 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1265 input[i + 1].pict_type = is_p ?
1266 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1267 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1269 out_size = encode_frame(c, &input[i + 1]);
1271 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1274 /* get the delayed frames */
1276 out_size = encode_frame(c, NULL);
1277 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1280 rd += c->error[0] + c->error[1] + c->error[2];
1291 for (i = 0; i < s->max_b_frames + 2; i++) {
1292 av_freep(&input[i].data[0]);
1295 return best_b_count;
1298 static int select_input_picture(MpegEncContext *s)
1302 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1303 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1304 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1306 /* set next picture type & ordering */
1307 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1308 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1309 s->next_picture_ptr == NULL || s->intra_only) {
1310 s->reordered_input_picture[0] = s->input_picture[0];
1311 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1312 s->reordered_input_picture[0]->f.coded_picture_number =
1313 s->coded_picture_number++;
1317 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1318 if (s->picture_in_gop_number < s->gop_size &&
1319 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1320 // FIXME check that te gop check above is +-1 correct
1321 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1322 for (i = 0; i < 4; i++)
1323 s->input_picture[0]->f.data[i] = NULL;
1324 s->input_picture[0]->f.type = 0;
1326 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1327 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1329 s->avctx->release_buffer(s->avctx,
1330 &s->input_picture[0]->f);
1334 ff_vbv_update(s, 0);
1340 if (s->flags & CODEC_FLAG_PASS2) {
1341 for (i = 0; i < s->max_b_frames + 1; i++) {
1342 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1344 if (pict_num >= s->rc_context.num_entries)
1346 if (!s->input_picture[i]) {
1347 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1351 s->input_picture[i]->f.pict_type =
1352 s->rc_context.entry[pict_num].new_pict_type;
1356 if (s->avctx->b_frame_strategy == 0) {
1357 b_frames = s->max_b_frames;
1358 while (b_frames && !s->input_picture[b_frames])
1360 } else if (s->avctx->b_frame_strategy == 1) {
1361 for (i = 1; i < s->max_b_frames + 1; i++) {
1362 if (s->input_picture[i] &&
1363 s->input_picture[i]->b_frame_score == 0) {
1364 s->input_picture[i]->b_frame_score =
1366 s->input_picture[i ]->f.data[0],
1367 s->input_picture[i - 1]->f.data[0],
1371 for (i = 0; i < s->max_b_frames + 1; i++) {
1372 if (s->input_picture[i] == NULL ||
1373 s->input_picture[i]->b_frame_score - 1 >
1374 s->mb_num / s->avctx->b_sensitivity)
1378 b_frames = FFMAX(0, i - 1);
1381 for (i = 0; i < b_frames + 1; i++) {
1382 s->input_picture[i]->b_frame_score = 0;
1384 } else if (s->avctx->b_frame_strategy == 2) {
1385 b_frames = estimate_best_b_count(s);
1387 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1393 for (i = b_frames - 1; i >= 0; i--) {
1394 int type = s->input_picture[i]->f.pict_type;
1395 if (type && type != AV_PICTURE_TYPE_B)
1398 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1399 b_frames == s->max_b_frames) {
1400 av_log(s->avctx, AV_LOG_ERROR,
1401 "warning, too many b frames in a row\n");
1404 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1405 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1406 s->gop_size > s->picture_in_gop_number) {
1407 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1409 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1411 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1415 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1416 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1419 s->reordered_input_picture[0] = s->input_picture[b_frames];
1420 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1421 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1422 s->reordered_input_picture[0]->f.coded_picture_number =
1423 s->coded_picture_number++;
1424 for (i = 0; i < b_frames; i++) {
1425 s->reordered_input_picture[i + 1] = s->input_picture[i];
1426 s->reordered_input_picture[i + 1]->f.pict_type =
1428 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1429 s->coded_picture_number++;
1434 if (s->reordered_input_picture[0]) {
1435 s->reordered_input_picture[0]->f.reference =
1436 s->reordered_input_picture[0]->f.pict_type !=
1437 AV_PICTURE_TYPE_B ? 3 : 0;
1439 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1441 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1442 s->avctx->rc_buffer_size) {
1443 // input is a shared pix, so we can't modifiy it -> alloc a new
1444 // one & ensure that the shared one is reuseable
1447 int i = ff_find_unused_picture(s, 0);
1450 pic = &s->picture[i];
1452 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1453 if (ff_alloc_picture(s, pic, 0) < 0) {
1457 /* mark us unused / free shared pic */
1458 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1459 s->avctx->release_buffer(s->avctx,
1460 &s->reordered_input_picture[0]->f);
1461 for (i = 0; i < 4; i++)
1462 s->reordered_input_picture[0]->f.data[i] = NULL;
1463 s->reordered_input_picture[0]->f.type = 0;
1465 copy_picture_attributes(s, &pic->f,
1466 &s->reordered_input_picture[0]->f);
1468 s->current_picture_ptr = pic;
1470 // input is not a shared pix -> reuse buffer for current_pix
1472 assert(s->reordered_input_picture[0]->f.type ==
1473 FF_BUFFER_TYPE_USER ||
1474 s->reordered_input_picture[0]->f.type ==
1475 FF_BUFFER_TYPE_INTERNAL);
1477 s->current_picture_ptr = s->reordered_input_picture[0];
1478 for (i = 0; i < 4; i++) {
1479 s->new_picture.f.data[i] += INPLACE_OFFSET;
1482 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1484 s->picture_number = s->new_picture.f.display_picture_number;
1486 memset(&s->new_picture, 0, sizeof(Picture));
1491 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1492 AVFrame *pic_arg, int *got_packet)
1494 MpegEncContext *s = avctx->priv_data;
1495 int i, stuffing_count, ret;
1496 int context_count = s->slice_context_count;
1498 s->picture_in_gop_number++;
1500 if (load_input_picture(s, pic_arg) < 0)
1503 if (select_input_picture(s) < 0) {
1508 if (s->new_picture.f.data[0]) {
1509 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1512 s->mb_info_ptr = av_packet_new_side_data(pkt,
1513 AV_PKT_DATA_H263_MB_INFO,
1514 s->mb_width*s->mb_height*12);
1515 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1518 for (i = 0; i < context_count; i++) {
1519 int start_y = s->thread_context[i]->start_mb_y;
1520 int end_y = s->thread_context[i]-> end_mb_y;
1521 int h = s->mb_height;
1522 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1523 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1525 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1528 s->pict_type = s->new_picture.f.pict_type;
1530 if (ff_MPV_frame_start(s, avctx) < 0)
1533 if (encode_picture(s, s->picture_number) < 0)
1536 avctx->header_bits = s->header_bits;
1537 avctx->mv_bits = s->mv_bits;
1538 avctx->misc_bits = s->misc_bits;
1539 avctx->i_tex_bits = s->i_tex_bits;
1540 avctx->p_tex_bits = s->p_tex_bits;
1541 avctx->i_count = s->i_count;
1542 // FIXME f/b_count in avctx
1543 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1544 avctx->skip_count = s->skip_count;
1546 ff_MPV_frame_end(s);
1548 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1549 ff_mjpeg_encode_picture_trailer(s);
1551 if (avctx->rc_buffer_size) {
1552 RateControlContext *rcc = &s->rc_context;
1553 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1555 if (put_bits_count(&s->pb) > max_size &&
1556 s->lambda < s->avctx->lmax) {
1557 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1558 (s->qscale + 1) / s->qscale);
1559 if (s->adaptive_quant) {
1561 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1562 s->lambda_table[i] =
1563 FFMAX(s->lambda_table[i] + 1,
1564 s->lambda_table[i] * (s->qscale + 1) /
1567 s->mb_skipped = 0; // done in MPV_frame_start()
1568 // done in encode_picture() so we must undo it
1569 if (s->pict_type == AV_PICTURE_TYPE_P) {
1570 if (s->flipflop_rounding ||
1571 s->codec_id == AV_CODEC_ID_H263P ||
1572 s->codec_id == AV_CODEC_ID_MPEG4)
1573 s->no_rounding ^= 1;
1575 if (s->pict_type != AV_PICTURE_TYPE_B) {
1576 s->time_base = s->last_time_base;
1577 s->last_non_b_time = s->time - s->pp_time;
1579 for (i = 0; i < context_count; i++) {
1580 PutBitContext *pb = &s->thread_context[i]->pb;
1581 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1586 assert(s->avctx->rc_max_rate);
1589 if (s->flags & CODEC_FLAG_PASS1)
1590 ff_write_pass1_stats(s);
1592 for (i = 0; i < 4; i++) {
1593 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1594 avctx->error[i] += s->current_picture_ptr->f.error[i];
1597 if (s->flags & CODEC_FLAG_PASS1)
1598 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1599 avctx->i_tex_bits + avctx->p_tex_bits ==
1600 put_bits_count(&s->pb));
1601 flush_put_bits(&s->pb);
1602 s->frame_bits = put_bits_count(&s->pb);
1604 stuffing_count = ff_vbv_update(s, s->frame_bits);
1605 s->stuffing_bits = 8*stuffing_count;
1606 if (stuffing_count) {
1607 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1608 stuffing_count + 50) {
1609 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1613 switch (s->codec_id) {
1614 case AV_CODEC_ID_MPEG1VIDEO:
1615 case AV_CODEC_ID_MPEG2VIDEO:
1616 while (stuffing_count--) {
1617 put_bits(&s->pb, 8, 0);
1620 case AV_CODEC_ID_MPEG4:
1621 put_bits(&s->pb, 16, 0);
1622 put_bits(&s->pb, 16, 0x1C3);
1623 stuffing_count -= 4;
1624 while (stuffing_count--) {
1625 put_bits(&s->pb, 8, 0xFF);
1629 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1631 flush_put_bits(&s->pb);
1632 s->frame_bits = put_bits_count(&s->pb);
1635 /* update mpeg1/2 vbv_delay for CBR */
1636 if (s->avctx->rc_max_rate &&
1637 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1638 s->out_format == FMT_MPEG1 &&
1639 90000LL * (avctx->rc_buffer_size - 1) <=
1640 s->avctx->rc_max_rate * 0xFFFFLL) {
1641 int vbv_delay, min_delay;
1642 double inbits = s->avctx->rc_max_rate *
1643 av_q2d(s->avctx->time_base);
1644 int minbits = s->frame_bits - 8 *
1645 (s->vbv_delay_ptr - s->pb.buf - 1);
1646 double bits = s->rc_context.buffer_index + minbits - inbits;
1649 av_log(s->avctx, AV_LOG_ERROR,
1650 "Internal error, negative bits\n");
1652 assert(s->repeat_first_field == 0);
1654 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1655 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1656 s->avctx->rc_max_rate;
1658 vbv_delay = FFMAX(vbv_delay, min_delay);
1660 av_assert0(vbv_delay < 0xFFFF);
1662 s->vbv_delay_ptr[0] &= 0xF8;
1663 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1664 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1665 s->vbv_delay_ptr[2] &= 0x07;
1666 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1667 avctx->vbv_delay = vbv_delay * 300;
1669 s->total_bits += s->frame_bits;
1670 avctx->frame_bits = s->frame_bits;
1672 pkt->pts = s->current_picture.f.pts;
1673 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1674 if (!s->current_picture.f.coded_picture_number)
1675 pkt->dts = pkt->pts - s->dts_delta;
1677 pkt->dts = s->reordered_pts;
1678 s->reordered_pts = pkt->pts;
1680 pkt->dts = pkt->pts;
1681 if (s->current_picture.f.key_frame)
1682 pkt->flags |= AV_PKT_FLAG_KEY;
1684 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1688 assert((s->frame_bits & 7) == 0);
1690 pkt->size = s->frame_bits / 8;
1691 *got_packet = !!pkt->size;
1695 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1696 int n, int threshold)
1698 static const char tab[64] = {
1699 3, 2, 2, 1, 1, 1, 1, 1,
1700 1, 1, 1, 1, 1, 1, 1, 1,
1701 1, 1, 1, 1, 1, 1, 1, 1,
1702 0, 0, 0, 0, 0, 0, 0, 0,
1703 0, 0, 0, 0, 0, 0, 0, 0,
1704 0, 0, 0, 0, 0, 0, 0, 0,
1705 0, 0, 0, 0, 0, 0, 0, 0,
1706 0, 0, 0, 0, 0, 0, 0, 0
1711 DCTELEM *block = s->block[n];
1712 const int last_index = s->block_last_index[n];
1715 if (threshold < 0) {
1717 threshold = -threshold;
1721 /* Are all we could set to zero already zero? */
1722 if (last_index <= skip_dc - 1)
1725 for (i = 0; i <= last_index; i++) {
1726 const int j = s->intra_scantable.permutated[i];
1727 const int level = FFABS(block[j]);
1729 if (skip_dc && i == 0)
1733 } else if (level > 1) {
1739 if (score >= threshold)
1741 for (i = skip_dc; i <= last_index; i++) {
1742 const int j = s->intra_scantable.permutated[i];
1746 s->block_last_index[n] = 0;
1748 s->block_last_index[n] = -1;
1751 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1755 const int maxlevel = s->max_qcoeff;
1756 const int minlevel = s->min_qcoeff;
1760 i = 1; // skip clipping of intra dc
1764 for (; i <= last_index; i++) {
1765 const int j = s->intra_scantable.permutated[i];
1766 int level = block[j];
1768 if (level > maxlevel) {
1771 } else if (level < minlevel) {
1779 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1780 av_log(s->avctx, AV_LOG_INFO,
1781 "warning, clipping %d dct coefficients to %d..%d\n",
1782 overflow, minlevel, maxlevel);
1785 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1789 for (y = 0; y < 8; y++) {
1790 for (x = 0; x < 8; x++) {
1796 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1797 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1798 int v = ptr[x2 + y2 * stride];
1804 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1809 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1810 int motion_x, int motion_y,
1811 int mb_block_height,
1814 int16_t weight[8][64];
1815 DCTELEM orig[8][64];
1816 const int mb_x = s->mb_x;
1817 const int mb_y = s->mb_y;
1820 int dct_offset = s->linesize * 8; // default for progressive frames
1821 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1824 for (i = 0; i < mb_block_count; i++)
1825 skip_dct[i] = s->skipdct;
1827 if (s->adaptive_quant) {
1828 const int last_qp = s->qscale;
1829 const int mb_xy = mb_x + mb_y * s->mb_stride;
1831 s->lambda = s->lambda_table[mb_xy];
1834 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1835 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1836 s->dquant = s->qscale - last_qp;
1838 if (s->out_format == FMT_H263) {
1839 s->dquant = av_clip(s->dquant, -2, 2);
1841 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1843 if (s->pict_type == AV_PICTURE_TYPE_B) {
1844 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1847 if (s->mv_type == MV_TYPE_8X8)
1853 ff_set_qscale(s, last_qp + s->dquant);
1854 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1855 ff_set_qscale(s, s->qscale + s->dquant);
1857 wrap_y = s->linesize;
1858 wrap_c = s->uvlinesize;
1859 ptr_y = s->new_picture.f.data[0] +
1860 (mb_y * 16 * wrap_y) + mb_x * 16;
1861 ptr_cb = s->new_picture.f.data[1] +
1862 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1863 ptr_cr = s->new_picture.f.data[2] +
1864 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1866 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1867 uint8_t *ebuf = s->edge_emu_buffer + 32;
1868 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1869 mb_y * 16, s->width, s->height);
1871 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1872 mb_block_height, mb_x * 8, mb_y * 8,
1873 (s->width+1) >> 1, (s->height+1) >> 1);
1874 ptr_cb = ebuf + 18 * wrap_y;
1875 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1876 mb_block_height, mb_x * 8, mb_y * 8,
1877 (s->width+1) >> 1, (s->height+1) >> 1);
1878 ptr_cr = ebuf + 18 * wrap_y + 8;
1882 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1883 int progressive_score, interlaced_score;
1885 s->interlaced_dct = 0;
1886 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1888 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1889 NULL, wrap_y, 8) - 400;
1891 if (progressive_score > 0) {
1892 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1893 NULL, wrap_y * 2, 8) +
1894 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1895 NULL, wrap_y * 2, 8);
1896 if (progressive_score > interlaced_score) {
1897 s->interlaced_dct = 1;
1899 dct_offset = wrap_y;
1901 if (s->chroma_format == CHROMA_422)
1907 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1908 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1909 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1910 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1912 if (s->flags & CODEC_FLAG_GRAY) {
1916 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1917 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1918 if (!s->chroma_y_shift) { /* 422 */
1919 s->dsp.get_pixels(s->block[6],
1920 ptr_cb + (dct_offset >> 1), wrap_c);
1921 s->dsp.get_pixels(s->block[7],
1922 ptr_cr + (dct_offset >> 1), wrap_c);
1926 op_pixels_func (*op_pix)[4];
1927 qpel_mc_func (*op_qpix)[16];
1928 uint8_t *dest_y, *dest_cb, *dest_cr;
1930 dest_y = s->dest[0];
1931 dest_cb = s->dest[1];
1932 dest_cr = s->dest[2];
1934 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1935 op_pix = s->dsp.put_pixels_tab;
1936 op_qpix = s->dsp.put_qpel_pixels_tab;
1938 op_pix = s->dsp.put_no_rnd_pixels_tab;
1939 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1942 if (s->mv_dir & MV_DIR_FORWARD) {
1943 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1944 s->last_picture.f.data,
1946 op_pix = s->dsp.avg_pixels_tab;
1947 op_qpix = s->dsp.avg_qpel_pixels_tab;
1949 if (s->mv_dir & MV_DIR_BACKWARD) {
1950 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1951 s->next_picture.f.data,
1955 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1956 int progressive_score, interlaced_score;
1958 s->interlaced_dct = 0;
1959 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1962 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1963 ptr_y + wrap_y * 8, wrap_y,
1966 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1967 progressive_score -= 400;
1969 if (progressive_score > 0) {
1970 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1973 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1977 if (progressive_score > interlaced_score) {
1978 s->interlaced_dct = 1;
1980 dct_offset = wrap_y;
1982 if (s->chroma_format == CHROMA_422)
1988 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1989 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1990 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1991 dest_y + dct_offset, wrap_y);
1992 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1993 dest_y + dct_offset + 8, wrap_y);
1995 if (s->flags & CODEC_FLAG_GRAY) {
1999 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2000 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2001 if (!s->chroma_y_shift) { /* 422 */
2002 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2003 dest_cb + (dct_offset >> 1), wrap_c);
2004 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2005 dest_cr + (dct_offset >> 1), wrap_c);
2008 /* pre quantization */
2009 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2010 2 * s->qscale * s->qscale) {
2012 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
2013 wrap_y, 8) < 20 * s->qscale)
2015 if (s->dsp.sad[1](NULL, ptr_y + 8,
2016 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2018 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
2019 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
2021 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
2022 dest_y + dct_offset + 8,
2023 wrap_y, 8) < 20 * s->qscale)
2025 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2026 wrap_c, 8) < 20 * s->qscale)
2028 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2029 wrap_c, 8) < 20 * s->qscale)
2031 if (!s->chroma_y_shift) { /* 422 */
2032 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2033 dest_cb + (dct_offset >> 1),
2034 wrap_c, 8) < 20 * s->qscale)
2036 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2037 dest_cr + (dct_offset >> 1),
2038 wrap_c, 8) < 20 * s->qscale)
2044 if (s->quantizer_noise_shaping) {
2046 get_visual_weight(weight[0], ptr_y , wrap_y);
2048 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2050 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2052 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2054 get_visual_weight(weight[4], ptr_cb , wrap_c);
2056 get_visual_weight(weight[5], ptr_cr , wrap_c);
2057 if (!s->chroma_y_shift) { /* 422 */
2059 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2062 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2065 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2068 /* DCT & quantize */
2069 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2071 for (i = 0; i < mb_block_count; i++) {
2074 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2075 // FIXME we could decide to change to quantizer instead of
2077 // JS: I don't think that would be a good idea it could lower
2078 // quality instead of improve it. Just INTRADC clipping
2079 // deserves changes in quantizer
2081 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2083 s->block_last_index[i] = -1;
2085 if (s->quantizer_noise_shaping) {
2086 for (i = 0; i < mb_block_count; i++) {
2088 s->block_last_index[i] =
2089 dct_quantize_refine(s, s->block[i], weight[i],
2090 orig[i], i, s->qscale);
2095 if (s->luma_elim_threshold && !s->mb_intra)
2096 for (i = 0; i < 4; i++)
2097 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2098 if (s->chroma_elim_threshold && !s->mb_intra)
2099 for (i = 4; i < mb_block_count; i++)
2100 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2102 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2103 for (i = 0; i < mb_block_count; i++) {
2104 if (s->block_last_index[i] == -1)
2105 s->coded_score[i] = INT_MAX / 256;
2110 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2111 s->block_last_index[4] =
2112 s->block_last_index[5] = 0;
2114 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2117 // non c quantize code returns incorrect block_last_index FIXME
2118 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2119 for (i = 0; i < mb_block_count; i++) {
2121 if (s->block_last_index[i] > 0) {
2122 for (j = 63; j > 0; j--) {
2123 if (s->block[i][s->intra_scantable.permutated[j]])
2126 s->block_last_index[i] = j;
2131 /* huffman encode */
2132 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2133 case AV_CODEC_ID_MPEG1VIDEO:
2134 case AV_CODEC_ID_MPEG2VIDEO:
2135 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2136 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2138 case AV_CODEC_ID_MPEG4:
2139 if (CONFIG_MPEG4_ENCODER)
2140 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2142 case AV_CODEC_ID_MSMPEG4V2:
2143 case AV_CODEC_ID_MSMPEG4V3:
2144 case AV_CODEC_ID_WMV1:
2145 if (CONFIG_MSMPEG4_ENCODER)
2146 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2148 case AV_CODEC_ID_WMV2:
2149 if (CONFIG_WMV2_ENCODER)
2150 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2152 case AV_CODEC_ID_H261:
2153 if (CONFIG_H261_ENCODER)
2154 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2156 case AV_CODEC_ID_H263:
2157 case AV_CODEC_ID_H263P:
2158 case AV_CODEC_ID_FLV1:
2159 case AV_CODEC_ID_RV10:
2160 case AV_CODEC_ID_RV20:
2161 if (CONFIG_H263_ENCODER)
2162 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2164 case AV_CODEC_ID_MJPEG:
2165 case AV_CODEC_ID_AMV:
2166 if (CONFIG_MJPEG_ENCODER)
2167 ff_mjpeg_encode_mb(s, s->block);
2174 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2176 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2177 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2180 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2183 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2186 d->mb_skip_run= s->mb_skip_run;
2188 d->last_dc[i] = s->last_dc[i];
2191 d->mv_bits= s->mv_bits;
2192 d->i_tex_bits= s->i_tex_bits;
2193 d->p_tex_bits= s->p_tex_bits;
2194 d->i_count= s->i_count;
2195 d->f_count= s->f_count;
2196 d->b_count= s->b_count;
2197 d->skip_count= s->skip_count;
2198 d->misc_bits= s->misc_bits;
2202 d->qscale= s->qscale;
2203 d->dquant= s->dquant;
2205 d->esc3_level_length= s->esc3_level_length;
2208 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2211 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2212 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2215 d->mb_skip_run= s->mb_skip_run;
2217 d->last_dc[i] = s->last_dc[i];
2220 d->mv_bits= s->mv_bits;
2221 d->i_tex_bits= s->i_tex_bits;
2222 d->p_tex_bits= s->p_tex_bits;
2223 d->i_count= s->i_count;
2224 d->f_count= s->f_count;
2225 d->b_count= s->b_count;
2226 d->skip_count= s->skip_count;
2227 d->misc_bits= s->misc_bits;
2229 d->mb_intra= s->mb_intra;
2230 d->mb_skipped= s->mb_skipped;
2231 d->mv_type= s->mv_type;
2232 d->mv_dir= s->mv_dir;
2234 if(s->data_partitioning){
2236 d->tex_pb= s->tex_pb;
2240 d->block_last_index[i]= s->block_last_index[i];
2241 d->interlaced_dct= s->interlaced_dct;
2242 d->qscale= s->qscale;
2244 d->esc3_level_length= s->esc3_level_length;
2247 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2248 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2249 int *dmin, int *next_block, int motion_x, int motion_y)
2252 uint8_t *dest_backup[3];
2254 copy_context_before_encode(s, backup, type);
2256 s->block= s->blocks[*next_block];
2257 s->pb= pb[*next_block];
2258 if(s->data_partitioning){
2259 s->pb2 = pb2 [*next_block];
2260 s->tex_pb= tex_pb[*next_block];
2264 memcpy(dest_backup, s->dest, sizeof(s->dest));
2265 s->dest[0] = s->rd_scratchpad;
2266 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2267 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2268 assert(s->linesize >= 32); //FIXME
2271 encode_mb(s, motion_x, motion_y);
2273 score= put_bits_count(&s->pb);
2274 if(s->data_partitioning){
2275 score+= put_bits_count(&s->pb2);
2276 score+= put_bits_count(&s->tex_pb);
2279 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2280 ff_MPV_decode_mb(s, s->block);
2282 score *= s->lambda2;
2283 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2287 memcpy(s->dest, dest_backup, sizeof(s->dest));
2294 copy_context_after_encode(best, s, type);
2298 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2299 uint32_t *sq = ff_squareTbl + 256;
2304 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2305 else if(w==8 && h==8)
2306 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2310 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2319 static int sse_mb(MpegEncContext *s){
2323 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2324 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2327 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2328 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)
2329 +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)
2330 +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);
2332 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)
2333 +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)
2334 +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);
2337 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)
2338 +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)
2339 +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);
2342 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2343 MpegEncContext *s= *(void**)arg;
2347 s->me.dia_size= s->avctx->pre_dia_size;
2348 s->first_slice_line=1;
2349 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2350 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2351 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2353 s->first_slice_line=0;
2361 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2362 MpegEncContext *s= *(void**)arg;
2364 ff_check_alignment();
2366 s->me.dia_size= s->avctx->dia_size;
2367 s->first_slice_line=1;
2368 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2369 s->mb_x=0; //for block init below
2370 ff_init_block_index(s);
2371 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2372 s->block_index[0]+=2;
2373 s->block_index[1]+=2;
2374 s->block_index[2]+=2;
2375 s->block_index[3]+=2;
2377 /* compute motion vector & mb_type and store in context */
2378 if(s->pict_type==AV_PICTURE_TYPE_B)
2379 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2381 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2383 s->first_slice_line=0;
2388 static int mb_var_thread(AVCodecContext *c, void *arg){
2389 MpegEncContext *s= *(void**)arg;
2392 ff_check_alignment();
2394 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2395 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2398 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2400 int sum = s->dsp.pix_sum(pix, s->linesize);
2402 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2404 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2405 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2406 s->me.mb_var_sum_temp += varc;
2412 static void write_slice_end(MpegEncContext *s){
2413 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2414 if(s->partitioned_frame){
2415 ff_mpeg4_merge_partitions(s);
2418 ff_mpeg4_stuffing(&s->pb);
2419 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2420 ff_mjpeg_encode_stuffing(s);
2423 avpriv_align_put_bits(&s->pb);
2424 flush_put_bits(&s->pb);
2426 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2427 s->misc_bits+= get_bits_diff(s);
2430 static void write_mb_info(MpegEncContext *s)
2432 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2433 int offset = put_bits_count(&s->pb);
2434 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2435 int gobn = s->mb_y / s->gob_index;
2437 if (CONFIG_H263_ENCODER)
2438 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2439 bytestream_put_le32(&ptr, offset);
2440 bytestream_put_byte(&ptr, s->qscale);
2441 bytestream_put_byte(&ptr, gobn);
2442 bytestream_put_le16(&ptr, mba);
2443 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2444 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2445 /* 4MV not implemented */
2446 bytestream_put_byte(&ptr, 0); /* hmv2 */
2447 bytestream_put_byte(&ptr, 0); /* vmv2 */
2450 static void update_mb_info(MpegEncContext *s, int startcode)
2454 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2455 s->mb_info_size += 12;
2456 s->prev_mb_info = s->last_mb_info;
2459 s->prev_mb_info = put_bits_count(&s->pb)/8;
2460 /* This might have incremented mb_info_size above, and we return without
2461 * actually writing any info into that slot yet. But in that case,
2462 * this will be called again at the start of the after writing the
2463 * start code, actually writing the mb info. */
2467 s->last_mb_info = put_bits_count(&s->pb)/8;
2468 if (!s->mb_info_size)
2469 s->mb_info_size += 12;
2473 static int encode_thread(AVCodecContext *c, void *arg){
2474 MpegEncContext *s= *(void**)arg;
2475 int mb_x, mb_y, pdif = 0;
2476 int chr_h= 16>>s->chroma_y_shift;
2478 MpegEncContext best_s, backup_s;
2479 uint8_t bit_buf[2][MAX_MB_BYTES];
2480 uint8_t bit_buf2[2][MAX_MB_BYTES];
2481 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2482 PutBitContext pb[2], pb2[2], tex_pb[2];
2484 ff_check_alignment();
2487 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2488 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2489 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2492 s->last_bits= put_bits_count(&s->pb);
2503 /* init last dc values */
2504 /* note: quant matrix value (8) is implied here */
2505 s->last_dc[i] = 128 << s->intra_dc_precision;
2507 s->current_picture.f.error[i] = 0;
2509 if(s->codec_id==AV_CODEC_ID_AMV){
2510 s->last_dc[0] = 128*8/13;
2511 s->last_dc[1] = 128*8/14;
2512 s->last_dc[2] = 128*8/14;
2515 memset(s->last_mv, 0, sizeof(s->last_mv));
2519 switch(s->codec_id){
2520 case AV_CODEC_ID_H263:
2521 case AV_CODEC_ID_H263P:
2522 case AV_CODEC_ID_FLV1:
2523 if (CONFIG_H263_ENCODER)
2524 s->gob_index = ff_h263_get_gob_height(s);
2526 case AV_CODEC_ID_MPEG4:
2527 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2528 ff_mpeg4_init_partitions(s);
2534 s->first_slice_line = 1;
2535 s->ptr_lastgob = s->pb.buf;
2536 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2540 ff_set_qscale(s, s->qscale);
2541 ff_init_block_index(s);
2543 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2544 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2545 int mb_type= s->mb_type[xy];
2550 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2551 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2554 if(s->data_partitioning){
2555 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2556 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2557 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2563 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2564 ff_update_block_index(s);
2566 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2567 ff_h261_reorder_mb_index(s);
2568 xy= s->mb_y*s->mb_stride + s->mb_x;
2569 mb_type= s->mb_type[xy];
2572 /* write gob / video packet header */
2574 int current_packet_size, is_gob_start;
2576 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2578 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2580 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2582 switch(s->codec_id){
2583 case AV_CODEC_ID_H263:
2584 case AV_CODEC_ID_H263P:
2585 if(!s->h263_slice_structured)
2586 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2588 case AV_CODEC_ID_MPEG2VIDEO:
2589 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2590 case AV_CODEC_ID_MPEG1VIDEO:
2591 if(s->mb_skip_run) is_gob_start=0;
2593 case AV_CODEC_ID_MJPEG:
2594 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2599 if(s->start_mb_y != mb_y || mb_x!=0){
2601 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2602 ff_mpeg4_init_partitions(s);
2606 av_assert2((put_bits_count(&s->pb)&7) == 0);
2607 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2609 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2610 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2611 int d= 100 / s->avctx->error_rate;
2613 current_packet_size=0;
2614 s->pb.buf_ptr= s->ptr_lastgob;
2615 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2619 if (s->avctx->rtp_callback){
2620 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2621 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2623 update_mb_info(s, 1);
2625 switch(s->codec_id){
2626 case AV_CODEC_ID_MPEG4:
2627 if (CONFIG_MPEG4_ENCODER) {
2628 ff_mpeg4_encode_video_packet_header(s);
2629 ff_mpeg4_clean_buffers(s);
2632 case AV_CODEC_ID_MPEG1VIDEO:
2633 case AV_CODEC_ID_MPEG2VIDEO:
2634 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2635 ff_mpeg1_encode_slice_header(s);
2636 ff_mpeg1_clean_buffers(s);
2639 case AV_CODEC_ID_H263:
2640 case AV_CODEC_ID_H263P:
2641 if (CONFIG_H263_ENCODER)
2642 ff_h263_encode_gob_header(s, mb_y);
2646 if(s->flags&CODEC_FLAG_PASS1){
2647 int bits= put_bits_count(&s->pb);
2648 s->misc_bits+= bits - s->last_bits;
2652 s->ptr_lastgob += current_packet_size;
2653 s->first_slice_line=1;
2654 s->resync_mb_x=mb_x;
2655 s->resync_mb_y=mb_y;
2659 if( (s->resync_mb_x == s->mb_x)
2660 && s->resync_mb_y+1 == s->mb_y){
2661 s->first_slice_line=0;
2665 s->dquant=0; //only for QP_RD
2667 update_mb_info(s, 0);
2669 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
2671 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2673 copy_context_before_encode(&backup_s, s, -1);
2675 best_s.data_partitioning= s->data_partitioning;
2676 best_s.partitioned_frame= s->partitioned_frame;
2677 if(s->data_partitioning){
2678 backup_s.pb2= s->pb2;
2679 backup_s.tex_pb= s->tex_pb;
2682 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2683 s->mv_dir = MV_DIR_FORWARD;
2684 s->mv_type = MV_TYPE_16X16;
2686 s->mv[0][0][0] = s->p_mv_table[xy][0];
2687 s->mv[0][0][1] = s->p_mv_table[xy][1];
2688 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2689 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2691 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2692 s->mv_dir = MV_DIR_FORWARD;
2693 s->mv_type = MV_TYPE_FIELD;
2696 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2697 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2698 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2700 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2701 &dmin, &next_block, 0, 0);
2703 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2704 s->mv_dir = MV_DIR_FORWARD;
2705 s->mv_type = MV_TYPE_16X16;
2709 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2710 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2712 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2713 s->mv_dir = MV_DIR_FORWARD;
2714 s->mv_type = MV_TYPE_8X8;
2717 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2718 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2720 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2721 &dmin, &next_block, 0, 0);
2723 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2724 s->mv_dir = MV_DIR_FORWARD;
2725 s->mv_type = MV_TYPE_16X16;
2727 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2728 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2729 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2730 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2732 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2733 s->mv_dir = MV_DIR_BACKWARD;
2734 s->mv_type = MV_TYPE_16X16;
2736 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2737 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2738 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2739 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2741 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2742 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2743 s->mv_type = MV_TYPE_16X16;
2745 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2746 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2747 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2748 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2749 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2750 &dmin, &next_block, 0, 0);
2752 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2753 s->mv_dir = MV_DIR_FORWARD;
2754 s->mv_type = MV_TYPE_FIELD;
2757 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2758 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2759 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2761 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2762 &dmin, &next_block, 0, 0);
2764 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2765 s->mv_dir = MV_DIR_BACKWARD;
2766 s->mv_type = MV_TYPE_FIELD;
2769 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2770 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2771 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2773 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2774 &dmin, &next_block, 0, 0);
2776 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2777 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2778 s->mv_type = MV_TYPE_FIELD;
2780 for(dir=0; dir<2; dir++){
2782 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2783 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2784 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2787 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2788 &dmin, &next_block, 0, 0);
2790 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2792 s->mv_type = MV_TYPE_16X16;
2796 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2797 &dmin, &next_block, 0, 0);
2798 if(s->h263_pred || s->h263_aic){
2800 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2802 ff_clean_intra_table_entries(s); //old mode?
2806 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2807 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2808 const int last_qp= backup_s.qscale;
2811 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2812 static const int dquant_tab[4]={-1,1,-2,2};
2814 av_assert2(backup_s.dquant == 0);
2817 s->mv_dir= best_s.mv_dir;
2818 s->mv_type = MV_TYPE_16X16;
2819 s->mb_intra= best_s.mb_intra;
2820 s->mv[0][0][0] = best_s.mv[0][0][0];
2821 s->mv[0][0][1] = best_s.mv[0][0][1];
2822 s->mv[1][0][0] = best_s.mv[1][0][0];
2823 s->mv[1][0][1] = best_s.mv[1][0][1];
2825 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2826 for(; qpi<4; qpi++){
2827 int dquant= dquant_tab[qpi];
2828 qp= last_qp + dquant;
2829 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2831 backup_s.dquant= dquant;
2832 if(s->mb_intra && s->dc_val[0]){
2834 dc[i]= s->dc_val[0][ s->block_index[i] ];
2835 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2839 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2840 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2841 if(best_s.qscale != qp){
2842 if(s->mb_intra && s->dc_val[0]){
2844 s->dc_val[0][ s->block_index[i] ]= dc[i];
2845 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2852 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2853 int mx= s->b_direct_mv_table[xy][0];
2854 int my= s->b_direct_mv_table[xy][1];
2856 backup_s.dquant = 0;
2857 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2859 ff_mpeg4_set_direct_mv(s, mx, my);
2860 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2861 &dmin, &next_block, mx, my);
2863 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2864 backup_s.dquant = 0;
2865 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2867 ff_mpeg4_set_direct_mv(s, 0, 0);
2868 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2869 &dmin, &next_block, 0, 0);
2871 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2874 coded |= s->block_last_index[i];
2877 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2878 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2879 mx=my=0; //FIXME find the one we actually used
2880 ff_mpeg4_set_direct_mv(s, mx, my);
2881 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2889 s->mv_dir= best_s.mv_dir;
2890 s->mv_type = best_s.mv_type;
2892 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2893 s->mv[0][0][1] = best_s.mv[0][0][1];
2894 s->mv[1][0][0] = best_s.mv[1][0][0];
2895 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2898 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2899 &dmin, &next_block, mx, my);
2904 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2906 copy_context_after_encode(s, &best_s, -1);
2908 pb_bits_count= put_bits_count(&s->pb);
2909 flush_put_bits(&s->pb);
2910 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2913 if(s->data_partitioning){
2914 pb2_bits_count= put_bits_count(&s->pb2);
2915 flush_put_bits(&s->pb2);
2916 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2917 s->pb2= backup_s.pb2;
2919 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2920 flush_put_bits(&s->tex_pb);
2921 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2922 s->tex_pb= backup_s.tex_pb;
2924 s->last_bits= put_bits_count(&s->pb);
2926 if (CONFIG_H263_ENCODER &&
2927 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2928 ff_h263_update_motion_val(s);
2930 if(next_block==0){ //FIXME 16 vs linesize16
2931 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2932 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2933 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2936 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2937 ff_MPV_decode_mb(s, s->block);
2939 int motion_x = 0, motion_y = 0;
2940 s->mv_type=MV_TYPE_16X16;
2941 // only one MB-Type possible
2944 case CANDIDATE_MB_TYPE_INTRA:
2947 motion_x= s->mv[0][0][0] = 0;
2948 motion_y= s->mv[0][0][1] = 0;
2950 case CANDIDATE_MB_TYPE_INTER:
2951 s->mv_dir = MV_DIR_FORWARD;
2953 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2954 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2956 case CANDIDATE_MB_TYPE_INTER_I:
2957 s->mv_dir = MV_DIR_FORWARD;
2958 s->mv_type = MV_TYPE_FIELD;
2961 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2962 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2963 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2966 case CANDIDATE_MB_TYPE_INTER4V:
2967 s->mv_dir = MV_DIR_FORWARD;
2968 s->mv_type = MV_TYPE_8X8;
2971 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2972 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2975 case CANDIDATE_MB_TYPE_DIRECT:
2976 if (CONFIG_MPEG4_ENCODER) {
2977 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2979 motion_x=s->b_direct_mv_table[xy][0];
2980 motion_y=s->b_direct_mv_table[xy][1];
2981 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2984 case CANDIDATE_MB_TYPE_DIRECT0:
2985 if (CONFIG_MPEG4_ENCODER) {
2986 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2988 ff_mpeg4_set_direct_mv(s, 0, 0);
2991 case CANDIDATE_MB_TYPE_BIDIR:
2992 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2994 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2995 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2996 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2997 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2999 case CANDIDATE_MB_TYPE_BACKWARD:
3000 s->mv_dir = MV_DIR_BACKWARD;
3002 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3003 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3005 case CANDIDATE_MB_TYPE_FORWARD:
3006 s->mv_dir = MV_DIR_FORWARD;
3008 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3009 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3011 case CANDIDATE_MB_TYPE_FORWARD_I:
3012 s->mv_dir = MV_DIR_FORWARD;
3013 s->mv_type = MV_TYPE_FIELD;
3016 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3017 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3018 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3021 case CANDIDATE_MB_TYPE_BACKWARD_I:
3022 s->mv_dir = MV_DIR_BACKWARD;
3023 s->mv_type = MV_TYPE_FIELD;
3026 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3027 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3028 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3031 case CANDIDATE_MB_TYPE_BIDIR_I:
3032 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3033 s->mv_type = MV_TYPE_FIELD;
3035 for(dir=0; dir<2; dir++){
3037 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3038 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3039 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3044 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3047 encode_mb(s, motion_x, motion_y);
3049 // RAL: Update last macroblock type
3050 s->last_mv_dir = s->mv_dir;
3052 if (CONFIG_H263_ENCODER &&
3053 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3054 ff_h263_update_motion_val(s);
3056 ff_MPV_decode_mb(s, s->block);
3059 /* clean the MV table in IPS frames for direct mode in B frames */
3060 if(s->mb_intra /* && I,P,S_TYPE */){
3061 s->p_mv_table[xy][0]=0;
3062 s->p_mv_table[xy][1]=0;
3065 if(s->flags&CODEC_FLAG_PSNR){
3069 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3070 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3072 s->current_picture.f.error[0] += sse(
3073 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3074 s->dest[0], w, h, s->linesize);
3075 s->current_picture.f.error[1] += sse(
3076 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3077 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3078 s->current_picture.f.error[2] += sse(
3079 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3080 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3083 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3084 ff_h263_loop_filter(s);
3086 av_dlog(s->avctx, "MB %d %d bits\n",
3087 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3091 //not beautiful here but we must write it before flushing so it has to be here
3092 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3093 ff_msmpeg4_encode_ext_header(s);
3097 /* Send the last GOB if RTP */
3098 if (s->avctx->rtp_callback) {
3099 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3100 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3101 /* Call the RTP callback to send the last GOB */
3103 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3109 #define MERGE(field) dst->field += src->field; src->field=0
3110 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3111 MERGE(me.scene_change_score);
3112 MERGE(me.mc_mb_var_sum_temp);
3113 MERGE(me.mb_var_sum_temp);
3116 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3119 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3120 MERGE(dct_count[1]);
3130 MERGE(padding_bug_score);
3131 MERGE(current_picture.f.error[0]);
3132 MERGE(current_picture.f.error[1]);
3133 MERGE(current_picture.f.error[2]);
3135 if(dst->avctx->noise_reduction){
3136 for(i=0; i<64; i++){
3137 MERGE(dct_error_sum[0][i]);
3138 MERGE(dct_error_sum[1][i]);
3142 assert(put_bits_count(&src->pb) % 8 ==0);
3143 assert(put_bits_count(&dst->pb) % 8 ==0);
3144 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3145 flush_put_bits(&dst->pb);
3148 static int estimate_qp(MpegEncContext *s, int dry_run){
3149 if (s->next_lambda){
3150 s->current_picture_ptr->f.quality =
3151 s->current_picture.f.quality = s->next_lambda;
3152 if(!dry_run) s->next_lambda= 0;
3153 } else if (!s->fixed_qscale) {
3154 s->current_picture_ptr->f.quality =
3155 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3156 if (s->current_picture.f.quality < 0)
3160 if(s->adaptive_quant){
3161 switch(s->codec_id){
3162 case AV_CODEC_ID_MPEG4:
3163 if (CONFIG_MPEG4_ENCODER)
3164 ff_clean_mpeg4_qscales(s);
3166 case AV_CODEC_ID_H263:
3167 case AV_CODEC_ID_H263P:
3168 case AV_CODEC_ID_FLV1:
3169 if (CONFIG_H263_ENCODER)
3170 ff_clean_h263_qscales(s);
3173 ff_init_qscale_tab(s);
3176 s->lambda= s->lambda_table[0];
3179 s->lambda = s->current_picture.f.quality;
3184 /* must be called before writing the header */
3185 static void set_frame_distances(MpegEncContext * s){
3186 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3187 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3189 if(s->pict_type==AV_PICTURE_TYPE_B){
3190 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3191 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3193 s->pp_time= s->time - s->last_non_b_time;
3194 s->last_non_b_time= s->time;
3195 assert(s->picture_number==0 || s->pp_time > 0);
3199 static int encode_picture(MpegEncContext *s, int picture_number)
3203 int context_count = s->slice_context_count;
3205 s->picture_number = picture_number;
3207 /* Reset the average MB variance */
3208 s->me.mb_var_sum_temp =
3209 s->me.mc_mb_var_sum_temp = 0;
3211 /* we need to initialize some time vars before we can encode b-frames */
3212 // RAL: Condition added for MPEG1VIDEO
3213 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3214 set_frame_distances(s);
3215 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3216 ff_set_mpeg4_time(s);
3218 s->me.scene_change_score=0;
3220 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3222 if(s->pict_type==AV_PICTURE_TYPE_I){
3223 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3224 else s->no_rounding=0;
3225 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3226 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3227 s->no_rounding ^= 1;
3230 if(s->flags & CODEC_FLAG_PASS2){
3231 if (estimate_qp(s,1) < 0)
3233 ff_get_2pass_fcode(s);
3234 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3235 if(s->pict_type==AV_PICTURE_TYPE_B)
3236 s->lambda= s->last_lambda_for[s->pict_type];
3238 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3242 if(s->codec_id != AV_CODEC_ID_AMV){
3243 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3244 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3245 s->q_chroma_intra_matrix = s->q_intra_matrix;
3246 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3249 s->mb_intra=0; //for the rate distortion & bit compare functions
3250 for(i=1; i<context_count; i++){
3251 ff_update_duplicate_context(s->thread_context[i], s);
3257 /* Estimate motion for every MB */
3258 if(s->pict_type != AV_PICTURE_TYPE_I){
3259 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3260 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3261 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3262 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3263 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3267 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3268 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3270 for(i=0; i<s->mb_stride*s->mb_height; i++)
3271 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3273 if(!s->fixed_qscale){
3274 /* finding spatial complexity for I-frame rate control */
3275 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3278 for(i=1; i<context_count; i++){
3279 merge_context_after_me(s, s->thread_context[i]);
3281 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3282 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3285 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3286 s->pict_type= AV_PICTURE_TYPE_I;
3287 for(i=0; i<s->mb_stride*s->mb_height; i++)
3288 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3289 if(s->msmpeg4_version >= 3)
3291 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3292 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3296 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3297 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3299 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3301 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3302 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3303 s->f_code= FFMAX3(s->f_code, a, b);
3306 ff_fix_long_p_mvs(s);
3307 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3308 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3312 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3313 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3318 if(s->pict_type==AV_PICTURE_TYPE_B){
3321 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3322 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3323 s->f_code = FFMAX(a, b);
3325 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3326 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3327 s->b_code = FFMAX(a, b);
3329 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3330 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3331 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3332 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3333 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3335 for(dir=0; dir<2; dir++){
3338 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3339 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3340 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3341 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3349 if (estimate_qp(s, 0) < 0)
3352 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3353 s->qscale= 3; //reduce clipping problems
3355 if (s->out_format == FMT_MJPEG) {
3356 /* for mjpeg, we do include qscale in the matrix */
3358 int j= s->dsp.idct_permutation[i];
3360 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3362 s->y_dc_scale_table=
3363 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3364 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3365 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3366 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3369 if(s->codec_id == AV_CODEC_ID_AMV){
3370 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};
3371 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};
3373 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3375 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3376 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3378 s->y_dc_scale_table= y;
3379 s->c_dc_scale_table= c;
3380 s->intra_matrix[0] = 13;
3381 s->chroma_intra_matrix[0] = 14;
3382 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3383 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3384 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3385 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3389 //FIXME var duplication
3390 s->current_picture_ptr->f.key_frame =
3391 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3392 s->current_picture_ptr->f.pict_type =
3393 s->current_picture.f.pict_type = s->pict_type;
3395 if (s->current_picture.f.key_frame)
3396 s->picture_in_gop_number=0;
3398 s->mb_x = s->mb_y = 0;
3399 s->last_bits= put_bits_count(&s->pb);
3400 switch(s->out_format) {
3402 if (CONFIG_MJPEG_ENCODER)
3403 ff_mjpeg_encode_picture_header(s);
3406 if (CONFIG_H261_ENCODER)
3407 ff_h261_encode_picture_header(s, picture_number);
3410 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3411 ff_wmv2_encode_picture_header(s, picture_number);
3412 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3413 ff_msmpeg4_encode_picture_header(s, picture_number);
3414 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3415 ff_mpeg4_encode_picture_header(s, picture_number);
3416 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3417 ff_rv10_encode_picture_header(s, picture_number);
3418 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3419 ff_rv20_encode_picture_header(s, picture_number);
3420 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3421 ff_flv_encode_picture_header(s, picture_number);
3422 else if (CONFIG_H263_ENCODER)
3423 ff_h263_encode_picture_header(s, picture_number);
3426 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3427 ff_mpeg1_encode_picture_header(s, picture_number);
3434 bits= put_bits_count(&s->pb);
3435 s->header_bits= bits - s->last_bits;
3437 for(i=1; i<context_count; i++){
3438 update_duplicate_context_after_me(s->thread_context[i], s);
3440 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3441 for(i=1; i<context_count; i++){
3442 merge_context_after_encode(s, s->thread_context[i]);
3448 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3449 const int intra= s->mb_intra;
3452 s->dct_count[intra]++;
3454 for(i=0; i<64; i++){
3455 int level= block[i];
3459 s->dct_error_sum[intra][i] += level;
3460 level -= s->dct_offset[intra][i];
3461 if(level<0) level=0;
3463 s->dct_error_sum[intra][i] -= level;
3464 level += s->dct_offset[intra][i];
3465 if(level>0) level=0;
3472 static int dct_quantize_trellis_c(MpegEncContext *s,
3473 DCTELEM *block, int n,
3474 int qscale, int *overflow){
3476 const uint8_t *scantable= s->intra_scantable.scantable;
3477 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3479 unsigned int threshold1, threshold2;
3491 int coeff_count[64];
3492 int qmul, qadd, start_i, last_non_zero, i, dc;
3493 const int esc_length= s->ac_esc_length;
3495 uint8_t * last_length;
3496 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3498 s->dsp.fdct (block);
3500 if(s->dct_error_sum)
3501 s->denoise_dct(s, block);
3503 qadd= ((qscale-1)|1)*8;
3514 /* For AIC we skip quant/dequant of INTRADC */
3519 /* note: block[0] is assumed to be positive */
3520 block[0] = (block[0] + (q >> 1)) / q;
3523 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3524 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3525 bias= 1<<(QMAT_SHIFT-1);
3526 length = s->intra_ac_vlc_length;
3527 last_length= s->intra_ac_vlc_last_length;
3531 qmat = s->q_inter_matrix[qscale];
3532 length = s->inter_ac_vlc_length;
3533 last_length= s->inter_ac_vlc_last_length;
3537 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3538 threshold2= (threshold1<<1);
3540 for(i=63; i>=start_i; i--) {
3541 const int j = scantable[i];
3542 int level = block[j] * qmat[j];
3544 if(((unsigned)(level+threshold1))>threshold2){
3550 for(i=start_i; i<=last_non_zero; i++) {
3551 const int j = scantable[i];
3552 int level = block[j] * qmat[j];
3554 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3555 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3556 if(((unsigned)(level+threshold1))>threshold2){
3558 level= (bias + level)>>QMAT_SHIFT;
3560 coeff[1][i]= level-1;
3561 // coeff[2][k]= level-2;
3563 level= (bias - level)>>QMAT_SHIFT;
3564 coeff[0][i]= -level;
3565 coeff[1][i]= -level+1;
3566 // coeff[2][k]= -level+2;
3568 coeff_count[i]= FFMIN(level, 2);
3569 av_assert2(coeff_count[i]);
3572 coeff[0][i]= (level>>31)|1;
3577 *overflow= s->max_qcoeff < max; //overflow might have happened
3579 if(last_non_zero < start_i){
3580 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3581 return last_non_zero;
3584 score_tab[start_i]= 0;
3585 survivor[0]= start_i;
3588 for(i=start_i; i<=last_non_zero; i++){
3589 int level_index, j, zero_distortion;
3590 int dct_coeff= FFABS(block[ scantable[i] ]);
3591 int best_score=256*256*256*120;
3593 if (s->dsp.fdct == ff_fdct_ifast)
3594 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3595 zero_distortion= dct_coeff*dct_coeff;
3597 for(level_index=0; level_index < coeff_count[i]; level_index++){
3599 int level= coeff[level_index][i];
3600 const int alevel= FFABS(level);
3605 if(s->out_format == FMT_H263){
3606 unquant_coeff= alevel*qmul + qadd;
3608 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3610 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3611 unquant_coeff = (unquant_coeff - 1) | 1;
3613 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3614 unquant_coeff = (unquant_coeff - 1) | 1;
3619 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3621 if((level&(~127)) == 0){
3622 for(j=survivor_count-1; j>=0; j--){
3623 int run= i - survivor[j];
3624 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3625 score += 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 + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3638 score += score_tab[i-run];
3639 if(score < last_score){
3642 last_level= level-64;
3648 distortion += esc_length*lambda;
3649 for(j=survivor_count-1; j>=0; j--){
3650 int run= i - survivor[j];
3651 int score= distortion + score_tab[i-run];
3653 if(score < best_score){
3656 level_tab[i+1]= level-64;
3660 if(s->out_format == FMT_H263){
3661 for(j=survivor_count-1; j>=0; j--){
3662 int run= i - survivor[j];
3663 int score= distortion + score_tab[i-run];
3664 if(score < last_score){
3667 last_level= level-64;
3675 score_tab[i+1]= best_score;
3677 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3678 if(last_non_zero <= 27){
3679 for(; survivor_count; survivor_count--){
3680 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3684 for(; survivor_count; survivor_count--){
3685 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3690 survivor[ survivor_count++ ]= i+1;
3693 if(s->out_format != FMT_H263){
3694 last_score= 256*256*256*120;
3695 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3696 int score= score_tab[i];
3697 if(i) score += lambda*2; //FIXME exacter?
3699 if(score < last_score){
3702 last_level= level_tab[i];
3703 last_run= run_tab[i];
3708 s->coded_score[n] = last_score;
3710 dc= FFABS(block[0]);
3711 last_non_zero= last_i - 1;
3712 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3714 if(last_non_zero < start_i)
3715 return last_non_zero;
3717 if(last_non_zero == 0 && start_i == 0){
3719 int best_score= dc * dc;
3721 for(i=0; i<coeff_count[0]; i++){
3722 int level= coeff[i][0];
3723 int alevel= FFABS(level);
3724 int unquant_coeff, score, distortion;
3726 if(s->out_format == FMT_H263){
3727 unquant_coeff= (alevel*qmul + qadd)>>3;
3729 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3730 unquant_coeff = (unquant_coeff - 1) | 1;
3732 unquant_coeff = (unquant_coeff + 4) >> 3;
3733 unquant_coeff<<= 3 + 3;
3735 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3737 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3738 else score= distortion + esc_length*lambda;
3740 if(score < best_score){
3742 best_level= level - 64;
3745 block[0]= best_level;
3746 s->coded_score[n] = best_score - dc*dc;
3747 if(best_level == 0) return -1;
3748 else return last_non_zero;
3752 av_assert2(last_level);
3754 block[ perm_scantable[last_non_zero] ]= last_level;
3757 for(; i>start_i; i -= run_tab[i] + 1){
3758 block[ perm_scantable[i-1] ]= level_tab[i];
3761 return last_non_zero;
3764 //#define REFINE_STATS 1
3765 static int16_t basis[64][64];
3767 static void build_basis(uint8_t *perm){
3774 double s= 0.25*(1<<BASIS_SHIFT);
3776 int perm_index= perm[index];
3777 if(i==0) s*= sqrt(0.5);
3778 if(j==0) s*= sqrt(0.5);
3779 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)));
3786 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3787 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3790 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3791 const uint8_t *scantable= s->intra_scantable.scantable;
3792 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3793 // unsigned int threshold1, threshold2;
3798 int qmul, qadd, start_i, last_non_zero, i, dc;
3800 uint8_t * last_length;
3802 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3805 static int after_last=0;
3806 static int to_zero=0;
3807 static int from_zero=0;
3810 static int messed_sign=0;
3813 if(basis[0][0] == 0)
3814 build_basis(s->dsp.idct_permutation);
3825 /* For AIC we skip quant/dequant of INTRADC */
3829 q <<= RECON_SHIFT-3;
3830 /* note: block[0] is assumed to be positive */
3832 // block[0] = (block[0] + (q >> 1)) / q;
3834 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3835 // bias= 1<<(QMAT_SHIFT-1);
3836 length = s->intra_ac_vlc_length;
3837 last_length= s->intra_ac_vlc_last_length;
3841 length = s->inter_ac_vlc_length;
3842 last_length= s->inter_ac_vlc_last_length;
3844 last_non_zero = s->block_last_index[n];
3849 dc += (1<<(RECON_SHIFT-1));
3850 for(i=0; i<64; i++){
3851 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3854 STOP_TIMER("memset rem[]")}
3857 for(i=0; i<64; i++){
3862 w= FFABS(weight[i]) + qns*one;
3863 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3866 // w=weight[i] = (63*qns + (w/2)) / w;
3869 av_assert2(w<(1<<6));
3872 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3878 for(i=start_i; i<=last_non_zero; i++){
3879 int j= perm_scantable[i];
3880 const int level= block[j];
3884 if(level<0) coeff= qmul*level - qadd;
3885 else coeff= qmul*level + qadd;
3886 run_tab[rle_index++]=run;
3889 s->dsp.add_8x8basis(rem, basis[j], coeff);
3895 if(last_non_zero>0){
3896 STOP_TIMER("init rem[]")
3903 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3906 int run2, best_unquant_change=0, analyze_gradient;
3910 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3912 if(analyze_gradient){
3916 for(i=0; i<64; i++){
3919 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3922 STOP_TIMER("rem*w*w")}
3932 const int level= block[0];
3933 int change, old_coeff;
3935 av_assert2(s->mb_intra);
3939 for(change=-1; change<=1; change+=2){
3940 int new_level= level + change;
3941 int score, new_coeff;
3943 new_coeff= q*new_level;
3944 if(new_coeff >= 2048 || new_coeff < 0)
3947 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3948 if(score<best_score){
3951 best_change= change;
3952 best_unquant_change= new_coeff - old_coeff;
3959 run2= run_tab[rle_index++];
3963 for(i=start_i; i<64; i++){
3964 int j= perm_scantable[i];
3965 const int level= block[j];
3966 int change, old_coeff;
3968 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3972 if(level<0) old_coeff= qmul*level - qadd;
3973 else old_coeff= qmul*level + qadd;
3974 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3978 av_assert2(run2>=0 || i >= last_non_zero );
3981 for(change=-1; change<=1; change+=2){
3982 int new_level= level + change;
3983 int score, new_coeff, unquant_change;
3986 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3990 if(new_level<0) new_coeff= qmul*new_level - qadd;
3991 else new_coeff= qmul*new_level + qadd;
3992 if(new_coeff >= 2048 || new_coeff <= -2048)
3994 //FIXME check for overflow
3997 if(level < 63 && level > -63){
3998 if(i < last_non_zero)
3999 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4000 - length[UNI_AC_ENC_INDEX(run, level+64)];
4002 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4003 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4006 av_assert2(FFABS(new_level)==1);
4008 if(analyze_gradient){
4009 int g= d1[ scantable[i] ];
4010 if(g && (g^new_level) >= 0)
4014 if(i < last_non_zero){
4015 int next_i= i + run2 + 1;
4016 int next_level= block[ perm_scantable[next_i] ] + 64;
4018 if(next_level&(~127))
4021 if(next_i < last_non_zero)
4022 score += length[UNI_AC_ENC_INDEX(run, 65)]
4023 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4024 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4026 score += length[UNI_AC_ENC_INDEX(run, 65)]
4027 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4028 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4030 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4032 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4033 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4039 av_assert2(FFABS(level)==1);
4041 if(i < last_non_zero){
4042 int next_i= i + run2 + 1;
4043 int next_level= block[ perm_scantable[next_i] ] + 64;
4045 if(next_level&(~127))
4048 if(next_i < last_non_zero)
4049 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4050 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4051 - length[UNI_AC_ENC_INDEX(run, 65)];
4053 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4054 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4055 - length[UNI_AC_ENC_INDEX(run, 65)];
4057 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4059 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4060 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4067 unquant_change= new_coeff - old_coeff;
4068 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4070 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4071 if(score<best_score){
4074 best_change= change;
4075 best_unquant_change= unquant_change;
4079 prev_level= level + 64;
4080 if(prev_level&(~127))
4089 STOP_TIMER("iterative step")}
4093 int j= perm_scantable[ best_coeff ];
4095 block[j] += best_change;
4097 if(best_coeff > last_non_zero){
4098 last_non_zero= best_coeff;
4099 av_assert2(block[j]);
4106 if(block[j] - best_change){
4107 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4119 for(; last_non_zero>=start_i; last_non_zero--){
4120 if(block[perm_scantable[last_non_zero]])
4126 if(256*256*256*64 % count == 0){
4127 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);
4132 for(i=start_i; i<=last_non_zero; i++){
4133 int j= perm_scantable[i];
4134 const int level= block[j];
4137 run_tab[rle_index++]=run;
4144 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4150 if(last_non_zero>0){
4151 STOP_TIMER("iterative search")
4156 return last_non_zero;
4159 int ff_dct_quantize_c(MpegEncContext *s,
4160 DCTELEM *block, int n,
4161 int qscale, int *overflow)
4163 int i, j, level, last_non_zero, q, start_i;
4165 const uint8_t *scantable= s->intra_scantable.scantable;
4168 unsigned int threshold1, threshold2;
4170 s->dsp.fdct (block);
4172 if(s->dct_error_sum)
4173 s->denoise_dct(s, block);
4183 /* For AIC we skip quant/dequant of INTRADC */
4186 /* note: block[0] is assumed to be positive */
4187 block[0] = (block[0] + (q >> 1)) / q;
4190 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4191 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4195 qmat = s->q_inter_matrix[qscale];
4196 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4198 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4199 threshold2= (threshold1<<1);
4200 for(i=63;i>=start_i;i--) {
4202 level = block[j] * qmat[j];
4204 if(((unsigned)(level+threshold1))>threshold2){
4211 for(i=start_i; i<=last_non_zero; i++) {
4213 level = block[j] * qmat[j];
4215 // if( bias+level >= (1<<QMAT_SHIFT)
4216 // || bias-level >= (1<<QMAT_SHIFT)){
4217 if(((unsigned)(level+threshold1))>threshold2){
4219 level= (bias + level)>>QMAT_SHIFT;
4222 level= (bias - level)>>QMAT_SHIFT;
4230 *overflow= s->max_qcoeff < max; //overflow might have happened
4232 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4233 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4234 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4236 return last_non_zero;
4239 #define OFFSET(x) offsetof(MpegEncContext, x)
4240 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4241 static const AVOption h263_options[] = {
4242 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4243 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4244 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4249 static const AVClass h263_class = {
4250 .class_name = "H.263 encoder",
4251 .item_name = av_default_item_name,
4252 .option = h263_options,
4253 .version = LIBAVUTIL_VERSION_INT,
4256 AVCodec ff_h263_encoder = {
4258 .type = AVMEDIA_TYPE_VIDEO,
4259 .id = AV_CODEC_ID_H263,
4260 .priv_data_size = sizeof(MpegEncContext),
4261 .init = ff_MPV_encode_init,
4262 .encode2 = ff_MPV_encode_picture,
4263 .close = ff_MPV_encode_end,
4264 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4265 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4266 .priv_class = &h263_class,
4269 static const AVOption h263p_options[] = {
4270 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4271 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4272 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4273 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4277 static const AVClass h263p_class = {
4278 .class_name = "H.263p encoder",
4279 .item_name = av_default_item_name,
4280 .option = h263p_options,
4281 .version = LIBAVUTIL_VERSION_INT,
4284 AVCodec ff_h263p_encoder = {
4286 .type = AVMEDIA_TYPE_VIDEO,
4287 .id = AV_CODEC_ID_H263P,
4288 .priv_data_size = sizeof(MpegEncContext),
4289 .init = ff_MPV_encode_init,
4290 .encode2 = ff_MPV_encode_picture,
4291 .close = ff_MPV_encode_end,
4292 .capabilities = CODEC_CAP_SLICE_THREADS,
4293 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4294 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4295 .priv_class = &h263p_class,
4298 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4300 AVCodec ff_msmpeg4v2_encoder = {
4301 .name = "msmpeg4v2",
4302 .type = AVMEDIA_TYPE_VIDEO,
4303 .id = AV_CODEC_ID_MSMPEG4V2,
4304 .priv_data_size = sizeof(MpegEncContext),
4305 .init = ff_MPV_encode_init,
4306 .encode2 = ff_MPV_encode_picture,
4307 .close = ff_MPV_encode_end,
4308 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4309 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4310 .priv_class = &msmpeg4v2_class,
4313 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4315 AVCodec ff_msmpeg4v3_encoder = {
4317 .type = AVMEDIA_TYPE_VIDEO,
4318 .id = AV_CODEC_ID_MSMPEG4V3,
4319 .priv_data_size = sizeof(MpegEncContext),
4320 .init = ff_MPV_encode_init,
4321 .encode2 = ff_MPV_encode_picture,
4322 .close = ff_MPV_encode_end,
4323 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4324 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4325 .priv_class = &msmpeg4v3_class,
4328 FF_MPV_GENERIC_CLASS(wmv1)
4330 AVCodec ff_wmv1_encoder = {
4332 .type = AVMEDIA_TYPE_VIDEO,
4333 .id = AV_CODEC_ID_WMV1,
4334 .priv_data_size = sizeof(MpegEncContext),
4335 .init = ff_MPV_encode_init,
4336 .encode2 = ff_MPV_encode_picture,
4337 .close = ff_MPV_encode_end,
4338 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4339 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4340 .priv_class = &wmv1_class,