2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
42 #include "aandcttab.h"
44 #include "mpeg4video.h"
46 #include "bytestream.h"
53 static int encode_picture(MpegEncContext *s, int picture_number);
54 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
55 static int sse_mb(MpegEncContext *s);
56 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
57 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 /* enable all paranoid tests for rounding, overflows, etc... */
64 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
65 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
67 const AVOption ff_mpv_generic_options[] = {
72 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
73 uint16_t (*qmat16)[2][64],
74 const uint16_t *quant_matrix,
75 int bias, int qmin, int qmax, int intra)
80 for (qscale = qmin; qscale <= qmax; qscale++) {
82 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
83 dsp->fdct == ff_jpeg_fdct_islow_10 ||
84 dsp->fdct == ff_faandct) {
85 for (i = 0; i < 64; i++) {
86 const int j = dsp->idct_permutation[i];
87 /* 16 <= qscale * quant_matrix[i] <= 7905
88 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
89 * 19952 <= x <= 249205026
90 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
91 * 3444240 >= (1 << 36) / (x) >= 275 */
93 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
94 (qscale * quant_matrix[j]));
96 } else if (dsp->fdct == ff_fdct_ifast) {
97 for (i = 0; i < 64; i++) {
98 const int j = dsp->idct_permutation[i];
99 /* 16 <= qscale * quant_matrix[i] <= 7905
100 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101 * 19952 <= x <= 249205026
102 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103 * 3444240 >= (1 << 36) / (x) >= 275 */
105 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
106 (ff_aanscales[i] * qscale * quant_matrix[j]));
109 for (i = 0; i < 64; i++) {
110 const int j = dsp->idct_permutation[i];
111 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
112 * Assume x = qscale * quant_matrix[i]
114 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
115 * so 32768 >= (1 << 19) / (x) >= 67 */
116 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
117 (qscale * quant_matrix[j]));
118 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
119 // (qscale * quant_matrix[i]);
120 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
121 (qscale * quant_matrix[j]);
123 if (qmat16[qscale][0][i] == 0 ||
124 qmat16[qscale][0][i] == 128 * 256)
125 qmat16[qscale][0][i] = 128 * 256 - 1;
126 qmat16[qscale][1][i] =
127 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
128 qmat16[qscale][0][i]);
132 for (i = intra; i < 64; i++) {
134 if (dsp->fdct == ff_fdct_ifast) {
135 max = (8191LL * ff_aanscales[i]) >> 14;
137 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
143 av_log(NULL, AV_LOG_INFO,
144 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
149 static inline void update_qscale(MpegEncContext *s)
151 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
152 (FF_LAMBDA_SHIFT + 7);
153 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
155 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
159 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165 for (i = 0; i < 64; i++) {
166 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
173 * init s->current_picture.qscale_table from s->lambda_table
175 void ff_init_qscale_tab(MpegEncContext *s)
177 int8_t * const qscale_table = s->current_picture.f.qscale_table;
180 for (i = 0; i < s->mb_num; i++) {
181 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
182 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
183 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
188 static void copy_picture_attributes(MpegEncContext *s,
194 dst->pict_type = src->pict_type;
195 dst->quality = src->quality;
196 dst->coded_picture_number = src->coded_picture_number;
197 dst->display_picture_number = src->display_picture_number;
198 //dst->reference = src->reference;
200 dst->interlaced_frame = src->interlaced_frame;
201 dst->top_field_first = src->top_field_first;
203 if (s->avctx->me_threshold) {
204 if (!src->motion_val[0])
205 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
207 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
208 if (!src->ref_index[0])
209 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
210 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
211 av_log(s->avctx, AV_LOG_ERROR,
212 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
213 src->motion_subsample_log2, dst->motion_subsample_log2);
215 memcpy(dst->mb_type, src->mb_type,
216 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
218 for (i = 0; i < 2; i++) {
219 int stride = ((16 * s->mb_width ) >>
220 src->motion_subsample_log2) + 1;
221 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
223 if (src->motion_val[i] &&
224 src->motion_val[i] != dst->motion_val[i]) {
225 memcpy(dst->motion_val[i], src->motion_val[i],
226 2 * stride * height * sizeof(int16_t));
228 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
229 memcpy(dst->ref_index[i], src->ref_index[i],
230 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
236 static void update_duplicate_context_after_me(MpegEncContext *dst,
239 #define COPY(a) dst->a= src->a
241 COPY(current_picture);
247 COPY(picture_in_gop_number);
248 COPY(gop_picture_number);
249 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
250 COPY(progressive_frame); // FIXME don't set in encode_header
251 COPY(partitioned_frame); // FIXME don't set in encode_header
256 * Set the given MpegEncContext to defaults for encoding.
257 * the changed fields will not depend upon the prior state of the MpegEncContext.
259 static void MPV_encode_defaults(MpegEncContext *s)
262 ff_MPV_common_defaults(s);
264 for (i = -16; i < 16; i++) {
265 default_fcode_tab[i + MAX_MV] = 1;
267 s->me.mv_penalty = default_mv_penalty;
268 s->fcode_tab = default_fcode_tab;
271 /* init video encoder */
272 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
274 MpegEncContext *s = avctx->priv_data;
276 int chroma_h_shift, chroma_v_shift;
278 MPV_encode_defaults(s);
280 switch (avctx->codec_id) {
281 case CODEC_ID_MPEG2VIDEO:
282 if (avctx->pix_fmt != PIX_FMT_YUV420P &&
283 avctx->pix_fmt != PIX_FMT_YUV422P) {
284 av_log(avctx, AV_LOG_ERROR,
285 "only YUV420 and YUV422 are supported\n");
290 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
291 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
292 avctx->pix_fmt != PIX_FMT_YUVJ444P &&
293 avctx->pix_fmt != PIX_FMT_BGR0 &&
294 avctx->pix_fmt != PIX_FMT_BGRA &&
295 avctx->pix_fmt != PIX_FMT_BGR24 &&
296 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
297 avctx->pix_fmt != PIX_FMT_YUV422P &&
298 avctx->pix_fmt != PIX_FMT_YUV444P) ||
299 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
300 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
306 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
307 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
308 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
309 avctx->pix_fmt != PIX_FMT_YUV422P) ||
310 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
311 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
316 if (avctx->pix_fmt != PIX_FMT_YUV420P) {
317 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
322 switch (avctx->pix_fmt) {
323 case PIX_FMT_YUVJ422P:
324 case PIX_FMT_YUV422P:
325 s->chroma_format = CHROMA_422;
327 case PIX_FMT_YUVJ420P:
328 case PIX_FMT_YUV420P:
330 s->chroma_format = CHROMA_420;
334 s->bit_rate = avctx->bit_rate;
335 s->width = avctx->width;
336 s->height = avctx->height;
337 if (avctx->gop_size > 600 &&
338 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
339 av_log(avctx, AV_LOG_WARNING,
340 "keyframe interval too large!, reducing it from %d to %d\n",
341 avctx->gop_size, 600);
342 avctx->gop_size = 600;
344 s->gop_size = avctx->gop_size;
346 s->flags = avctx->flags;
347 s->flags2 = avctx->flags2;
348 s->max_b_frames = avctx->max_b_frames;
349 s->codec_id = avctx->codec->id;
350 #if FF_API_MPV_GLOBAL_OPTS
351 if (avctx->luma_elim_threshold)
352 s->luma_elim_threshold = avctx->luma_elim_threshold;
353 if (avctx->chroma_elim_threshold)
354 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
356 s->strict_std_compliance = avctx->strict_std_compliance;
357 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
358 s->mpeg_quant = avctx->mpeg_quant;
359 s->rtp_mode = !!avctx->rtp_payload_size;
360 s->intra_dc_precision = avctx->intra_dc_precision;
361 s->user_specified_pts = AV_NOPTS_VALUE;
363 if (s->gop_size <= 1) {
370 s->me_method = avctx->me_method;
373 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
375 #if FF_API_MPV_GLOBAL_OPTS
376 if (s->flags & CODEC_FLAG_QP_RD)
377 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
380 s->adaptive_quant = (s->avctx->lumi_masking ||
381 s->avctx->dark_masking ||
382 s->avctx->temporal_cplx_masking ||
383 s->avctx->spatial_cplx_masking ||
384 s->avctx->p_masking ||
385 s->avctx->border_masking ||
386 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
389 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
391 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
392 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
393 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
397 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
398 av_log(avctx, AV_LOG_INFO,
399 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
402 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
403 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
407 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
408 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
412 if (avctx->rc_max_rate &&
413 avctx->rc_max_rate == avctx->bit_rate &&
414 avctx->rc_max_rate != avctx->rc_min_rate) {
415 av_log(avctx, AV_LOG_INFO,
416 "impossible bitrate constraints, this will fail\n");
419 if (avctx->rc_buffer_size &&
420 avctx->bit_rate * (int64_t)avctx->time_base.num >
421 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
422 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
426 if (!s->fixed_qscale &&
427 avctx->bit_rate * av_q2d(avctx->time_base) >
428 avctx->bit_rate_tolerance) {
429 av_log(avctx, AV_LOG_ERROR,
430 "bitrate tolerance too small for bitrate\n");
434 if (s->avctx->rc_max_rate &&
435 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
436 (s->codec_id == CODEC_ID_MPEG1VIDEO ||
437 s->codec_id == CODEC_ID_MPEG2VIDEO) &&
438 90000LL * (avctx->rc_buffer_size - 1) >
439 s->avctx->rc_max_rate * 0xFFFFLL) {
440 av_log(avctx, AV_LOG_INFO,
441 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
442 "specified vbv buffer is too large for the given bitrate!\n");
445 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 &&
446 s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P &&
447 s->codec_id != CODEC_ID_FLV1) {
448 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
452 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
453 av_log(avctx, AV_LOG_ERROR,
454 "OBMC is only supported with simple mb decision\n");
458 if (s->quarter_sample && s->codec_id != CODEC_ID_MPEG4) {
459 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
463 if (s->max_b_frames &&
464 s->codec_id != CODEC_ID_MPEG4 &&
465 s->codec_id != CODEC_ID_MPEG1VIDEO &&
466 s->codec_id != CODEC_ID_MPEG2VIDEO) {
467 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
471 if ((s->codec_id == CODEC_ID_MPEG4 ||
472 s->codec_id == CODEC_ID_H263 ||
473 s->codec_id == CODEC_ID_H263P) &&
474 (avctx->sample_aspect_ratio.num > 255 ||
475 avctx->sample_aspect_ratio.den > 255)) {
476 av_log(avctx, AV_LOG_WARNING,
477 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
478 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
479 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
480 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
483 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
484 s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO) {
485 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
489 // FIXME mpeg2 uses that too
490 if (s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4) {
491 av_log(avctx, AV_LOG_ERROR,
492 "mpeg2 style quantization not supported by codec\n");
496 #if FF_API_MPV_GLOBAL_OPTS
497 if (s->flags & CODEC_FLAG_CBP_RD)
498 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
501 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
502 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
506 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
507 s->avctx->mb_decision != FF_MB_DECISION_RD) {
508 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
512 if (s->avctx->scenechange_threshold < 1000000000 &&
513 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
514 av_log(avctx, AV_LOG_ERROR,
515 "closed gop with scene change detection are not supported yet, "
516 "set threshold to 1000000000\n");
520 if (s->flags & CODEC_FLAG_LOW_DELAY) {
521 if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
522 av_log(avctx, AV_LOG_ERROR,
523 "low delay forcing is only available for mpeg2\n");
526 if (s->max_b_frames != 0) {
527 av_log(avctx, AV_LOG_ERROR,
528 "b frames cannot be used with low delay\n");
533 if (s->q_scale_type == 1) {
534 if (avctx->qmax > 12) {
535 av_log(avctx, AV_LOG_ERROR,
536 "non linear quant only supports qmax <= 12 currently\n");
541 if (s->avctx->thread_count > 1 &&
542 s->codec_id != CODEC_ID_MPEG4 &&
543 s->codec_id != CODEC_ID_MPEG1VIDEO &&
544 s->codec_id != CODEC_ID_MPEG2VIDEO &&
545 (s->codec_id != CODEC_ID_H263P)) {
546 av_log(avctx, AV_LOG_ERROR,
547 "multi threaded encoding not supported by codec\n");
551 if (s->avctx->thread_count < 1) {
552 av_log(avctx, AV_LOG_ERROR,
553 "automatic thread number detection not supported by codec, "
558 if (s->avctx->thread_count > 1)
561 if (!avctx->time_base.den || !avctx->time_base.num) {
562 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
566 i = (INT_MAX / 2 + 128) >> 8;
567 if (avctx->me_threshold >= i) {
568 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
572 if (avctx->mb_threshold >= i) {
573 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
578 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
579 av_log(avctx, AV_LOG_INFO,
580 "notice: b_frame_strategy only affects the first pass\n");
581 avctx->b_frame_strategy = 0;
584 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
586 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
587 avctx->time_base.den /= i;
588 avctx->time_base.num /= i;
592 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id==CODEC_ID_AMV) {
593 // (a + x * 3 / 8) / x
594 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
595 s->inter_quant_bias = 0;
597 s->intra_quant_bias = 0;
599 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
602 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
603 s->intra_quant_bias = avctx->intra_quant_bias;
604 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
605 s->inter_quant_bias = avctx->inter_quant_bias;
607 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
609 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
612 if (avctx->codec_id == CODEC_ID_MPEG4 &&
613 s->avctx->time_base.den > (1 << 16) - 1) {
614 av_log(avctx, AV_LOG_ERROR,
615 "timebase %d/%d not supported by MPEG 4 standard, "
616 "the maximum admitted value for the timebase denominator "
617 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
621 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
623 #if FF_API_MPV_GLOBAL_OPTS
624 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
625 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
626 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
627 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
628 if (avctx->quantizer_noise_shaping)
629 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
632 switch (avctx->codec->id) {
633 case CODEC_ID_MPEG1VIDEO:
634 s->out_format = FMT_MPEG1;
635 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
636 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
638 case CODEC_ID_MPEG2VIDEO:
639 s->out_format = FMT_MPEG1;
640 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
641 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
647 s->out_format = FMT_MJPEG;
648 s->intra_only = 1; /* force intra only for jpeg */
649 if (avctx->codec->id == CODEC_ID_LJPEG &&
650 (avctx->pix_fmt == PIX_FMT_BGR0
651 || s->avctx->pix_fmt == PIX_FMT_BGRA
652 || s->avctx->pix_fmt == PIX_FMT_BGR24)) {
653 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
654 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
655 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
657 s->mjpeg_vsample[0] = 2;
658 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
659 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
660 s->mjpeg_hsample[0] = 2;
661 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
662 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
664 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
665 ff_mjpeg_encode_init(s) < 0)
671 if (!CONFIG_H261_ENCODER)
673 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
674 av_log(avctx, AV_LOG_ERROR,
675 "The specified picture size of %dx%d is not valid for the "
676 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
677 s->width, s->height);
680 s->out_format = FMT_H261;
685 if (!CONFIG_H263_ENCODER)
687 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
688 s->width, s->height) == 8) {
689 av_log(avctx, AV_LOG_ERROR,
690 "The specified picture size of %dx%d is not valid for "
691 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
692 "352x288, 704x576, and 1408x1152. "
693 "Try H.263+.\n", s->width, s->height);
696 s->out_format = FMT_H263;
701 s->out_format = FMT_H263;
704 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
705 s->modified_quant = s->h263_aic;
706 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
707 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
710 /* These are just to be sure */
715 s->out_format = FMT_H263;
716 s->h263_flv = 2; /* format = 1; 11-bit codes */
717 s->unrestricted_mv = 1;
718 s->rtp_mode = 0; /* don't allow GOB */
723 s->out_format = FMT_H263;
728 s->out_format = FMT_H263;
731 s->modified_quant = 1;
735 s->unrestricted_mv = 0;
738 s->out_format = FMT_H263;
740 s->unrestricted_mv = 1;
741 s->low_delay = s->max_b_frames ? 0 : 1;
742 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
744 case CODEC_ID_MSMPEG4V2:
745 s->out_format = FMT_H263;
747 s->unrestricted_mv = 1;
748 s->msmpeg4_version = 2;
752 case CODEC_ID_MSMPEG4V3:
753 s->out_format = FMT_H263;
755 s->unrestricted_mv = 1;
756 s->msmpeg4_version = 3;
757 s->flipflop_rounding = 1;
762 s->out_format = FMT_H263;
764 s->unrestricted_mv = 1;
765 s->msmpeg4_version = 4;
766 s->flipflop_rounding = 1;
771 s->out_format = FMT_H263;
773 s->unrestricted_mv = 1;
774 s->msmpeg4_version = 5;
775 s->flipflop_rounding = 1;
783 avctx->has_b_frames = !s->low_delay;
787 s->progressive_frame =
788 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
789 CODEC_FLAG_INTERLACED_ME) ||
793 if (ff_MPV_common_init(s) < 0)
796 if (!s->dct_quantize)
797 s->dct_quantize = ff_dct_quantize_c;
799 s->denoise_dct = denoise_dct_c;
800 s->fast_dct_quantize = s->dct_quantize;
802 s->dct_quantize = dct_quantize_trellis_c;
804 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
805 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
807 s->quant_precision = 5;
809 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
810 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
812 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
813 ff_h261_encode_init(s);
814 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
815 ff_h263_encode_init(s);
816 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
817 ff_msmpeg4_encode_init(s);
818 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
819 && s->out_format == FMT_MPEG1)
820 ff_mpeg1_encode_init(s);
823 for (i = 0; i < 64; i++) {
824 int j = s->dsp.idct_permutation[i];
825 if (CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4 &&
827 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
828 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
829 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
831 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
834 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
835 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
837 if (s->avctx->intra_matrix)
838 s->intra_matrix[j] = s->avctx->intra_matrix[i];
839 if (s->avctx->inter_matrix)
840 s->inter_matrix[j] = s->avctx->inter_matrix[i];
843 /* precompute matrix */
844 /* for mjpeg, we do include qscale in the matrix */
845 if (s->out_format != FMT_MJPEG) {
846 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
847 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
849 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
850 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
854 if (ff_rate_control_init(s) < 0)
860 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
862 MpegEncContext *s = avctx->priv_data;
864 ff_rate_control_uninit(s);
866 ff_MPV_common_end(s);
867 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
868 s->out_format == FMT_MJPEG)
869 ff_mjpeg_encode_close(s);
871 av_freep(&avctx->extradata);
876 static int get_sae(uint8_t *src, int ref, int stride)
881 for (y = 0; y < 16; y++) {
882 for (x = 0; x < 16; x++) {
883 acc += FFABS(src[x + y * stride] - ref);
890 static int get_intra_count(MpegEncContext *s, uint8_t *src,
891 uint8_t *ref, int stride)
899 for (y = 0; y < h; y += 16) {
900 for (x = 0; x < w; x += 16) {
901 int offset = x + y * stride;
902 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
904 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
905 int sae = get_sae(src + offset, mean, stride);
907 acc += sae + 500 < sad;
914 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
919 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
920 (s->low_delay ? 0 : 1);
925 pic_arg->display_picture_number = s->input_picture_number++;
927 if (pts != AV_NOPTS_VALUE) {
928 if (s->user_specified_pts != AV_NOPTS_VALUE) {
930 int64_t last = s->user_specified_pts;
933 av_log(s->avctx, AV_LOG_ERROR,
934 "Error, Invalid timestamp=%"PRId64", "
935 "last=%"PRId64"\n", pts, s->user_specified_pts);
939 if (!s->low_delay && pic_arg->display_picture_number == 1)
940 s->dts_delta = time - last;
942 s->user_specified_pts = pts;
944 if (s->user_specified_pts != AV_NOPTS_VALUE) {
945 s->user_specified_pts =
946 pts = s->user_specified_pts + 1;
947 av_log(s->avctx, AV_LOG_INFO,
948 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
951 pts = pic_arg->display_picture_number;
957 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
959 if (pic_arg->linesize[0] != s->linesize)
961 if (pic_arg->linesize[1] != s->uvlinesize)
963 if (pic_arg->linesize[2] != s->uvlinesize)
966 //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
967 // pic_arg->linesize[1], s->linesize, s->uvlinesize);
970 i = ff_find_unused_picture(s, 1);
974 pic = &s->picture[i].f;
977 for (i = 0; i < 4; i++) {
978 pic->data[i] = pic_arg->data[i];
979 pic->linesize[i] = pic_arg->linesize[i];
981 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
985 i = ff_find_unused_picture(s, 0);
989 pic = &s->picture[i].f;
992 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
996 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
997 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
998 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1001 int h_chroma_shift, v_chroma_shift;
1002 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1005 for (i = 0; i < 3; i++) {
1006 int src_stride = pic_arg->linesize[i];
1007 int dst_stride = i ? s->uvlinesize : s->linesize;
1008 int h_shift = i ? h_chroma_shift : 0;
1009 int v_shift = i ? v_chroma_shift : 0;
1010 int w = s->width >> h_shift;
1011 int h = s->height >> v_shift;
1012 uint8_t *src = pic_arg->data[i];
1013 uint8_t *dst = pic->data[i];
1015 if(s->codec_id == CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1016 h= ((s->height+15)/16*16)>>v_shift;
1019 if (!s->avctx->rc_buffer_size)
1020 dst += INPLACE_OFFSET;
1022 if (src_stride == dst_stride)
1023 memcpy(dst, src, src_stride * h);
1026 memcpy(dst, src, w);
1034 copy_picture_attributes(s, pic, pic_arg);
1035 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1038 /* shift buffer entries */
1039 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1040 s->input_picture[i - 1] = s->input_picture[i];
1042 s->input_picture[encoding_delay] = (Picture*) pic;
1047 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1051 int64_t score64 = 0;
1053 for (plane = 0; plane < 3; plane++) {
1054 const int stride = p->f.linesize[plane];
1055 const int bw = plane ? 1 : 2;
1056 for (y = 0; y < s->mb_height * bw; y++) {
1057 for (x = 0; x < s->mb_width * bw; x++) {
1058 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1059 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1060 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1061 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1063 switch (s->avctx->frame_skip_exp) {
1064 case 0: score = FFMAX(score, v); break;
1065 case 1: score += FFABS(v); break;
1066 case 2: score += v * v; break;
1067 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1068 case 4: score64 += v * v * (int64_t)(v * v); break;
1077 if (score64 < s->avctx->frame_skip_threshold)
1079 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1084 static int estimate_best_b_count(MpegEncContext *s)
1086 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1087 AVCodecContext *c = avcodec_alloc_context3(NULL);
1088 AVFrame input[FF_MAX_B_FRAMES + 2];
1089 const int scale = s->avctx->brd_scale;
1090 int i, j, out_size, p_lambda, b_lambda, lambda2;
1091 int outbuf_size = s->width * s->height; // FIXME
1092 uint8_t *outbuf = av_malloc(outbuf_size);
1093 int64_t best_rd = INT64_MAX;
1094 int best_b_count = -1;
1096 assert(scale >= 0 && scale <= 3);
1099 //s->next_picture_ptr->quality;
1100 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1101 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1102 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1103 if (!b_lambda) // FIXME we should do this somewhere else
1104 b_lambda = p_lambda;
1105 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1108 c->width = s->width >> scale;
1109 c->height = s->height >> scale;
1110 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1111 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1112 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1113 c->mb_decision = s->avctx->mb_decision;
1114 c->me_cmp = s->avctx->me_cmp;
1115 c->mb_cmp = s->avctx->mb_cmp;
1116 c->me_sub_cmp = s->avctx->me_sub_cmp;
1117 c->pix_fmt = PIX_FMT_YUV420P;
1118 c->time_base = s->avctx->time_base;
1119 c->max_b_frames = s->max_b_frames;
1121 if (avcodec_open2(c, codec, NULL) < 0)
1124 for (i = 0; i < s->max_b_frames + 2; i++) {
1125 int ysize = c->width * c->height;
1126 int csize = (c->width / 2) * (c->height / 2);
1127 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1128 s->next_picture_ptr;
1130 avcodec_get_frame_defaults(&input[i]);
1131 input[i].data[0] = av_malloc(ysize + 2 * csize);
1132 input[i].data[1] = input[i].data[0] + ysize;
1133 input[i].data[2] = input[i].data[1] + csize;
1134 input[i].linesize[0] = c->width;
1135 input[i].linesize[1] =
1136 input[i].linesize[2] = c->width / 2;
1138 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1139 pre_input = *pre_input_ptr;
1141 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1142 pre_input.f.data[0] += INPLACE_OFFSET;
1143 pre_input.f.data[1] += INPLACE_OFFSET;
1144 pre_input.f.data[2] += INPLACE_OFFSET;
1147 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1148 pre_input.f.data[0], pre_input.f.linesize[0],
1149 c->width, c->height);
1150 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1151 pre_input.f.data[1], pre_input.f.linesize[1],
1152 c->width >> 1, c->height >> 1);
1153 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1154 pre_input.f.data[2], pre_input.f.linesize[2],
1155 c->width >> 1, c->height >> 1);
1159 for (j = 0; j < s->max_b_frames + 1; j++) {
1162 if (!s->input_picture[j])
1165 c->error[0] = c->error[1] = c->error[2] = 0;
1167 input[0].pict_type = AV_PICTURE_TYPE_I;
1168 input[0].quality = 1 * FF_QP2LAMBDA;
1169 out_size = avcodec_encode_video(c, outbuf,
1170 outbuf_size, &input[0]);
1171 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1173 for (i = 0; i < s->max_b_frames + 1; i++) {
1174 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1176 input[i + 1].pict_type = is_p ?
1177 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1178 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1179 out_size = avcodec_encode_video(c, outbuf, outbuf_size,
1181 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1184 /* get the delayed frames */
1186 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
1187 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1190 rd += c->error[0] + c->error[1] + c->error[2];
1202 for (i = 0; i < s->max_b_frames + 2; i++) {
1203 av_freep(&input[i].data[0]);
1206 return best_b_count;
1209 static int select_input_picture(MpegEncContext *s)
1213 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1214 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1215 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1217 /* set next picture type & ordering */
1218 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1219 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1220 s->next_picture_ptr == NULL || s->intra_only) {
1221 s->reordered_input_picture[0] = s->input_picture[0];
1222 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1223 s->reordered_input_picture[0]->f.coded_picture_number =
1224 s->coded_picture_number++;
1228 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1229 if (s->picture_in_gop_number < s->gop_size &&
1230 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1231 // FIXME check that te gop check above is +-1 correct
1232 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1233 // s->input_picture[0]->f.data[0],
1234 // s->input_picture[0]->pts);
1236 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1237 for (i = 0; i < 4; i++)
1238 s->input_picture[0]->f.data[i] = NULL;
1239 s->input_picture[0]->f.type = 0;
1241 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1242 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1244 s->avctx->release_buffer(s->avctx,
1245 &s->input_picture[0]->f);
1249 ff_vbv_update(s, 0);
1255 if (s->flags & CODEC_FLAG_PASS2) {
1256 for (i = 0; i < s->max_b_frames + 1; i++) {
1257 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1259 if (pict_num >= s->rc_context.num_entries)
1261 if (!s->input_picture[i]) {
1262 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1266 s->input_picture[i]->f.pict_type =
1267 s->rc_context.entry[pict_num].new_pict_type;
1271 if (s->avctx->b_frame_strategy == 0) {
1272 b_frames = s->max_b_frames;
1273 while (b_frames && !s->input_picture[b_frames])
1275 } else if (s->avctx->b_frame_strategy == 1) {
1276 for (i = 1; i < s->max_b_frames + 1; i++) {
1277 if (s->input_picture[i] &&
1278 s->input_picture[i]->b_frame_score == 0) {
1279 s->input_picture[i]->b_frame_score =
1281 s->input_picture[i ]->f.data[0],
1282 s->input_picture[i - 1]->f.data[0],
1286 for (i = 0; i < s->max_b_frames + 1; i++) {
1287 if (s->input_picture[i] == NULL ||
1288 s->input_picture[i]->b_frame_score - 1 >
1289 s->mb_num / s->avctx->b_sensitivity)
1293 b_frames = FFMAX(0, i - 1);
1296 for (i = 0; i < b_frames + 1; i++) {
1297 s->input_picture[i]->b_frame_score = 0;
1299 } else if (s->avctx->b_frame_strategy == 2) {
1300 b_frames = estimate_best_b_count(s);
1302 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1307 //static int b_count = 0;
1308 //b_count += b_frames;
1309 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1311 for (i = b_frames - 1; i >= 0; i--) {
1312 int type = s->input_picture[i]->f.pict_type;
1313 if (type && type != AV_PICTURE_TYPE_B)
1316 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1317 b_frames == s->max_b_frames) {
1318 av_log(s->avctx, AV_LOG_ERROR,
1319 "warning, too many b frames in a row\n");
1322 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1323 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1324 s->gop_size > s->picture_in_gop_number) {
1325 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1327 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1329 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1333 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1334 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1337 s->reordered_input_picture[0] = s->input_picture[b_frames];
1338 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1339 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1340 s->reordered_input_picture[0]->f.coded_picture_number =
1341 s->coded_picture_number++;
1342 for (i = 0; i < b_frames; i++) {
1343 s->reordered_input_picture[i + 1] = s->input_picture[i];
1344 s->reordered_input_picture[i + 1]->f.pict_type =
1346 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1347 s->coded_picture_number++;
1352 if (s->reordered_input_picture[0]) {
1353 s->reordered_input_picture[0]->f.reference =
1354 s->reordered_input_picture[0]->f.pict_type !=
1355 AV_PICTURE_TYPE_B ? 3 : 0;
1357 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1359 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1360 s->avctx->rc_buffer_size) {
1361 // input is a shared pix, so we can't modifiy it -> alloc a new
1362 // one & ensure that the shared one is reuseable
1365 int i = ff_find_unused_picture(s, 0);
1368 pic = &s->picture[i];
1370 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1371 if (ff_alloc_picture(s, pic, 0) < 0) {
1375 /* mark us unused / free shared pic */
1376 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1377 s->avctx->release_buffer(s->avctx,
1378 &s->reordered_input_picture[0]->f);
1379 for (i = 0; i < 4; i++)
1380 s->reordered_input_picture[0]->f.data[i] = NULL;
1381 s->reordered_input_picture[0]->f.type = 0;
1383 copy_picture_attributes(s, &pic->f,
1384 &s->reordered_input_picture[0]->f);
1386 s->current_picture_ptr = pic;
1388 // input is not a shared pix -> reuse buffer for current_pix
1390 assert(s->reordered_input_picture[0]->f.type ==
1391 FF_BUFFER_TYPE_USER ||
1392 s->reordered_input_picture[0]->f.type ==
1393 FF_BUFFER_TYPE_INTERNAL);
1395 s->current_picture_ptr = s->reordered_input_picture[0];
1396 for (i = 0; i < 4; i++) {
1397 s->new_picture.f.data[i] += INPLACE_OFFSET;
1400 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1402 s->picture_number = s->new_picture.f.display_picture_number;
1403 //printf("dpn:%d\n", s->picture_number);
1405 memset(&s->new_picture, 0, sizeof(Picture));
1410 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1411 AVFrame *pic_arg, int *got_packet)
1413 MpegEncContext *s = avctx->priv_data;
1414 int i, stuffing_count, ret;
1415 int context_count = s->slice_context_count;
1417 s->picture_in_gop_number++;
1419 if (load_input_picture(s, pic_arg) < 0)
1422 if (select_input_picture(s) < 0) {
1427 if (s->new_picture.f.data[0]) {
1428 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1431 s->mb_info_ptr = av_packet_new_side_data(pkt,
1432 AV_PKT_DATA_H263_MB_INFO,
1433 s->mb_width*s->mb_height*12);
1434 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1437 for (i = 0; i < context_count; i++) {
1438 int start_y = s->thread_context[i]->start_mb_y;
1439 int end_y = s->thread_context[i]-> end_mb_y;
1440 int h = s->mb_height;
1441 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1442 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1444 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1447 s->pict_type = s->new_picture.f.pict_type;
1449 //printf("qs:%f %f %d\n", s->new_picture.quality,
1450 // s->current_picture.quality, s->qscale);
1451 ff_MPV_frame_start(s, avctx);
1453 if (encode_picture(s, s->picture_number) < 0)
1456 avctx->header_bits = s->header_bits;
1457 avctx->mv_bits = s->mv_bits;
1458 avctx->misc_bits = s->misc_bits;
1459 avctx->i_tex_bits = s->i_tex_bits;
1460 avctx->p_tex_bits = s->p_tex_bits;
1461 avctx->i_count = s->i_count;
1462 // FIXME f/b_count in avctx
1463 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1464 avctx->skip_count = s->skip_count;
1466 ff_MPV_frame_end(s);
1468 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1469 ff_mjpeg_encode_picture_trailer(s);
1471 if (avctx->rc_buffer_size) {
1472 RateControlContext *rcc = &s->rc_context;
1473 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1475 if (put_bits_count(&s->pb) > max_size &&
1476 s->lambda < s->avctx->lmax) {
1477 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1478 (s->qscale + 1) / s->qscale);
1479 if (s->adaptive_quant) {
1481 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1482 s->lambda_table[i] =
1483 FFMAX(s->lambda_table[i] + 1,
1484 s->lambda_table[i] * (s->qscale + 1) /
1487 s->mb_skipped = 0; // done in MPV_frame_start()
1488 // done in encode_picture() so we must undo it
1489 if (s->pict_type == AV_PICTURE_TYPE_P) {
1490 if (s->flipflop_rounding ||
1491 s->codec_id == CODEC_ID_H263P ||
1492 s->codec_id == CODEC_ID_MPEG4)
1493 s->no_rounding ^= 1;
1495 if (s->pict_type != AV_PICTURE_TYPE_B) {
1496 s->time_base = s->last_time_base;
1497 s->last_non_b_time = s->time - s->pp_time;
1499 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1500 for (i = 0; i < context_count; i++) {
1501 PutBitContext *pb = &s->thread_context[i]->pb;
1502 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1507 assert(s->avctx->rc_max_rate);
1510 if (s->flags & CODEC_FLAG_PASS1)
1511 ff_write_pass1_stats(s);
1513 for (i = 0; i < 4; i++) {
1514 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1515 avctx->error[i] += s->current_picture_ptr->f.error[i];
1518 if (s->flags & CODEC_FLAG_PASS1)
1519 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1520 avctx->i_tex_bits + avctx->p_tex_bits ==
1521 put_bits_count(&s->pb));
1522 flush_put_bits(&s->pb);
1523 s->frame_bits = put_bits_count(&s->pb);
1525 stuffing_count = ff_vbv_update(s, s->frame_bits);
1526 if (stuffing_count) {
1527 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1528 stuffing_count + 50) {
1529 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1533 switch (s->codec_id) {
1534 case CODEC_ID_MPEG1VIDEO:
1535 case CODEC_ID_MPEG2VIDEO:
1536 while (stuffing_count--) {
1537 put_bits(&s->pb, 8, 0);
1540 case CODEC_ID_MPEG4:
1541 put_bits(&s->pb, 16, 0);
1542 put_bits(&s->pb, 16, 0x1C3);
1543 stuffing_count -= 4;
1544 while (stuffing_count--) {
1545 put_bits(&s->pb, 8, 0xFF);
1549 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1551 flush_put_bits(&s->pb);
1552 s->frame_bits = put_bits_count(&s->pb);
1555 /* update mpeg1/2 vbv_delay for CBR */
1556 if (s->avctx->rc_max_rate &&
1557 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1558 s->out_format == FMT_MPEG1 &&
1559 90000LL * (avctx->rc_buffer_size - 1) <=
1560 s->avctx->rc_max_rate * 0xFFFFLL) {
1561 int vbv_delay, min_delay;
1562 double inbits = s->avctx->rc_max_rate *
1563 av_q2d(s->avctx->time_base);
1564 int minbits = s->frame_bits - 8 *
1565 (s->vbv_delay_ptr - s->pb.buf - 1);
1566 double bits = s->rc_context.buffer_index + minbits - inbits;
1569 av_log(s->avctx, AV_LOG_ERROR,
1570 "Internal error, negative bits\n");
1572 assert(s->repeat_first_field == 0);
1574 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1575 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1576 s->avctx->rc_max_rate;
1578 vbv_delay = FFMAX(vbv_delay, min_delay);
1580 assert(vbv_delay < 0xFFFF);
1582 s->vbv_delay_ptr[0] &= 0xF8;
1583 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1584 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1585 s->vbv_delay_ptr[2] &= 0x07;
1586 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1587 avctx->vbv_delay = vbv_delay * 300;
1589 s->total_bits += s->frame_bits;
1590 avctx->frame_bits = s->frame_bits;
1592 pkt->pts = s->current_picture.f.pts;
1593 if (!s->low_delay) {
1594 if (!s->current_picture.f.coded_picture_number)
1595 pkt->dts = pkt->pts - s->dts_delta;
1597 pkt->dts = s->reordered_pts;
1598 s->reordered_pts = s->input_picture[0]->f.pts;
1600 pkt->dts = pkt->pts;
1601 if (s->current_picture.f.key_frame)
1602 pkt->flags |= AV_PKT_FLAG_KEY;
1604 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1606 assert((put_bits_ptr(&s->pb) == s->pb.buf));
1609 assert((s->frame_bits & 7) == 0);
1611 pkt->size = s->frame_bits / 8;
1612 *got_packet = !!pkt->size;
1616 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1617 int n, int threshold)
1619 static const char tab[64] = {
1620 3, 2, 2, 1, 1, 1, 1, 1,
1621 1, 1, 1, 1, 1, 1, 1, 1,
1622 1, 1, 1, 1, 1, 1, 1, 1,
1623 0, 0, 0, 0, 0, 0, 0, 0,
1624 0, 0, 0, 0, 0, 0, 0, 0,
1625 0, 0, 0, 0, 0, 0, 0, 0,
1626 0, 0, 0, 0, 0, 0, 0, 0,
1627 0, 0, 0, 0, 0, 0, 0, 0
1632 DCTELEM *block = s->block[n];
1633 const int last_index = s->block_last_index[n];
1636 if (threshold < 0) {
1638 threshold = -threshold;
1642 /* Are all we could set to zero already zero? */
1643 if (last_index <= skip_dc - 1)
1646 for (i = 0; i <= last_index; i++) {
1647 const int j = s->intra_scantable.permutated[i];
1648 const int level = FFABS(block[j]);
1650 if (skip_dc && i == 0)
1654 } else if (level > 1) {
1660 if (score >= threshold)
1662 for (i = skip_dc; i <= last_index; i++) {
1663 const int j = s->intra_scantable.permutated[i];
1667 s->block_last_index[n] = 0;
1669 s->block_last_index[n] = -1;
1672 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1676 const int maxlevel = s->max_qcoeff;
1677 const int minlevel = s->min_qcoeff;
1681 i = 1; // skip clipping of intra dc
1685 for (; i <= last_index; i++) {
1686 const int j = s->intra_scantable.permutated[i];
1687 int level = block[j];
1689 if (level > maxlevel) {
1692 } else if (level < minlevel) {
1700 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1701 av_log(s->avctx, AV_LOG_INFO,
1702 "warning, clipping %d dct coefficients to %d..%d\n",
1703 overflow, minlevel, maxlevel);
1706 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1710 for (y = 0; y < 8; y++) {
1711 for (x = 0; x < 8; x++) {
1717 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1718 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1719 int v = ptr[x2 + y2 * stride];
1725 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1730 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1731 int motion_x, int motion_y,
1732 int mb_block_height,
1735 int16_t weight[8][64];
1736 DCTELEM orig[8][64];
1737 const int mb_x = s->mb_x;
1738 const int mb_y = s->mb_y;
1741 int dct_offset = s->linesize * 8; // default for progressive frames
1742 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1745 for (i = 0; i < mb_block_count; i++)
1746 skip_dct[i] = s->skipdct;
1748 if (s->adaptive_quant) {
1749 const int last_qp = s->qscale;
1750 const int mb_xy = mb_x + mb_y * s->mb_stride;
1752 s->lambda = s->lambda_table[mb_xy];
1755 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1756 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1757 s->dquant = s->qscale - last_qp;
1759 if (s->out_format == FMT_H263) {
1760 s->dquant = av_clip(s->dquant, -2, 2);
1762 if (s->codec_id == CODEC_ID_MPEG4) {
1764 if (s->pict_type == AV_PICTURE_TYPE_B) {
1765 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1768 if (s->mv_type == MV_TYPE_8X8)
1774 ff_set_qscale(s, last_qp + s->dquant);
1775 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1776 ff_set_qscale(s, s->qscale + s->dquant);
1778 wrap_y = s->linesize;
1779 wrap_c = s->uvlinesize;
1780 ptr_y = s->new_picture.f.data[0] +
1781 (mb_y * 16 * wrap_y) + mb_x * 16;
1782 ptr_cb = s->new_picture.f.data[1] +
1783 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1784 ptr_cr = s->new_picture.f.data[2] +
1785 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1787 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != CODEC_ID_AMV){
1788 uint8_t *ebuf = s->edge_emu_buffer + 32;
1789 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1790 mb_y * 16, s->width, s->height);
1792 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1793 mb_block_height, mb_x * 8, mb_y * 8,
1794 s->width >> 1, s->height >> 1);
1795 ptr_cb = ebuf + 18 * wrap_y;
1796 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1797 mb_block_height, mb_x * 8, mb_y * 8,
1798 s->width >> 1, s->height >> 1);
1799 ptr_cr = ebuf + 18 * wrap_y + 8;
1803 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1804 int progressive_score, interlaced_score;
1806 s->interlaced_dct = 0;
1807 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1809 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1810 NULL, wrap_y, 8) - 400;
1812 if (progressive_score > 0) {
1813 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1814 NULL, wrap_y * 2, 8) +
1815 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1816 NULL, wrap_y * 2, 8);
1817 if (progressive_score > interlaced_score) {
1818 s->interlaced_dct = 1;
1820 dct_offset = wrap_y;
1822 if (s->chroma_format == CHROMA_422)
1828 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1829 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1830 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1831 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1833 if (s->flags & CODEC_FLAG_GRAY) {
1837 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1838 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1839 if (!s->chroma_y_shift) { /* 422 */
1840 s->dsp.get_pixels(s->block[6],
1841 ptr_cb + (dct_offset >> 1), wrap_c);
1842 s->dsp.get_pixels(s->block[7],
1843 ptr_cr + (dct_offset >> 1), wrap_c);
1847 op_pixels_func (*op_pix)[4];
1848 qpel_mc_func (*op_qpix)[16];
1849 uint8_t *dest_y, *dest_cb, *dest_cr;
1851 dest_y = s->dest[0];
1852 dest_cb = s->dest[1];
1853 dest_cr = s->dest[2];
1855 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1856 op_pix = s->dsp.put_pixels_tab;
1857 op_qpix = s->dsp.put_qpel_pixels_tab;
1859 op_pix = s->dsp.put_no_rnd_pixels_tab;
1860 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1863 if (s->mv_dir & MV_DIR_FORWARD) {
1864 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data,
1866 op_pix = s->dsp.avg_pixels_tab;
1867 op_qpix = s->dsp.avg_qpel_pixels_tab;
1869 if (s->mv_dir & MV_DIR_BACKWARD) {
1870 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data,
1874 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1875 int progressive_score, interlaced_score;
1877 s->interlaced_dct = 0;
1878 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1881 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1882 ptr_y + wrap_y * 8, wrap_y,
1885 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1886 progressive_score -= 400;
1888 if (progressive_score > 0) {
1889 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1892 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1896 if (progressive_score > interlaced_score) {
1897 s->interlaced_dct = 1;
1899 dct_offset = wrap_y;
1901 if (s->chroma_format == CHROMA_422)
1907 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1908 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1909 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1910 dest_y + dct_offset, wrap_y);
1911 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1912 dest_y + dct_offset + 8, wrap_y);
1914 if (s->flags & CODEC_FLAG_GRAY) {
1918 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1919 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1920 if (!s->chroma_y_shift) { /* 422 */
1921 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1922 dest_cb + (dct_offset >> 1), wrap_c);
1923 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1924 dest_cr + (dct_offset >> 1), wrap_c);
1927 /* pre quantization */
1928 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1929 2 * s->qscale * s->qscale) {
1931 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1932 wrap_y, 8) < 20 * s->qscale)
1934 if (s->dsp.sad[1](NULL, ptr_y + 8,
1935 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1937 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1938 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1940 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1941 dest_y + dct_offset + 8,
1942 wrap_y, 8) < 20 * s->qscale)
1944 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1945 wrap_c, 8) < 20 * s->qscale)
1947 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1948 wrap_c, 8) < 20 * s->qscale)
1950 if (!s->chroma_y_shift) { /* 422 */
1951 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1952 dest_cb + (dct_offset >> 1),
1953 wrap_c, 8) < 20 * s->qscale)
1955 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1956 dest_cr + (dct_offset >> 1),
1957 wrap_c, 8) < 20 * s->qscale)
1963 if (s->quantizer_noise_shaping) {
1965 get_visual_weight(weight[0], ptr_y , wrap_y);
1967 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
1969 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
1971 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
1973 get_visual_weight(weight[4], ptr_cb , wrap_c);
1975 get_visual_weight(weight[5], ptr_cr , wrap_c);
1976 if (!s->chroma_y_shift) { /* 422 */
1978 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
1981 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
1984 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
1987 /* DCT & quantize */
1988 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
1990 for (i = 0; i < mb_block_count; i++) {
1993 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
1994 // FIXME we could decide to change to quantizer instead of
1996 // JS: I don't think that would be a good idea it could lower
1997 // quality instead of improve it. Just INTRADC clipping
1998 // deserves changes in quantizer
2000 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2002 s->block_last_index[i] = -1;
2004 if (s->quantizer_noise_shaping) {
2005 for (i = 0; i < mb_block_count; i++) {
2007 s->block_last_index[i] =
2008 dct_quantize_refine(s, s->block[i], weight[i],
2009 orig[i], i, s->qscale);
2014 if (s->luma_elim_threshold && !s->mb_intra)
2015 for (i = 0; i < 4; i++)
2016 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2017 if (s->chroma_elim_threshold && !s->mb_intra)
2018 for (i = 4; i < mb_block_count; i++)
2019 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2021 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2022 for (i = 0; i < mb_block_count; i++) {
2023 if (s->block_last_index[i] == -1)
2024 s->coded_score[i] = INT_MAX / 256;
2029 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2030 s->block_last_index[4] =
2031 s->block_last_index[5] = 0;
2033 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2036 // non c quantize code returns incorrect block_last_index FIXME
2037 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2038 for (i = 0; i < mb_block_count; i++) {
2040 if (s->block_last_index[i] > 0) {
2041 for (j = 63; j > 0; j--) {
2042 if (s->block[i][s->intra_scantable.permutated[j]])
2045 s->block_last_index[i] = j;
2050 /* huffman encode */
2051 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2052 case CODEC_ID_MPEG1VIDEO:
2053 case CODEC_ID_MPEG2VIDEO:
2054 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2055 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2057 case CODEC_ID_MPEG4:
2058 if (CONFIG_MPEG4_ENCODER)
2059 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2061 case CODEC_ID_MSMPEG4V2:
2062 case CODEC_ID_MSMPEG4V3:
2064 if (CONFIG_MSMPEG4_ENCODER)
2065 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2068 if (CONFIG_WMV2_ENCODER)
2069 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2072 if (CONFIG_H261_ENCODER)
2073 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2076 case CODEC_ID_H263P:
2080 if (CONFIG_H263_ENCODER)
2081 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2083 case CODEC_ID_MJPEG:
2085 if (CONFIG_MJPEG_ENCODER)
2086 ff_mjpeg_encode_mb(s, s->block);
2093 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2095 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2096 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2099 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2102 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2105 d->mb_skip_run= s->mb_skip_run;
2107 d->last_dc[i] = s->last_dc[i];
2110 d->mv_bits= s->mv_bits;
2111 d->i_tex_bits= s->i_tex_bits;
2112 d->p_tex_bits= s->p_tex_bits;
2113 d->i_count= s->i_count;
2114 d->f_count= s->f_count;
2115 d->b_count= s->b_count;
2116 d->skip_count= s->skip_count;
2117 d->misc_bits= s->misc_bits;
2121 d->qscale= s->qscale;
2122 d->dquant= s->dquant;
2124 d->esc3_level_length= s->esc3_level_length;
2127 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2130 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2131 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2134 d->mb_skip_run= s->mb_skip_run;
2136 d->last_dc[i] = s->last_dc[i];
2139 d->mv_bits= s->mv_bits;
2140 d->i_tex_bits= s->i_tex_bits;
2141 d->p_tex_bits= s->p_tex_bits;
2142 d->i_count= s->i_count;
2143 d->f_count= s->f_count;
2144 d->b_count= s->b_count;
2145 d->skip_count= s->skip_count;
2146 d->misc_bits= s->misc_bits;
2148 d->mb_intra= s->mb_intra;
2149 d->mb_skipped= s->mb_skipped;
2150 d->mv_type= s->mv_type;
2151 d->mv_dir= s->mv_dir;
2153 if(s->data_partitioning){
2155 d->tex_pb= s->tex_pb;
2159 d->block_last_index[i]= s->block_last_index[i];
2160 d->interlaced_dct= s->interlaced_dct;
2161 d->qscale= s->qscale;
2163 d->esc3_level_length= s->esc3_level_length;
2166 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2167 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2168 int *dmin, int *next_block, int motion_x, int motion_y)
2171 uint8_t *dest_backup[3];
2173 copy_context_before_encode(s, backup, type);
2175 s->block= s->blocks[*next_block];
2176 s->pb= pb[*next_block];
2177 if(s->data_partitioning){
2178 s->pb2 = pb2 [*next_block];
2179 s->tex_pb= tex_pb[*next_block];
2183 memcpy(dest_backup, s->dest, sizeof(s->dest));
2184 s->dest[0] = s->rd_scratchpad;
2185 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2186 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2187 assert(s->linesize >= 32); //FIXME
2190 encode_mb(s, motion_x, motion_y);
2192 score= put_bits_count(&s->pb);
2193 if(s->data_partitioning){
2194 score+= put_bits_count(&s->pb2);
2195 score+= put_bits_count(&s->tex_pb);
2198 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2199 ff_MPV_decode_mb(s, s->block);
2201 score *= s->lambda2;
2202 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2206 memcpy(s->dest, dest_backup, sizeof(s->dest));
2213 copy_context_after_encode(best, s, type);
2217 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2218 uint32_t *sq = ff_squareTbl + 256;
2223 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2224 else if(w==8 && h==8)
2225 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2229 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2238 static int sse_mb(MpegEncContext *s){
2242 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2243 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2246 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2247 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)
2248 +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)
2249 +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);
2251 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)
2252 +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)
2253 +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);
2256 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)
2257 +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)
2258 +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);
2261 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2262 MpegEncContext *s= *(void**)arg;
2266 s->me.dia_size= s->avctx->pre_dia_size;
2267 s->first_slice_line=1;
2268 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2269 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2270 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2272 s->first_slice_line=0;
2280 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2281 MpegEncContext *s= *(void**)arg;
2283 ff_check_alignment();
2285 s->me.dia_size= s->avctx->dia_size;
2286 s->first_slice_line=1;
2287 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2288 s->mb_x=0; //for block init below
2289 ff_init_block_index(s);
2290 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2291 s->block_index[0]+=2;
2292 s->block_index[1]+=2;
2293 s->block_index[2]+=2;
2294 s->block_index[3]+=2;
2296 /* compute motion vector & mb_type and store in context */
2297 if(s->pict_type==AV_PICTURE_TYPE_B)
2298 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2300 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2302 s->first_slice_line=0;
2307 static int mb_var_thread(AVCodecContext *c, void *arg){
2308 MpegEncContext *s= *(void**)arg;
2311 ff_check_alignment();
2313 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2314 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2317 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2319 int sum = s->dsp.pix_sum(pix, s->linesize);
2321 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2323 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2324 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2325 s->me.mb_var_sum_temp += varc;
2331 static void write_slice_end(MpegEncContext *s){
2332 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
2333 if(s->partitioned_frame){
2334 ff_mpeg4_merge_partitions(s);
2337 ff_mpeg4_stuffing(&s->pb);
2338 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2339 ff_mjpeg_encode_stuffing(&s->pb);
2342 avpriv_align_put_bits(&s->pb);
2343 flush_put_bits(&s->pb);
2345 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2346 s->misc_bits+= get_bits_diff(s);
2349 static void write_mb_info(MpegEncContext *s)
2351 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2352 int offset = put_bits_count(&s->pb);
2353 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2354 int gobn = s->mb_y / s->gob_index;
2356 if (CONFIG_H263_ENCODER)
2357 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2358 bytestream_put_le32(&ptr, offset);
2359 bytestream_put_byte(&ptr, s->qscale);
2360 bytestream_put_byte(&ptr, gobn);
2361 bytestream_put_le16(&ptr, mba);
2362 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2363 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2364 /* 4MV not implemented */
2365 bytestream_put_byte(&ptr, 0); /* hmv2 */
2366 bytestream_put_byte(&ptr, 0); /* vmv2 */
2369 static void update_mb_info(MpegEncContext *s, int startcode)
2373 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2374 s->mb_info_size += 12;
2375 s->prev_mb_info = s->last_mb_info;
2378 s->prev_mb_info = put_bits_count(&s->pb)/8;
2379 /* This might have incremented mb_info_size above, and we return without
2380 * actually writing any info into that slot yet. But in that case,
2381 * this will be called again at the start of the after writing the
2382 * start code, actually writing the mb info. */
2386 s->last_mb_info = put_bits_count(&s->pb)/8;
2387 if (!s->mb_info_size)
2388 s->mb_info_size += 12;
2392 static int encode_thread(AVCodecContext *c, void *arg){
2393 MpegEncContext *s= *(void**)arg;
2394 int mb_x, mb_y, pdif = 0;
2395 int chr_h= 16>>s->chroma_y_shift;
2397 MpegEncContext best_s, backup_s;
2398 uint8_t bit_buf[2][MAX_MB_BYTES];
2399 uint8_t bit_buf2[2][MAX_MB_BYTES];
2400 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2401 PutBitContext pb[2], pb2[2], tex_pb[2];
2402 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2404 ff_check_alignment();
2407 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2408 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2409 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2412 s->last_bits= put_bits_count(&s->pb);
2423 /* init last dc values */
2424 /* note: quant matrix value (8) is implied here */
2425 s->last_dc[i] = 128 << s->intra_dc_precision;
2427 s->current_picture.f.error[i] = 0;
2429 if(s->codec_id==CODEC_ID_AMV){
2430 s->last_dc[0] = 128*8/13;
2431 s->last_dc[1] = 128*8/14;
2432 s->last_dc[2] = 128*8/14;
2435 memset(s->last_mv, 0, sizeof(s->last_mv));
2439 switch(s->codec_id){
2441 case CODEC_ID_H263P:
2443 if (CONFIG_H263_ENCODER)
2444 s->gob_index = ff_h263_get_gob_height(s);
2446 case CODEC_ID_MPEG4:
2447 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2448 ff_mpeg4_init_partitions(s);
2454 s->first_slice_line = 1;
2455 s->ptr_lastgob = s->pb.buf;
2456 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2457 // printf("row %d at %X\n", s->mb_y, (int)s);
2461 ff_set_qscale(s, s->qscale);
2462 ff_init_block_index(s);
2464 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2465 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2466 int mb_type= s->mb_type[xy];
2471 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2472 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2475 if(s->data_partitioning){
2476 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2477 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2478 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2484 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2485 ff_update_block_index(s);
2487 if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){
2488 ff_h261_reorder_mb_index(s);
2489 xy= s->mb_y*s->mb_stride + s->mb_x;
2490 mb_type= s->mb_type[xy];
2493 /* write gob / video packet header */
2495 int current_packet_size, is_gob_start;
2497 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2499 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2501 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2503 switch(s->codec_id){
2505 case CODEC_ID_H263P:
2506 if(!s->h263_slice_structured)
2507 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2509 case CODEC_ID_MPEG2VIDEO:
2510 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2511 case CODEC_ID_MPEG1VIDEO:
2512 if(s->mb_skip_run) is_gob_start=0;
2517 if(s->start_mb_y != mb_y || mb_x!=0){
2520 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
2521 ff_mpeg4_init_partitions(s);
2525 assert((put_bits_count(&s->pb)&7) == 0);
2526 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2528 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2529 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2530 int d= 100 / s->avctx->error_rate;
2532 current_packet_size=0;
2533 s->pb.buf_ptr= s->ptr_lastgob;
2534 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2538 if (s->avctx->rtp_callback){
2539 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2540 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2542 update_mb_info(s, 1);
2544 switch(s->codec_id){
2545 case CODEC_ID_MPEG4:
2546 if (CONFIG_MPEG4_ENCODER) {
2547 ff_mpeg4_encode_video_packet_header(s);
2548 ff_mpeg4_clean_buffers(s);
2551 case CODEC_ID_MPEG1VIDEO:
2552 case CODEC_ID_MPEG2VIDEO:
2553 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2554 ff_mpeg1_encode_slice_header(s);
2555 ff_mpeg1_clean_buffers(s);
2559 case CODEC_ID_H263P:
2560 if (CONFIG_H263_ENCODER)
2561 ff_h263_encode_gob_header(s, mb_y);
2565 if(s->flags&CODEC_FLAG_PASS1){
2566 int bits= put_bits_count(&s->pb);
2567 s->misc_bits+= bits - s->last_bits;
2571 s->ptr_lastgob += current_packet_size;
2572 s->first_slice_line=1;
2573 s->resync_mb_x=mb_x;
2574 s->resync_mb_y=mb_y;
2578 if( (s->resync_mb_x == s->mb_x)
2579 && s->resync_mb_y+1 == s->mb_y){
2580 s->first_slice_line=0;
2584 s->dquant=0; //only for QP_RD
2586 update_mb_info(s, 0);
2588 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
2590 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2592 copy_context_before_encode(&backup_s, s, -1);
2594 best_s.data_partitioning= s->data_partitioning;
2595 best_s.partitioned_frame= s->partitioned_frame;
2596 if(s->data_partitioning){
2597 backup_s.pb2= s->pb2;
2598 backup_s.tex_pb= s->tex_pb;
2601 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2602 s->mv_dir = MV_DIR_FORWARD;
2603 s->mv_type = MV_TYPE_16X16;
2605 s->mv[0][0][0] = s->p_mv_table[xy][0];
2606 s->mv[0][0][1] = s->p_mv_table[xy][1];
2607 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2608 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2610 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2611 s->mv_dir = MV_DIR_FORWARD;
2612 s->mv_type = MV_TYPE_FIELD;
2615 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2616 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2617 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2619 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2620 &dmin, &next_block, 0, 0);
2622 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2623 s->mv_dir = MV_DIR_FORWARD;
2624 s->mv_type = MV_TYPE_16X16;
2628 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2629 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2631 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2632 s->mv_dir = MV_DIR_FORWARD;
2633 s->mv_type = MV_TYPE_8X8;
2636 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2637 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2639 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2640 &dmin, &next_block, 0, 0);
2642 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2643 s->mv_dir = MV_DIR_FORWARD;
2644 s->mv_type = MV_TYPE_16X16;
2646 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2647 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2648 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2649 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2651 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2652 s->mv_dir = MV_DIR_BACKWARD;
2653 s->mv_type = MV_TYPE_16X16;
2655 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2656 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2657 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2658 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2660 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2661 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2662 s->mv_type = MV_TYPE_16X16;
2664 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2665 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2666 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2667 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2668 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2669 &dmin, &next_block, 0, 0);
2671 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2672 s->mv_dir = MV_DIR_FORWARD;
2673 s->mv_type = MV_TYPE_FIELD;
2676 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2677 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2678 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2680 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2681 &dmin, &next_block, 0, 0);
2683 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2684 s->mv_dir = MV_DIR_BACKWARD;
2685 s->mv_type = MV_TYPE_FIELD;
2688 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2689 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2690 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2692 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2693 &dmin, &next_block, 0, 0);
2695 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2696 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2697 s->mv_type = MV_TYPE_FIELD;
2699 for(dir=0; dir<2; dir++){
2701 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2702 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2703 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2706 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2707 &dmin, &next_block, 0, 0);
2709 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2711 s->mv_type = MV_TYPE_16X16;
2715 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2716 &dmin, &next_block, 0, 0);
2717 if(s->h263_pred || s->h263_aic){
2719 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2721 ff_clean_intra_table_entries(s); //old mode?
2725 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2726 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2727 const int last_qp= backup_s.qscale;
2730 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2731 static const int dquant_tab[4]={-1,1,-2,2};
2733 assert(backup_s.dquant == 0);
2736 s->mv_dir= best_s.mv_dir;
2737 s->mv_type = MV_TYPE_16X16;
2738 s->mb_intra= best_s.mb_intra;
2739 s->mv[0][0][0] = best_s.mv[0][0][0];
2740 s->mv[0][0][1] = best_s.mv[0][0][1];
2741 s->mv[1][0][0] = best_s.mv[1][0][0];
2742 s->mv[1][0][1] = best_s.mv[1][0][1];
2744 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2745 for(; qpi<4; qpi++){
2746 int dquant= dquant_tab[qpi];
2747 qp= last_qp + dquant;
2748 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2750 backup_s.dquant= dquant;
2751 if(s->mb_intra && s->dc_val[0]){
2753 dc[i]= s->dc_val[0][ s->block_index[i] ];
2754 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2758 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2759 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2760 if(best_s.qscale != qp){
2761 if(s->mb_intra && s->dc_val[0]){
2763 s->dc_val[0][ s->block_index[i] ]= dc[i];
2764 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2771 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2772 int mx= s->b_direct_mv_table[xy][0];
2773 int my= s->b_direct_mv_table[xy][1];
2775 backup_s.dquant = 0;
2776 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2778 ff_mpeg4_set_direct_mv(s, mx, my);
2779 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2780 &dmin, &next_block, mx, my);
2782 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2783 backup_s.dquant = 0;
2784 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2786 ff_mpeg4_set_direct_mv(s, 0, 0);
2787 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2788 &dmin, &next_block, 0, 0);
2790 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2793 coded |= s->block_last_index[i];
2796 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2797 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2798 mx=my=0; //FIXME find the one we actually used
2799 ff_mpeg4_set_direct_mv(s, mx, my);
2800 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2808 s->mv_dir= best_s.mv_dir;
2809 s->mv_type = best_s.mv_type;
2811 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2812 s->mv[0][0][1] = best_s.mv[0][0][1];
2813 s->mv[1][0][0] = best_s.mv[1][0][0];
2814 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2817 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2818 &dmin, &next_block, mx, my);
2823 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2825 copy_context_after_encode(s, &best_s, -1);
2827 pb_bits_count= put_bits_count(&s->pb);
2828 flush_put_bits(&s->pb);
2829 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2832 if(s->data_partitioning){
2833 pb2_bits_count= put_bits_count(&s->pb2);
2834 flush_put_bits(&s->pb2);
2835 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2836 s->pb2= backup_s.pb2;
2838 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2839 flush_put_bits(&s->tex_pb);
2840 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2841 s->tex_pb= backup_s.tex_pb;
2843 s->last_bits= put_bits_count(&s->pb);
2845 if (CONFIG_H263_ENCODER &&
2846 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2847 ff_h263_update_motion_val(s);
2849 if(next_block==0){ //FIXME 16 vs linesize16
2850 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2851 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2852 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2855 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2856 ff_MPV_decode_mb(s, s->block);
2858 int motion_x = 0, motion_y = 0;
2859 s->mv_type=MV_TYPE_16X16;
2860 // only one MB-Type possible
2863 case CANDIDATE_MB_TYPE_INTRA:
2866 motion_x= s->mv[0][0][0] = 0;
2867 motion_y= s->mv[0][0][1] = 0;
2869 case CANDIDATE_MB_TYPE_INTER:
2870 s->mv_dir = MV_DIR_FORWARD;
2872 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2873 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2875 case CANDIDATE_MB_TYPE_INTER_I:
2876 s->mv_dir = MV_DIR_FORWARD;
2877 s->mv_type = MV_TYPE_FIELD;
2880 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2881 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2882 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2885 case CANDIDATE_MB_TYPE_INTER4V:
2886 s->mv_dir = MV_DIR_FORWARD;
2887 s->mv_type = MV_TYPE_8X8;
2890 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2891 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2894 case CANDIDATE_MB_TYPE_DIRECT:
2895 if (CONFIG_MPEG4_ENCODER) {
2896 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2898 motion_x=s->b_direct_mv_table[xy][0];
2899 motion_y=s->b_direct_mv_table[xy][1];
2900 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2903 case CANDIDATE_MB_TYPE_DIRECT0:
2904 if (CONFIG_MPEG4_ENCODER) {
2905 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2907 ff_mpeg4_set_direct_mv(s, 0, 0);
2910 case CANDIDATE_MB_TYPE_BIDIR:
2911 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2913 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2914 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2915 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2916 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2918 case CANDIDATE_MB_TYPE_BACKWARD:
2919 s->mv_dir = MV_DIR_BACKWARD;
2921 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2922 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2924 case CANDIDATE_MB_TYPE_FORWARD:
2925 s->mv_dir = MV_DIR_FORWARD;
2927 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2928 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2929 // printf(" %d %d ", motion_x, motion_y);
2931 case CANDIDATE_MB_TYPE_FORWARD_I:
2932 s->mv_dir = MV_DIR_FORWARD;
2933 s->mv_type = MV_TYPE_FIELD;
2936 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2937 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2938 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2941 case CANDIDATE_MB_TYPE_BACKWARD_I:
2942 s->mv_dir = MV_DIR_BACKWARD;
2943 s->mv_type = MV_TYPE_FIELD;
2946 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2947 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2948 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2951 case CANDIDATE_MB_TYPE_BIDIR_I:
2952 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2953 s->mv_type = MV_TYPE_FIELD;
2955 for(dir=0; dir<2; dir++){
2957 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2958 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2959 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2964 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
2967 encode_mb(s, motion_x, motion_y);
2969 // RAL: Update last macroblock type
2970 s->last_mv_dir = s->mv_dir;
2972 if (CONFIG_H263_ENCODER &&
2973 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2974 ff_h263_update_motion_val(s);
2976 ff_MPV_decode_mb(s, s->block);
2979 /* clean the MV table in IPS frames for direct mode in B frames */
2980 if(s->mb_intra /* && I,P,S_TYPE */){
2981 s->p_mv_table[xy][0]=0;
2982 s->p_mv_table[xy][1]=0;
2985 if(s->flags&CODEC_FLAG_PSNR){
2989 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2990 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2992 s->current_picture.f.error[0] += sse(
2993 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
2994 s->dest[0], w, h, s->linesize);
2995 s->current_picture.f.error[1] += sse(
2996 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
2997 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
2998 s->current_picture.f.error[2] += sse(
2999 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3000 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3003 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3004 ff_h263_loop_filter(s);
3006 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
3010 //not beautiful here but we must write it before flushing so it has to be here
3011 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3012 ff_msmpeg4_encode_ext_header(s);
3016 /* Send the last GOB if RTP */
3017 if (s->avctx->rtp_callback) {
3018 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3019 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3020 /* Call the RTP callback to send the last GOB */
3022 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3028 #define MERGE(field) dst->field += src->field; src->field=0
3029 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3030 MERGE(me.scene_change_score);
3031 MERGE(me.mc_mb_var_sum_temp);
3032 MERGE(me.mb_var_sum_temp);
3035 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3038 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3039 MERGE(dct_count[1]);
3049 MERGE(padding_bug_score);
3050 MERGE(current_picture.f.error[0]);
3051 MERGE(current_picture.f.error[1]);
3052 MERGE(current_picture.f.error[2]);
3054 if(dst->avctx->noise_reduction){
3055 for(i=0; i<64; i++){
3056 MERGE(dct_error_sum[0][i]);
3057 MERGE(dct_error_sum[1][i]);
3061 assert(put_bits_count(&src->pb) % 8 ==0);
3062 assert(put_bits_count(&dst->pb) % 8 ==0);
3063 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3064 flush_put_bits(&dst->pb);
3067 static int estimate_qp(MpegEncContext *s, int dry_run){
3068 if (s->next_lambda){
3069 s->current_picture_ptr->f.quality =
3070 s->current_picture.f.quality = s->next_lambda;
3071 if(!dry_run) s->next_lambda= 0;
3072 } else if (!s->fixed_qscale) {
3073 s->current_picture_ptr->f.quality =
3074 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3075 if (s->current_picture.f.quality < 0)
3079 if(s->adaptive_quant){
3080 switch(s->codec_id){
3081 case CODEC_ID_MPEG4:
3082 if (CONFIG_MPEG4_ENCODER)
3083 ff_clean_mpeg4_qscales(s);
3086 case CODEC_ID_H263P:
3088 if (CONFIG_H263_ENCODER)
3089 ff_clean_h263_qscales(s);
3092 ff_init_qscale_tab(s);
3095 s->lambda= s->lambda_table[0];
3098 s->lambda = s->current_picture.f.quality;
3099 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3104 /* must be called before writing the header */
3105 static void set_frame_distances(MpegEncContext * s){
3106 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3107 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3109 if(s->pict_type==AV_PICTURE_TYPE_B){
3110 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3111 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3113 s->pp_time= s->time - s->last_non_b_time;
3114 s->last_non_b_time= s->time;
3115 assert(s->picture_number==0 || s->pp_time > 0);
3119 static int encode_picture(MpegEncContext *s, int picture_number)
3123 int context_count = s->slice_context_count;
3125 s->picture_number = picture_number;
3127 /* Reset the average MB variance */
3128 s->me.mb_var_sum_temp =
3129 s->me.mc_mb_var_sum_temp = 0;
3131 /* we need to initialize some time vars before we can encode b-frames */
3132 // RAL: Condition added for MPEG1VIDEO
3133 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3134 set_frame_distances(s);
3135 if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
3136 ff_set_mpeg4_time(s);
3138 s->me.scene_change_score=0;
3140 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3142 if(s->pict_type==AV_PICTURE_TYPE_I){
3143 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3144 else s->no_rounding=0;
3145 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3146 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3147 s->no_rounding ^= 1;
3150 if(s->flags & CODEC_FLAG_PASS2){
3151 if (estimate_qp(s,1) < 0)
3153 ff_get_2pass_fcode(s);
3154 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3155 if(s->pict_type==AV_PICTURE_TYPE_B)
3156 s->lambda= s->last_lambda_for[s->pict_type];
3158 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3162 if(s->codec_id != CODEC_ID_AMV){
3163 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3164 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3165 s->q_chroma_intra_matrix = s->q_intra_matrix;
3166 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3169 s->mb_intra=0; //for the rate distortion & bit compare functions
3170 for(i=1; i<context_count; i++){
3171 ff_update_duplicate_context(s->thread_context[i], s);
3177 /* Estimate motion for every MB */
3178 if(s->pict_type != AV_PICTURE_TYPE_I){
3179 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3180 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3181 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3182 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3183 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3187 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3188 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3190 for(i=0; i<s->mb_stride*s->mb_height; i++)
3191 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3193 if(!s->fixed_qscale){
3194 /* finding spatial complexity for I-frame rate control */
3195 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3198 for(i=1; i<context_count; i++){
3199 merge_context_after_me(s, s->thread_context[i]);
3201 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3202 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3205 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3206 s->pict_type= AV_PICTURE_TYPE_I;
3207 for(i=0; i<s->mb_stride*s->mb_height; i++)
3208 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3209 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3213 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3214 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3216 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3218 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3219 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3220 s->f_code= FFMAX3(s->f_code, a, b);
3223 ff_fix_long_p_mvs(s);
3224 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3225 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3229 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3230 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3235 if(s->pict_type==AV_PICTURE_TYPE_B){
3238 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3239 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3240 s->f_code = FFMAX(a, b);
3242 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3243 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3244 s->b_code = FFMAX(a, b);
3246 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3247 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3248 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3249 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3250 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3252 for(dir=0; dir<2; dir++){
3255 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3256 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3257 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3258 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3266 if (estimate_qp(s, 0) < 0)
3269 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3270 s->qscale= 3; //reduce clipping problems
3272 if (s->out_format == FMT_MJPEG) {
3273 /* for mjpeg, we do include qscale in the matrix */
3275 int j= s->dsp.idct_permutation[i];
3277 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3279 s->y_dc_scale_table=
3280 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3281 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3282 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3283 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3286 if(s->codec_id == CODEC_ID_AMV){
3287 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};
3288 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};
3290 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3292 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3293 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3295 s->y_dc_scale_table= y;
3296 s->c_dc_scale_table= c;
3297 s->intra_matrix[0] = 13;
3298 s->chroma_intra_matrix[0] = 14;
3299 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3300 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3301 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3302 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3306 //FIXME var duplication
3307 s->current_picture_ptr->f.key_frame =
3308 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3309 s->current_picture_ptr->f.pict_type =
3310 s->current_picture.f.pict_type = s->pict_type;
3312 if (s->current_picture.f.key_frame)
3313 s->picture_in_gop_number=0;
3315 s->last_bits= put_bits_count(&s->pb);
3316 switch(s->out_format) {
3318 if (CONFIG_MJPEG_ENCODER)
3319 ff_mjpeg_encode_picture_header(s);
3322 if (CONFIG_H261_ENCODER)
3323 ff_h261_encode_picture_header(s, picture_number);
3326 if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2)
3327 ff_wmv2_encode_picture_header(s, picture_number);
3328 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3329 ff_msmpeg4_encode_picture_header(s, picture_number);
3330 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3331 ff_mpeg4_encode_picture_header(s, picture_number);
3332 else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
3333 ff_rv10_encode_picture_header(s, picture_number);
3334 else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
3335 ff_rv20_encode_picture_header(s, picture_number);
3336 else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
3337 ff_flv_encode_picture_header(s, picture_number);
3338 else if (CONFIG_H263_ENCODER)
3339 ff_h263_encode_picture_header(s, picture_number);
3342 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3343 ff_mpeg1_encode_picture_header(s, picture_number);
3350 bits= put_bits_count(&s->pb);
3351 s->header_bits= bits - s->last_bits;
3353 for(i=1; i<context_count; i++){
3354 update_duplicate_context_after_me(s->thread_context[i], s);
3356 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3357 for(i=1; i<context_count; i++){
3358 merge_context_after_encode(s, s->thread_context[i]);
3364 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3365 const int intra= s->mb_intra;
3368 s->dct_count[intra]++;
3370 for(i=0; i<64; i++){
3371 int level= block[i];
3375 s->dct_error_sum[intra][i] += level;
3376 level -= s->dct_offset[intra][i];
3377 if(level<0) level=0;
3379 s->dct_error_sum[intra][i] -= level;
3380 level += s->dct_offset[intra][i];
3381 if(level>0) level=0;
3388 static int dct_quantize_trellis_c(MpegEncContext *s,
3389 DCTELEM *block, int n,
3390 int qscale, int *overflow){
3392 const uint8_t *scantable= s->intra_scantable.scantable;
3393 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3395 unsigned int threshold1, threshold2;
3407 int coeff_count[64];
3408 int qmul, qadd, start_i, last_non_zero, i, dc;
3409 const int esc_length= s->ac_esc_length;
3411 uint8_t * last_length;
3412 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3414 s->dsp.fdct (block);
3416 if(s->dct_error_sum)
3417 s->denoise_dct(s, block);
3419 qadd= ((qscale-1)|1)*8;
3430 /* For AIC we skip quant/dequant of INTRADC */
3435 /* note: block[0] is assumed to be positive */
3436 block[0] = (block[0] + (q >> 1)) / q;
3439 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3440 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3441 bias= 1<<(QMAT_SHIFT-1);
3442 length = s->intra_ac_vlc_length;
3443 last_length= s->intra_ac_vlc_last_length;
3447 qmat = s->q_inter_matrix[qscale];
3448 length = s->inter_ac_vlc_length;
3449 last_length= s->inter_ac_vlc_last_length;
3453 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3454 threshold2= (threshold1<<1);
3456 for(i=63; i>=start_i; i--) {
3457 const int j = scantable[i];
3458 int level = block[j] * qmat[j];
3460 if(((unsigned)(level+threshold1))>threshold2){
3466 for(i=start_i; i<=last_non_zero; i++) {
3467 const int j = scantable[i];
3468 int level = block[j] * qmat[j];
3470 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3471 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3472 if(((unsigned)(level+threshold1))>threshold2){
3474 level= (bias + level)>>QMAT_SHIFT;
3476 coeff[1][i]= level-1;
3477 // coeff[2][k]= level-2;
3479 level= (bias - level)>>QMAT_SHIFT;
3480 coeff[0][i]= -level;
3481 coeff[1][i]= -level+1;
3482 // coeff[2][k]= -level+2;
3484 coeff_count[i]= FFMIN(level, 2);
3485 assert(coeff_count[i]);
3488 coeff[0][i]= (level>>31)|1;
3493 *overflow= s->max_qcoeff < max; //overflow might have happened
3495 if(last_non_zero < start_i){
3496 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3497 return last_non_zero;
3500 score_tab[start_i]= 0;
3501 survivor[0]= start_i;
3504 for(i=start_i; i<=last_non_zero; i++){
3505 int level_index, j, zero_distortion;
3506 int dct_coeff= FFABS(block[ scantable[i] ]);
3507 int best_score=256*256*256*120;
3509 if (s->dsp.fdct == ff_fdct_ifast)
3510 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3511 zero_distortion= dct_coeff*dct_coeff;
3513 for(level_index=0; level_index < coeff_count[i]; level_index++){
3515 int level= coeff[level_index][i];
3516 const int alevel= FFABS(level);
3521 if(s->out_format == FMT_H263){
3522 unquant_coeff= alevel*qmul + qadd;
3524 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3526 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3527 unquant_coeff = (unquant_coeff - 1) | 1;
3529 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3530 unquant_coeff = (unquant_coeff - 1) | 1;
3535 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3537 if((level&(~127)) == 0){
3538 for(j=survivor_count-1; j>=0; j--){
3539 int run= i - survivor[j];
3540 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3541 score += score_tab[i-run];
3543 if(score < best_score){
3546 level_tab[i+1]= level-64;
3550 if(s->out_format == FMT_H263){
3551 for(j=survivor_count-1; j>=0; j--){
3552 int run= i - survivor[j];
3553 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3554 score += score_tab[i-run];
3555 if(score < last_score){
3558 last_level= level-64;
3564 distortion += esc_length*lambda;
3565 for(j=survivor_count-1; j>=0; j--){
3566 int run= i - survivor[j];
3567 int score= distortion + score_tab[i-run];
3569 if(score < best_score){
3572 level_tab[i+1]= level-64;
3576 if(s->out_format == FMT_H263){
3577 for(j=survivor_count-1; j>=0; j--){
3578 int run= i - survivor[j];
3579 int score= distortion + score_tab[i-run];
3580 if(score < last_score){
3583 last_level= level-64;
3591 score_tab[i+1]= best_score;
3593 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3594 if(last_non_zero <= 27){
3595 for(; survivor_count; survivor_count--){
3596 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3600 for(; survivor_count; survivor_count--){
3601 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3606 survivor[ survivor_count++ ]= i+1;
3609 if(s->out_format != FMT_H263){
3610 last_score= 256*256*256*120;
3611 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3612 int score= score_tab[i];
3613 if(i) score += lambda*2; //FIXME exacter?
3615 if(score < last_score){
3618 last_level= level_tab[i];
3619 last_run= run_tab[i];
3624 s->coded_score[n] = last_score;
3626 dc= FFABS(block[0]);
3627 last_non_zero= last_i - 1;
3628 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3630 if(last_non_zero < start_i)
3631 return last_non_zero;
3633 if(last_non_zero == 0 && start_i == 0){
3635 int best_score= dc * dc;
3637 for(i=0; i<coeff_count[0]; i++){
3638 int level= coeff[i][0];
3639 int alevel= FFABS(level);
3640 int unquant_coeff, score, distortion;
3642 if(s->out_format == FMT_H263){
3643 unquant_coeff= (alevel*qmul + qadd)>>3;
3645 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3646 unquant_coeff = (unquant_coeff - 1) | 1;
3648 unquant_coeff = (unquant_coeff + 4) >> 3;
3649 unquant_coeff<<= 3 + 3;
3651 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3653 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3654 else score= distortion + esc_length*lambda;
3656 if(score < best_score){
3658 best_level= level - 64;
3661 block[0]= best_level;
3662 s->coded_score[n] = best_score - dc*dc;
3663 if(best_level == 0) return -1;
3664 else return last_non_zero;
3670 block[ perm_scantable[last_non_zero] ]= last_level;
3673 for(; i>start_i; i -= run_tab[i] + 1){
3674 block[ perm_scantable[i-1] ]= level_tab[i];
3677 return last_non_zero;
3680 //#define REFINE_STATS 1
3681 static int16_t basis[64][64];
3683 static void build_basis(uint8_t *perm){
3690 double s= 0.25*(1<<BASIS_SHIFT);
3692 int perm_index= perm[index];
3693 if(i==0) s*= sqrt(0.5);
3694 if(j==0) s*= sqrt(0.5);
3695 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)));
3702 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3703 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3706 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3707 const uint8_t *scantable= s->intra_scantable.scantable;
3708 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3709 // unsigned int threshold1, threshold2;
3714 int qmul, qadd, start_i, last_non_zero, i, dc;
3716 uint8_t * last_length;
3718 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3721 static int after_last=0;
3722 static int to_zero=0;
3723 static int from_zero=0;
3726 static int messed_sign=0;
3729 if(basis[0][0] == 0)
3730 build_basis(s->dsp.idct_permutation);
3741 /* For AIC we skip quant/dequant of INTRADC */
3745 q <<= RECON_SHIFT-3;
3746 /* note: block[0] is assumed to be positive */
3748 // block[0] = (block[0] + (q >> 1)) / q;
3750 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3751 // bias= 1<<(QMAT_SHIFT-1);
3752 length = s->intra_ac_vlc_length;
3753 last_length= s->intra_ac_vlc_last_length;
3757 length = s->inter_ac_vlc_length;
3758 last_length= s->inter_ac_vlc_last_length;
3760 last_non_zero = s->block_last_index[n];
3765 dc += (1<<(RECON_SHIFT-1));
3766 for(i=0; i<64; i++){
3767 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3770 STOP_TIMER("memset rem[]")}
3773 for(i=0; i<64; i++){
3778 w= FFABS(weight[i]) + qns*one;
3779 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3782 // w=weight[i] = (63*qns + (w/2)) / w;
3788 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3794 for(i=start_i; i<=last_non_zero; i++){
3795 int j= perm_scantable[i];
3796 const int level= block[j];
3800 if(level<0) coeff= qmul*level - qadd;
3801 else coeff= qmul*level + qadd;
3802 run_tab[rle_index++]=run;
3805 s->dsp.add_8x8basis(rem, basis[j], coeff);
3811 if(last_non_zero>0){
3812 STOP_TIMER("init rem[]")
3819 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3822 int run2, best_unquant_change=0, analyze_gradient;
3826 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3828 if(analyze_gradient){
3832 for(i=0; i<64; i++){
3835 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3838 STOP_TIMER("rem*w*w")}
3848 const int level= block[0];
3849 int change, old_coeff;
3851 assert(s->mb_intra);
3855 for(change=-1; change<=1; change+=2){
3856 int new_level= level + change;
3857 int score, new_coeff;
3859 new_coeff= q*new_level;
3860 if(new_coeff >= 2048 || new_coeff < 0)
3863 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3864 if(score<best_score){
3867 best_change= change;
3868 best_unquant_change= new_coeff - old_coeff;
3875 run2= run_tab[rle_index++];
3879 for(i=start_i; i<64; i++){
3880 int j= perm_scantable[i];
3881 const int level= block[j];
3882 int change, old_coeff;
3884 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3888 if(level<0) old_coeff= qmul*level - qadd;
3889 else old_coeff= qmul*level + qadd;
3890 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3894 assert(run2>=0 || i >= last_non_zero );
3897 for(change=-1; change<=1; change+=2){
3898 int new_level= level + change;
3899 int score, new_coeff, unquant_change;
3902 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3906 if(new_level<0) new_coeff= qmul*new_level - qadd;
3907 else new_coeff= qmul*new_level + qadd;
3908 if(new_coeff >= 2048 || new_coeff <= -2048)
3910 //FIXME check for overflow
3913 if(level < 63 && level > -63){
3914 if(i < last_non_zero)
3915 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3916 - length[UNI_AC_ENC_INDEX(run, level+64)];
3918 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3919 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3922 assert(FFABS(new_level)==1);
3924 if(analyze_gradient){
3925 int g= d1[ scantable[i] ];
3926 if(g && (g^new_level) >= 0)
3930 if(i < last_non_zero){
3931 int next_i= i + run2 + 1;
3932 int next_level= block[ perm_scantable[next_i] ] + 64;
3934 if(next_level&(~127))
3937 if(next_i < last_non_zero)
3938 score += length[UNI_AC_ENC_INDEX(run, 65)]
3939 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3940 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3942 score += length[UNI_AC_ENC_INDEX(run, 65)]
3943 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3944 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3946 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
3948 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3949 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3955 assert(FFABS(level)==1);
3957 if(i < last_non_zero){
3958 int next_i= i + run2 + 1;
3959 int next_level= block[ perm_scantable[next_i] ] + 64;
3961 if(next_level&(~127))
3964 if(next_i < last_non_zero)
3965 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
3966 - length[UNI_AC_ENC_INDEX(run2, next_level)]
3967 - length[UNI_AC_ENC_INDEX(run, 65)];
3969 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
3970 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3971 - length[UNI_AC_ENC_INDEX(run, 65)];
3973 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
3975 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3976 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3983 unquant_change= new_coeff - old_coeff;
3984 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
3986 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
3987 if(score<best_score){
3990 best_change= change;
3991 best_unquant_change= unquant_change;
3995 prev_level= level + 64;
3996 if(prev_level&(~127))
4005 STOP_TIMER("iterative step")}
4009 int j= perm_scantable[ best_coeff ];
4011 block[j] += best_change;
4013 if(best_coeff > last_non_zero){
4014 last_non_zero= best_coeff;
4022 if(block[j] - best_change){
4023 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4035 for(; last_non_zero>=start_i; last_non_zero--){
4036 if(block[perm_scantable[last_non_zero]])
4042 if(256*256*256*64 % count == 0){
4043 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);
4048 for(i=start_i; i<=last_non_zero; i++){
4049 int j= perm_scantable[i];
4050 const int level= block[j];
4053 run_tab[rle_index++]=run;
4060 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4066 if(last_non_zero>0){
4067 STOP_TIMER("iterative search")
4072 return last_non_zero;
4075 int ff_dct_quantize_c(MpegEncContext *s,
4076 DCTELEM *block, int n,
4077 int qscale, int *overflow)
4079 int i, j, level, last_non_zero, q, start_i;
4081 const uint8_t *scantable= s->intra_scantable.scantable;
4084 unsigned int threshold1, threshold2;
4086 s->dsp.fdct (block);
4088 if(s->dct_error_sum)
4089 s->denoise_dct(s, block);
4099 /* For AIC we skip quant/dequant of INTRADC */
4102 /* note: block[0] is assumed to be positive */
4103 block[0] = (block[0] + (q >> 1)) / q;
4106 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4107 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4111 qmat = s->q_inter_matrix[qscale];
4112 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4114 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4115 threshold2= (threshold1<<1);
4116 for(i=63;i>=start_i;i--) {
4118 level = block[j] * qmat[j];
4120 if(((unsigned)(level+threshold1))>threshold2){
4127 for(i=start_i; i<=last_non_zero; i++) {
4129 level = block[j] * qmat[j];
4131 // if( bias+level >= (1<<QMAT_SHIFT)
4132 // || bias-level >= (1<<QMAT_SHIFT)){
4133 if(((unsigned)(level+threshold1))>threshold2){
4135 level= (bias + level)>>QMAT_SHIFT;
4138 level= (bias - level)>>QMAT_SHIFT;
4146 *overflow= s->max_qcoeff < max; //overflow might have happened
4148 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4149 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4150 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4152 return last_non_zero;
4155 #define OFFSET(x) offsetof(MpegEncContext, x)
4156 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4157 static const AVOption h263_options[] = {
4158 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4159 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4160 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { 0 }, 0, INT_MAX, VE },
4165 static const AVClass h263_class = {
4166 .class_name = "H.263 encoder",
4167 .item_name = av_default_item_name,
4168 .option = h263_options,
4169 .version = LIBAVUTIL_VERSION_INT,
4172 AVCodec ff_h263_encoder = {
4174 .type = AVMEDIA_TYPE_VIDEO,
4175 .id = CODEC_ID_H263,
4176 .priv_data_size = sizeof(MpegEncContext),
4177 .init = ff_MPV_encode_init,
4178 .encode2 = ff_MPV_encode_picture,
4179 .close = ff_MPV_encode_end,
4180 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4181 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4182 .priv_class = &h263_class,
4185 static const AVOption h263p_options[] = {
4186 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4187 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4188 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4189 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4193 static const AVClass h263p_class = {
4194 .class_name = "H.263p encoder",
4195 .item_name = av_default_item_name,
4196 .option = h263p_options,
4197 .version = LIBAVUTIL_VERSION_INT,
4200 AVCodec ff_h263p_encoder = {
4202 .type = AVMEDIA_TYPE_VIDEO,
4203 .id = CODEC_ID_H263P,
4204 .priv_data_size = sizeof(MpegEncContext),
4205 .init = ff_MPV_encode_init,
4206 .encode2 = ff_MPV_encode_picture,
4207 .close = ff_MPV_encode_end,
4208 .capabilities = CODEC_CAP_SLICE_THREADS,
4209 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4210 .long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4211 .priv_class = &h263p_class,
4214 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4216 AVCodec ff_msmpeg4v2_encoder = {
4217 .name = "msmpeg4v2",
4218 .type = AVMEDIA_TYPE_VIDEO,
4219 .id = CODEC_ID_MSMPEG4V2,
4220 .priv_data_size = sizeof(MpegEncContext),
4221 .init = ff_MPV_encode_init,
4222 .encode2 = ff_MPV_encode_picture,
4223 .close = ff_MPV_encode_end,
4224 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4225 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4226 .priv_class = &msmpeg4v2_class,
4229 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4231 AVCodec ff_msmpeg4v3_encoder = {
4233 .type = AVMEDIA_TYPE_VIDEO,
4234 .id = CODEC_ID_MSMPEG4V3,
4235 .priv_data_size = sizeof(MpegEncContext),
4236 .init = ff_MPV_encode_init,
4237 .encode2 = ff_MPV_encode_picture,
4238 .close = ff_MPV_encode_end,
4239 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4240 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4241 .priv_class = &msmpeg4v3_class,
4244 FF_MPV_GENERIC_CLASS(wmv1)
4246 AVCodec ff_wmv1_encoder = {
4248 .type = AVMEDIA_TYPE_VIDEO,
4249 .id = CODEC_ID_WMV1,
4250 .priv_data_size = sizeof(MpegEncContext),
4251 .init = ff_MPV_encode_init,
4252 .encode2 = ff_MPV_encode_picture,
4253 .close = ff_MPV_encode_end,
4254 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4255 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4256 .priv_class = &wmv1_class,