2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
35 #include "mpegvideo.h"
41 #include "aandcttab.h"
43 #include "mpeg4video.h"
45 #include "bytestream.h"
52 static int encode_picture(MpegEncContext *s, int picture_number);
53 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
54 static int sse_mb(MpegEncContext *s);
55 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
56 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
58 /* enable all paranoid tests for rounding, overflows, etc... */
63 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
64 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
66 const AVOption ff_mpv_generic_options[] = {
71 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
72 uint16_t (*qmat16)[2][64],
73 const uint16_t *quant_matrix,
74 int bias, int qmin, int qmax, int intra)
79 for (qscale = qmin; qscale <= qmax; qscale++) {
81 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
82 dsp->fdct == ff_jpeg_fdct_islow_10 ||
83 dsp->fdct == ff_faandct) {
84 for (i = 0; i < 64; i++) {
85 const int j = dsp->idct_permutation[i];
86 /* 16 <= qscale * quant_matrix[i] <= 7905
87 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
88 * 19952 <= x <= 249205026
89 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
90 * 3444240 >= (1 << 36) / (x) >= 275 */
92 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
93 (qscale * quant_matrix[j]));
95 } else if (dsp->fdct == ff_fdct_ifast) {
96 for (i = 0; i < 64; i++) {
97 const int j = dsp->idct_permutation[i];
98 /* 16 <= qscale * quant_matrix[i] <= 7905
99 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
100 * 19952 <= x <= 249205026
101 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
102 * 3444240 >= (1 << 36) / (x) >= 275 */
104 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
105 (ff_aanscales[i] * qscale * quant_matrix[j]));
108 for (i = 0; i < 64; i++) {
109 const int j = dsp->idct_permutation[i];
110 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
111 * Assume x = qscale * quant_matrix[i]
113 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
114 * so 32768 >= (1 << 19) / (x) >= 67 */
115 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
116 (qscale * quant_matrix[j]));
117 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
118 // (qscale * quant_matrix[i]);
119 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
120 (qscale * quant_matrix[j]);
122 if (qmat16[qscale][0][i] == 0 ||
123 qmat16[qscale][0][i] == 128 * 256)
124 qmat16[qscale][0][i] = 128 * 256 - 1;
125 qmat16[qscale][1][i] =
126 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
127 qmat16[qscale][0][i]);
131 for (i = intra; i < 64; i++) {
133 if (dsp->fdct == ff_fdct_ifast) {
134 max = (8191LL * ff_aanscales[i]) >> 14;
136 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
142 av_log(NULL, AV_LOG_INFO,
143 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
148 static inline void update_qscale(MpegEncContext *s)
150 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
151 (FF_LAMBDA_SHIFT + 7);
152 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
154 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
158 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
164 for (i = 0; i < 64; i++) {
165 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
172 * init s->current_picture.qscale_table from s->lambda_table
174 void ff_init_qscale_tab(MpegEncContext *s)
176 int8_t * const qscale_table = s->current_picture.f.qscale_table;
179 for (i = 0; i < s->mb_num; i++) {
180 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
181 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
182 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
187 static void copy_picture_attributes(MpegEncContext *s,
193 dst->pict_type = src->pict_type;
194 dst->quality = src->quality;
195 dst->coded_picture_number = src->coded_picture_number;
196 dst->display_picture_number = src->display_picture_number;
197 //dst->reference = src->reference;
199 dst->interlaced_frame = src->interlaced_frame;
200 dst->top_field_first = src->top_field_first;
202 if (s->avctx->me_threshold) {
203 if (!src->motion_val[0])
204 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
206 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
207 if (!src->ref_index[0])
208 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
209 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
210 av_log(s->avctx, AV_LOG_ERROR,
211 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
212 src->motion_subsample_log2, dst->motion_subsample_log2);
214 memcpy(dst->mb_type, src->mb_type,
215 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
217 for (i = 0; i < 2; i++) {
218 int stride = ((16 * s->mb_width ) >>
219 src->motion_subsample_log2) + 1;
220 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
222 if (src->motion_val[i] &&
223 src->motion_val[i] != dst->motion_val[i]) {
224 memcpy(dst->motion_val[i], src->motion_val[i],
225 2 * stride * height * sizeof(int16_t));
227 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
228 memcpy(dst->ref_index[i], src->ref_index[i],
229 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
235 static void update_duplicate_context_after_me(MpegEncContext *dst,
238 #define COPY(a) dst->a= src->a
240 COPY(current_picture);
246 COPY(picture_in_gop_number);
247 COPY(gop_picture_number);
248 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
249 COPY(progressive_frame); // FIXME don't set in encode_header
250 COPY(partitioned_frame); // FIXME don't set in encode_header
255 * Set the given MpegEncContext to defaults for encoding.
256 * the changed fields will not depend upon the prior state of the MpegEncContext.
258 static void MPV_encode_defaults(MpegEncContext *s)
261 ff_MPV_common_defaults(s);
263 for (i = -16; i < 16; i++) {
264 default_fcode_tab[i + MAX_MV] = 1;
266 s->me.mv_penalty = default_mv_penalty;
267 s->fcode_tab = default_fcode_tab;
270 av_cold int ff_dct_encode_init(MpegEncContext *s) {
272 ff_dct_encode_init_x86(s);
274 if (!s->dct_quantize)
275 s->dct_quantize = ff_dct_quantize_c;
277 s->denoise_dct = denoise_dct_c;
278 s->fast_dct_quantize = s->dct_quantize;
279 if (s->avctx->trellis)
280 s->dct_quantize = dct_quantize_trellis_c;
285 /* init video encoder */
286 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
288 MpegEncContext *s = avctx->priv_data;
290 int chroma_h_shift, chroma_v_shift;
292 MPV_encode_defaults(s);
294 switch (avctx->codec_id) {
295 case AV_CODEC_ID_MPEG2VIDEO:
296 if (avctx->pix_fmt != PIX_FMT_YUV420P &&
297 avctx->pix_fmt != PIX_FMT_YUV422P) {
298 av_log(avctx, AV_LOG_ERROR,
299 "only YUV420 and YUV422 are supported\n");
303 case AV_CODEC_ID_LJPEG:
304 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
305 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
306 avctx->pix_fmt != PIX_FMT_YUVJ444P &&
307 avctx->pix_fmt != PIX_FMT_BGR0 &&
308 avctx->pix_fmt != PIX_FMT_BGRA &&
309 avctx->pix_fmt != PIX_FMT_BGR24 &&
310 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
311 avctx->pix_fmt != PIX_FMT_YUV422P &&
312 avctx->pix_fmt != PIX_FMT_YUV444P) ||
313 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
314 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
318 case AV_CODEC_ID_MJPEG:
319 case AV_CODEC_ID_AMV:
320 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
321 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
322 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
323 avctx->pix_fmt != PIX_FMT_YUV422P) ||
324 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
325 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
330 if (avctx->pix_fmt != PIX_FMT_YUV420P) {
331 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
336 switch (avctx->pix_fmt) {
337 case PIX_FMT_YUVJ422P:
338 case PIX_FMT_YUV422P:
339 s->chroma_format = CHROMA_422;
341 case PIX_FMT_YUVJ420P:
342 case PIX_FMT_YUV420P:
344 s->chroma_format = CHROMA_420;
348 s->bit_rate = avctx->bit_rate;
349 s->width = avctx->width;
350 s->height = avctx->height;
351 if (avctx->gop_size > 600 &&
352 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
353 av_log(avctx, AV_LOG_WARNING,
354 "keyframe interval too large!, reducing it from %d to %d\n",
355 avctx->gop_size, 600);
356 avctx->gop_size = 600;
358 s->gop_size = avctx->gop_size;
360 s->flags = avctx->flags;
361 s->flags2 = avctx->flags2;
362 s->max_b_frames = avctx->max_b_frames;
363 s->codec_id = avctx->codec->id;
364 #if FF_API_MPV_GLOBAL_OPTS
365 if (avctx->luma_elim_threshold)
366 s->luma_elim_threshold = avctx->luma_elim_threshold;
367 if (avctx->chroma_elim_threshold)
368 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
370 s->strict_std_compliance = avctx->strict_std_compliance;
371 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
372 s->mpeg_quant = avctx->mpeg_quant;
373 s->rtp_mode = !!avctx->rtp_payload_size;
374 s->intra_dc_precision = avctx->intra_dc_precision;
375 s->user_specified_pts = AV_NOPTS_VALUE;
377 if (s->gop_size <= 1) {
384 s->me_method = avctx->me_method;
387 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
389 #if FF_API_MPV_GLOBAL_OPTS
390 if (s->flags & CODEC_FLAG_QP_RD)
391 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
394 s->adaptive_quant = (s->avctx->lumi_masking ||
395 s->avctx->dark_masking ||
396 s->avctx->temporal_cplx_masking ||
397 s->avctx->spatial_cplx_masking ||
398 s->avctx->p_masking ||
399 s->avctx->border_masking ||
400 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
403 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
405 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
406 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
407 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
411 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
412 av_log(avctx, AV_LOG_INFO,
413 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
416 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
417 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
421 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
422 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
426 if (avctx->rc_max_rate &&
427 avctx->rc_max_rate == avctx->bit_rate &&
428 avctx->rc_max_rate != avctx->rc_min_rate) {
429 av_log(avctx, AV_LOG_INFO,
430 "impossible bitrate constraints, this will fail\n");
433 if (avctx->rc_buffer_size &&
434 avctx->bit_rate * (int64_t)avctx->time_base.num >
435 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
436 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
440 if (!s->fixed_qscale &&
441 avctx->bit_rate * av_q2d(avctx->time_base) >
442 avctx->bit_rate_tolerance) {
443 av_log(avctx, AV_LOG_ERROR,
444 "bitrate tolerance too small for bitrate\n");
448 if (s->avctx->rc_max_rate &&
449 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
450 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
451 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
452 90000LL * (avctx->rc_buffer_size - 1) >
453 s->avctx->rc_max_rate * 0xFFFFLL) {
454 av_log(avctx, AV_LOG_INFO,
455 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
456 "specified vbv buffer is too large for the given bitrate!\n");
459 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
460 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
461 s->codec_id != AV_CODEC_ID_FLV1) {
462 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
466 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
467 av_log(avctx, AV_LOG_ERROR,
468 "OBMC is only supported with simple mb decision\n");
472 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
473 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
477 if (s->max_b_frames &&
478 s->codec_id != AV_CODEC_ID_MPEG4 &&
479 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
480 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
481 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
485 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
486 s->codec_id == AV_CODEC_ID_H263 ||
487 s->codec_id == AV_CODEC_ID_H263P) &&
488 (avctx->sample_aspect_ratio.num > 255 ||
489 avctx->sample_aspect_ratio.den > 255)) {
490 av_log(avctx, AV_LOG_WARNING,
491 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
492 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
493 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
494 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
497 if ((s->codec_id == AV_CODEC_ID_H263 ||
498 s->codec_id == AV_CODEC_ID_H263P) &&
499 (avctx->width > 2048 ||
500 avctx->height > 1152 )) {
501 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
504 if ((s->codec_id == AV_CODEC_ID_H263 ||
505 s->codec_id == AV_CODEC_ID_H263P) &&
506 ((avctx->width &3) ||
507 (avctx->height&3) )) {
508 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
512 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
513 (avctx->width > 4095 ||
514 avctx->height > 4095 )) {
515 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
519 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
520 (avctx->width > 16383 ||
521 avctx->height > 16383 )) {
522 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
526 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
527 s->codec_id == AV_CODEC_ID_WMV2) &&
529 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
533 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
534 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
535 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
539 // FIXME mpeg2 uses that too
540 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
541 av_log(avctx, AV_LOG_ERROR,
542 "mpeg2 style quantization not supported by codec\n");
546 #if FF_API_MPV_GLOBAL_OPTS
547 if (s->flags & CODEC_FLAG_CBP_RD)
548 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
551 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
552 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
556 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
557 s->avctx->mb_decision != FF_MB_DECISION_RD) {
558 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
562 if (s->avctx->scenechange_threshold < 1000000000 &&
563 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
564 av_log(avctx, AV_LOG_ERROR,
565 "closed gop with scene change detection are not supported yet, "
566 "set threshold to 1000000000\n");
570 if (s->flags & CODEC_FLAG_LOW_DELAY) {
571 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
572 av_log(avctx, AV_LOG_ERROR,
573 "low delay forcing is only available for mpeg2\n");
576 if (s->max_b_frames != 0) {
577 av_log(avctx, AV_LOG_ERROR,
578 "b frames cannot be used with low delay\n");
583 if (s->q_scale_type == 1) {
584 if (avctx->qmax > 12) {
585 av_log(avctx, AV_LOG_ERROR,
586 "non linear quant only supports qmax <= 12 currently\n");
591 if (s->avctx->thread_count > 1 &&
592 s->codec_id != AV_CODEC_ID_MPEG4 &&
593 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
594 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
595 s->codec_id != AV_CODEC_ID_MJPEG &&
596 (s->codec_id != AV_CODEC_ID_H263P)) {
597 av_log(avctx, AV_LOG_ERROR,
598 "multi threaded encoding not supported by codec\n");
602 if (s->avctx->thread_count < 1) {
603 av_log(avctx, AV_LOG_ERROR,
604 "automatic thread number detection not supported by codec, "
609 if (s->avctx->thread_count > 1)
612 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
613 s->h263_slice_structured = 1;
615 if (!avctx->time_base.den || !avctx->time_base.num) {
616 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
620 i = (INT_MAX / 2 + 128) >> 8;
621 if (avctx->me_threshold >= i) {
622 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
626 if (avctx->mb_threshold >= i) {
627 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
632 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
633 av_log(avctx, AV_LOG_INFO,
634 "notice: b_frame_strategy only affects the first pass\n");
635 avctx->b_frame_strategy = 0;
638 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
640 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
641 avctx->time_base.den /= i;
642 avctx->time_base.num /= i;
646 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
647 // (a + x * 3 / 8) / x
648 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
649 s->inter_quant_bias = 0;
651 s->intra_quant_bias = 0;
653 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
656 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
657 s->intra_quant_bias = avctx->intra_quant_bias;
658 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
659 s->inter_quant_bias = avctx->inter_quant_bias;
661 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
663 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
666 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
667 s->avctx->time_base.den > (1 << 16) - 1) {
668 av_log(avctx, AV_LOG_ERROR,
669 "timebase %d/%d not supported by MPEG 4 standard, "
670 "the maximum admitted value for the timebase denominator "
671 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
675 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
677 #if FF_API_MPV_GLOBAL_OPTS
678 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
679 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
680 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
681 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
682 if (avctx->quantizer_noise_shaping)
683 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
686 switch (avctx->codec->id) {
687 case AV_CODEC_ID_MPEG1VIDEO:
688 s->out_format = FMT_MPEG1;
689 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
690 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
692 case AV_CODEC_ID_MPEG2VIDEO:
693 s->out_format = FMT_MPEG1;
694 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
695 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
698 case AV_CODEC_ID_LJPEG:
699 case AV_CODEC_ID_MJPEG:
700 case AV_CODEC_ID_AMV:
701 s->out_format = FMT_MJPEG;
702 s->intra_only = 1; /* force intra only for jpeg */
703 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
704 (avctx->pix_fmt == PIX_FMT_BGR0
705 || s->avctx->pix_fmt == PIX_FMT_BGRA
706 || s->avctx->pix_fmt == PIX_FMT_BGR24)) {
707 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
708 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
709 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
711 s->mjpeg_vsample[0] = 2;
712 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
713 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
714 s->mjpeg_hsample[0] = 2;
715 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
716 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
718 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
719 ff_mjpeg_encode_init(s) < 0)
724 case AV_CODEC_ID_H261:
725 if (!CONFIG_H261_ENCODER)
727 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
728 av_log(avctx, AV_LOG_ERROR,
729 "The specified picture size of %dx%d is not valid for the "
730 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
731 s->width, s->height);
734 s->out_format = FMT_H261;
738 case AV_CODEC_ID_H263:
739 if (!CONFIG_H263_ENCODER)
741 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
742 s->width, s->height) == 8) {
743 av_log(avctx, AV_LOG_ERROR,
744 "The specified picture size of %dx%d is not valid for "
745 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
746 "352x288, 704x576, and 1408x1152. "
747 "Try H.263+.\n", s->width, s->height);
750 s->out_format = FMT_H263;
754 case AV_CODEC_ID_H263P:
755 s->out_format = FMT_H263;
758 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
759 s->modified_quant = s->h263_aic;
760 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
761 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
764 /* These are just to be sure */
768 case AV_CODEC_ID_FLV1:
769 s->out_format = FMT_H263;
770 s->h263_flv = 2; /* format = 1; 11-bit codes */
771 s->unrestricted_mv = 1;
772 s->rtp_mode = 0; /* don't allow GOB */
776 case AV_CODEC_ID_RV10:
777 s->out_format = FMT_H263;
781 case AV_CODEC_ID_RV20:
782 s->out_format = FMT_H263;
785 s->modified_quant = 1;
789 s->unrestricted_mv = 0;
791 case AV_CODEC_ID_MPEG4:
792 s->out_format = FMT_H263;
794 s->unrestricted_mv = 1;
795 s->low_delay = s->max_b_frames ? 0 : 1;
796 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
798 case AV_CODEC_ID_MSMPEG4V2:
799 s->out_format = FMT_H263;
801 s->unrestricted_mv = 1;
802 s->msmpeg4_version = 2;
806 case AV_CODEC_ID_MSMPEG4V3:
807 s->out_format = FMT_H263;
809 s->unrestricted_mv = 1;
810 s->msmpeg4_version = 3;
811 s->flipflop_rounding = 1;
815 case AV_CODEC_ID_WMV1:
816 s->out_format = FMT_H263;
818 s->unrestricted_mv = 1;
819 s->msmpeg4_version = 4;
820 s->flipflop_rounding = 1;
824 case AV_CODEC_ID_WMV2:
825 s->out_format = FMT_H263;
827 s->unrestricted_mv = 1;
828 s->msmpeg4_version = 5;
829 s->flipflop_rounding = 1;
837 avctx->has_b_frames = !s->low_delay;
841 s->progressive_frame =
842 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
843 CODEC_FLAG_INTERLACED_ME) ||
847 if (ff_MPV_common_init(s) < 0)
850 ff_dct_encode_init(s);
852 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
853 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
855 s->quant_precision = 5;
857 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
858 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
860 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
861 ff_h261_encode_init(s);
862 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
863 ff_h263_encode_init(s);
864 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
865 ff_msmpeg4_encode_init(s);
866 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
867 && s->out_format == FMT_MPEG1)
868 ff_mpeg1_encode_init(s);
871 for (i = 0; i < 64; i++) {
872 int j = s->dsp.idct_permutation[i];
873 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
875 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
876 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
877 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
879 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
882 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
883 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
885 if (s->avctx->intra_matrix)
886 s->intra_matrix[j] = s->avctx->intra_matrix[i];
887 if (s->avctx->inter_matrix)
888 s->inter_matrix[j] = s->avctx->inter_matrix[i];
891 /* precompute matrix */
892 /* for mjpeg, we do include qscale in the matrix */
893 if (s->out_format != FMT_MJPEG) {
894 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
895 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
897 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
898 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
902 if (ff_rate_control_init(s) < 0)
908 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
910 MpegEncContext *s = avctx->priv_data;
912 ff_rate_control_uninit(s);
914 ff_MPV_common_end(s);
915 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
916 s->out_format == FMT_MJPEG)
917 ff_mjpeg_encode_close(s);
919 av_freep(&avctx->extradata);
924 static int get_sae(uint8_t *src, int ref, int stride)
929 for (y = 0; y < 16; y++) {
930 for (x = 0; x < 16; x++) {
931 acc += FFABS(src[x + y * stride] - ref);
938 static int get_intra_count(MpegEncContext *s, uint8_t *src,
939 uint8_t *ref, int stride)
947 for (y = 0; y < h; y += 16) {
948 for (x = 0; x < w; x += 16) {
949 int offset = x + y * stride;
950 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
952 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
953 int sae = get_sae(src + offset, mean, stride);
955 acc += sae + 500 < sad;
962 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
967 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
968 (s->low_delay ? 0 : 1);
973 pic_arg->display_picture_number = s->input_picture_number++;
975 if (pts != AV_NOPTS_VALUE) {
976 if (s->user_specified_pts != AV_NOPTS_VALUE) {
978 int64_t last = s->user_specified_pts;
981 av_log(s->avctx, AV_LOG_ERROR,
982 "Error, Invalid timestamp=%"PRId64", "
983 "last=%"PRId64"\n", pts, s->user_specified_pts);
987 if (!s->low_delay && pic_arg->display_picture_number == 1)
988 s->dts_delta = time - last;
990 s->user_specified_pts = pts;
992 if (s->user_specified_pts != AV_NOPTS_VALUE) {
993 s->user_specified_pts =
994 pts = s->user_specified_pts + 1;
995 av_log(s->avctx, AV_LOG_INFO,
996 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
999 pts = pic_arg->display_picture_number;
1005 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
1007 if (pic_arg->linesize[0] != s->linesize)
1009 if (pic_arg->linesize[1] != s->uvlinesize)
1011 if (pic_arg->linesize[2] != s->uvlinesize)
1014 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
1015 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1018 i = ff_find_unused_picture(s, 1);
1022 pic = &s->picture[i].f;
1025 for (i = 0; i < 4; i++) {
1026 pic->data[i] = pic_arg->data[i];
1027 pic->linesize[i] = pic_arg->linesize[i];
1029 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1033 i = ff_find_unused_picture(s, 0);
1037 pic = &s->picture[i].f;
1040 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1044 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1045 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1046 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1049 int h_chroma_shift, v_chroma_shift;
1050 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1053 for (i = 0; i < 3; i++) {
1054 int src_stride = pic_arg->linesize[i];
1055 int dst_stride = i ? s->uvlinesize : s->linesize;
1056 int h_shift = i ? h_chroma_shift : 0;
1057 int v_shift = i ? v_chroma_shift : 0;
1058 int w = s->width >> h_shift;
1059 int h = s->height >> v_shift;
1060 uint8_t *src = pic_arg->data[i];
1061 uint8_t *dst = pic->data[i];
1063 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1064 h= ((s->height+15)/16*16)>>v_shift;
1067 if (!s->avctx->rc_buffer_size)
1068 dst += INPLACE_OFFSET;
1070 if (src_stride == dst_stride)
1071 memcpy(dst, src, src_stride * h);
1074 memcpy(dst, src, w);
1082 copy_picture_attributes(s, pic, pic_arg);
1083 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1086 /* shift buffer entries */
1087 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1088 s->input_picture[i - 1] = s->input_picture[i];
1090 s->input_picture[encoding_delay] = (Picture*) pic;
1095 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1099 int64_t score64 = 0;
1101 for (plane = 0; plane < 3; plane++) {
1102 const int stride = p->f.linesize[plane];
1103 const int bw = plane ? 1 : 2;
1104 for (y = 0; y < s->mb_height * bw; y++) {
1105 for (x = 0; x < s->mb_width * bw; x++) {
1106 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1107 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1108 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1109 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1111 switch (s->avctx->frame_skip_exp) {
1112 case 0: score = FFMAX(score, v); break;
1113 case 1: score += FFABS(v); break;
1114 case 2: score += v * v; break;
1115 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1116 case 4: score64 += v * v * (int64_t)(v * v); break;
1125 if (score64 < s->avctx->frame_skip_threshold)
1127 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1132 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1134 AVPacket pkt = { 0 };
1135 int ret, got_output;
1137 av_init_packet(&pkt);
1138 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1143 av_free_packet(&pkt);
1147 static int estimate_best_b_count(MpegEncContext *s)
1149 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1150 AVCodecContext *c = avcodec_alloc_context3(NULL);
1151 AVFrame input[FF_MAX_B_FRAMES + 2];
1152 const int scale = s->avctx->brd_scale;
1153 int i, j, out_size, p_lambda, b_lambda, lambda2;
1154 int64_t best_rd = INT64_MAX;
1155 int best_b_count = -1;
1157 av_assert0(scale >= 0 && scale <= 3);
1160 //s->next_picture_ptr->quality;
1161 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1162 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1163 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1164 if (!b_lambda) // FIXME we should do this somewhere else
1165 b_lambda = p_lambda;
1166 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1169 c->width = s->width >> scale;
1170 c->height = s->height >> scale;
1171 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1172 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1173 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1174 c->mb_decision = s->avctx->mb_decision;
1175 c->me_cmp = s->avctx->me_cmp;
1176 c->mb_cmp = s->avctx->mb_cmp;
1177 c->me_sub_cmp = s->avctx->me_sub_cmp;
1178 c->pix_fmt = PIX_FMT_YUV420P;
1179 c->time_base = s->avctx->time_base;
1180 c->max_b_frames = s->max_b_frames;
1182 if (avcodec_open2(c, codec, NULL) < 0)
1185 for (i = 0; i < s->max_b_frames + 2; i++) {
1186 int ysize = c->width * c->height;
1187 int csize = (c->width / 2) * (c->height / 2);
1188 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1189 s->next_picture_ptr;
1191 avcodec_get_frame_defaults(&input[i]);
1192 input[i].data[0] = av_malloc(ysize + 2 * csize);
1193 input[i].data[1] = input[i].data[0] + ysize;
1194 input[i].data[2] = input[i].data[1] + csize;
1195 input[i].linesize[0] = c->width;
1196 input[i].linesize[1] =
1197 input[i].linesize[2] = c->width / 2;
1199 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1200 pre_input = *pre_input_ptr;
1202 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1203 pre_input.f.data[0] += INPLACE_OFFSET;
1204 pre_input.f.data[1] += INPLACE_OFFSET;
1205 pre_input.f.data[2] += INPLACE_OFFSET;
1208 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1209 pre_input.f.data[0], pre_input.f.linesize[0],
1210 c->width, c->height);
1211 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1212 pre_input.f.data[1], pre_input.f.linesize[1],
1213 c->width >> 1, c->height >> 1);
1214 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1215 pre_input.f.data[2], pre_input.f.linesize[2],
1216 c->width >> 1, c->height >> 1);
1220 for (j = 0; j < s->max_b_frames + 1; j++) {
1223 if (!s->input_picture[j])
1226 c->error[0] = c->error[1] = c->error[2] = 0;
1228 input[0].pict_type = AV_PICTURE_TYPE_I;
1229 input[0].quality = 1 * FF_QP2LAMBDA;
1231 out_size = encode_frame(c, &input[0]);
1233 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1235 for (i = 0; i < s->max_b_frames + 1; i++) {
1236 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1238 input[i + 1].pict_type = is_p ?
1239 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1240 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1242 out_size = encode_frame(c, &input[i + 1]);
1244 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1247 /* get the delayed frames */
1249 out_size = encode_frame(c, NULL);
1250 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1253 rd += c->error[0] + c->error[1] + c->error[2];
1264 for (i = 0; i < s->max_b_frames + 2; i++) {
1265 av_freep(&input[i].data[0]);
1268 return best_b_count;
1271 static int select_input_picture(MpegEncContext *s)
1275 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1276 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1277 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1279 /* set next picture type & ordering */
1280 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1281 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1282 s->next_picture_ptr == NULL || s->intra_only) {
1283 s->reordered_input_picture[0] = s->input_picture[0];
1284 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1285 s->reordered_input_picture[0]->f.coded_picture_number =
1286 s->coded_picture_number++;
1290 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1291 if (s->picture_in_gop_number < s->gop_size &&
1292 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1293 // FIXME check that te gop check above is +-1 correct
1294 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1295 for (i = 0; i < 4; i++)
1296 s->input_picture[0]->f.data[i] = NULL;
1297 s->input_picture[0]->f.type = 0;
1299 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1300 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1302 s->avctx->release_buffer(s->avctx,
1303 &s->input_picture[0]->f);
1307 ff_vbv_update(s, 0);
1313 if (s->flags & CODEC_FLAG_PASS2) {
1314 for (i = 0; i < s->max_b_frames + 1; i++) {
1315 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1317 if (pict_num >= s->rc_context.num_entries)
1319 if (!s->input_picture[i]) {
1320 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1324 s->input_picture[i]->f.pict_type =
1325 s->rc_context.entry[pict_num].new_pict_type;
1329 if (s->avctx->b_frame_strategy == 0) {
1330 b_frames = s->max_b_frames;
1331 while (b_frames && !s->input_picture[b_frames])
1333 } else if (s->avctx->b_frame_strategy == 1) {
1334 for (i = 1; i < s->max_b_frames + 1; i++) {
1335 if (s->input_picture[i] &&
1336 s->input_picture[i]->b_frame_score == 0) {
1337 s->input_picture[i]->b_frame_score =
1339 s->input_picture[i ]->f.data[0],
1340 s->input_picture[i - 1]->f.data[0],
1344 for (i = 0; i < s->max_b_frames + 1; i++) {
1345 if (s->input_picture[i] == NULL ||
1346 s->input_picture[i]->b_frame_score - 1 >
1347 s->mb_num / s->avctx->b_sensitivity)
1351 b_frames = FFMAX(0, i - 1);
1354 for (i = 0; i < b_frames + 1; i++) {
1355 s->input_picture[i]->b_frame_score = 0;
1357 } else if (s->avctx->b_frame_strategy == 2) {
1358 b_frames = estimate_best_b_count(s);
1360 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1366 for (i = b_frames - 1; i >= 0; i--) {
1367 int type = s->input_picture[i]->f.pict_type;
1368 if (type && type != AV_PICTURE_TYPE_B)
1371 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1372 b_frames == s->max_b_frames) {
1373 av_log(s->avctx, AV_LOG_ERROR,
1374 "warning, too many b frames in a row\n");
1377 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1378 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1379 s->gop_size > s->picture_in_gop_number) {
1380 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1382 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1384 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1388 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1389 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1392 s->reordered_input_picture[0] = s->input_picture[b_frames];
1393 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1394 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1395 s->reordered_input_picture[0]->f.coded_picture_number =
1396 s->coded_picture_number++;
1397 for (i = 0; i < b_frames; i++) {
1398 s->reordered_input_picture[i + 1] = s->input_picture[i];
1399 s->reordered_input_picture[i + 1]->f.pict_type =
1401 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1402 s->coded_picture_number++;
1407 if (s->reordered_input_picture[0]) {
1408 s->reordered_input_picture[0]->f.reference =
1409 s->reordered_input_picture[0]->f.pict_type !=
1410 AV_PICTURE_TYPE_B ? 3 : 0;
1412 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1414 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1415 s->avctx->rc_buffer_size) {
1416 // input is a shared pix, so we can't modifiy it -> alloc a new
1417 // one & ensure that the shared one is reuseable
1420 int i = ff_find_unused_picture(s, 0);
1423 pic = &s->picture[i];
1425 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1426 if (ff_alloc_picture(s, pic, 0) < 0) {
1430 /* mark us unused / free shared pic */
1431 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1432 s->avctx->release_buffer(s->avctx,
1433 &s->reordered_input_picture[0]->f);
1434 for (i = 0; i < 4; i++)
1435 s->reordered_input_picture[0]->f.data[i] = NULL;
1436 s->reordered_input_picture[0]->f.type = 0;
1438 copy_picture_attributes(s, &pic->f,
1439 &s->reordered_input_picture[0]->f);
1441 s->current_picture_ptr = pic;
1443 // input is not a shared pix -> reuse buffer for current_pix
1445 assert(s->reordered_input_picture[0]->f.type ==
1446 FF_BUFFER_TYPE_USER ||
1447 s->reordered_input_picture[0]->f.type ==
1448 FF_BUFFER_TYPE_INTERNAL);
1450 s->current_picture_ptr = s->reordered_input_picture[0];
1451 for (i = 0; i < 4; i++) {
1452 s->new_picture.f.data[i] += INPLACE_OFFSET;
1455 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1457 s->picture_number = s->new_picture.f.display_picture_number;
1459 memset(&s->new_picture, 0, sizeof(Picture));
1464 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1465 AVFrame *pic_arg, int *got_packet)
1467 MpegEncContext *s = avctx->priv_data;
1468 int i, stuffing_count, ret;
1469 int context_count = s->slice_context_count;
1471 s->picture_in_gop_number++;
1473 if (load_input_picture(s, pic_arg) < 0)
1476 if (select_input_picture(s) < 0) {
1481 if (s->new_picture.f.data[0]) {
1482 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1485 s->mb_info_ptr = av_packet_new_side_data(pkt,
1486 AV_PKT_DATA_H263_MB_INFO,
1487 s->mb_width*s->mb_height*12);
1488 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1491 for (i = 0; i < context_count; i++) {
1492 int start_y = s->thread_context[i]->start_mb_y;
1493 int end_y = s->thread_context[i]-> end_mb_y;
1494 int h = s->mb_height;
1495 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1496 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1498 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1501 s->pict_type = s->new_picture.f.pict_type;
1503 ff_MPV_frame_start(s, avctx);
1505 if (encode_picture(s, s->picture_number) < 0)
1508 avctx->header_bits = s->header_bits;
1509 avctx->mv_bits = s->mv_bits;
1510 avctx->misc_bits = s->misc_bits;
1511 avctx->i_tex_bits = s->i_tex_bits;
1512 avctx->p_tex_bits = s->p_tex_bits;
1513 avctx->i_count = s->i_count;
1514 // FIXME f/b_count in avctx
1515 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1516 avctx->skip_count = s->skip_count;
1518 ff_MPV_frame_end(s);
1520 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1521 ff_mjpeg_encode_picture_trailer(s);
1523 if (avctx->rc_buffer_size) {
1524 RateControlContext *rcc = &s->rc_context;
1525 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1527 if (put_bits_count(&s->pb) > max_size &&
1528 s->lambda < s->avctx->lmax) {
1529 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1530 (s->qscale + 1) / s->qscale);
1531 if (s->adaptive_quant) {
1533 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1534 s->lambda_table[i] =
1535 FFMAX(s->lambda_table[i] + 1,
1536 s->lambda_table[i] * (s->qscale + 1) /
1539 s->mb_skipped = 0; // done in MPV_frame_start()
1540 // done in encode_picture() so we must undo it
1541 if (s->pict_type == AV_PICTURE_TYPE_P) {
1542 if (s->flipflop_rounding ||
1543 s->codec_id == AV_CODEC_ID_H263P ||
1544 s->codec_id == AV_CODEC_ID_MPEG4)
1545 s->no_rounding ^= 1;
1547 if (s->pict_type != AV_PICTURE_TYPE_B) {
1548 s->time_base = s->last_time_base;
1549 s->last_non_b_time = s->time - s->pp_time;
1551 for (i = 0; i < context_count; i++) {
1552 PutBitContext *pb = &s->thread_context[i]->pb;
1553 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1558 assert(s->avctx->rc_max_rate);
1561 if (s->flags & CODEC_FLAG_PASS1)
1562 ff_write_pass1_stats(s);
1564 for (i = 0; i < 4; i++) {
1565 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1566 avctx->error[i] += s->current_picture_ptr->f.error[i];
1569 if (s->flags & CODEC_FLAG_PASS1)
1570 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1571 avctx->i_tex_bits + avctx->p_tex_bits ==
1572 put_bits_count(&s->pb));
1573 flush_put_bits(&s->pb);
1574 s->frame_bits = put_bits_count(&s->pb);
1576 stuffing_count = ff_vbv_update(s, s->frame_bits);
1577 s->stuffing_bits = 8*stuffing_count;
1578 if (stuffing_count) {
1579 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1580 stuffing_count + 50) {
1581 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1585 switch (s->codec_id) {
1586 case AV_CODEC_ID_MPEG1VIDEO:
1587 case AV_CODEC_ID_MPEG2VIDEO:
1588 while (stuffing_count--) {
1589 put_bits(&s->pb, 8, 0);
1592 case AV_CODEC_ID_MPEG4:
1593 put_bits(&s->pb, 16, 0);
1594 put_bits(&s->pb, 16, 0x1C3);
1595 stuffing_count -= 4;
1596 while (stuffing_count--) {
1597 put_bits(&s->pb, 8, 0xFF);
1601 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1603 flush_put_bits(&s->pb);
1604 s->frame_bits = put_bits_count(&s->pb);
1607 /* update mpeg1/2 vbv_delay for CBR */
1608 if (s->avctx->rc_max_rate &&
1609 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1610 s->out_format == FMT_MPEG1 &&
1611 90000LL * (avctx->rc_buffer_size - 1) <=
1612 s->avctx->rc_max_rate * 0xFFFFLL) {
1613 int vbv_delay, min_delay;
1614 double inbits = s->avctx->rc_max_rate *
1615 av_q2d(s->avctx->time_base);
1616 int minbits = s->frame_bits - 8 *
1617 (s->vbv_delay_ptr - s->pb.buf - 1);
1618 double bits = s->rc_context.buffer_index + minbits - inbits;
1621 av_log(s->avctx, AV_LOG_ERROR,
1622 "Internal error, negative bits\n");
1624 assert(s->repeat_first_field == 0);
1626 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1627 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1628 s->avctx->rc_max_rate;
1630 vbv_delay = FFMAX(vbv_delay, min_delay);
1632 av_assert0(vbv_delay < 0xFFFF);
1634 s->vbv_delay_ptr[0] &= 0xF8;
1635 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1636 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1637 s->vbv_delay_ptr[2] &= 0x07;
1638 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1639 avctx->vbv_delay = vbv_delay * 300;
1641 s->total_bits += s->frame_bits;
1642 avctx->frame_bits = s->frame_bits;
1644 pkt->pts = s->current_picture.f.pts;
1645 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1646 if (!s->current_picture.f.coded_picture_number)
1647 pkt->dts = pkt->pts - s->dts_delta;
1649 pkt->dts = s->reordered_pts;
1650 s->reordered_pts = pkt->pts;
1652 pkt->dts = pkt->pts;
1653 if (s->current_picture.f.key_frame)
1654 pkt->flags |= AV_PKT_FLAG_KEY;
1656 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1660 assert((s->frame_bits & 7) == 0);
1662 pkt->size = s->frame_bits / 8;
1663 *got_packet = !!pkt->size;
1667 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1668 int n, int threshold)
1670 static const char tab[64] = {
1671 3, 2, 2, 1, 1, 1, 1, 1,
1672 1, 1, 1, 1, 1, 1, 1, 1,
1673 1, 1, 1, 1, 1, 1, 1, 1,
1674 0, 0, 0, 0, 0, 0, 0, 0,
1675 0, 0, 0, 0, 0, 0, 0, 0,
1676 0, 0, 0, 0, 0, 0, 0, 0,
1677 0, 0, 0, 0, 0, 0, 0, 0,
1678 0, 0, 0, 0, 0, 0, 0, 0
1683 DCTELEM *block = s->block[n];
1684 const int last_index = s->block_last_index[n];
1687 if (threshold < 0) {
1689 threshold = -threshold;
1693 /* Are all we could set to zero already zero? */
1694 if (last_index <= skip_dc - 1)
1697 for (i = 0; i <= last_index; i++) {
1698 const int j = s->intra_scantable.permutated[i];
1699 const int level = FFABS(block[j]);
1701 if (skip_dc && i == 0)
1705 } else if (level > 1) {
1711 if (score >= threshold)
1713 for (i = skip_dc; i <= last_index; i++) {
1714 const int j = s->intra_scantable.permutated[i];
1718 s->block_last_index[n] = 0;
1720 s->block_last_index[n] = -1;
1723 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1727 const int maxlevel = s->max_qcoeff;
1728 const int minlevel = s->min_qcoeff;
1732 i = 1; // skip clipping of intra dc
1736 for (; i <= last_index; i++) {
1737 const int j = s->intra_scantable.permutated[i];
1738 int level = block[j];
1740 if (level > maxlevel) {
1743 } else if (level < minlevel) {
1751 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1752 av_log(s->avctx, AV_LOG_INFO,
1753 "warning, clipping %d dct coefficients to %d..%d\n",
1754 overflow, minlevel, maxlevel);
1757 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1761 for (y = 0; y < 8; y++) {
1762 for (x = 0; x < 8; x++) {
1768 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1769 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1770 int v = ptr[x2 + y2 * stride];
1776 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1781 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1782 int motion_x, int motion_y,
1783 int mb_block_height,
1786 int16_t weight[8][64];
1787 DCTELEM orig[8][64];
1788 const int mb_x = s->mb_x;
1789 const int mb_y = s->mb_y;
1792 int dct_offset = s->linesize * 8; // default for progressive frames
1793 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1796 for (i = 0; i < mb_block_count; i++)
1797 skip_dct[i] = s->skipdct;
1799 if (s->adaptive_quant) {
1800 const int last_qp = s->qscale;
1801 const int mb_xy = mb_x + mb_y * s->mb_stride;
1803 s->lambda = s->lambda_table[mb_xy];
1806 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1807 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1808 s->dquant = s->qscale - last_qp;
1810 if (s->out_format == FMT_H263) {
1811 s->dquant = av_clip(s->dquant, -2, 2);
1813 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1815 if (s->pict_type == AV_PICTURE_TYPE_B) {
1816 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1819 if (s->mv_type == MV_TYPE_8X8)
1825 ff_set_qscale(s, last_qp + s->dquant);
1826 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1827 ff_set_qscale(s, s->qscale + s->dquant);
1829 wrap_y = s->linesize;
1830 wrap_c = s->uvlinesize;
1831 ptr_y = s->new_picture.f.data[0] +
1832 (mb_y * 16 * wrap_y) + mb_x * 16;
1833 ptr_cb = s->new_picture.f.data[1] +
1834 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1835 ptr_cr = s->new_picture.f.data[2] +
1836 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1838 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1839 uint8_t *ebuf = s->edge_emu_buffer + 32;
1840 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1841 mb_y * 16, s->width, s->height);
1843 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1844 mb_block_height, mb_x * 8, mb_y * 8,
1845 (s->width+1) >> 1, (s->height+1) >> 1);
1846 ptr_cb = ebuf + 18 * wrap_y;
1847 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1848 mb_block_height, mb_x * 8, mb_y * 8,
1849 (s->width+1) >> 1, (s->height+1) >> 1);
1850 ptr_cr = ebuf + 18 * wrap_y + 8;
1854 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1855 int progressive_score, interlaced_score;
1857 s->interlaced_dct = 0;
1858 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1860 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1861 NULL, wrap_y, 8) - 400;
1863 if (progressive_score > 0) {
1864 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1865 NULL, wrap_y * 2, 8) +
1866 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1867 NULL, wrap_y * 2, 8);
1868 if (progressive_score > interlaced_score) {
1869 s->interlaced_dct = 1;
1871 dct_offset = wrap_y;
1873 if (s->chroma_format == CHROMA_422)
1879 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1880 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1881 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1882 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1884 if (s->flags & CODEC_FLAG_GRAY) {
1888 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1889 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1890 if (!s->chroma_y_shift) { /* 422 */
1891 s->dsp.get_pixels(s->block[6],
1892 ptr_cb + (dct_offset >> 1), wrap_c);
1893 s->dsp.get_pixels(s->block[7],
1894 ptr_cr + (dct_offset >> 1), wrap_c);
1898 op_pixels_func (*op_pix)[4];
1899 qpel_mc_func (*op_qpix)[16];
1900 uint8_t *dest_y, *dest_cb, *dest_cr;
1902 dest_y = s->dest[0];
1903 dest_cb = s->dest[1];
1904 dest_cr = s->dest[2];
1906 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1907 op_pix = s->dsp.put_pixels_tab;
1908 op_qpix = s->dsp.put_qpel_pixels_tab;
1910 op_pix = s->dsp.put_no_rnd_pixels_tab;
1911 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1914 if (s->mv_dir & MV_DIR_FORWARD) {
1915 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1916 s->last_picture.f.data,
1918 op_pix = s->dsp.avg_pixels_tab;
1919 op_qpix = s->dsp.avg_qpel_pixels_tab;
1921 if (s->mv_dir & MV_DIR_BACKWARD) {
1922 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1923 s->next_picture.f.data,
1927 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1928 int progressive_score, interlaced_score;
1930 s->interlaced_dct = 0;
1931 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1934 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1935 ptr_y + wrap_y * 8, wrap_y,
1938 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1939 progressive_score -= 400;
1941 if (progressive_score > 0) {
1942 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1945 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1949 if (progressive_score > interlaced_score) {
1950 s->interlaced_dct = 1;
1952 dct_offset = wrap_y;
1954 if (s->chroma_format == CHROMA_422)
1960 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1961 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1962 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1963 dest_y + dct_offset, wrap_y);
1964 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1965 dest_y + dct_offset + 8, wrap_y);
1967 if (s->flags & CODEC_FLAG_GRAY) {
1971 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1972 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1973 if (!s->chroma_y_shift) { /* 422 */
1974 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1975 dest_cb + (dct_offset >> 1), wrap_c);
1976 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1977 dest_cr + (dct_offset >> 1), wrap_c);
1980 /* pre quantization */
1981 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1982 2 * s->qscale * s->qscale) {
1984 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1985 wrap_y, 8) < 20 * s->qscale)
1987 if (s->dsp.sad[1](NULL, ptr_y + 8,
1988 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1990 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1991 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1993 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1994 dest_y + dct_offset + 8,
1995 wrap_y, 8) < 20 * s->qscale)
1997 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1998 wrap_c, 8) < 20 * s->qscale)
2000 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2001 wrap_c, 8) < 20 * s->qscale)
2003 if (!s->chroma_y_shift) { /* 422 */
2004 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2005 dest_cb + (dct_offset >> 1),
2006 wrap_c, 8) < 20 * s->qscale)
2008 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2009 dest_cr + (dct_offset >> 1),
2010 wrap_c, 8) < 20 * s->qscale)
2016 if (s->quantizer_noise_shaping) {
2018 get_visual_weight(weight[0], ptr_y , wrap_y);
2020 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2022 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2024 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2026 get_visual_weight(weight[4], ptr_cb , wrap_c);
2028 get_visual_weight(weight[5], ptr_cr , wrap_c);
2029 if (!s->chroma_y_shift) { /* 422 */
2031 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2034 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2037 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2040 /* DCT & quantize */
2041 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2043 for (i = 0; i < mb_block_count; i++) {
2046 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2047 // FIXME we could decide to change to quantizer instead of
2049 // JS: I don't think that would be a good idea it could lower
2050 // quality instead of improve it. Just INTRADC clipping
2051 // deserves changes in quantizer
2053 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2055 s->block_last_index[i] = -1;
2057 if (s->quantizer_noise_shaping) {
2058 for (i = 0; i < mb_block_count; i++) {
2060 s->block_last_index[i] =
2061 dct_quantize_refine(s, s->block[i], weight[i],
2062 orig[i], i, s->qscale);
2067 if (s->luma_elim_threshold && !s->mb_intra)
2068 for (i = 0; i < 4; i++)
2069 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2070 if (s->chroma_elim_threshold && !s->mb_intra)
2071 for (i = 4; i < mb_block_count; i++)
2072 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2074 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2075 for (i = 0; i < mb_block_count; i++) {
2076 if (s->block_last_index[i] == -1)
2077 s->coded_score[i] = INT_MAX / 256;
2082 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2083 s->block_last_index[4] =
2084 s->block_last_index[5] = 0;
2086 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2089 // non c quantize code returns incorrect block_last_index FIXME
2090 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2091 for (i = 0; i < mb_block_count; i++) {
2093 if (s->block_last_index[i] > 0) {
2094 for (j = 63; j > 0; j--) {
2095 if (s->block[i][s->intra_scantable.permutated[j]])
2098 s->block_last_index[i] = j;
2103 /* huffman encode */
2104 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2105 case AV_CODEC_ID_MPEG1VIDEO:
2106 case AV_CODEC_ID_MPEG2VIDEO:
2107 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2108 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2110 case AV_CODEC_ID_MPEG4:
2111 if (CONFIG_MPEG4_ENCODER)
2112 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2114 case AV_CODEC_ID_MSMPEG4V2:
2115 case AV_CODEC_ID_MSMPEG4V3:
2116 case AV_CODEC_ID_WMV1:
2117 if (CONFIG_MSMPEG4_ENCODER)
2118 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2120 case AV_CODEC_ID_WMV2:
2121 if (CONFIG_WMV2_ENCODER)
2122 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2124 case AV_CODEC_ID_H261:
2125 if (CONFIG_H261_ENCODER)
2126 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2128 case AV_CODEC_ID_H263:
2129 case AV_CODEC_ID_H263P:
2130 case AV_CODEC_ID_FLV1:
2131 case AV_CODEC_ID_RV10:
2132 case AV_CODEC_ID_RV20:
2133 if (CONFIG_H263_ENCODER)
2134 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2136 case AV_CODEC_ID_MJPEG:
2137 case AV_CODEC_ID_AMV:
2138 if (CONFIG_MJPEG_ENCODER)
2139 ff_mjpeg_encode_mb(s, s->block);
2146 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2148 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2149 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2152 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2155 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2158 d->mb_skip_run= s->mb_skip_run;
2160 d->last_dc[i] = s->last_dc[i];
2163 d->mv_bits= s->mv_bits;
2164 d->i_tex_bits= s->i_tex_bits;
2165 d->p_tex_bits= s->p_tex_bits;
2166 d->i_count= s->i_count;
2167 d->f_count= s->f_count;
2168 d->b_count= s->b_count;
2169 d->skip_count= s->skip_count;
2170 d->misc_bits= s->misc_bits;
2174 d->qscale= s->qscale;
2175 d->dquant= s->dquant;
2177 d->esc3_level_length= s->esc3_level_length;
2180 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2183 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2184 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2187 d->mb_skip_run= s->mb_skip_run;
2189 d->last_dc[i] = s->last_dc[i];
2192 d->mv_bits= s->mv_bits;
2193 d->i_tex_bits= s->i_tex_bits;
2194 d->p_tex_bits= s->p_tex_bits;
2195 d->i_count= s->i_count;
2196 d->f_count= s->f_count;
2197 d->b_count= s->b_count;
2198 d->skip_count= s->skip_count;
2199 d->misc_bits= s->misc_bits;
2201 d->mb_intra= s->mb_intra;
2202 d->mb_skipped= s->mb_skipped;
2203 d->mv_type= s->mv_type;
2204 d->mv_dir= s->mv_dir;
2206 if(s->data_partitioning){
2208 d->tex_pb= s->tex_pb;
2212 d->block_last_index[i]= s->block_last_index[i];
2213 d->interlaced_dct= s->interlaced_dct;
2214 d->qscale= s->qscale;
2216 d->esc3_level_length= s->esc3_level_length;
2219 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2220 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2221 int *dmin, int *next_block, int motion_x, int motion_y)
2224 uint8_t *dest_backup[3];
2226 copy_context_before_encode(s, backup, type);
2228 s->block= s->blocks[*next_block];
2229 s->pb= pb[*next_block];
2230 if(s->data_partitioning){
2231 s->pb2 = pb2 [*next_block];
2232 s->tex_pb= tex_pb[*next_block];
2236 memcpy(dest_backup, s->dest, sizeof(s->dest));
2237 s->dest[0] = s->rd_scratchpad;
2238 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2239 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2240 assert(s->linesize >= 32); //FIXME
2243 encode_mb(s, motion_x, motion_y);
2245 score= put_bits_count(&s->pb);
2246 if(s->data_partitioning){
2247 score+= put_bits_count(&s->pb2);
2248 score+= put_bits_count(&s->tex_pb);
2251 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2252 ff_MPV_decode_mb(s, s->block);
2254 score *= s->lambda2;
2255 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2259 memcpy(s->dest, dest_backup, sizeof(s->dest));
2266 copy_context_after_encode(best, s, type);
2270 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2271 uint32_t *sq = ff_squareTbl + 256;
2276 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2277 else if(w==8 && h==8)
2278 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2282 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2291 static int sse_mb(MpegEncContext *s){
2295 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2296 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2299 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2300 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)
2301 +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)
2302 +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);
2304 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)
2305 +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)
2306 +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);
2309 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)
2310 +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)
2311 +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);
2314 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2315 MpegEncContext *s= *(void**)arg;
2319 s->me.dia_size= s->avctx->pre_dia_size;
2320 s->first_slice_line=1;
2321 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2322 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2323 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2325 s->first_slice_line=0;
2333 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2334 MpegEncContext *s= *(void**)arg;
2336 ff_check_alignment();
2338 s->me.dia_size= s->avctx->dia_size;
2339 s->first_slice_line=1;
2340 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2341 s->mb_x=0; //for block init below
2342 ff_init_block_index(s);
2343 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2344 s->block_index[0]+=2;
2345 s->block_index[1]+=2;
2346 s->block_index[2]+=2;
2347 s->block_index[3]+=2;
2349 /* compute motion vector & mb_type and store in context */
2350 if(s->pict_type==AV_PICTURE_TYPE_B)
2351 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2353 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2355 s->first_slice_line=0;
2360 static int mb_var_thread(AVCodecContext *c, void *arg){
2361 MpegEncContext *s= *(void**)arg;
2364 ff_check_alignment();
2366 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2367 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2370 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2372 int sum = s->dsp.pix_sum(pix, s->linesize);
2374 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2376 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2377 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2378 s->me.mb_var_sum_temp += varc;
2384 static void write_slice_end(MpegEncContext *s){
2385 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2386 if(s->partitioned_frame){
2387 ff_mpeg4_merge_partitions(s);
2390 ff_mpeg4_stuffing(&s->pb);
2391 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2392 ff_mjpeg_encode_stuffing(s);
2395 avpriv_align_put_bits(&s->pb);
2396 flush_put_bits(&s->pb);
2398 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2399 s->misc_bits+= get_bits_diff(s);
2402 static void write_mb_info(MpegEncContext *s)
2404 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2405 int offset = put_bits_count(&s->pb);
2406 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2407 int gobn = s->mb_y / s->gob_index;
2409 if (CONFIG_H263_ENCODER)
2410 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2411 bytestream_put_le32(&ptr, offset);
2412 bytestream_put_byte(&ptr, s->qscale);
2413 bytestream_put_byte(&ptr, gobn);
2414 bytestream_put_le16(&ptr, mba);
2415 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2416 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2417 /* 4MV not implemented */
2418 bytestream_put_byte(&ptr, 0); /* hmv2 */
2419 bytestream_put_byte(&ptr, 0); /* vmv2 */
2422 static void update_mb_info(MpegEncContext *s, int startcode)
2426 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2427 s->mb_info_size += 12;
2428 s->prev_mb_info = s->last_mb_info;
2431 s->prev_mb_info = put_bits_count(&s->pb)/8;
2432 /* This might have incremented mb_info_size above, and we return without
2433 * actually writing any info into that slot yet. But in that case,
2434 * this will be called again at the start of the after writing the
2435 * start code, actually writing the mb info. */
2439 s->last_mb_info = put_bits_count(&s->pb)/8;
2440 if (!s->mb_info_size)
2441 s->mb_info_size += 12;
2445 static int encode_thread(AVCodecContext *c, void *arg){
2446 MpegEncContext *s= *(void**)arg;
2447 int mb_x, mb_y, pdif = 0;
2448 int chr_h= 16>>s->chroma_y_shift;
2450 MpegEncContext best_s, backup_s;
2451 uint8_t bit_buf[2][MAX_MB_BYTES];
2452 uint8_t bit_buf2[2][MAX_MB_BYTES];
2453 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2454 PutBitContext pb[2], pb2[2], tex_pb[2];
2456 ff_check_alignment();
2459 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2460 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2461 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2464 s->last_bits= put_bits_count(&s->pb);
2475 /* init last dc values */
2476 /* note: quant matrix value (8) is implied here */
2477 s->last_dc[i] = 128 << s->intra_dc_precision;
2479 s->current_picture.f.error[i] = 0;
2481 if(s->codec_id==AV_CODEC_ID_AMV){
2482 s->last_dc[0] = 128*8/13;
2483 s->last_dc[1] = 128*8/14;
2484 s->last_dc[2] = 128*8/14;
2487 memset(s->last_mv, 0, sizeof(s->last_mv));
2491 switch(s->codec_id){
2492 case AV_CODEC_ID_H263:
2493 case AV_CODEC_ID_H263P:
2494 case AV_CODEC_ID_FLV1:
2495 if (CONFIG_H263_ENCODER)
2496 s->gob_index = ff_h263_get_gob_height(s);
2498 case AV_CODEC_ID_MPEG4:
2499 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2500 ff_mpeg4_init_partitions(s);
2506 s->first_slice_line = 1;
2507 s->ptr_lastgob = s->pb.buf;
2508 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2512 ff_set_qscale(s, s->qscale);
2513 ff_init_block_index(s);
2515 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2516 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2517 int mb_type= s->mb_type[xy];
2522 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2523 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2526 if(s->data_partitioning){
2527 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2528 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2529 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2535 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2536 ff_update_block_index(s);
2538 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2539 ff_h261_reorder_mb_index(s);
2540 xy= s->mb_y*s->mb_stride + s->mb_x;
2541 mb_type= s->mb_type[xy];
2544 /* write gob / video packet header */
2546 int current_packet_size, is_gob_start;
2548 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2550 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2552 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2554 switch(s->codec_id){
2555 case AV_CODEC_ID_H263:
2556 case AV_CODEC_ID_H263P:
2557 if(!s->h263_slice_structured)
2558 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2560 case AV_CODEC_ID_MPEG2VIDEO:
2561 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2562 case AV_CODEC_ID_MPEG1VIDEO:
2563 if(s->mb_skip_run) is_gob_start=0;
2565 case AV_CODEC_ID_MJPEG:
2566 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2571 if(s->start_mb_y != mb_y || mb_x!=0){
2573 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2574 ff_mpeg4_init_partitions(s);
2578 av_assert2((put_bits_count(&s->pb)&7) == 0);
2579 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2581 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2582 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2583 int d= 100 / s->avctx->error_rate;
2585 current_packet_size=0;
2586 s->pb.buf_ptr= s->ptr_lastgob;
2587 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2591 if (s->avctx->rtp_callback){
2592 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2593 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2595 update_mb_info(s, 1);
2597 switch(s->codec_id){
2598 case AV_CODEC_ID_MPEG4:
2599 if (CONFIG_MPEG4_ENCODER) {
2600 ff_mpeg4_encode_video_packet_header(s);
2601 ff_mpeg4_clean_buffers(s);
2604 case AV_CODEC_ID_MPEG1VIDEO:
2605 case AV_CODEC_ID_MPEG2VIDEO:
2606 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2607 ff_mpeg1_encode_slice_header(s);
2608 ff_mpeg1_clean_buffers(s);
2611 case AV_CODEC_ID_H263:
2612 case AV_CODEC_ID_H263P:
2613 if (CONFIG_H263_ENCODER)
2614 ff_h263_encode_gob_header(s, mb_y);
2618 if(s->flags&CODEC_FLAG_PASS1){
2619 int bits= put_bits_count(&s->pb);
2620 s->misc_bits+= bits - s->last_bits;
2624 s->ptr_lastgob += current_packet_size;
2625 s->first_slice_line=1;
2626 s->resync_mb_x=mb_x;
2627 s->resync_mb_y=mb_y;
2631 if( (s->resync_mb_x == s->mb_x)
2632 && s->resync_mb_y+1 == s->mb_y){
2633 s->first_slice_line=0;
2637 s->dquant=0; //only for QP_RD
2639 update_mb_info(s, 0);
2641 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
2643 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2645 copy_context_before_encode(&backup_s, s, -1);
2647 best_s.data_partitioning= s->data_partitioning;
2648 best_s.partitioned_frame= s->partitioned_frame;
2649 if(s->data_partitioning){
2650 backup_s.pb2= s->pb2;
2651 backup_s.tex_pb= s->tex_pb;
2654 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2655 s->mv_dir = MV_DIR_FORWARD;
2656 s->mv_type = MV_TYPE_16X16;
2658 s->mv[0][0][0] = s->p_mv_table[xy][0];
2659 s->mv[0][0][1] = s->p_mv_table[xy][1];
2660 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2661 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2663 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2664 s->mv_dir = MV_DIR_FORWARD;
2665 s->mv_type = MV_TYPE_FIELD;
2668 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2669 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2670 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2672 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2673 &dmin, &next_block, 0, 0);
2675 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2676 s->mv_dir = MV_DIR_FORWARD;
2677 s->mv_type = MV_TYPE_16X16;
2681 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2682 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2684 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2685 s->mv_dir = MV_DIR_FORWARD;
2686 s->mv_type = MV_TYPE_8X8;
2689 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2690 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2692 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2693 &dmin, &next_block, 0, 0);
2695 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2696 s->mv_dir = MV_DIR_FORWARD;
2697 s->mv_type = MV_TYPE_16X16;
2699 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2700 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2701 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2702 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2704 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2705 s->mv_dir = MV_DIR_BACKWARD;
2706 s->mv_type = MV_TYPE_16X16;
2708 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2709 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2710 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2711 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2713 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2714 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2715 s->mv_type = MV_TYPE_16X16;
2717 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2718 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2719 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2720 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2721 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2722 &dmin, &next_block, 0, 0);
2724 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2725 s->mv_dir = MV_DIR_FORWARD;
2726 s->mv_type = MV_TYPE_FIELD;
2729 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2730 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2731 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2733 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2734 &dmin, &next_block, 0, 0);
2736 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2737 s->mv_dir = MV_DIR_BACKWARD;
2738 s->mv_type = MV_TYPE_FIELD;
2741 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2742 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2743 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2745 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2746 &dmin, &next_block, 0, 0);
2748 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2749 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2750 s->mv_type = MV_TYPE_FIELD;
2752 for(dir=0; dir<2; dir++){
2754 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2755 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2756 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2759 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2760 &dmin, &next_block, 0, 0);
2762 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2764 s->mv_type = MV_TYPE_16X16;
2768 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2769 &dmin, &next_block, 0, 0);
2770 if(s->h263_pred || s->h263_aic){
2772 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2774 ff_clean_intra_table_entries(s); //old mode?
2778 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2779 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2780 const int last_qp= backup_s.qscale;
2783 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2784 static const int dquant_tab[4]={-1,1,-2,2};
2786 av_assert2(backup_s.dquant == 0);
2789 s->mv_dir= best_s.mv_dir;
2790 s->mv_type = MV_TYPE_16X16;
2791 s->mb_intra= best_s.mb_intra;
2792 s->mv[0][0][0] = best_s.mv[0][0][0];
2793 s->mv[0][0][1] = best_s.mv[0][0][1];
2794 s->mv[1][0][0] = best_s.mv[1][0][0];
2795 s->mv[1][0][1] = best_s.mv[1][0][1];
2797 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2798 for(; qpi<4; qpi++){
2799 int dquant= dquant_tab[qpi];
2800 qp= last_qp + dquant;
2801 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2803 backup_s.dquant= dquant;
2804 if(s->mb_intra && s->dc_val[0]){
2806 dc[i]= s->dc_val[0][ s->block_index[i] ];
2807 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2811 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2812 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2813 if(best_s.qscale != qp){
2814 if(s->mb_intra && s->dc_val[0]){
2816 s->dc_val[0][ s->block_index[i] ]= dc[i];
2817 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2824 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2825 int mx= s->b_direct_mv_table[xy][0];
2826 int my= s->b_direct_mv_table[xy][1];
2828 backup_s.dquant = 0;
2829 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2831 ff_mpeg4_set_direct_mv(s, mx, my);
2832 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2833 &dmin, &next_block, mx, my);
2835 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2836 backup_s.dquant = 0;
2837 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2839 ff_mpeg4_set_direct_mv(s, 0, 0);
2840 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2841 &dmin, &next_block, 0, 0);
2843 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2846 coded |= s->block_last_index[i];
2849 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2850 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2851 mx=my=0; //FIXME find the one we actually used
2852 ff_mpeg4_set_direct_mv(s, mx, my);
2853 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2861 s->mv_dir= best_s.mv_dir;
2862 s->mv_type = best_s.mv_type;
2864 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2865 s->mv[0][0][1] = best_s.mv[0][0][1];
2866 s->mv[1][0][0] = best_s.mv[1][0][0];
2867 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2870 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2871 &dmin, &next_block, mx, my);
2876 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2878 copy_context_after_encode(s, &best_s, -1);
2880 pb_bits_count= put_bits_count(&s->pb);
2881 flush_put_bits(&s->pb);
2882 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2885 if(s->data_partitioning){
2886 pb2_bits_count= put_bits_count(&s->pb2);
2887 flush_put_bits(&s->pb2);
2888 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2889 s->pb2= backup_s.pb2;
2891 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2892 flush_put_bits(&s->tex_pb);
2893 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2894 s->tex_pb= backup_s.tex_pb;
2896 s->last_bits= put_bits_count(&s->pb);
2898 if (CONFIG_H263_ENCODER &&
2899 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2900 ff_h263_update_motion_val(s);
2902 if(next_block==0){ //FIXME 16 vs linesize16
2903 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2904 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2905 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2908 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2909 ff_MPV_decode_mb(s, s->block);
2911 int motion_x = 0, motion_y = 0;
2912 s->mv_type=MV_TYPE_16X16;
2913 // only one MB-Type possible
2916 case CANDIDATE_MB_TYPE_INTRA:
2919 motion_x= s->mv[0][0][0] = 0;
2920 motion_y= s->mv[0][0][1] = 0;
2922 case CANDIDATE_MB_TYPE_INTER:
2923 s->mv_dir = MV_DIR_FORWARD;
2925 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2926 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2928 case CANDIDATE_MB_TYPE_INTER_I:
2929 s->mv_dir = MV_DIR_FORWARD;
2930 s->mv_type = MV_TYPE_FIELD;
2933 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2934 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2935 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2938 case CANDIDATE_MB_TYPE_INTER4V:
2939 s->mv_dir = MV_DIR_FORWARD;
2940 s->mv_type = MV_TYPE_8X8;
2943 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2944 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2947 case CANDIDATE_MB_TYPE_DIRECT:
2948 if (CONFIG_MPEG4_ENCODER) {
2949 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2951 motion_x=s->b_direct_mv_table[xy][0];
2952 motion_y=s->b_direct_mv_table[xy][1];
2953 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2956 case CANDIDATE_MB_TYPE_DIRECT0:
2957 if (CONFIG_MPEG4_ENCODER) {
2958 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2960 ff_mpeg4_set_direct_mv(s, 0, 0);
2963 case CANDIDATE_MB_TYPE_BIDIR:
2964 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2966 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2967 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2968 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2969 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2971 case CANDIDATE_MB_TYPE_BACKWARD:
2972 s->mv_dir = MV_DIR_BACKWARD;
2974 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2975 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2977 case CANDIDATE_MB_TYPE_FORWARD:
2978 s->mv_dir = MV_DIR_FORWARD;
2980 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2981 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2983 case CANDIDATE_MB_TYPE_FORWARD_I:
2984 s->mv_dir = MV_DIR_FORWARD;
2985 s->mv_type = MV_TYPE_FIELD;
2988 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2989 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2990 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2993 case CANDIDATE_MB_TYPE_BACKWARD_I:
2994 s->mv_dir = MV_DIR_BACKWARD;
2995 s->mv_type = MV_TYPE_FIELD;
2998 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2999 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3000 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3003 case CANDIDATE_MB_TYPE_BIDIR_I:
3004 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3005 s->mv_type = MV_TYPE_FIELD;
3007 for(dir=0; dir<2; dir++){
3009 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3010 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3011 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3016 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3019 encode_mb(s, motion_x, motion_y);
3021 // RAL: Update last macroblock type
3022 s->last_mv_dir = s->mv_dir;
3024 if (CONFIG_H263_ENCODER &&
3025 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3026 ff_h263_update_motion_val(s);
3028 ff_MPV_decode_mb(s, s->block);
3031 /* clean the MV table in IPS frames for direct mode in B frames */
3032 if(s->mb_intra /* && I,P,S_TYPE */){
3033 s->p_mv_table[xy][0]=0;
3034 s->p_mv_table[xy][1]=0;
3037 if(s->flags&CODEC_FLAG_PSNR){
3041 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3042 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3044 s->current_picture.f.error[0] += sse(
3045 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3046 s->dest[0], w, h, s->linesize);
3047 s->current_picture.f.error[1] += sse(
3048 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3049 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3050 s->current_picture.f.error[2] += sse(
3051 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3052 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3055 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3056 ff_h263_loop_filter(s);
3058 av_dlog(s->avctx, "MB %d %d bits\n",
3059 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3063 //not beautiful here but we must write it before flushing so it has to be here
3064 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3065 ff_msmpeg4_encode_ext_header(s);
3069 /* Send the last GOB if RTP */
3070 if (s->avctx->rtp_callback) {
3071 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3072 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3073 /* Call the RTP callback to send the last GOB */
3075 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3081 #define MERGE(field) dst->field += src->field; src->field=0
3082 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3083 MERGE(me.scene_change_score);
3084 MERGE(me.mc_mb_var_sum_temp);
3085 MERGE(me.mb_var_sum_temp);
3088 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3091 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3092 MERGE(dct_count[1]);
3102 MERGE(padding_bug_score);
3103 MERGE(current_picture.f.error[0]);
3104 MERGE(current_picture.f.error[1]);
3105 MERGE(current_picture.f.error[2]);
3107 if(dst->avctx->noise_reduction){
3108 for(i=0; i<64; i++){
3109 MERGE(dct_error_sum[0][i]);
3110 MERGE(dct_error_sum[1][i]);
3114 assert(put_bits_count(&src->pb) % 8 ==0);
3115 assert(put_bits_count(&dst->pb) % 8 ==0);
3116 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3117 flush_put_bits(&dst->pb);
3120 static int estimate_qp(MpegEncContext *s, int dry_run){
3121 if (s->next_lambda){
3122 s->current_picture_ptr->f.quality =
3123 s->current_picture.f.quality = s->next_lambda;
3124 if(!dry_run) s->next_lambda= 0;
3125 } else if (!s->fixed_qscale) {
3126 s->current_picture_ptr->f.quality =
3127 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3128 if (s->current_picture.f.quality < 0)
3132 if(s->adaptive_quant){
3133 switch(s->codec_id){
3134 case AV_CODEC_ID_MPEG4:
3135 if (CONFIG_MPEG4_ENCODER)
3136 ff_clean_mpeg4_qscales(s);
3138 case AV_CODEC_ID_H263:
3139 case AV_CODEC_ID_H263P:
3140 case AV_CODEC_ID_FLV1:
3141 if (CONFIG_H263_ENCODER)
3142 ff_clean_h263_qscales(s);
3145 ff_init_qscale_tab(s);
3148 s->lambda= s->lambda_table[0];
3151 s->lambda = s->current_picture.f.quality;
3156 /* must be called before writing the header */
3157 static void set_frame_distances(MpegEncContext * s){
3158 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3159 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3161 if(s->pict_type==AV_PICTURE_TYPE_B){
3162 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3163 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3165 s->pp_time= s->time - s->last_non_b_time;
3166 s->last_non_b_time= s->time;
3167 assert(s->picture_number==0 || s->pp_time > 0);
3171 static int encode_picture(MpegEncContext *s, int picture_number)
3175 int context_count = s->slice_context_count;
3177 s->picture_number = picture_number;
3179 /* Reset the average MB variance */
3180 s->me.mb_var_sum_temp =
3181 s->me.mc_mb_var_sum_temp = 0;
3183 /* we need to initialize some time vars before we can encode b-frames */
3184 // RAL: Condition added for MPEG1VIDEO
3185 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3186 set_frame_distances(s);
3187 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3188 ff_set_mpeg4_time(s);
3190 s->me.scene_change_score=0;
3192 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3194 if(s->pict_type==AV_PICTURE_TYPE_I){
3195 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3196 else s->no_rounding=0;
3197 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3198 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3199 s->no_rounding ^= 1;
3202 if(s->flags & CODEC_FLAG_PASS2){
3203 if (estimate_qp(s,1) < 0)
3205 ff_get_2pass_fcode(s);
3206 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3207 if(s->pict_type==AV_PICTURE_TYPE_B)
3208 s->lambda= s->last_lambda_for[s->pict_type];
3210 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3214 if(s->codec_id != AV_CODEC_ID_AMV){
3215 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3216 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3217 s->q_chroma_intra_matrix = s->q_intra_matrix;
3218 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3221 s->mb_intra=0; //for the rate distortion & bit compare functions
3222 for(i=1; i<context_count; i++){
3223 ff_update_duplicate_context(s->thread_context[i], s);
3229 /* Estimate motion for every MB */
3230 if(s->pict_type != AV_PICTURE_TYPE_I){
3231 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3232 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3233 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3234 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3235 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3239 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3240 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3242 for(i=0; i<s->mb_stride*s->mb_height; i++)
3243 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3245 if(!s->fixed_qscale){
3246 /* finding spatial complexity for I-frame rate control */
3247 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3250 for(i=1; i<context_count; i++){
3251 merge_context_after_me(s, s->thread_context[i]);
3253 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3254 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3257 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3258 s->pict_type= AV_PICTURE_TYPE_I;
3259 for(i=0; i<s->mb_stride*s->mb_height; i++)
3260 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3261 if(s->msmpeg4_version >= 3)
3263 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3264 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3268 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3269 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3271 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3273 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3274 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3275 s->f_code= FFMAX3(s->f_code, a, b);
3278 ff_fix_long_p_mvs(s);
3279 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3280 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3284 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3285 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3290 if(s->pict_type==AV_PICTURE_TYPE_B){
3293 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3294 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3295 s->f_code = FFMAX(a, b);
3297 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3298 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3299 s->b_code = FFMAX(a, b);
3301 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3302 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3303 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3304 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3305 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3307 for(dir=0; dir<2; dir++){
3310 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3311 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3312 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3313 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3321 if (estimate_qp(s, 0) < 0)
3324 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3325 s->qscale= 3; //reduce clipping problems
3327 if (s->out_format == FMT_MJPEG) {
3328 /* for mjpeg, we do include qscale in the matrix */
3330 int j= s->dsp.idct_permutation[i];
3332 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3334 s->y_dc_scale_table=
3335 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3336 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3337 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3338 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3341 if(s->codec_id == AV_CODEC_ID_AMV){
3342 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};
3343 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};
3345 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3347 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3348 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3350 s->y_dc_scale_table= y;
3351 s->c_dc_scale_table= c;
3352 s->intra_matrix[0] = 13;
3353 s->chroma_intra_matrix[0] = 14;
3354 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3355 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3356 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3357 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3361 //FIXME var duplication
3362 s->current_picture_ptr->f.key_frame =
3363 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3364 s->current_picture_ptr->f.pict_type =
3365 s->current_picture.f.pict_type = s->pict_type;
3367 if (s->current_picture.f.key_frame)
3368 s->picture_in_gop_number=0;
3370 s->mb_x = s->mb_y = 0;
3371 s->last_bits= put_bits_count(&s->pb);
3372 switch(s->out_format) {
3374 if (CONFIG_MJPEG_ENCODER)
3375 ff_mjpeg_encode_picture_header(s);
3378 if (CONFIG_H261_ENCODER)
3379 ff_h261_encode_picture_header(s, picture_number);
3382 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3383 ff_wmv2_encode_picture_header(s, picture_number);
3384 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3385 ff_msmpeg4_encode_picture_header(s, picture_number);
3386 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3387 ff_mpeg4_encode_picture_header(s, picture_number);
3388 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3389 ff_rv10_encode_picture_header(s, picture_number);
3390 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3391 ff_rv20_encode_picture_header(s, picture_number);
3392 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3393 ff_flv_encode_picture_header(s, picture_number);
3394 else if (CONFIG_H263_ENCODER)
3395 ff_h263_encode_picture_header(s, picture_number);
3398 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3399 ff_mpeg1_encode_picture_header(s, picture_number);
3406 bits= put_bits_count(&s->pb);
3407 s->header_bits= bits - s->last_bits;
3409 for(i=1; i<context_count; i++){
3410 update_duplicate_context_after_me(s->thread_context[i], s);
3412 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3413 for(i=1; i<context_count; i++){
3414 merge_context_after_encode(s, s->thread_context[i]);
3420 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3421 const int intra= s->mb_intra;
3424 s->dct_count[intra]++;
3426 for(i=0; i<64; i++){
3427 int level= block[i];
3431 s->dct_error_sum[intra][i] += level;
3432 level -= s->dct_offset[intra][i];
3433 if(level<0) level=0;
3435 s->dct_error_sum[intra][i] -= level;
3436 level += s->dct_offset[intra][i];
3437 if(level>0) level=0;
3444 static int dct_quantize_trellis_c(MpegEncContext *s,
3445 DCTELEM *block, int n,
3446 int qscale, int *overflow){
3448 const uint8_t *scantable= s->intra_scantable.scantable;
3449 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3451 unsigned int threshold1, threshold2;
3463 int coeff_count[64];
3464 int qmul, qadd, start_i, last_non_zero, i, dc;
3465 const int esc_length= s->ac_esc_length;
3467 uint8_t * last_length;
3468 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3470 s->dsp.fdct (block);
3472 if(s->dct_error_sum)
3473 s->denoise_dct(s, block);
3475 qadd= ((qscale-1)|1)*8;
3486 /* For AIC we skip quant/dequant of INTRADC */
3491 /* note: block[0] is assumed to be positive */
3492 block[0] = (block[0] + (q >> 1)) / q;
3495 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3496 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3497 bias= 1<<(QMAT_SHIFT-1);
3498 length = s->intra_ac_vlc_length;
3499 last_length= s->intra_ac_vlc_last_length;
3503 qmat = s->q_inter_matrix[qscale];
3504 length = s->inter_ac_vlc_length;
3505 last_length= s->inter_ac_vlc_last_length;
3509 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3510 threshold2= (threshold1<<1);
3512 for(i=63; i>=start_i; i--) {
3513 const int j = scantable[i];
3514 int level = block[j] * qmat[j];
3516 if(((unsigned)(level+threshold1))>threshold2){
3522 for(i=start_i; i<=last_non_zero; i++) {
3523 const int j = scantable[i];
3524 int level = block[j] * qmat[j];
3526 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3527 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3528 if(((unsigned)(level+threshold1))>threshold2){
3530 level= (bias + level)>>QMAT_SHIFT;
3532 coeff[1][i]= level-1;
3533 // coeff[2][k]= level-2;
3535 level= (bias - level)>>QMAT_SHIFT;
3536 coeff[0][i]= -level;
3537 coeff[1][i]= -level+1;
3538 // coeff[2][k]= -level+2;
3540 coeff_count[i]= FFMIN(level, 2);
3541 av_assert2(coeff_count[i]);
3544 coeff[0][i]= (level>>31)|1;
3549 *overflow= s->max_qcoeff < max; //overflow might have happened
3551 if(last_non_zero < start_i){
3552 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3553 return last_non_zero;
3556 score_tab[start_i]= 0;
3557 survivor[0]= start_i;
3560 for(i=start_i; i<=last_non_zero; i++){
3561 int level_index, j, zero_distortion;
3562 int dct_coeff= FFABS(block[ scantable[i] ]);
3563 int best_score=256*256*256*120;
3565 if (s->dsp.fdct == ff_fdct_ifast)
3566 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3567 zero_distortion= dct_coeff*dct_coeff;
3569 for(level_index=0; level_index < coeff_count[i]; level_index++){
3571 int level= coeff[level_index][i];
3572 const int alevel= FFABS(level);
3577 if(s->out_format == FMT_H263){
3578 unquant_coeff= alevel*qmul + qadd;
3580 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3582 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3583 unquant_coeff = (unquant_coeff - 1) | 1;
3585 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3586 unquant_coeff = (unquant_coeff - 1) | 1;
3591 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3593 if((level&(~127)) == 0){
3594 for(j=survivor_count-1; j>=0; j--){
3595 int run= i - survivor[j];
3596 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3597 score += score_tab[i-run];
3599 if(score < best_score){
3602 level_tab[i+1]= level-64;
3606 if(s->out_format == FMT_H263){
3607 for(j=survivor_count-1; j>=0; j--){
3608 int run= i - survivor[j];
3609 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3610 score += score_tab[i-run];
3611 if(score < last_score){
3614 last_level= level-64;
3620 distortion += esc_length*lambda;
3621 for(j=survivor_count-1; j>=0; j--){
3622 int run= i - survivor[j];
3623 int score= distortion + score_tab[i-run];
3625 if(score < best_score){
3628 level_tab[i+1]= level-64;
3632 if(s->out_format == FMT_H263){
3633 for(j=survivor_count-1; j>=0; j--){
3634 int run= i - survivor[j];
3635 int score= distortion + score_tab[i-run];
3636 if(score < last_score){
3639 last_level= level-64;
3647 score_tab[i+1]= best_score;
3649 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3650 if(last_non_zero <= 27){
3651 for(; survivor_count; survivor_count--){
3652 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3656 for(; survivor_count; survivor_count--){
3657 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3662 survivor[ survivor_count++ ]= i+1;
3665 if(s->out_format != FMT_H263){
3666 last_score= 256*256*256*120;
3667 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3668 int score= score_tab[i];
3669 if(i) score += lambda*2; //FIXME exacter?
3671 if(score < last_score){
3674 last_level= level_tab[i];
3675 last_run= run_tab[i];
3680 s->coded_score[n] = last_score;
3682 dc= FFABS(block[0]);
3683 last_non_zero= last_i - 1;
3684 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3686 if(last_non_zero < start_i)
3687 return last_non_zero;
3689 if(last_non_zero == 0 && start_i == 0){
3691 int best_score= dc * dc;
3693 for(i=0; i<coeff_count[0]; i++){
3694 int level= coeff[i][0];
3695 int alevel= FFABS(level);
3696 int unquant_coeff, score, distortion;
3698 if(s->out_format == FMT_H263){
3699 unquant_coeff= (alevel*qmul + qadd)>>3;
3701 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3702 unquant_coeff = (unquant_coeff - 1) | 1;
3704 unquant_coeff = (unquant_coeff + 4) >> 3;
3705 unquant_coeff<<= 3 + 3;
3707 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3709 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3710 else score= distortion + esc_length*lambda;
3712 if(score < best_score){
3714 best_level= level - 64;
3717 block[0]= best_level;
3718 s->coded_score[n] = best_score - dc*dc;
3719 if(best_level == 0) return -1;
3720 else return last_non_zero;
3724 av_assert2(last_level);
3726 block[ perm_scantable[last_non_zero] ]= last_level;
3729 for(; i>start_i; i -= run_tab[i] + 1){
3730 block[ perm_scantable[i-1] ]= level_tab[i];
3733 return last_non_zero;
3736 //#define REFINE_STATS 1
3737 static int16_t basis[64][64];
3739 static void build_basis(uint8_t *perm){
3746 double s= 0.25*(1<<BASIS_SHIFT);
3748 int perm_index= perm[index];
3749 if(i==0) s*= sqrt(0.5);
3750 if(j==0) s*= sqrt(0.5);
3751 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)));
3758 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3759 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3762 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3763 const uint8_t *scantable= s->intra_scantable.scantable;
3764 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3765 // unsigned int threshold1, threshold2;
3770 int qmul, qadd, start_i, last_non_zero, i, dc;
3772 uint8_t * last_length;
3774 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3777 static int after_last=0;
3778 static int to_zero=0;
3779 static int from_zero=0;
3782 static int messed_sign=0;
3785 if(basis[0][0] == 0)
3786 build_basis(s->dsp.idct_permutation);
3797 /* For AIC we skip quant/dequant of INTRADC */
3801 q <<= RECON_SHIFT-3;
3802 /* note: block[0] is assumed to be positive */
3804 // block[0] = (block[0] + (q >> 1)) / q;
3806 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3807 // bias= 1<<(QMAT_SHIFT-1);
3808 length = s->intra_ac_vlc_length;
3809 last_length= s->intra_ac_vlc_last_length;
3813 length = s->inter_ac_vlc_length;
3814 last_length= s->inter_ac_vlc_last_length;
3816 last_non_zero = s->block_last_index[n];
3821 dc += (1<<(RECON_SHIFT-1));
3822 for(i=0; i<64; i++){
3823 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3826 STOP_TIMER("memset rem[]")}
3829 for(i=0; i<64; i++){
3834 w= FFABS(weight[i]) + qns*one;
3835 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3838 // w=weight[i] = (63*qns + (w/2)) / w;
3841 av_assert2(w<(1<<6));
3844 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3850 for(i=start_i; i<=last_non_zero; i++){
3851 int j= perm_scantable[i];
3852 const int level= block[j];
3856 if(level<0) coeff= qmul*level - qadd;
3857 else coeff= qmul*level + qadd;
3858 run_tab[rle_index++]=run;
3861 s->dsp.add_8x8basis(rem, basis[j], coeff);
3867 if(last_non_zero>0){
3868 STOP_TIMER("init rem[]")
3875 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3878 int run2, best_unquant_change=0, analyze_gradient;
3882 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3884 if(analyze_gradient){
3888 for(i=0; i<64; i++){
3891 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3894 STOP_TIMER("rem*w*w")}
3904 const int level= block[0];
3905 int change, old_coeff;
3907 av_assert2(s->mb_intra);
3911 for(change=-1; change<=1; change+=2){
3912 int new_level= level + change;
3913 int score, new_coeff;
3915 new_coeff= q*new_level;
3916 if(new_coeff >= 2048 || new_coeff < 0)
3919 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3920 if(score<best_score){
3923 best_change= change;
3924 best_unquant_change= new_coeff - old_coeff;
3931 run2= run_tab[rle_index++];
3935 for(i=start_i; i<64; i++){
3936 int j= perm_scantable[i];
3937 const int level= block[j];
3938 int change, old_coeff;
3940 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3944 if(level<0) old_coeff= qmul*level - qadd;
3945 else old_coeff= qmul*level + qadd;
3946 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3950 av_assert2(run2>=0 || i >= last_non_zero );
3953 for(change=-1; change<=1; change+=2){
3954 int new_level= level + change;
3955 int score, new_coeff, unquant_change;
3958 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3962 if(new_level<0) new_coeff= qmul*new_level - qadd;
3963 else new_coeff= qmul*new_level + qadd;
3964 if(new_coeff >= 2048 || new_coeff <= -2048)
3966 //FIXME check for overflow
3969 if(level < 63 && level > -63){
3970 if(i < last_non_zero)
3971 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3972 - length[UNI_AC_ENC_INDEX(run, level+64)];
3974 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3975 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3978 av_assert2(FFABS(new_level)==1);
3980 if(analyze_gradient){
3981 int g= d1[ scantable[i] ];
3982 if(g && (g^new_level) >= 0)
3986 if(i < last_non_zero){
3987 int next_i= i + run2 + 1;
3988 int next_level= block[ perm_scantable[next_i] ] + 64;
3990 if(next_level&(~127))
3993 if(next_i < last_non_zero)
3994 score += length[UNI_AC_ENC_INDEX(run, 65)]
3995 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3996 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3998 score += length[UNI_AC_ENC_INDEX(run, 65)]
3999 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4000 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4002 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4004 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4005 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4011 av_assert2(FFABS(level)==1);
4013 if(i < last_non_zero){
4014 int next_i= i + run2 + 1;
4015 int next_level= block[ perm_scantable[next_i] ] + 64;
4017 if(next_level&(~127))
4020 if(next_i < last_non_zero)
4021 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4022 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4023 - length[UNI_AC_ENC_INDEX(run, 65)];
4025 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4026 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4027 - length[UNI_AC_ENC_INDEX(run, 65)];
4029 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4031 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4032 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4039 unquant_change= new_coeff - old_coeff;
4040 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4042 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4043 if(score<best_score){
4046 best_change= change;
4047 best_unquant_change= unquant_change;
4051 prev_level= level + 64;
4052 if(prev_level&(~127))
4061 STOP_TIMER("iterative step")}
4065 int j= perm_scantable[ best_coeff ];
4067 block[j] += best_change;
4069 if(best_coeff > last_non_zero){
4070 last_non_zero= best_coeff;
4071 av_assert2(block[j]);
4078 if(block[j] - best_change){
4079 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4091 for(; last_non_zero>=start_i; last_non_zero--){
4092 if(block[perm_scantable[last_non_zero]])
4098 if(256*256*256*64 % count == 0){
4099 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);
4104 for(i=start_i; i<=last_non_zero; i++){
4105 int j= perm_scantable[i];
4106 const int level= block[j];
4109 run_tab[rle_index++]=run;
4116 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4122 if(last_non_zero>0){
4123 STOP_TIMER("iterative search")
4128 return last_non_zero;
4131 int ff_dct_quantize_c(MpegEncContext *s,
4132 DCTELEM *block, int n,
4133 int qscale, int *overflow)
4135 int i, j, level, last_non_zero, q, start_i;
4137 const uint8_t *scantable= s->intra_scantable.scantable;
4140 unsigned int threshold1, threshold2;
4142 s->dsp.fdct (block);
4144 if(s->dct_error_sum)
4145 s->denoise_dct(s, block);
4155 /* For AIC we skip quant/dequant of INTRADC */
4158 /* note: block[0] is assumed to be positive */
4159 block[0] = (block[0] + (q >> 1)) / q;
4162 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4163 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4167 qmat = s->q_inter_matrix[qscale];
4168 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4170 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4171 threshold2= (threshold1<<1);
4172 for(i=63;i>=start_i;i--) {
4174 level = block[j] * qmat[j];
4176 if(((unsigned)(level+threshold1))>threshold2){
4183 for(i=start_i; i<=last_non_zero; i++) {
4185 level = block[j] * qmat[j];
4187 // if( bias+level >= (1<<QMAT_SHIFT)
4188 // || bias-level >= (1<<QMAT_SHIFT)){
4189 if(((unsigned)(level+threshold1))>threshold2){
4191 level= (bias + level)>>QMAT_SHIFT;
4194 level= (bias - level)>>QMAT_SHIFT;
4202 *overflow= s->max_qcoeff < max; //overflow might have happened
4204 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4205 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4206 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4208 return last_non_zero;
4211 #define OFFSET(x) offsetof(MpegEncContext, x)
4212 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4213 static const AVOption h263_options[] = {
4214 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4215 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4216 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4221 static const AVClass h263_class = {
4222 .class_name = "H.263 encoder",
4223 .item_name = av_default_item_name,
4224 .option = h263_options,
4225 .version = LIBAVUTIL_VERSION_INT,
4228 AVCodec ff_h263_encoder = {
4230 .type = AVMEDIA_TYPE_VIDEO,
4231 .id = AV_CODEC_ID_H263,
4232 .priv_data_size = sizeof(MpegEncContext),
4233 .init = ff_MPV_encode_init,
4234 .encode2 = ff_MPV_encode_picture,
4235 .close = ff_MPV_encode_end,
4236 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4237 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4238 .priv_class = &h263_class,
4241 static const AVOption h263p_options[] = {
4242 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4243 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4244 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4245 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4249 static const AVClass h263p_class = {
4250 .class_name = "H.263p encoder",
4251 .item_name = av_default_item_name,
4252 .option = h263p_options,
4253 .version = LIBAVUTIL_VERSION_INT,
4256 AVCodec ff_h263p_encoder = {
4258 .type = AVMEDIA_TYPE_VIDEO,
4259 .id = AV_CODEC_ID_H263P,
4260 .priv_data_size = sizeof(MpegEncContext),
4261 .init = ff_MPV_encode_init,
4262 .encode2 = ff_MPV_encode_picture,
4263 .close = ff_MPV_encode_end,
4264 .capabilities = CODEC_CAP_SLICE_THREADS,
4265 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4266 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4267 .priv_class = &h263p_class,
4270 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4272 AVCodec ff_msmpeg4v2_encoder = {
4273 .name = "msmpeg4v2",
4274 .type = AVMEDIA_TYPE_VIDEO,
4275 .id = AV_CODEC_ID_MSMPEG4V2,
4276 .priv_data_size = sizeof(MpegEncContext),
4277 .init = ff_MPV_encode_init,
4278 .encode2 = ff_MPV_encode_picture,
4279 .close = ff_MPV_encode_end,
4280 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4281 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4282 .priv_class = &msmpeg4v2_class,
4285 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4287 AVCodec ff_msmpeg4v3_encoder = {
4289 .type = AVMEDIA_TYPE_VIDEO,
4290 .id = AV_CODEC_ID_MSMPEG4V3,
4291 .priv_data_size = sizeof(MpegEncContext),
4292 .init = ff_MPV_encode_init,
4293 .encode2 = ff_MPV_encode_picture,
4294 .close = ff_MPV_encode_end,
4295 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4296 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4297 .priv_class = &msmpeg4v3_class,
4300 FF_MPV_GENERIC_CLASS(wmv1)
4302 AVCodec ff_wmv1_encoder = {
4304 .type = AVMEDIA_TYPE_VIDEO,
4305 .id = AV_CODEC_ID_WMV1,
4306 .priv_data_size = sizeof(MpegEncContext),
4307 .init = ff_MPV_encode_init,
4308 .encode2 = ff_MPV_encode_picture,
4309 .close = ff_MPV_encode_end,
4310 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUV420P, PIX_FMT_NONE },
4311 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4312 .priv_class = &wmv1_class,