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] * 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 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
408 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
412 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
413 av_log(avctx, AV_LOG_INFO,
414 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
417 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
418 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
422 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
423 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
427 if (avctx->rc_max_rate &&
428 avctx->rc_max_rate == avctx->bit_rate &&
429 avctx->rc_max_rate != avctx->rc_min_rate) {
430 av_log(avctx, AV_LOG_INFO,
431 "impossible bitrate constraints, this will fail\n");
434 if (avctx->rc_buffer_size &&
435 avctx->bit_rate * (int64_t)avctx->time_base.num >
436 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
437 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
441 if (!s->fixed_qscale &&
442 avctx->bit_rate * av_q2d(avctx->time_base) >
443 avctx->bit_rate_tolerance) {
444 av_log(avctx, AV_LOG_ERROR,
445 "bitrate tolerance too small for bitrate\n");
449 if (s->avctx->rc_max_rate &&
450 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
451 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
452 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
453 90000LL * (avctx->rc_buffer_size - 1) >
454 s->avctx->rc_max_rate * 0xFFFFLL) {
455 av_log(avctx, AV_LOG_INFO,
456 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
457 "specified vbv buffer is too large for the given bitrate!\n");
460 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
461 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
462 s->codec_id != AV_CODEC_ID_FLV1) {
463 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
467 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
468 av_log(avctx, AV_LOG_ERROR,
469 "OBMC is only supported with simple mb decision\n");
473 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
474 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
478 if (s->max_b_frames &&
479 s->codec_id != AV_CODEC_ID_MPEG4 &&
480 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
481 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
482 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
486 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
487 s->codec_id == AV_CODEC_ID_H263 ||
488 s->codec_id == AV_CODEC_ID_H263P) &&
489 (avctx->sample_aspect_ratio.num > 255 ||
490 avctx->sample_aspect_ratio.den > 255)) {
491 av_log(avctx, AV_LOG_WARNING,
492 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
493 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
494 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
495 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
498 if ((s->codec_id == AV_CODEC_ID_H263 ||
499 s->codec_id == AV_CODEC_ID_H263P) &&
500 (avctx->width > 2048 ||
501 avctx->height > 1152 )) {
502 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
505 if ((s->codec_id == AV_CODEC_ID_H263 ||
506 s->codec_id == AV_CODEC_ID_H263P) &&
507 ((avctx->width &3) ||
508 (avctx->height&3) )) {
509 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
513 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
514 (avctx->width > 4095 ||
515 avctx->height > 4095 )) {
516 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
520 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
521 (avctx->width > 16383 ||
522 avctx->height > 16383 )) {
523 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
527 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
528 s->codec_id == AV_CODEC_ID_WMV2) &&
530 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
534 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
535 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
536 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
540 // FIXME mpeg2 uses that too
541 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
542 av_log(avctx, AV_LOG_ERROR,
543 "mpeg2 style quantization not supported by codec\n");
547 #if FF_API_MPV_GLOBAL_OPTS
548 if (s->flags & CODEC_FLAG_CBP_RD)
549 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
552 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
553 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
557 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
558 s->avctx->mb_decision != FF_MB_DECISION_RD) {
559 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
563 if (s->avctx->scenechange_threshold < 1000000000 &&
564 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
565 av_log(avctx, AV_LOG_ERROR,
566 "closed gop with scene change detection are not supported yet, "
567 "set threshold to 1000000000\n");
571 if (s->flags & CODEC_FLAG_LOW_DELAY) {
572 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
573 av_log(avctx, AV_LOG_ERROR,
574 "low delay forcing is only available for mpeg2\n");
577 if (s->max_b_frames != 0) {
578 av_log(avctx, AV_LOG_ERROR,
579 "b frames cannot be used with low delay\n");
584 if (s->q_scale_type == 1) {
585 if (avctx->qmax > 12) {
586 av_log(avctx, AV_LOG_ERROR,
587 "non linear quant only supports qmax <= 12 currently\n");
592 if (s->avctx->thread_count > 1 &&
593 s->codec_id != AV_CODEC_ID_MPEG4 &&
594 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
595 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
596 s->codec_id != AV_CODEC_ID_MJPEG &&
597 (s->codec_id != AV_CODEC_ID_H263P)) {
598 av_log(avctx, AV_LOG_ERROR,
599 "multi threaded encoding not supported by codec\n");
603 if (s->avctx->thread_count < 1) {
604 av_log(avctx, AV_LOG_ERROR,
605 "automatic thread number detection not supported by codec, "
610 if (s->avctx->thread_count > 1)
613 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
614 s->h263_slice_structured = 1;
616 if (!avctx->time_base.den || !avctx->time_base.num) {
617 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
621 i = (INT_MAX / 2 + 128) >> 8;
622 if (avctx->me_threshold >= i) {
623 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
627 if (avctx->mb_threshold >= i) {
628 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
633 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
634 av_log(avctx, AV_LOG_INFO,
635 "notice: b_frame_strategy only affects the first pass\n");
636 avctx->b_frame_strategy = 0;
639 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
641 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
642 avctx->time_base.den /= i;
643 avctx->time_base.num /= i;
647 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) {
648 // (a + x * 3 / 8) / x
649 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
650 s->inter_quant_bias = 0;
652 s->intra_quant_bias = 0;
654 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
657 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
658 s->intra_quant_bias = avctx->intra_quant_bias;
659 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
660 s->inter_quant_bias = avctx->inter_quant_bias;
662 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
664 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
667 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
668 s->avctx->time_base.den > (1 << 16) - 1) {
669 av_log(avctx, AV_LOG_ERROR,
670 "timebase %d/%d not supported by MPEG 4 standard, "
671 "the maximum admitted value for the timebase denominator "
672 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
676 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
678 #if FF_API_MPV_GLOBAL_OPTS
679 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
680 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
681 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
682 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
683 if (avctx->quantizer_noise_shaping)
684 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
687 switch (avctx->codec->id) {
688 case AV_CODEC_ID_MPEG1VIDEO:
689 s->out_format = FMT_MPEG1;
690 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
691 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
693 case AV_CODEC_ID_MPEG2VIDEO:
694 s->out_format = FMT_MPEG1;
695 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
696 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
699 case AV_CODEC_ID_LJPEG:
700 case AV_CODEC_ID_MJPEG:
701 case AV_CODEC_ID_AMV:
702 s->out_format = FMT_MJPEG;
703 s->intra_only = 1; /* force intra only for jpeg */
704 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
705 (avctx->pix_fmt == AV_PIX_FMT_BGR0
706 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
707 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
708 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
709 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
710 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
712 s->mjpeg_vsample[0] = 2;
713 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
714 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
715 s->mjpeg_hsample[0] = 2;
716 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
717 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
719 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
720 ff_mjpeg_encode_init(s) < 0)
725 case AV_CODEC_ID_H261:
726 if (!CONFIG_H261_ENCODER)
728 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
729 av_log(avctx, AV_LOG_ERROR,
730 "The specified picture size of %dx%d is not valid for the "
731 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
732 s->width, s->height);
735 s->out_format = FMT_H261;
739 case AV_CODEC_ID_H263:
740 if (!CONFIG_H263_ENCODER)
742 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
743 s->width, s->height) == 8) {
744 av_log(avctx, AV_LOG_ERROR,
745 "The specified picture size of %dx%d is not valid for "
746 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
747 "352x288, 704x576, and 1408x1152. "
748 "Try H.263+.\n", s->width, s->height);
751 s->out_format = FMT_H263;
755 case AV_CODEC_ID_H263P:
756 s->out_format = FMT_H263;
759 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
760 s->modified_quant = s->h263_aic;
761 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
762 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
765 /* These are just to be sure */
769 case AV_CODEC_ID_FLV1:
770 s->out_format = FMT_H263;
771 s->h263_flv = 2; /* format = 1; 11-bit codes */
772 s->unrestricted_mv = 1;
773 s->rtp_mode = 0; /* don't allow GOB */
777 case AV_CODEC_ID_RV10:
778 s->out_format = FMT_H263;
782 case AV_CODEC_ID_RV20:
783 s->out_format = FMT_H263;
786 s->modified_quant = 1;
790 s->unrestricted_mv = 0;
792 case AV_CODEC_ID_MPEG4:
793 s->out_format = FMT_H263;
795 s->unrestricted_mv = 1;
796 s->low_delay = s->max_b_frames ? 0 : 1;
797 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
799 case AV_CODEC_ID_MSMPEG4V2:
800 s->out_format = FMT_H263;
802 s->unrestricted_mv = 1;
803 s->msmpeg4_version = 2;
807 case AV_CODEC_ID_MSMPEG4V3:
808 s->out_format = FMT_H263;
810 s->unrestricted_mv = 1;
811 s->msmpeg4_version = 3;
812 s->flipflop_rounding = 1;
816 case AV_CODEC_ID_WMV1:
817 s->out_format = FMT_H263;
819 s->unrestricted_mv = 1;
820 s->msmpeg4_version = 4;
821 s->flipflop_rounding = 1;
825 case AV_CODEC_ID_WMV2:
826 s->out_format = FMT_H263;
828 s->unrestricted_mv = 1;
829 s->msmpeg4_version = 5;
830 s->flipflop_rounding = 1;
838 avctx->has_b_frames = !s->low_delay;
842 s->progressive_frame =
843 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
844 CODEC_FLAG_INTERLACED_ME) ||
848 if (ff_MPV_common_init(s) < 0)
851 ff_dct_encode_init(s);
853 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
854 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
856 s->quant_precision = 5;
858 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
859 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
861 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
862 ff_h261_encode_init(s);
863 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
864 ff_h263_encode_init(s);
865 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
866 ff_msmpeg4_encode_init(s);
867 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
868 && s->out_format == FMT_MPEG1)
869 ff_mpeg1_encode_init(s);
872 for (i = 0; i < 64; i++) {
873 int j = s->dsp.idct_permutation[i];
874 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
876 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
877 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
878 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
880 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
883 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
884 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
886 if (s->avctx->intra_matrix)
887 s->intra_matrix[j] = s->avctx->intra_matrix[i];
888 if (s->avctx->inter_matrix)
889 s->inter_matrix[j] = s->avctx->inter_matrix[i];
892 /* precompute matrix */
893 /* for mjpeg, we do include qscale in the matrix */
894 if (s->out_format != FMT_MJPEG) {
895 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
896 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
898 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
899 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
903 if (ff_rate_control_init(s) < 0)
909 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
911 MpegEncContext *s = avctx->priv_data;
913 ff_rate_control_uninit(s);
915 ff_MPV_common_end(s);
916 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
917 s->out_format == FMT_MJPEG)
918 ff_mjpeg_encode_close(s);
920 av_freep(&avctx->extradata);
925 static int get_sae(uint8_t *src, int ref, int stride)
930 for (y = 0; y < 16; y++) {
931 for (x = 0; x < 16; x++) {
932 acc += FFABS(src[x + y * stride] - ref);
939 static int get_intra_count(MpegEncContext *s, uint8_t *src,
940 uint8_t *ref, int stride)
948 for (y = 0; y < h; y += 16) {
949 for (x = 0; x < w; x += 16) {
950 int offset = x + y * stride;
951 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
953 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
954 int sae = get_sae(src + offset, mean, stride);
956 acc += sae + 500 < sad;
963 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
968 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
969 (s->low_delay ? 0 : 1);
974 pic_arg->display_picture_number = s->input_picture_number++;
976 if (pts != AV_NOPTS_VALUE) {
977 if (s->user_specified_pts != AV_NOPTS_VALUE) {
979 int64_t last = s->user_specified_pts;
982 av_log(s->avctx, AV_LOG_ERROR,
983 "Error, Invalid timestamp=%"PRId64", "
984 "last=%"PRId64"\n", pts, s->user_specified_pts);
988 if (!s->low_delay && pic_arg->display_picture_number == 1)
989 s->dts_delta = time - last;
991 s->user_specified_pts = pts;
993 if (s->user_specified_pts != AV_NOPTS_VALUE) {
994 s->user_specified_pts =
995 pts = s->user_specified_pts + 1;
996 av_log(s->avctx, AV_LOG_INFO,
997 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1000 pts = pic_arg->display_picture_number;
1006 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
1008 if (pic_arg->linesize[0] != s->linesize)
1010 if (pic_arg->linesize[1] != s->uvlinesize)
1012 if (pic_arg->linesize[2] != s->uvlinesize)
1015 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
1016 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1019 i = ff_find_unused_picture(s, 1);
1023 pic = &s->picture[i].f;
1026 for (i = 0; i < 4; i++) {
1027 pic->data[i] = pic_arg->data[i];
1028 pic->linesize[i] = pic_arg->linesize[i];
1030 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1034 i = ff_find_unused_picture(s, 0);
1038 pic = &s->picture[i].f;
1041 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1045 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1046 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1047 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1050 int h_chroma_shift, v_chroma_shift;
1051 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1054 for (i = 0; i < 3; i++) {
1055 int src_stride = pic_arg->linesize[i];
1056 int dst_stride = i ? s->uvlinesize : s->linesize;
1057 int h_shift = i ? h_chroma_shift : 0;
1058 int v_shift = i ? v_chroma_shift : 0;
1059 int w = s->width >> h_shift;
1060 int h = s->height >> v_shift;
1061 uint8_t *src = pic_arg->data[i];
1062 uint8_t *dst = pic->data[i];
1064 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1065 h= ((s->height+15)/16*16)>>v_shift;
1068 if (!s->avctx->rc_buffer_size)
1069 dst += INPLACE_OFFSET;
1071 if (src_stride == dst_stride)
1072 memcpy(dst, src, src_stride * h);
1075 memcpy(dst, src, w);
1083 copy_picture_attributes(s, pic, pic_arg);
1084 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1087 /* shift buffer entries */
1088 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1089 s->input_picture[i - 1] = s->input_picture[i];
1091 s->input_picture[encoding_delay] = (Picture*) pic;
1096 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1100 int64_t score64 = 0;
1102 for (plane = 0; plane < 3; plane++) {
1103 const int stride = p->f.linesize[plane];
1104 const int bw = plane ? 1 : 2;
1105 for (y = 0; y < s->mb_height * bw; y++) {
1106 for (x = 0; x < s->mb_width * bw; x++) {
1107 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1108 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1109 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1110 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1112 switch (s->avctx->frame_skip_exp) {
1113 case 0: score = FFMAX(score, v); break;
1114 case 1: score += FFABS(v); break;
1115 case 2: score += v * v; break;
1116 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1117 case 4: score64 += v * v * (int64_t)(v * v); break;
1126 if (score64 < s->avctx->frame_skip_threshold)
1128 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1133 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1135 AVPacket pkt = { 0 };
1136 int ret, got_output;
1138 av_init_packet(&pkt);
1139 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1144 av_free_packet(&pkt);
1148 static int estimate_best_b_count(MpegEncContext *s)
1150 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1151 AVCodecContext *c = avcodec_alloc_context3(NULL);
1152 AVFrame input[FF_MAX_B_FRAMES + 2];
1153 const int scale = s->avctx->brd_scale;
1154 int i, j, out_size, p_lambda, b_lambda, lambda2;
1155 int64_t best_rd = INT64_MAX;
1156 int best_b_count = -1;
1158 av_assert0(scale >= 0 && scale <= 3);
1161 //s->next_picture_ptr->quality;
1162 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1163 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1164 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1165 if (!b_lambda) // FIXME we should do this somewhere else
1166 b_lambda = p_lambda;
1167 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1170 c->width = s->width >> scale;
1171 c->height = s->height >> scale;
1172 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1173 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1174 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1175 c->mb_decision = s->avctx->mb_decision;
1176 c->me_cmp = s->avctx->me_cmp;
1177 c->mb_cmp = s->avctx->mb_cmp;
1178 c->me_sub_cmp = s->avctx->me_sub_cmp;
1179 c->pix_fmt = AV_PIX_FMT_YUV420P;
1180 c->time_base = s->avctx->time_base;
1181 c->max_b_frames = s->max_b_frames;
1183 if (avcodec_open2(c, codec, NULL) < 0)
1186 for (i = 0; i < s->max_b_frames + 2; i++) {
1187 int ysize = c->width * c->height;
1188 int csize = (c->width / 2) * (c->height / 2);
1189 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1190 s->next_picture_ptr;
1192 avcodec_get_frame_defaults(&input[i]);
1193 input[i].data[0] = av_malloc(ysize + 2 * csize);
1194 input[i].data[1] = input[i].data[0] + ysize;
1195 input[i].data[2] = input[i].data[1] + csize;
1196 input[i].linesize[0] = c->width;
1197 input[i].linesize[1] =
1198 input[i].linesize[2] = c->width / 2;
1200 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1201 pre_input = *pre_input_ptr;
1203 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1204 pre_input.f.data[0] += INPLACE_OFFSET;
1205 pre_input.f.data[1] += INPLACE_OFFSET;
1206 pre_input.f.data[2] += INPLACE_OFFSET;
1209 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1210 pre_input.f.data[0], pre_input.f.linesize[0],
1211 c->width, c->height);
1212 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1213 pre_input.f.data[1], pre_input.f.linesize[1],
1214 c->width >> 1, c->height >> 1);
1215 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1216 pre_input.f.data[2], pre_input.f.linesize[2],
1217 c->width >> 1, c->height >> 1);
1221 for (j = 0; j < s->max_b_frames + 1; j++) {
1224 if (!s->input_picture[j])
1227 c->error[0] = c->error[1] = c->error[2] = 0;
1229 input[0].pict_type = AV_PICTURE_TYPE_I;
1230 input[0].quality = 1 * FF_QP2LAMBDA;
1232 out_size = encode_frame(c, &input[0]);
1234 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1236 for (i = 0; i < s->max_b_frames + 1; i++) {
1237 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1239 input[i + 1].pict_type = is_p ?
1240 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1241 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1243 out_size = encode_frame(c, &input[i + 1]);
1245 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1248 /* get the delayed frames */
1250 out_size = encode_frame(c, NULL);
1251 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1254 rd += c->error[0] + c->error[1] + c->error[2];
1265 for (i = 0; i < s->max_b_frames + 2; i++) {
1266 av_freep(&input[i].data[0]);
1269 return best_b_count;
1272 static int select_input_picture(MpegEncContext *s)
1276 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1277 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1278 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1280 /* set next picture type & ordering */
1281 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1282 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1283 s->next_picture_ptr == NULL || s->intra_only) {
1284 s->reordered_input_picture[0] = s->input_picture[0];
1285 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1286 s->reordered_input_picture[0]->f.coded_picture_number =
1287 s->coded_picture_number++;
1291 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1292 if (s->picture_in_gop_number < s->gop_size &&
1293 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1294 // FIXME check that te gop check above is +-1 correct
1295 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1296 for (i = 0; i < 4; i++)
1297 s->input_picture[0]->f.data[i] = NULL;
1298 s->input_picture[0]->f.type = 0;
1300 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1301 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1303 s->avctx->release_buffer(s->avctx,
1304 &s->input_picture[0]->f);
1308 ff_vbv_update(s, 0);
1314 if (s->flags & CODEC_FLAG_PASS2) {
1315 for (i = 0; i < s->max_b_frames + 1; i++) {
1316 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1318 if (pict_num >= s->rc_context.num_entries)
1320 if (!s->input_picture[i]) {
1321 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1325 s->input_picture[i]->f.pict_type =
1326 s->rc_context.entry[pict_num].new_pict_type;
1330 if (s->avctx->b_frame_strategy == 0) {
1331 b_frames = s->max_b_frames;
1332 while (b_frames && !s->input_picture[b_frames])
1334 } else if (s->avctx->b_frame_strategy == 1) {
1335 for (i = 1; i < s->max_b_frames + 1; i++) {
1336 if (s->input_picture[i] &&
1337 s->input_picture[i]->b_frame_score == 0) {
1338 s->input_picture[i]->b_frame_score =
1340 s->input_picture[i ]->f.data[0],
1341 s->input_picture[i - 1]->f.data[0],
1345 for (i = 0; i < s->max_b_frames + 1; i++) {
1346 if (s->input_picture[i] == NULL ||
1347 s->input_picture[i]->b_frame_score - 1 >
1348 s->mb_num / s->avctx->b_sensitivity)
1352 b_frames = FFMAX(0, i - 1);
1355 for (i = 0; i < b_frames + 1; i++) {
1356 s->input_picture[i]->b_frame_score = 0;
1358 } else if (s->avctx->b_frame_strategy == 2) {
1359 b_frames = estimate_best_b_count(s);
1361 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1367 for (i = b_frames - 1; i >= 0; i--) {
1368 int type = s->input_picture[i]->f.pict_type;
1369 if (type && type != AV_PICTURE_TYPE_B)
1372 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1373 b_frames == s->max_b_frames) {
1374 av_log(s->avctx, AV_LOG_ERROR,
1375 "warning, too many b frames in a row\n");
1378 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1379 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1380 s->gop_size > s->picture_in_gop_number) {
1381 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1383 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1385 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1389 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1390 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1393 s->reordered_input_picture[0] = s->input_picture[b_frames];
1394 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1395 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1396 s->reordered_input_picture[0]->f.coded_picture_number =
1397 s->coded_picture_number++;
1398 for (i = 0; i < b_frames; i++) {
1399 s->reordered_input_picture[i + 1] = s->input_picture[i];
1400 s->reordered_input_picture[i + 1]->f.pict_type =
1402 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1403 s->coded_picture_number++;
1408 if (s->reordered_input_picture[0]) {
1409 s->reordered_input_picture[0]->f.reference =
1410 s->reordered_input_picture[0]->f.pict_type !=
1411 AV_PICTURE_TYPE_B ? 3 : 0;
1413 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1415 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1416 s->avctx->rc_buffer_size) {
1417 // input is a shared pix, so we can't modifiy it -> alloc a new
1418 // one & ensure that the shared one is reuseable
1421 int i = ff_find_unused_picture(s, 0);
1424 pic = &s->picture[i];
1426 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1427 if (ff_alloc_picture(s, pic, 0) < 0) {
1431 /* mark us unused / free shared pic */
1432 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1433 s->avctx->release_buffer(s->avctx,
1434 &s->reordered_input_picture[0]->f);
1435 for (i = 0; i < 4; i++)
1436 s->reordered_input_picture[0]->f.data[i] = NULL;
1437 s->reordered_input_picture[0]->f.type = 0;
1439 copy_picture_attributes(s, &pic->f,
1440 &s->reordered_input_picture[0]->f);
1442 s->current_picture_ptr = pic;
1444 // input is not a shared pix -> reuse buffer for current_pix
1446 assert(s->reordered_input_picture[0]->f.type ==
1447 FF_BUFFER_TYPE_USER ||
1448 s->reordered_input_picture[0]->f.type ==
1449 FF_BUFFER_TYPE_INTERNAL);
1451 s->current_picture_ptr = s->reordered_input_picture[0];
1452 for (i = 0; i < 4; i++) {
1453 s->new_picture.f.data[i] += INPLACE_OFFSET;
1456 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1458 s->picture_number = s->new_picture.f.display_picture_number;
1460 memset(&s->new_picture, 0, sizeof(Picture));
1465 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1466 AVFrame *pic_arg, int *got_packet)
1468 MpegEncContext *s = avctx->priv_data;
1469 int i, stuffing_count, ret;
1470 int context_count = s->slice_context_count;
1472 s->picture_in_gop_number++;
1474 if (load_input_picture(s, pic_arg) < 0)
1477 if (select_input_picture(s) < 0) {
1482 if (s->new_picture.f.data[0]) {
1483 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1486 s->mb_info_ptr = av_packet_new_side_data(pkt,
1487 AV_PKT_DATA_H263_MB_INFO,
1488 s->mb_width*s->mb_height*12);
1489 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1492 for (i = 0; i < context_count; i++) {
1493 int start_y = s->thread_context[i]->start_mb_y;
1494 int end_y = s->thread_context[i]-> end_mb_y;
1495 int h = s->mb_height;
1496 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1497 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1499 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1502 s->pict_type = s->new_picture.f.pict_type;
1504 ff_MPV_frame_start(s, avctx);
1506 if (encode_picture(s, s->picture_number) < 0)
1509 avctx->header_bits = s->header_bits;
1510 avctx->mv_bits = s->mv_bits;
1511 avctx->misc_bits = s->misc_bits;
1512 avctx->i_tex_bits = s->i_tex_bits;
1513 avctx->p_tex_bits = s->p_tex_bits;
1514 avctx->i_count = s->i_count;
1515 // FIXME f/b_count in avctx
1516 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1517 avctx->skip_count = s->skip_count;
1519 ff_MPV_frame_end(s);
1521 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1522 ff_mjpeg_encode_picture_trailer(s);
1524 if (avctx->rc_buffer_size) {
1525 RateControlContext *rcc = &s->rc_context;
1526 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1528 if (put_bits_count(&s->pb) > max_size &&
1529 s->lambda < s->avctx->lmax) {
1530 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1531 (s->qscale + 1) / s->qscale);
1532 if (s->adaptive_quant) {
1534 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1535 s->lambda_table[i] =
1536 FFMAX(s->lambda_table[i] + 1,
1537 s->lambda_table[i] * (s->qscale + 1) /
1540 s->mb_skipped = 0; // done in MPV_frame_start()
1541 // done in encode_picture() so we must undo it
1542 if (s->pict_type == AV_PICTURE_TYPE_P) {
1543 if (s->flipflop_rounding ||
1544 s->codec_id == AV_CODEC_ID_H263P ||
1545 s->codec_id == AV_CODEC_ID_MPEG4)
1546 s->no_rounding ^= 1;
1548 if (s->pict_type != AV_PICTURE_TYPE_B) {
1549 s->time_base = s->last_time_base;
1550 s->last_non_b_time = s->time - s->pp_time;
1552 for (i = 0; i < context_count; i++) {
1553 PutBitContext *pb = &s->thread_context[i]->pb;
1554 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1559 assert(s->avctx->rc_max_rate);
1562 if (s->flags & CODEC_FLAG_PASS1)
1563 ff_write_pass1_stats(s);
1565 for (i = 0; i < 4; i++) {
1566 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1567 avctx->error[i] += s->current_picture_ptr->f.error[i];
1570 if (s->flags & CODEC_FLAG_PASS1)
1571 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1572 avctx->i_tex_bits + avctx->p_tex_bits ==
1573 put_bits_count(&s->pb));
1574 flush_put_bits(&s->pb);
1575 s->frame_bits = put_bits_count(&s->pb);
1577 stuffing_count = ff_vbv_update(s, s->frame_bits);
1578 s->stuffing_bits = 8*stuffing_count;
1579 if (stuffing_count) {
1580 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1581 stuffing_count + 50) {
1582 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1586 switch (s->codec_id) {
1587 case AV_CODEC_ID_MPEG1VIDEO:
1588 case AV_CODEC_ID_MPEG2VIDEO:
1589 while (stuffing_count--) {
1590 put_bits(&s->pb, 8, 0);
1593 case AV_CODEC_ID_MPEG4:
1594 put_bits(&s->pb, 16, 0);
1595 put_bits(&s->pb, 16, 0x1C3);
1596 stuffing_count -= 4;
1597 while (stuffing_count--) {
1598 put_bits(&s->pb, 8, 0xFF);
1602 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1604 flush_put_bits(&s->pb);
1605 s->frame_bits = put_bits_count(&s->pb);
1608 /* update mpeg1/2 vbv_delay for CBR */
1609 if (s->avctx->rc_max_rate &&
1610 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1611 s->out_format == FMT_MPEG1 &&
1612 90000LL * (avctx->rc_buffer_size - 1) <=
1613 s->avctx->rc_max_rate * 0xFFFFLL) {
1614 int vbv_delay, min_delay;
1615 double inbits = s->avctx->rc_max_rate *
1616 av_q2d(s->avctx->time_base);
1617 int minbits = s->frame_bits - 8 *
1618 (s->vbv_delay_ptr - s->pb.buf - 1);
1619 double bits = s->rc_context.buffer_index + minbits - inbits;
1622 av_log(s->avctx, AV_LOG_ERROR,
1623 "Internal error, negative bits\n");
1625 assert(s->repeat_first_field == 0);
1627 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1628 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1629 s->avctx->rc_max_rate;
1631 vbv_delay = FFMAX(vbv_delay, min_delay);
1633 av_assert0(vbv_delay < 0xFFFF);
1635 s->vbv_delay_ptr[0] &= 0xF8;
1636 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1637 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1638 s->vbv_delay_ptr[2] &= 0x07;
1639 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1640 avctx->vbv_delay = vbv_delay * 300;
1642 s->total_bits += s->frame_bits;
1643 avctx->frame_bits = s->frame_bits;
1645 pkt->pts = s->current_picture.f.pts;
1646 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1647 if (!s->current_picture.f.coded_picture_number)
1648 pkt->dts = pkt->pts - s->dts_delta;
1650 pkt->dts = s->reordered_pts;
1651 s->reordered_pts = pkt->pts;
1653 pkt->dts = pkt->pts;
1654 if (s->current_picture.f.key_frame)
1655 pkt->flags |= AV_PKT_FLAG_KEY;
1657 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1661 assert((s->frame_bits & 7) == 0);
1663 pkt->size = s->frame_bits / 8;
1664 *got_packet = !!pkt->size;
1668 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1669 int n, int threshold)
1671 static const char tab[64] = {
1672 3, 2, 2, 1, 1, 1, 1, 1,
1673 1, 1, 1, 1, 1, 1, 1, 1,
1674 1, 1, 1, 1, 1, 1, 1, 1,
1675 0, 0, 0, 0, 0, 0, 0, 0,
1676 0, 0, 0, 0, 0, 0, 0, 0,
1677 0, 0, 0, 0, 0, 0, 0, 0,
1678 0, 0, 0, 0, 0, 0, 0, 0,
1679 0, 0, 0, 0, 0, 0, 0, 0
1684 DCTELEM *block = s->block[n];
1685 const int last_index = s->block_last_index[n];
1688 if (threshold < 0) {
1690 threshold = -threshold;
1694 /* Are all we could set to zero already zero? */
1695 if (last_index <= skip_dc - 1)
1698 for (i = 0; i <= last_index; i++) {
1699 const int j = s->intra_scantable.permutated[i];
1700 const int level = FFABS(block[j]);
1702 if (skip_dc && i == 0)
1706 } else if (level > 1) {
1712 if (score >= threshold)
1714 for (i = skip_dc; i <= last_index; i++) {
1715 const int j = s->intra_scantable.permutated[i];
1719 s->block_last_index[n] = 0;
1721 s->block_last_index[n] = -1;
1724 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1728 const int maxlevel = s->max_qcoeff;
1729 const int minlevel = s->min_qcoeff;
1733 i = 1; // skip clipping of intra dc
1737 for (; i <= last_index; i++) {
1738 const int j = s->intra_scantable.permutated[i];
1739 int level = block[j];
1741 if (level > maxlevel) {
1744 } else if (level < minlevel) {
1752 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1753 av_log(s->avctx, AV_LOG_INFO,
1754 "warning, clipping %d dct coefficients to %d..%d\n",
1755 overflow, minlevel, maxlevel);
1758 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1762 for (y = 0; y < 8; y++) {
1763 for (x = 0; x < 8; x++) {
1769 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1770 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1771 int v = ptr[x2 + y2 * stride];
1777 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1782 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1783 int motion_x, int motion_y,
1784 int mb_block_height,
1787 int16_t weight[8][64];
1788 DCTELEM orig[8][64];
1789 const int mb_x = s->mb_x;
1790 const int mb_y = s->mb_y;
1793 int dct_offset = s->linesize * 8; // default for progressive frames
1794 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1797 for (i = 0; i < mb_block_count; i++)
1798 skip_dct[i] = s->skipdct;
1800 if (s->adaptive_quant) {
1801 const int last_qp = s->qscale;
1802 const int mb_xy = mb_x + mb_y * s->mb_stride;
1804 s->lambda = s->lambda_table[mb_xy];
1807 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1808 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1809 s->dquant = s->qscale - last_qp;
1811 if (s->out_format == FMT_H263) {
1812 s->dquant = av_clip(s->dquant, -2, 2);
1814 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1816 if (s->pict_type == AV_PICTURE_TYPE_B) {
1817 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1820 if (s->mv_type == MV_TYPE_8X8)
1826 ff_set_qscale(s, last_qp + s->dquant);
1827 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1828 ff_set_qscale(s, s->qscale + s->dquant);
1830 wrap_y = s->linesize;
1831 wrap_c = s->uvlinesize;
1832 ptr_y = s->new_picture.f.data[0] +
1833 (mb_y * 16 * wrap_y) + mb_x * 16;
1834 ptr_cb = s->new_picture.f.data[1] +
1835 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1836 ptr_cr = s->new_picture.f.data[2] +
1837 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1839 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1840 uint8_t *ebuf = s->edge_emu_buffer + 32;
1841 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1842 mb_y * 16, s->width, s->height);
1844 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1845 mb_block_height, mb_x * 8, mb_y * 8,
1846 (s->width+1) >> 1, (s->height+1) >> 1);
1847 ptr_cb = ebuf + 18 * wrap_y;
1848 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1849 mb_block_height, mb_x * 8, mb_y * 8,
1850 (s->width+1) >> 1, (s->height+1) >> 1);
1851 ptr_cr = ebuf + 18 * wrap_y + 8;
1855 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1856 int progressive_score, interlaced_score;
1858 s->interlaced_dct = 0;
1859 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1861 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1862 NULL, wrap_y, 8) - 400;
1864 if (progressive_score > 0) {
1865 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1866 NULL, wrap_y * 2, 8) +
1867 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1868 NULL, wrap_y * 2, 8);
1869 if (progressive_score > interlaced_score) {
1870 s->interlaced_dct = 1;
1872 dct_offset = wrap_y;
1874 if (s->chroma_format == CHROMA_422)
1880 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1881 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1882 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1883 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1885 if (s->flags & CODEC_FLAG_GRAY) {
1889 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1890 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1891 if (!s->chroma_y_shift) { /* 422 */
1892 s->dsp.get_pixels(s->block[6],
1893 ptr_cb + (dct_offset >> 1), wrap_c);
1894 s->dsp.get_pixels(s->block[7],
1895 ptr_cr + (dct_offset >> 1), wrap_c);
1899 op_pixels_func (*op_pix)[4];
1900 qpel_mc_func (*op_qpix)[16];
1901 uint8_t *dest_y, *dest_cb, *dest_cr;
1903 dest_y = s->dest[0];
1904 dest_cb = s->dest[1];
1905 dest_cr = s->dest[2];
1907 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1908 op_pix = s->dsp.put_pixels_tab;
1909 op_qpix = s->dsp.put_qpel_pixels_tab;
1911 op_pix = s->dsp.put_no_rnd_pixels_tab;
1912 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1915 if (s->mv_dir & MV_DIR_FORWARD) {
1916 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1917 s->last_picture.f.data,
1919 op_pix = s->dsp.avg_pixels_tab;
1920 op_qpix = s->dsp.avg_qpel_pixels_tab;
1922 if (s->mv_dir & MV_DIR_BACKWARD) {
1923 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1924 s->next_picture.f.data,
1928 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1929 int progressive_score, interlaced_score;
1931 s->interlaced_dct = 0;
1932 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1935 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1936 ptr_y + wrap_y * 8, wrap_y,
1939 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1940 progressive_score -= 400;
1942 if (progressive_score > 0) {
1943 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1946 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1950 if (progressive_score > interlaced_score) {
1951 s->interlaced_dct = 1;
1953 dct_offset = wrap_y;
1955 if (s->chroma_format == CHROMA_422)
1961 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1962 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1963 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1964 dest_y + dct_offset, wrap_y);
1965 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1966 dest_y + dct_offset + 8, wrap_y);
1968 if (s->flags & CODEC_FLAG_GRAY) {
1972 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1973 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1974 if (!s->chroma_y_shift) { /* 422 */
1975 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1976 dest_cb + (dct_offset >> 1), wrap_c);
1977 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1978 dest_cr + (dct_offset >> 1), wrap_c);
1981 /* pre quantization */
1982 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1983 2 * s->qscale * s->qscale) {
1985 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1986 wrap_y, 8) < 20 * s->qscale)
1988 if (s->dsp.sad[1](NULL, ptr_y + 8,
1989 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1991 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1992 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1994 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1995 dest_y + dct_offset + 8,
1996 wrap_y, 8) < 20 * s->qscale)
1998 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1999 wrap_c, 8) < 20 * s->qscale)
2001 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2002 wrap_c, 8) < 20 * s->qscale)
2004 if (!s->chroma_y_shift) { /* 422 */
2005 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2006 dest_cb + (dct_offset >> 1),
2007 wrap_c, 8) < 20 * s->qscale)
2009 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2010 dest_cr + (dct_offset >> 1),
2011 wrap_c, 8) < 20 * s->qscale)
2017 if (s->quantizer_noise_shaping) {
2019 get_visual_weight(weight[0], ptr_y , wrap_y);
2021 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2023 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2025 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2027 get_visual_weight(weight[4], ptr_cb , wrap_c);
2029 get_visual_weight(weight[5], ptr_cr , wrap_c);
2030 if (!s->chroma_y_shift) { /* 422 */
2032 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2035 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2038 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2041 /* DCT & quantize */
2042 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2044 for (i = 0; i < mb_block_count; i++) {
2047 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2048 // FIXME we could decide to change to quantizer instead of
2050 // JS: I don't think that would be a good idea it could lower
2051 // quality instead of improve it. Just INTRADC clipping
2052 // deserves changes in quantizer
2054 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2056 s->block_last_index[i] = -1;
2058 if (s->quantizer_noise_shaping) {
2059 for (i = 0; i < mb_block_count; i++) {
2061 s->block_last_index[i] =
2062 dct_quantize_refine(s, s->block[i], weight[i],
2063 orig[i], i, s->qscale);
2068 if (s->luma_elim_threshold && !s->mb_intra)
2069 for (i = 0; i < 4; i++)
2070 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2071 if (s->chroma_elim_threshold && !s->mb_intra)
2072 for (i = 4; i < mb_block_count; i++)
2073 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2075 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2076 for (i = 0; i < mb_block_count; i++) {
2077 if (s->block_last_index[i] == -1)
2078 s->coded_score[i] = INT_MAX / 256;
2083 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2084 s->block_last_index[4] =
2085 s->block_last_index[5] = 0;
2087 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2090 // non c quantize code returns incorrect block_last_index FIXME
2091 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2092 for (i = 0; i < mb_block_count; i++) {
2094 if (s->block_last_index[i] > 0) {
2095 for (j = 63; j > 0; j--) {
2096 if (s->block[i][s->intra_scantable.permutated[j]])
2099 s->block_last_index[i] = j;
2104 /* huffman encode */
2105 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2106 case AV_CODEC_ID_MPEG1VIDEO:
2107 case AV_CODEC_ID_MPEG2VIDEO:
2108 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2109 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2111 case AV_CODEC_ID_MPEG4:
2112 if (CONFIG_MPEG4_ENCODER)
2113 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2115 case AV_CODEC_ID_MSMPEG4V2:
2116 case AV_CODEC_ID_MSMPEG4V3:
2117 case AV_CODEC_ID_WMV1:
2118 if (CONFIG_MSMPEG4_ENCODER)
2119 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2121 case AV_CODEC_ID_WMV2:
2122 if (CONFIG_WMV2_ENCODER)
2123 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2125 case AV_CODEC_ID_H261:
2126 if (CONFIG_H261_ENCODER)
2127 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2129 case AV_CODEC_ID_H263:
2130 case AV_CODEC_ID_H263P:
2131 case AV_CODEC_ID_FLV1:
2132 case AV_CODEC_ID_RV10:
2133 case AV_CODEC_ID_RV20:
2134 if (CONFIG_H263_ENCODER)
2135 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2137 case AV_CODEC_ID_MJPEG:
2138 case AV_CODEC_ID_AMV:
2139 if (CONFIG_MJPEG_ENCODER)
2140 ff_mjpeg_encode_mb(s, s->block);
2147 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2149 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2150 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2153 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2156 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2159 d->mb_skip_run= s->mb_skip_run;
2161 d->last_dc[i] = s->last_dc[i];
2164 d->mv_bits= s->mv_bits;
2165 d->i_tex_bits= s->i_tex_bits;
2166 d->p_tex_bits= s->p_tex_bits;
2167 d->i_count= s->i_count;
2168 d->f_count= s->f_count;
2169 d->b_count= s->b_count;
2170 d->skip_count= s->skip_count;
2171 d->misc_bits= s->misc_bits;
2175 d->qscale= s->qscale;
2176 d->dquant= s->dquant;
2178 d->esc3_level_length= s->esc3_level_length;
2181 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2184 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2185 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2188 d->mb_skip_run= s->mb_skip_run;
2190 d->last_dc[i] = s->last_dc[i];
2193 d->mv_bits= s->mv_bits;
2194 d->i_tex_bits= s->i_tex_bits;
2195 d->p_tex_bits= s->p_tex_bits;
2196 d->i_count= s->i_count;
2197 d->f_count= s->f_count;
2198 d->b_count= s->b_count;
2199 d->skip_count= s->skip_count;
2200 d->misc_bits= s->misc_bits;
2202 d->mb_intra= s->mb_intra;
2203 d->mb_skipped= s->mb_skipped;
2204 d->mv_type= s->mv_type;
2205 d->mv_dir= s->mv_dir;
2207 if(s->data_partitioning){
2209 d->tex_pb= s->tex_pb;
2213 d->block_last_index[i]= s->block_last_index[i];
2214 d->interlaced_dct= s->interlaced_dct;
2215 d->qscale= s->qscale;
2217 d->esc3_level_length= s->esc3_level_length;
2220 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2221 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2222 int *dmin, int *next_block, int motion_x, int motion_y)
2225 uint8_t *dest_backup[3];
2227 copy_context_before_encode(s, backup, type);
2229 s->block= s->blocks[*next_block];
2230 s->pb= pb[*next_block];
2231 if(s->data_partitioning){
2232 s->pb2 = pb2 [*next_block];
2233 s->tex_pb= tex_pb[*next_block];
2237 memcpy(dest_backup, s->dest, sizeof(s->dest));
2238 s->dest[0] = s->rd_scratchpad;
2239 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2240 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2241 assert(s->linesize >= 32); //FIXME
2244 encode_mb(s, motion_x, motion_y);
2246 score= put_bits_count(&s->pb);
2247 if(s->data_partitioning){
2248 score+= put_bits_count(&s->pb2);
2249 score+= put_bits_count(&s->tex_pb);
2252 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2253 ff_MPV_decode_mb(s, s->block);
2255 score *= s->lambda2;
2256 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2260 memcpy(s->dest, dest_backup, sizeof(s->dest));
2267 copy_context_after_encode(best, s, type);
2271 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2272 uint32_t *sq = ff_squareTbl + 256;
2277 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2278 else if(w==8 && h==8)
2279 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2283 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2292 static int sse_mb(MpegEncContext *s){
2296 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2297 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2300 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2301 return s->dsp.nsse[0](s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
2302 +s->dsp.nsse[1](s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
2303 +s->dsp.nsse[1](s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2305 return s->dsp.sse[0](NULL, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
2306 +s->dsp.sse[1](NULL, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
2307 +s->dsp.sse[1](NULL, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2310 return sse(s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
2311 +sse(s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
2312 +sse(s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
2315 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2316 MpegEncContext *s= *(void**)arg;
2320 s->me.dia_size= s->avctx->pre_dia_size;
2321 s->first_slice_line=1;
2322 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2323 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2324 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2326 s->first_slice_line=0;
2334 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2335 MpegEncContext *s= *(void**)arg;
2337 ff_check_alignment();
2339 s->me.dia_size= s->avctx->dia_size;
2340 s->first_slice_line=1;
2341 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2342 s->mb_x=0; //for block init below
2343 ff_init_block_index(s);
2344 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2345 s->block_index[0]+=2;
2346 s->block_index[1]+=2;
2347 s->block_index[2]+=2;
2348 s->block_index[3]+=2;
2350 /* compute motion vector & mb_type and store in context */
2351 if(s->pict_type==AV_PICTURE_TYPE_B)
2352 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2354 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2356 s->first_slice_line=0;
2361 static int mb_var_thread(AVCodecContext *c, void *arg){
2362 MpegEncContext *s= *(void**)arg;
2365 ff_check_alignment();
2367 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2368 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2371 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2373 int sum = s->dsp.pix_sum(pix, s->linesize);
2375 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2377 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2378 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2379 s->me.mb_var_sum_temp += varc;
2385 static void write_slice_end(MpegEncContext *s){
2386 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2387 if(s->partitioned_frame){
2388 ff_mpeg4_merge_partitions(s);
2391 ff_mpeg4_stuffing(&s->pb);
2392 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2393 ff_mjpeg_encode_stuffing(s);
2396 avpriv_align_put_bits(&s->pb);
2397 flush_put_bits(&s->pb);
2399 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2400 s->misc_bits+= get_bits_diff(s);
2403 static void write_mb_info(MpegEncContext *s)
2405 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2406 int offset = put_bits_count(&s->pb);
2407 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2408 int gobn = s->mb_y / s->gob_index;
2410 if (CONFIG_H263_ENCODER)
2411 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2412 bytestream_put_le32(&ptr, offset);
2413 bytestream_put_byte(&ptr, s->qscale);
2414 bytestream_put_byte(&ptr, gobn);
2415 bytestream_put_le16(&ptr, mba);
2416 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2417 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2418 /* 4MV not implemented */
2419 bytestream_put_byte(&ptr, 0); /* hmv2 */
2420 bytestream_put_byte(&ptr, 0); /* vmv2 */
2423 static void update_mb_info(MpegEncContext *s, int startcode)
2427 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2428 s->mb_info_size += 12;
2429 s->prev_mb_info = s->last_mb_info;
2432 s->prev_mb_info = put_bits_count(&s->pb)/8;
2433 /* This might have incremented mb_info_size above, and we return without
2434 * actually writing any info into that slot yet. But in that case,
2435 * this will be called again at the start of the after writing the
2436 * start code, actually writing the mb info. */
2440 s->last_mb_info = put_bits_count(&s->pb)/8;
2441 if (!s->mb_info_size)
2442 s->mb_info_size += 12;
2446 static int encode_thread(AVCodecContext *c, void *arg){
2447 MpegEncContext *s= *(void**)arg;
2448 int mb_x, mb_y, pdif = 0;
2449 int chr_h= 16>>s->chroma_y_shift;
2451 MpegEncContext best_s, backup_s;
2452 uint8_t bit_buf[2][MAX_MB_BYTES];
2453 uint8_t bit_buf2[2][MAX_MB_BYTES];
2454 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2455 PutBitContext pb[2], pb2[2], tex_pb[2];
2457 ff_check_alignment();
2460 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2461 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2462 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2465 s->last_bits= put_bits_count(&s->pb);
2476 /* init last dc values */
2477 /* note: quant matrix value (8) is implied here */
2478 s->last_dc[i] = 128 << s->intra_dc_precision;
2480 s->current_picture.f.error[i] = 0;
2482 if(s->codec_id==AV_CODEC_ID_AMV){
2483 s->last_dc[0] = 128*8/13;
2484 s->last_dc[1] = 128*8/14;
2485 s->last_dc[2] = 128*8/14;
2488 memset(s->last_mv, 0, sizeof(s->last_mv));
2492 switch(s->codec_id){
2493 case AV_CODEC_ID_H263:
2494 case AV_CODEC_ID_H263P:
2495 case AV_CODEC_ID_FLV1:
2496 if (CONFIG_H263_ENCODER)
2497 s->gob_index = ff_h263_get_gob_height(s);
2499 case AV_CODEC_ID_MPEG4:
2500 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2501 ff_mpeg4_init_partitions(s);
2507 s->first_slice_line = 1;
2508 s->ptr_lastgob = s->pb.buf;
2509 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2513 ff_set_qscale(s, s->qscale);
2514 ff_init_block_index(s);
2516 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2517 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2518 int mb_type= s->mb_type[xy];
2523 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2524 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2527 if(s->data_partitioning){
2528 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2529 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2530 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2536 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2537 ff_update_block_index(s);
2539 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2540 ff_h261_reorder_mb_index(s);
2541 xy= s->mb_y*s->mb_stride + s->mb_x;
2542 mb_type= s->mb_type[xy];
2545 /* write gob / video packet header */
2547 int current_packet_size, is_gob_start;
2549 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2551 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2553 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2555 switch(s->codec_id){
2556 case AV_CODEC_ID_H263:
2557 case AV_CODEC_ID_H263P:
2558 if(!s->h263_slice_structured)
2559 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2561 case AV_CODEC_ID_MPEG2VIDEO:
2562 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2563 case AV_CODEC_ID_MPEG1VIDEO:
2564 if(s->mb_skip_run) is_gob_start=0;
2566 case AV_CODEC_ID_MJPEG:
2567 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2572 if(s->start_mb_y != mb_y || mb_x!=0){
2574 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2575 ff_mpeg4_init_partitions(s);
2579 av_assert2((put_bits_count(&s->pb)&7) == 0);
2580 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2582 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2583 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2584 int d= 100 / s->avctx->error_rate;
2586 current_packet_size=0;
2587 s->pb.buf_ptr= s->ptr_lastgob;
2588 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2592 if (s->avctx->rtp_callback){
2593 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2594 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2596 update_mb_info(s, 1);
2598 switch(s->codec_id){
2599 case AV_CODEC_ID_MPEG4:
2600 if (CONFIG_MPEG4_ENCODER) {
2601 ff_mpeg4_encode_video_packet_header(s);
2602 ff_mpeg4_clean_buffers(s);
2605 case AV_CODEC_ID_MPEG1VIDEO:
2606 case AV_CODEC_ID_MPEG2VIDEO:
2607 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2608 ff_mpeg1_encode_slice_header(s);
2609 ff_mpeg1_clean_buffers(s);
2612 case AV_CODEC_ID_H263:
2613 case AV_CODEC_ID_H263P:
2614 if (CONFIG_H263_ENCODER)
2615 ff_h263_encode_gob_header(s, mb_y);
2619 if(s->flags&CODEC_FLAG_PASS1){
2620 int bits= put_bits_count(&s->pb);
2621 s->misc_bits+= bits - s->last_bits;
2625 s->ptr_lastgob += current_packet_size;
2626 s->first_slice_line=1;
2627 s->resync_mb_x=mb_x;
2628 s->resync_mb_y=mb_y;
2632 if( (s->resync_mb_x == s->mb_x)
2633 && s->resync_mb_y+1 == s->mb_y){
2634 s->first_slice_line=0;
2638 s->dquant=0; //only for QP_RD
2640 update_mb_info(s, 0);
2642 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
2644 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2646 copy_context_before_encode(&backup_s, s, -1);
2648 best_s.data_partitioning= s->data_partitioning;
2649 best_s.partitioned_frame= s->partitioned_frame;
2650 if(s->data_partitioning){
2651 backup_s.pb2= s->pb2;
2652 backup_s.tex_pb= s->tex_pb;
2655 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2656 s->mv_dir = MV_DIR_FORWARD;
2657 s->mv_type = MV_TYPE_16X16;
2659 s->mv[0][0][0] = s->p_mv_table[xy][0];
2660 s->mv[0][0][1] = s->p_mv_table[xy][1];
2661 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2662 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2664 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2665 s->mv_dir = MV_DIR_FORWARD;
2666 s->mv_type = MV_TYPE_FIELD;
2669 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2670 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2671 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2673 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2674 &dmin, &next_block, 0, 0);
2676 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2677 s->mv_dir = MV_DIR_FORWARD;
2678 s->mv_type = MV_TYPE_16X16;
2682 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2683 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2685 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2686 s->mv_dir = MV_DIR_FORWARD;
2687 s->mv_type = MV_TYPE_8X8;
2690 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2691 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2693 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2694 &dmin, &next_block, 0, 0);
2696 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2697 s->mv_dir = MV_DIR_FORWARD;
2698 s->mv_type = MV_TYPE_16X16;
2700 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2701 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2702 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2703 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2705 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2706 s->mv_dir = MV_DIR_BACKWARD;
2707 s->mv_type = MV_TYPE_16X16;
2709 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2710 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2711 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2712 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2714 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2715 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2716 s->mv_type = MV_TYPE_16X16;
2718 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2719 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2720 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2721 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2722 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2723 &dmin, &next_block, 0, 0);
2725 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2726 s->mv_dir = MV_DIR_FORWARD;
2727 s->mv_type = MV_TYPE_FIELD;
2730 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2731 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2732 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2734 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2735 &dmin, &next_block, 0, 0);
2737 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2738 s->mv_dir = MV_DIR_BACKWARD;
2739 s->mv_type = MV_TYPE_FIELD;
2742 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2743 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2744 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2746 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2747 &dmin, &next_block, 0, 0);
2749 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2750 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2751 s->mv_type = MV_TYPE_FIELD;
2753 for(dir=0; dir<2; dir++){
2755 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2756 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2757 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2760 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2761 &dmin, &next_block, 0, 0);
2763 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2765 s->mv_type = MV_TYPE_16X16;
2769 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2770 &dmin, &next_block, 0, 0);
2771 if(s->h263_pred || s->h263_aic){
2773 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2775 ff_clean_intra_table_entries(s); //old mode?
2779 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2780 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2781 const int last_qp= backup_s.qscale;
2784 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2785 static const int dquant_tab[4]={-1,1,-2,2};
2787 av_assert2(backup_s.dquant == 0);
2790 s->mv_dir= best_s.mv_dir;
2791 s->mv_type = MV_TYPE_16X16;
2792 s->mb_intra= best_s.mb_intra;
2793 s->mv[0][0][0] = best_s.mv[0][0][0];
2794 s->mv[0][0][1] = best_s.mv[0][0][1];
2795 s->mv[1][0][0] = best_s.mv[1][0][0];
2796 s->mv[1][0][1] = best_s.mv[1][0][1];
2798 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2799 for(; qpi<4; qpi++){
2800 int dquant= dquant_tab[qpi];
2801 qp= last_qp + dquant;
2802 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2804 backup_s.dquant= dquant;
2805 if(s->mb_intra && s->dc_val[0]){
2807 dc[i]= s->dc_val[0][ s->block_index[i] ];
2808 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2812 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2813 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2814 if(best_s.qscale != qp){
2815 if(s->mb_intra && s->dc_val[0]){
2817 s->dc_val[0][ s->block_index[i] ]= dc[i];
2818 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2825 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2826 int mx= s->b_direct_mv_table[xy][0];
2827 int my= s->b_direct_mv_table[xy][1];
2829 backup_s.dquant = 0;
2830 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2832 ff_mpeg4_set_direct_mv(s, mx, my);
2833 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2834 &dmin, &next_block, mx, my);
2836 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2837 backup_s.dquant = 0;
2838 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2840 ff_mpeg4_set_direct_mv(s, 0, 0);
2841 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2842 &dmin, &next_block, 0, 0);
2844 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2847 coded |= s->block_last_index[i];
2850 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2851 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2852 mx=my=0; //FIXME find the one we actually used
2853 ff_mpeg4_set_direct_mv(s, mx, my);
2854 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2862 s->mv_dir= best_s.mv_dir;
2863 s->mv_type = best_s.mv_type;
2865 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2866 s->mv[0][0][1] = best_s.mv[0][0][1];
2867 s->mv[1][0][0] = best_s.mv[1][0][0];
2868 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2871 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2872 &dmin, &next_block, mx, my);
2877 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2879 copy_context_after_encode(s, &best_s, -1);
2881 pb_bits_count= put_bits_count(&s->pb);
2882 flush_put_bits(&s->pb);
2883 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2886 if(s->data_partitioning){
2887 pb2_bits_count= put_bits_count(&s->pb2);
2888 flush_put_bits(&s->pb2);
2889 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2890 s->pb2= backup_s.pb2;
2892 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2893 flush_put_bits(&s->tex_pb);
2894 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2895 s->tex_pb= backup_s.tex_pb;
2897 s->last_bits= put_bits_count(&s->pb);
2899 if (CONFIG_H263_ENCODER &&
2900 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2901 ff_h263_update_motion_val(s);
2903 if(next_block==0){ //FIXME 16 vs linesize16
2904 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2905 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2906 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2909 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2910 ff_MPV_decode_mb(s, s->block);
2912 int motion_x = 0, motion_y = 0;
2913 s->mv_type=MV_TYPE_16X16;
2914 // only one MB-Type possible
2917 case CANDIDATE_MB_TYPE_INTRA:
2920 motion_x= s->mv[0][0][0] = 0;
2921 motion_y= s->mv[0][0][1] = 0;
2923 case CANDIDATE_MB_TYPE_INTER:
2924 s->mv_dir = MV_DIR_FORWARD;
2926 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2927 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2929 case CANDIDATE_MB_TYPE_INTER_I:
2930 s->mv_dir = MV_DIR_FORWARD;
2931 s->mv_type = MV_TYPE_FIELD;
2934 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2935 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2936 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2939 case CANDIDATE_MB_TYPE_INTER4V:
2940 s->mv_dir = MV_DIR_FORWARD;
2941 s->mv_type = MV_TYPE_8X8;
2944 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2945 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2948 case CANDIDATE_MB_TYPE_DIRECT:
2949 if (CONFIG_MPEG4_ENCODER) {
2950 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2952 motion_x=s->b_direct_mv_table[xy][0];
2953 motion_y=s->b_direct_mv_table[xy][1];
2954 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2957 case CANDIDATE_MB_TYPE_DIRECT0:
2958 if (CONFIG_MPEG4_ENCODER) {
2959 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2961 ff_mpeg4_set_direct_mv(s, 0, 0);
2964 case CANDIDATE_MB_TYPE_BIDIR:
2965 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2967 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2968 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2969 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2970 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2972 case CANDIDATE_MB_TYPE_BACKWARD:
2973 s->mv_dir = MV_DIR_BACKWARD;
2975 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2976 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2978 case CANDIDATE_MB_TYPE_FORWARD:
2979 s->mv_dir = MV_DIR_FORWARD;
2981 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2982 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2984 case CANDIDATE_MB_TYPE_FORWARD_I:
2985 s->mv_dir = MV_DIR_FORWARD;
2986 s->mv_type = MV_TYPE_FIELD;
2989 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2990 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2991 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2994 case CANDIDATE_MB_TYPE_BACKWARD_I:
2995 s->mv_dir = MV_DIR_BACKWARD;
2996 s->mv_type = MV_TYPE_FIELD;
2999 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3000 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3001 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3004 case CANDIDATE_MB_TYPE_BIDIR_I:
3005 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3006 s->mv_type = MV_TYPE_FIELD;
3008 for(dir=0; dir<2; dir++){
3010 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3011 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3012 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3017 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3020 encode_mb(s, motion_x, motion_y);
3022 // RAL: Update last macroblock type
3023 s->last_mv_dir = s->mv_dir;
3025 if (CONFIG_H263_ENCODER &&
3026 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3027 ff_h263_update_motion_val(s);
3029 ff_MPV_decode_mb(s, s->block);
3032 /* clean the MV table in IPS frames for direct mode in B frames */
3033 if(s->mb_intra /* && I,P,S_TYPE */){
3034 s->p_mv_table[xy][0]=0;
3035 s->p_mv_table[xy][1]=0;
3038 if(s->flags&CODEC_FLAG_PSNR){
3042 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3043 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3045 s->current_picture.f.error[0] += sse(
3046 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3047 s->dest[0], w, h, s->linesize);
3048 s->current_picture.f.error[1] += sse(
3049 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3050 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3051 s->current_picture.f.error[2] += sse(
3052 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3053 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3056 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3057 ff_h263_loop_filter(s);
3059 av_dlog(s->avctx, "MB %d %d bits\n",
3060 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3064 //not beautiful here but we must write it before flushing so it has to be here
3065 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3066 ff_msmpeg4_encode_ext_header(s);
3070 /* Send the last GOB if RTP */
3071 if (s->avctx->rtp_callback) {
3072 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3073 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3074 /* Call the RTP callback to send the last GOB */
3076 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3082 #define MERGE(field) dst->field += src->field; src->field=0
3083 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3084 MERGE(me.scene_change_score);
3085 MERGE(me.mc_mb_var_sum_temp);
3086 MERGE(me.mb_var_sum_temp);
3089 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3092 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3093 MERGE(dct_count[1]);
3103 MERGE(padding_bug_score);
3104 MERGE(current_picture.f.error[0]);
3105 MERGE(current_picture.f.error[1]);
3106 MERGE(current_picture.f.error[2]);
3108 if(dst->avctx->noise_reduction){
3109 for(i=0; i<64; i++){
3110 MERGE(dct_error_sum[0][i]);
3111 MERGE(dct_error_sum[1][i]);
3115 assert(put_bits_count(&src->pb) % 8 ==0);
3116 assert(put_bits_count(&dst->pb) % 8 ==0);
3117 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3118 flush_put_bits(&dst->pb);
3121 static int estimate_qp(MpegEncContext *s, int dry_run){
3122 if (s->next_lambda){
3123 s->current_picture_ptr->f.quality =
3124 s->current_picture.f.quality = s->next_lambda;
3125 if(!dry_run) s->next_lambda= 0;
3126 } else if (!s->fixed_qscale) {
3127 s->current_picture_ptr->f.quality =
3128 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3129 if (s->current_picture.f.quality < 0)
3133 if(s->adaptive_quant){
3134 switch(s->codec_id){
3135 case AV_CODEC_ID_MPEG4:
3136 if (CONFIG_MPEG4_ENCODER)
3137 ff_clean_mpeg4_qscales(s);
3139 case AV_CODEC_ID_H263:
3140 case AV_CODEC_ID_H263P:
3141 case AV_CODEC_ID_FLV1:
3142 if (CONFIG_H263_ENCODER)
3143 ff_clean_h263_qscales(s);
3146 ff_init_qscale_tab(s);
3149 s->lambda= s->lambda_table[0];
3152 s->lambda = s->current_picture.f.quality;
3157 /* must be called before writing the header */
3158 static void set_frame_distances(MpegEncContext * s){
3159 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3160 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3162 if(s->pict_type==AV_PICTURE_TYPE_B){
3163 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3164 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3166 s->pp_time= s->time - s->last_non_b_time;
3167 s->last_non_b_time= s->time;
3168 assert(s->picture_number==0 || s->pp_time > 0);
3172 static int encode_picture(MpegEncContext *s, int picture_number)
3176 int context_count = s->slice_context_count;
3178 s->picture_number = picture_number;
3180 /* Reset the average MB variance */
3181 s->me.mb_var_sum_temp =
3182 s->me.mc_mb_var_sum_temp = 0;
3184 /* we need to initialize some time vars before we can encode b-frames */
3185 // RAL: Condition added for MPEG1VIDEO
3186 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3187 set_frame_distances(s);
3188 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3189 ff_set_mpeg4_time(s);
3191 s->me.scene_change_score=0;
3193 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3195 if(s->pict_type==AV_PICTURE_TYPE_I){
3196 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3197 else s->no_rounding=0;
3198 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3199 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3200 s->no_rounding ^= 1;
3203 if(s->flags & CODEC_FLAG_PASS2){
3204 if (estimate_qp(s,1) < 0)
3206 ff_get_2pass_fcode(s);
3207 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3208 if(s->pict_type==AV_PICTURE_TYPE_B)
3209 s->lambda= s->last_lambda_for[s->pict_type];
3211 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3215 if(s->codec_id != AV_CODEC_ID_AMV){
3216 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3217 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3218 s->q_chroma_intra_matrix = s->q_intra_matrix;
3219 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3222 s->mb_intra=0; //for the rate distortion & bit compare functions
3223 for(i=1; i<context_count; i++){
3224 ff_update_duplicate_context(s->thread_context[i], s);
3230 /* Estimate motion for every MB */
3231 if(s->pict_type != AV_PICTURE_TYPE_I){
3232 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3233 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3234 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3235 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3236 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3240 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3241 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3243 for(i=0; i<s->mb_stride*s->mb_height; i++)
3244 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3246 if(!s->fixed_qscale){
3247 /* finding spatial complexity for I-frame rate control */
3248 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3251 for(i=1; i<context_count; i++){
3252 merge_context_after_me(s, s->thread_context[i]);
3254 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3255 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3258 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3259 s->pict_type= AV_PICTURE_TYPE_I;
3260 for(i=0; i<s->mb_stride*s->mb_height; i++)
3261 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3262 if(s->msmpeg4_version >= 3)
3264 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3265 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3269 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3270 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3272 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3274 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3275 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3276 s->f_code= FFMAX3(s->f_code, a, b);
3279 ff_fix_long_p_mvs(s);
3280 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3281 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3285 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3286 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3291 if(s->pict_type==AV_PICTURE_TYPE_B){
3294 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3295 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3296 s->f_code = FFMAX(a, b);
3298 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3299 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3300 s->b_code = FFMAX(a, b);
3302 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3303 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3304 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3305 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3306 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3308 for(dir=0; dir<2; dir++){
3311 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3312 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3313 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3314 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3322 if (estimate_qp(s, 0) < 0)
3325 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3326 s->qscale= 3; //reduce clipping problems
3328 if (s->out_format == FMT_MJPEG) {
3329 /* for mjpeg, we do include qscale in the matrix */
3331 int j= s->dsp.idct_permutation[i];
3333 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3335 s->y_dc_scale_table=
3336 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3337 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3338 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3339 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3342 if(s->codec_id == AV_CODEC_ID_AMV){
3343 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};
3344 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};
3346 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3348 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3349 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3351 s->y_dc_scale_table= y;
3352 s->c_dc_scale_table= c;
3353 s->intra_matrix[0] = 13;
3354 s->chroma_intra_matrix[0] = 14;
3355 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3356 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3357 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3358 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3362 //FIXME var duplication
3363 s->current_picture_ptr->f.key_frame =
3364 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3365 s->current_picture_ptr->f.pict_type =
3366 s->current_picture.f.pict_type = s->pict_type;
3368 if (s->current_picture.f.key_frame)
3369 s->picture_in_gop_number=0;
3371 s->mb_x = s->mb_y = 0;
3372 s->last_bits= put_bits_count(&s->pb);
3373 switch(s->out_format) {
3375 if (CONFIG_MJPEG_ENCODER)
3376 ff_mjpeg_encode_picture_header(s);
3379 if (CONFIG_H261_ENCODER)
3380 ff_h261_encode_picture_header(s, picture_number);
3383 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3384 ff_wmv2_encode_picture_header(s, picture_number);
3385 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3386 ff_msmpeg4_encode_picture_header(s, picture_number);
3387 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3388 ff_mpeg4_encode_picture_header(s, picture_number);
3389 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3390 ff_rv10_encode_picture_header(s, picture_number);
3391 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3392 ff_rv20_encode_picture_header(s, picture_number);
3393 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3394 ff_flv_encode_picture_header(s, picture_number);
3395 else if (CONFIG_H263_ENCODER)
3396 ff_h263_encode_picture_header(s, picture_number);
3399 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3400 ff_mpeg1_encode_picture_header(s, picture_number);
3407 bits= put_bits_count(&s->pb);
3408 s->header_bits= bits - s->last_bits;
3410 for(i=1; i<context_count; i++){
3411 update_duplicate_context_after_me(s->thread_context[i], s);
3413 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3414 for(i=1; i<context_count; i++){
3415 merge_context_after_encode(s, s->thread_context[i]);
3421 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3422 const int intra= s->mb_intra;
3425 s->dct_count[intra]++;
3427 for(i=0; i<64; i++){
3428 int level= block[i];
3432 s->dct_error_sum[intra][i] += level;
3433 level -= s->dct_offset[intra][i];
3434 if(level<0) level=0;
3436 s->dct_error_sum[intra][i] -= level;
3437 level += s->dct_offset[intra][i];
3438 if(level>0) level=0;
3445 static int dct_quantize_trellis_c(MpegEncContext *s,
3446 DCTELEM *block, int n,
3447 int qscale, int *overflow){
3449 const uint8_t *scantable= s->intra_scantable.scantable;
3450 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3452 unsigned int threshold1, threshold2;
3464 int coeff_count[64];
3465 int qmul, qadd, start_i, last_non_zero, i, dc;
3466 const int esc_length= s->ac_esc_length;
3468 uint8_t * last_length;
3469 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3471 s->dsp.fdct (block);
3473 if(s->dct_error_sum)
3474 s->denoise_dct(s, block);
3476 qadd= ((qscale-1)|1)*8;
3487 /* For AIC we skip quant/dequant of INTRADC */
3492 /* note: block[0] is assumed to be positive */
3493 block[0] = (block[0] + (q >> 1)) / q;
3496 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3497 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3498 bias= 1<<(QMAT_SHIFT-1);
3499 length = s->intra_ac_vlc_length;
3500 last_length= s->intra_ac_vlc_last_length;
3504 qmat = s->q_inter_matrix[qscale];
3505 length = s->inter_ac_vlc_length;
3506 last_length= s->inter_ac_vlc_last_length;
3510 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3511 threshold2= (threshold1<<1);
3513 for(i=63; i>=start_i; i--) {
3514 const int j = scantable[i];
3515 int level = block[j] * qmat[j];
3517 if(((unsigned)(level+threshold1))>threshold2){
3523 for(i=start_i; i<=last_non_zero; i++) {
3524 const int j = scantable[i];
3525 int level = block[j] * qmat[j];
3527 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3528 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3529 if(((unsigned)(level+threshold1))>threshold2){
3531 level= (bias + level)>>QMAT_SHIFT;
3533 coeff[1][i]= level-1;
3534 // coeff[2][k]= level-2;
3536 level= (bias - level)>>QMAT_SHIFT;
3537 coeff[0][i]= -level;
3538 coeff[1][i]= -level+1;
3539 // coeff[2][k]= -level+2;
3541 coeff_count[i]= FFMIN(level, 2);
3542 av_assert2(coeff_count[i]);
3545 coeff[0][i]= (level>>31)|1;
3550 *overflow= s->max_qcoeff < max; //overflow might have happened
3552 if(last_non_zero < start_i){
3553 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3554 return last_non_zero;
3557 score_tab[start_i]= 0;
3558 survivor[0]= start_i;
3561 for(i=start_i; i<=last_non_zero; i++){
3562 int level_index, j, zero_distortion;
3563 int dct_coeff= FFABS(block[ scantable[i] ]);
3564 int best_score=256*256*256*120;
3566 if (s->dsp.fdct == ff_fdct_ifast)
3567 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3568 zero_distortion= dct_coeff*dct_coeff;
3570 for(level_index=0; level_index < coeff_count[i]; level_index++){
3572 int level= coeff[level_index][i];
3573 const int alevel= FFABS(level);
3578 if(s->out_format == FMT_H263){
3579 unquant_coeff= alevel*qmul + qadd;
3581 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3583 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3584 unquant_coeff = (unquant_coeff - 1) | 1;
3586 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3587 unquant_coeff = (unquant_coeff - 1) | 1;
3592 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3594 if((level&(~127)) == 0){
3595 for(j=survivor_count-1; j>=0; j--){
3596 int run= i - survivor[j];
3597 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3598 score += score_tab[i-run];
3600 if(score < best_score){
3603 level_tab[i+1]= level-64;
3607 if(s->out_format == FMT_H263){
3608 for(j=survivor_count-1; j>=0; j--){
3609 int run= i - survivor[j];
3610 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3611 score += score_tab[i-run];
3612 if(score < last_score){
3615 last_level= level-64;
3621 distortion += esc_length*lambda;
3622 for(j=survivor_count-1; j>=0; j--){
3623 int run= i - survivor[j];
3624 int score= distortion + score_tab[i-run];
3626 if(score < best_score){
3629 level_tab[i+1]= level-64;
3633 if(s->out_format == FMT_H263){
3634 for(j=survivor_count-1; j>=0; j--){
3635 int run= i - survivor[j];
3636 int score= distortion + score_tab[i-run];
3637 if(score < last_score){
3640 last_level= level-64;
3648 score_tab[i+1]= best_score;
3650 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3651 if(last_non_zero <= 27){
3652 for(; survivor_count; survivor_count--){
3653 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3657 for(; survivor_count; survivor_count--){
3658 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3663 survivor[ survivor_count++ ]= i+1;
3666 if(s->out_format != FMT_H263){
3667 last_score= 256*256*256*120;
3668 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3669 int score= score_tab[i];
3670 if(i) score += lambda*2; //FIXME exacter?
3672 if(score < last_score){
3675 last_level= level_tab[i];
3676 last_run= run_tab[i];
3681 s->coded_score[n] = last_score;
3683 dc= FFABS(block[0]);
3684 last_non_zero= last_i - 1;
3685 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3687 if(last_non_zero < start_i)
3688 return last_non_zero;
3690 if(last_non_zero == 0 && start_i == 0){
3692 int best_score= dc * dc;
3694 for(i=0; i<coeff_count[0]; i++){
3695 int level= coeff[i][0];
3696 int alevel= FFABS(level);
3697 int unquant_coeff, score, distortion;
3699 if(s->out_format == FMT_H263){
3700 unquant_coeff= (alevel*qmul + qadd)>>3;
3702 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3703 unquant_coeff = (unquant_coeff - 1) | 1;
3705 unquant_coeff = (unquant_coeff + 4) >> 3;
3706 unquant_coeff<<= 3 + 3;
3708 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3710 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3711 else score= distortion + esc_length*lambda;
3713 if(score < best_score){
3715 best_level= level - 64;
3718 block[0]= best_level;
3719 s->coded_score[n] = best_score - dc*dc;
3720 if(best_level == 0) return -1;
3721 else return last_non_zero;
3725 av_assert2(last_level);
3727 block[ perm_scantable[last_non_zero] ]= last_level;
3730 for(; i>start_i; i -= run_tab[i] + 1){
3731 block[ perm_scantable[i-1] ]= level_tab[i];
3734 return last_non_zero;
3737 //#define REFINE_STATS 1
3738 static int16_t basis[64][64];
3740 static void build_basis(uint8_t *perm){
3747 double s= 0.25*(1<<BASIS_SHIFT);
3749 int perm_index= perm[index];
3750 if(i==0) s*= sqrt(0.5);
3751 if(j==0) s*= sqrt(0.5);
3752 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)));
3759 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3760 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3763 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3764 const uint8_t *scantable= s->intra_scantable.scantable;
3765 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3766 // unsigned int threshold1, threshold2;
3771 int qmul, qadd, start_i, last_non_zero, i, dc;
3773 uint8_t * last_length;
3775 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3778 static int after_last=0;
3779 static int to_zero=0;
3780 static int from_zero=0;
3783 static int messed_sign=0;
3786 if(basis[0][0] == 0)
3787 build_basis(s->dsp.idct_permutation);
3798 /* For AIC we skip quant/dequant of INTRADC */
3802 q <<= RECON_SHIFT-3;
3803 /* note: block[0] is assumed to be positive */
3805 // block[0] = (block[0] + (q >> 1)) / q;
3807 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3808 // bias= 1<<(QMAT_SHIFT-1);
3809 length = s->intra_ac_vlc_length;
3810 last_length= s->intra_ac_vlc_last_length;
3814 length = s->inter_ac_vlc_length;
3815 last_length= s->inter_ac_vlc_last_length;
3817 last_non_zero = s->block_last_index[n];
3822 dc += (1<<(RECON_SHIFT-1));
3823 for(i=0; i<64; i++){
3824 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3827 STOP_TIMER("memset rem[]")}
3830 for(i=0; i<64; i++){
3835 w= FFABS(weight[i]) + qns*one;
3836 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3839 // w=weight[i] = (63*qns + (w/2)) / w;
3842 av_assert2(w<(1<<6));
3845 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3851 for(i=start_i; i<=last_non_zero; i++){
3852 int j= perm_scantable[i];
3853 const int level= block[j];
3857 if(level<0) coeff= qmul*level - qadd;
3858 else coeff= qmul*level + qadd;
3859 run_tab[rle_index++]=run;
3862 s->dsp.add_8x8basis(rem, basis[j], coeff);
3868 if(last_non_zero>0){
3869 STOP_TIMER("init rem[]")
3876 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3879 int run2, best_unquant_change=0, analyze_gradient;
3883 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3885 if(analyze_gradient){
3889 for(i=0; i<64; i++){
3892 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3895 STOP_TIMER("rem*w*w")}
3905 const int level= block[0];
3906 int change, old_coeff;
3908 av_assert2(s->mb_intra);
3912 for(change=-1; change<=1; change+=2){
3913 int new_level= level + change;
3914 int score, new_coeff;
3916 new_coeff= q*new_level;
3917 if(new_coeff >= 2048 || new_coeff < 0)
3920 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3921 if(score<best_score){
3924 best_change= change;
3925 best_unquant_change= new_coeff - old_coeff;
3932 run2= run_tab[rle_index++];
3936 for(i=start_i; i<64; i++){
3937 int j= perm_scantable[i];
3938 const int level= block[j];
3939 int change, old_coeff;
3941 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3945 if(level<0) old_coeff= qmul*level - qadd;
3946 else old_coeff= qmul*level + qadd;
3947 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3951 av_assert2(run2>=0 || i >= last_non_zero );
3954 for(change=-1; change<=1; change+=2){
3955 int new_level= level + change;
3956 int score, new_coeff, unquant_change;
3959 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3963 if(new_level<0) new_coeff= qmul*new_level - qadd;
3964 else new_coeff= qmul*new_level + qadd;
3965 if(new_coeff >= 2048 || new_coeff <= -2048)
3967 //FIXME check for overflow
3970 if(level < 63 && level > -63){
3971 if(i < last_non_zero)
3972 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3973 - length[UNI_AC_ENC_INDEX(run, level+64)];
3975 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3976 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3979 av_assert2(FFABS(new_level)==1);
3981 if(analyze_gradient){
3982 int g= d1[ scantable[i] ];
3983 if(g && (g^new_level) >= 0)
3987 if(i < last_non_zero){
3988 int next_i= i + run2 + 1;
3989 int next_level= block[ perm_scantable[next_i] ] + 64;
3991 if(next_level&(~127))
3994 if(next_i < last_non_zero)
3995 score += length[UNI_AC_ENC_INDEX(run, 65)]
3996 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3997 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3999 score += length[UNI_AC_ENC_INDEX(run, 65)]
4000 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4001 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4003 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4005 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4006 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4012 av_assert2(FFABS(level)==1);
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 + run2 + 1, next_level)]
4023 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4024 - length[UNI_AC_ENC_INDEX(run, 65)];
4026 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4027 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4028 - length[UNI_AC_ENC_INDEX(run, 65)];
4030 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4032 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4033 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4040 unquant_change= new_coeff - old_coeff;
4041 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4043 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4044 if(score<best_score){
4047 best_change= change;
4048 best_unquant_change= unquant_change;
4052 prev_level= level + 64;
4053 if(prev_level&(~127))
4062 STOP_TIMER("iterative step")}
4066 int j= perm_scantable[ best_coeff ];
4068 block[j] += best_change;
4070 if(best_coeff > last_non_zero){
4071 last_non_zero= best_coeff;
4072 av_assert2(block[j]);
4079 if(block[j] - best_change){
4080 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4092 for(; last_non_zero>=start_i; last_non_zero--){
4093 if(block[perm_scantable[last_non_zero]])
4099 if(256*256*256*64 % count == 0){
4100 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);
4105 for(i=start_i; i<=last_non_zero; i++){
4106 int j= perm_scantable[i];
4107 const int level= block[j];
4110 run_tab[rle_index++]=run;
4117 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4123 if(last_non_zero>0){
4124 STOP_TIMER("iterative search")
4129 return last_non_zero;
4132 int ff_dct_quantize_c(MpegEncContext *s,
4133 DCTELEM *block, int n,
4134 int qscale, int *overflow)
4136 int i, j, level, last_non_zero, q, start_i;
4138 const uint8_t *scantable= s->intra_scantable.scantable;
4141 unsigned int threshold1, threshold2;
4143 s->dsp.fdct (block);
4145 if(s->dct_error_sum)
4146 s->denoise_dct(s, block);
4156 /* For AIC we skip quant/dequant of INTRADC */
4159 /* note: block[0] is assumed to be positive */
4160 block[0] = (block[0] + (q >> 1)) / q;
4163 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4164 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4168 qmat = s->q_inter_matrix[qscale];
4169 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4171 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4172 threshold2= (threshold1<<1);
4173 for(i=63;i>=start_i;i--) {
4175 level = block[j] * qmat[j];
4177 if(((unsigned)(level+threshold1))>threshold2){
4184 for(i=start_i; i<=last_non_zero; i++) {
4186 level = block[j] * qmat[j];
4188 // if( bias+level >= (1<<QMAT_SHIFT)
4189 // || bias-level >= (1<<QMAT_SHIFT)){
4190 if(((unsigned)(level+threshold1))>threshold2){
4192 level= (bias + level)>>QMAT_SHIFT;
4195 level= (bias - level)>>QMAT_SHIFT;
4203 *overflow= s->max_qcoeff < max; //overflow might have happened
4205 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4206 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4207 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4209 return last_non_zero;
4212 #define OFFSET(x) offsetof(MpegEncContext, x)
4213 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4214 static const AVOption h263_options[] = {
4215 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4216 { "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},
4217 { "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 },
4222 static const AVClass h263_class = {
4223 .class_name = "H.263 encoder",
4224 .item_name = av_default_item_name,
4225 .option = h263_options,
4226 .version = LIBAVUTIL_VERSION_INT,
4229 AVCodec ff_h263_encoder = {
4231 .type = AVMEDIA_TYPE_VIDEO,
4232 .id = AV_CODEC_ID_H263,
4233 .priv_data_size = sizeof(MpegEncContext),
4234 .init = ff_MPV_encode_init,
4235 .encode2 = ff_MPV_encode_picture,
4236 .close = ff_MPV_encode_end,
4237 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4238 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4239 .priv_class = &h263_class,
4242 static const AVOption h263p_options[] = {
4243 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4244 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4245 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4246 { "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},
4250 static const AVClass h263p_class = {
4251 .class_name = "H.263p encoder",
4252 .item_name = av_default_item_name,
4253 .option = h263p_options,
4254 .version = LIBAVUTIL_VERSION_INT,
4257 AVCodec ff_h263p_encoder = {
4259 .type = AVMEDIA_TYPE_VIDEO,
4260 .id = AV_CODEC_ID_H263P,
4261 .priv_data_size = sizeof(MpegEncContext),
4262 .init = ff_MPV_encode_init,
4263 .encode2 = ff_MPV_encode_picture,
4264 .close = ff_MPV_encode_end,
4265 .capabilities = CODEC_CAP_SLICE_THREADS,
4266 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4267 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4268 .priv_class = &h263p_class,
4271 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4273 AVCodec ff_msmpeg4v2_encoder = {
4274 .name = "msmpeg4v2",
4275 .type = AVMEDIA_TYPE_VIDEO,
4276 .id = AV_CODEC_ID_MSMPEG4V2,
4277 .priv_data_size = sizeof(MpegEncContext),
4278 .init = ff_MPV_encode_init,
4279 .encode2 = ff_MPV_encode_picture,
4280 .close = ff_MPV_encode_end,
4281 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4282 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4283 .priv_class = &msmpeg4v2_class,
4286 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4288 AVCodec ff_msmpeg4v3_encoder = {
4290 .type = AVMEDIA_TYPE_VIDEO,
4291 .id = AV_CODEC_ID_MSMPEG4V3,
4292 .priv_data_size = sizeof(MpegEncContext),
4293 .init = ff_MPV_encode_init,
4294 .encode2 = ff_MPV_encode_picture,
4295 .close = ff_MPV_encode_end,
4296 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4297 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4298 .priv_class = &msmpeg4v3_class,
4301 FF_MPV_GENERIC_CLASS(wmv1)
4303 AVCodec ff_wmv1_encoder = {
4305 .type = AVMEDIA_TYPE_VIDEO,
4306 .id = AV_CODEC_ID_WMV1,
4307 .priv_data_size = sizeof(MpegEncContext),
4308 .init = ff_MPV_encode_init,
4309 .encode2 = ff_MPV_encode_picture,
4310 .close = ff_MPV_encode_end,
4311 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4312 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4313 .priv_class = &wmv1_class,