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/internal.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/opt.h"
39 #include "mpegvideo.h"
47 #include "aandcttab.h"
49 #include "mpeg4video.h"
51 #include "bytestream.h"
55 static int encode_picture(MpegEncContext *s, int picture_number);
56 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
57 static int sse_mb(MpegEncContext *s);
58 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
59 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
61 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
62 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
64 const AVOption ff_mpv_generic_options[] = {
69 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
70 uint16_t (*qmat16)[2][64],
71 const uint16_t *quant_matrix,
72 int bias, int qmin, int qmax, int intra)
77 for (qscale = qmin; qscale <= qmax; qscale++) {
79 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
80 dsp->fdct == ff_jpeg_fdct_islow_10 ||
81 dsp->fdct == ff_faandct) {
82 for (i = 0; i < 64; i++) {
83 const int j = dsp->idct_permutation[i];
84 /* 16 <= qscale * quant_matrix[i] <= 7905
85 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
86 * 19952 <= x <= 249205026
87 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
88 * 3444240 >= (1 << 36) / (x) >= 275 */
90 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
91 (qscale * quant_matrix[j]));
93 } else if (dsp->fdct == ff_fdct_ifast) {
94 for (i = 0; i < 64; i++) {
95 const int j = dsp->idct_permutation[i];
96 /* 16 <= qscale * quant_matrix[i] <= 7905
97 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
98 * 19952 <= x <= 249205026
99 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
100 * 3444240 >= (1 << 36) / (x) >= 275 */
102 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
103 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
106 for (i = 0; i < 64; i++) {
107 const int j = dsp->idct_permutation[i];
108 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
109 * Assume x = qscale * quant_matrix[i]
111 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
112 * so 32768 >= (1 << 19) / (x) >= 67 */
113 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
114 (qscale * quant_matrix[j]));
115 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
116 // (qscale * quant_matrix[i]);
117 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
118 (qscale * quant_matrix[j]);
120 if (qmat16[qscale][0][i] == 0 ||
121 qmat16[qscale][0][i] == 128 * 256)
122 qmat16[qscale][0][i] = 128 * 256 - 1;
123 qmat16[qscale][1][i] =
124 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
125 qmat16[qscale][0][i]);
129 for (i = intra; i < 64; i++) {
131 if (dsp->fdct == ff_fdct_ifast) {
132 max = (8191LL * ff_aanscales[i]) >> 14;
134 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
140 av_log(NULL, AV_LOG_INFO,
141 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
146 static inline void update_qscale(MpegEncContext *s)
148 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
149 (FF_LAMBDA_SHIFT + 7);
150 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
152 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
156 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
162 for (i = 0; i < 64; i++) {
163 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
170 * init s->current_picture.qscale_table from s->lambda_table
172 void ff_init_qscale_tab(MpegEncContext *s)
174 int8_t * const qscale_table = s->current_picture.qscale_table;
177 for (i = 0; i < s->mb_num; i++) {
178 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
179 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
180 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
185 static void update_duplicate_context_after_me(MpegEncContext *dst,
188 #define COPY(a) dst->a= src->a
190 COPY(current_picture);
196 COPY(picture_in_gop_number);
197 COPY(gop_picture_number);
198 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
199 COPY(progressive_frame); // FIXME don't set in encode_header
200 COPY(partitioned_frame); // FIXME don't set in encode_header
205 * Set the given MpegEncContext to defaults for encoding.
206 * the changed fields will not depend upon the prior state of the MpegEncContext.
208 static void MPV_encode_defaults(MpegEncContext *s)
211 ff_MPV_common_defaults(s);
213 for (i = -16; i < 16; i++) {
214 default_fcode_tab[i + MAX_MV] = 1;
216 s->me.mv_penalty = default_mv_penalty;
217 s->fcode_tab = default_fcode_tab;
220 av_cold int ff_dct_encode_init(MpegEncContext *s) {
222 ff_dct_encode_init_x86(s);
224 if (!s->dct_quantize)
225 s->dct_quantize = ff_dct_quantize_c;
227 s->denoise_dct = denoise_dct_c;
228 s->fast_dct_quantize = s->dct_quantize;
229 if (s->avctx->trellis)
230 s->dct_quantize = dct_quantize_trellis_c;
235 /* init video encoder */
236 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
238 MpegEncContext *s = avctx->priv_data;
240 int chroma_h_shift, chroma_v_shift;
242 MPV_encode_defaults(s);
244 switch (avctx->codec_id) {
245 case AV_CODEC_ID_MPEG2VIDEO:
246 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
247 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
248 av_log(avctx, AV_LOG_ERROR,
249 "only YUV420 and YUV422 are supported\n");
253 case AV_CODEC_ID_LJPEG:
254 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
255 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
256 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
257 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
258 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
259 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
260 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
261 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
262 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
263 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
264 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
268 case AV_CODEC_ID_MJPEG:
269 case AV_CODEC_ID_AMV:
270 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
271 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
272 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
273 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
274 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
275 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
276 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
277 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
282 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
283 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
288 switch (avctx->pix_fmt) {
289 case AV_PIX_FMT_YUVJ444P:
290 case AV_PIX_FMT_YUV444P:
291 s->chroma_format = CHROMA_444;
293 case AV_PIX_FMT_YUVJ422P:
294 case AV_PIX_FMT_YUV422P:
295 s->chroma_format = CHROMA_422;
297 case AV_PIX_FMT_YUVJ420P:
298 case AV_PIX_FMT_YUV420P:
300 s->chroma_format = CHROMA_420;
304 s->bit_rate = avctx->bit_rate;
305 s->width = avctx->width;
306 s->height = avctx->height;
307 if (avctx->gop_size > 600 &&
308 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
309 av_log(avctx, AV_LOG_WARNING,
310 "keyframe interval too large!, reducing it from %d to %d\n",
311 avctx->gop_size, 600);
312 avctx->gop_size = 600;
314 s->gop_size = avctx->gop_size;
316 s->flags = avctx->flags;
317 s->flags2 = avctx->flags2;
318 s->max_b_frames = avctx->max_b_frames;
319 s->codec_id = avctx->codec->id;
320 s->strict_std_compliance = avctx->strict_std_compliance;
321 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
322 s->mpeg_quant = avctx->mpeg_quant;
323 s->rtp_mode = !!avctx->rtp_payload_size;
324 s->intra_dc_precision = avctx->intra_dc_precision;
325 s->user_specified_pts = AV_NOPTS_VALUE;
327 if (s->gop_size <= 1) {
334 s->me_method = avctx->me_method;
337 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
339 s->adaptive_quant = (s->avctx->lumi_masking ||
340 s->avctx->dark_masking ||
341 s->avctx->temporal_cplx_masking ||
342 s->avctx->spatial_cplx_masking ||
343 s->avctx->p_masking ||
344 s->avctx->border_masking ||
345 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
348 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
350 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
351 switch(avctx->codec_id) {
352 case AV_CODEC_ID_MPEG1VIDEO:
353 case AV_CODEC_ID_MPEG2VIDEO:
354 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
356 case AV_CODEC_ID_MPEG4:
357 case AV_CODEC_ID_MSMPEG4V1:
358 case AV_CODEC_ID_MSMPEG4V2:
359 case AV_CODEC_ID_MSMPEG4V3:
360 if (avctx->rc_max_rate >= 15000000) {
361 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
362 } else if(avctx->rc_max_rate >= 2000000) {
363 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
364 } else if(avctx->rc_max_rate >= 384000) {
365 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
367 avctx->rc_buffer_size = 40;
368 avctx->rc_buffer_size *= 16384;
371 if (avctx->rc_buffer_size) {
372 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
376 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
377 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
378 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
382 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
383 av_log(avctx, AV_LOG_INFO,
384 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
387 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
388 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
392 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
393 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
397 if (avctx->rc_max_rate &&
398 avctx->rc_max_rate == avctx->bit_rate &&
399 avctx->rc_max_rate != avctx->rc_min_rate) {
400 av_log(avctx, AV_LOG_INFO,
401 "impossible bitrate constraints, this will fail\n");
404 if (avctx->rc_buffer_size &&
405 avctx->bit_rate * (int64_t)avctx->time_base.num >
406 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
407 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
411 if (!s->fixed_qscale &&
412 avctx->bit_rate * av_q2d(avctx->time_base) >
413 avctx->bit_rate_tolerance) {
414 av_log(avctx, AV_LOG_ERROR,
415 "bitrate tolerance too small for bitrate\n");
419 if (s->avctx->rc_max_rate &&
420 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
421 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
422 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
423 90000LL * (avctx->rc_buffer_size - 1) >
424 s->avctx->rc_max_rate * 0xFFFFLL) {
425 av_log(avctx, AV_LOG_INFO,
426 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
427 "specified vbv buffer is too large for the given bitrate!\n");
430 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
431 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
432 s->codec_id != AV_CODEC_ID_FLV1) {
433 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
437 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
438 av_log(avctx, AV_LOG_ERROR,
439 "OBMC is only supported with simple mb decision\n");
443 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
444 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
448 if (s->max_b_frames &&
449 s->codec_id != AV_CODEC_ID_MPEG4 &&
450 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
451 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
452 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
456 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
457 s->codec_id == AV_CODEC_ID_H263 ||
458 s->codec_id == AV_CODEC_ID_H263P) &&
459 (avctx->sample_aspect_ratio.num > 255 ||
460 avctx->sample_aspect_ratio.den > 255)) {
461 av_log(avctx, AV_LOG_WARNING,
462 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
463 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
464 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
465 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
468 if ((s->codec_id == AV_CODEC_ID_H263 ||
469 s->codec_id == AV_CODEC_ID_H263P) &&
470 (avctx->width > 2048 ||
471 avctx->height > 1152 )) {
472 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
475 if ((s->codec_id == AV_CODEC_ID_H263 ||
476 s->codec_id == AV_CODEC_ID_H263P) &&
477 ((avctx->width &3) ||
478 (avctx->height&3) )) {
479 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
483 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
484 (avctx->width > 4095 ||
485 avctx->height > 4095 )) {
486 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
490 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
491 (avctx->width > 16383 ||
492 avctx->height > 16383 )) {
493 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
497 if (s->codec_id == AV_CODEC_ID_RV10 &&
499 avctx->height&15 )) {
500 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
501 return AVERROR(EINVAL);
504 if (s->codec_id == AV_CODEC_ID_RV20 &&
507 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
508 return AVERROR(EINVAL);
511 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
512 s->codec_id == AV_CODEC_ID_WMV2) &&
514 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
518 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
519 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
520 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
524 // FIXME mpeg2 uses that too
525 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
526 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
527 av_log(avctx, AV_LOG_ERROR,
528 "mpeg2 style quantization not supported by codec\n");
532 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
533 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
537 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
538 s->avctx->mb_decision != FF_MB_DECISION_RD) {
539 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
543 if (s->avctx->scenechange_threshold < 1000000000 &&
544 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
545 av_log(avctx, AV_LOG_ERROR,
546 "closed gop with scene change detection are not supported yet, "
547 "set threshold to 1000000000\n");
551 if (s->flags & CODEC_FLAG_LOW_DELAY) {
552 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
553 av_log(avctx, AV_LOG_ERROR,
554 "low delay forcing is only available for mpeg2\n");
557 if (s->max_b_frames != 0) {
558 av_log(avctx, AV_LOG_ERROR,
559 "b frames cannot be used with low delay\n");
564 if (s->q_scale_type == 1) {
565 if (avctx->qmax > 12) {
566 av_log(avctx, AV_LOG_ERROR,
567 "non linear quant only supports qmax <= 12 currently\n");
572 if (s->avctx->thread_count > 1 &&
573 s->codec_id != AV_CODEC_ID_MPEG4 &&
574 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
575 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
576 s->codec_id != AV_CODEC_ID_MJPEG &&
577 (s->codec_id != AV_CODEC_ID_H263P)) {
578 av_log(avctx, AV_LOG_ERROR,
579 "multi threaded encoding not supported by codec\n");
583 if (s->avctx->thread_count < 1) {
584 av_log(avctx, AV_LOG_ERROR,
585 "automatic thread number detection not supported by codec, "
590 if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
593 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
594 s->h263_slice_structured = 1;
596 if (!avctx->time_base.den || !avctx->time_base.num) {
597 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
601 i = (INT_MAX / 2 + 128) >> 8;
602 if (avctx->mb_threshold >= i) {
603 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
608 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
609 av_log(avctx, AV_LOG_INFO,
610 "notice: b_frame_strategy only affects the first pass\n");
611 avctx->b_frame_strategy = 0;
614 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
616 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
617 avctx->time_base.den /= i;
618 avctx->time_base.num /= i;
622 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) {
623 // (a + x * 3 / 8) / x
624 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
625 s->inter_quant_bias = 0;
627 s->intra_quant_bias = 0;
629 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
632 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
633 s->intra_quant_bias = avctx->intra_quant_bias;
634 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
635 s->inter_quant_bias = avctx->inter_quant_bias;
637 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
639 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
641 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
642 s->avctx->time_base.den > (1 << 16) - 1) {
643 av_log(avctx, AV_LOG_ERROR,
644 "timebase %d/%d not supported by MPEG 4 standard, "
645 "the maximum admitted value for the timebase denominator "
646 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
650 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
652 switch (avctx->codec->id) {
653 case AV_CODEC_ID_MPEG1VIDEO:
654 s->out_format = FMT_MPEG1;
655 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
656 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
658 case AV_CODEC_ID_MPEG2VIDEO:
659 s->out_format = FMT_MPEG1;
660 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
661 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
664 case AV_CODEC_ID_LJPEG:
665 case AV_CODEC_ID_MJPEG:
666 case AV_CODEC_ID_AMV:
667 s->out_format = FMT_MJPEG;
668 s->intra_only = 1; /* force intra only for jpeg */
669 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
670 (avctx->pix_fmt == AV_PIX_FMT_BGR0
671 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
672 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
673 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
674 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
675 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
676 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
677 s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
678 s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
680 s->mjpeg_vsample[0] = 2;
681 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
682 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
683 s->mjpeg_hsample[0] = 2;
684 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
685 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
687 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
688 ff_mjpeg_encode_init(s) < 0)
693 case AV_CODEC_ID_H261:
694 if (!CONFIG_H261_ENCODER)
696 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
697 av_log(avctx, AV_LOG_ERROR,
698 "The specified picture size of %dx%d is not valid for the "
699 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
700 s->width, s->height);
703 s->out_format = FMT_H261;
707 case AV_CODEC_ID_H263:
708 if (!CONFIG_H263_ENCODER)
710 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
711 s->width, s->height) == 8) {
712 av_log(avctx, AV_LOG_ERROR,
713 "The specified picture size of %dx%d is not valid for "
714 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
715 "352x288, 704x576, and 1408x1152. "
716 "Try H.263+.\n", s->width, s->height);
719 s->out_format = FMT_H263;
723 case AV_CODEC_ID_H263P:
724 s->out_format = FMT_H263;
727 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
728 s->modified_quant = s->h263_aic;
729 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
730 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
733 /* These are just to be sure */
737 case AV_CODEC_ID_FLV1:
738 s->out_format = FMT_H263;
739 s->h263_flv = 2; /* format = 1; 11-bit codes */
740 s->unrestricted_mv = 1;
741 s->rtp_mode = 0; /* don't allow GOB */
745 case AV_CODEC_ID_RV10:
746 s->out_format = FMT_H263;
750 case AV_CODEC_ID_RV20:
751 s->out_format = FMT_H263;
754 s->modified_quant = 1;
758 s->unrestricted_mv = 0;
760 case AV_CODEC_ID_MPEG4:
761 s->out_format = FMT_H263;
763 s->unrestricted_mv = 1;
764 s->low_delay = s->max_b_frames ? 0 : 1;
765 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
767 case AV_CODEC_ID_MSMPEG4V2:
768 s->out_format = FMT_H263;
770 s->unrestricted_mv = 1;
771 s->msmpeg4_version = 2;
775 case AV_CODEC_ID_MSMPEG4V3:
776 s->out_format = FMT_H263;
778 s->unrestricted_mv = 1;
779 s->msmpeg4_version = 3;
780 s->flipflop_rounding = 1;
784 case AV_CODEC_ID_WMV1:
785 s->out_format = FMT_H263;
787 s->unrestricted_mv = 1;
788 s->msmpeg4_version = 4;
789 s->flipflop_rounding = 1;
793 case AV_CODEC_ID_WMV2:
794 s->out_format = FMT_H263;
796 s->unrestricted_mv = 1;
797 s->msmpeg4_version = 5;
798 s->flipflop_rounding = 1;
806 avctx->has_b_frames = !s->low_delay;
810 s->progressive_frame =
811 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
812 CODEC_FLAG_INTERLACED_ME) ||
816 if (ff_MPV_common_init(s) < 0)
819 ff_dct_encode_init(s);
821 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
822 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
824 s->quant_precision = 5;
826 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
827 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
829 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
830 ff_h261_encode_init(s);
831 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
832 ff_h263_encode_init(s);
833 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
834 ff_msmpeg4_encode_init(s);
835 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
836 && s->out_format == FMT_MPEG1)
837 ff_mpeg1_encode_init(s);
840 for (i = 0; i < 64; i++) {
841 int j = s->dsp.idct_permutation[i];
842 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
844 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
845 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
846 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
848 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
851 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
852 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
854 if (s->avctx->intra_matrix)
855 s->intra_matrix[j] = s->avctx->intra_matrix[i];
856 if (s->avctx->inter_matrix)
857 s->inter_matrix[j] = s->avctx->inter_matrix[i];
860 /* precompute matrix */
861 /* for mjpeg, we do include qscale in the matrix */
862 if (s->out_format != FMT_MJPEG) {
863 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
864 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
866 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
867 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
871 if (ff_rate_control_init(s) < 0)
877 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
879 MpegEncContext *s = avctx->priv_data;
881 ff_rate_control_uninit(s);
883 ff_MPV_common_end(s);
884 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
885 s->out_format == FMT_MJPEG)
886 ff_mjpeg_encode_close(s);
888 av_freep(&avctx->extradata);
893 static int get_sae(uint8_t *src, int ref, int stride)
898 for (y = 0; y < 16; y++) {
899 for (x = 0; x < 16; x++) {
900 acc += FFABS(src[x + y * stride] - ref);
907 static int get_intra_count(MpegEncContext *s, uint8_t *src,
908 uint8_t *ref, int stride)
916 for (y = 0; y < h; y += 16) {
917 for (x = 0; x < w; x += 16) {
918 int offset = x + y * stride;
919 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
921 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
922 int sae = get_sae(src + offset, mean, stride);
924 acc += sae + 500 < sad;
931 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
935 int i, display_picture_number = 0, ret;
936 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
937 (s->low_delay ? 0 : 1);
942 display_picture_number = s->input_picture_number++;
944 if (pts != AV_NOPTS_VALUE) {
945 if (s->user_specified_pts != AV_NOPTS_VALUE) {
946 int64_t last = s->user_specified_pts;
949 av_log(s->avctx, AV_LOG_ERROR,
950 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
952 return AVERROR(EINVAL);
955 if (!s->low_delay && display_picture_number == 1)
956 s->dts_delta = pts - last;
958 s->user_specified_pts = pts;
960 if (s->user_specified_pts != AV_NOPTS_VALUE) {
961 s->user_specified_pts =
962 pts = s->user_specified_pts + 1;
963 av_log(s->avctx, AV_LOG_INFO,
964 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
967 pts = display_picture_number;
973 if (!pic_arg->buf[0])
975 if (pic_arg->linesize[0] != s->linesize)
977 if (pic_arg->linesize[1] != s->uvlinesize)
979 if (pic_arg->linesize[2] != s->uvlinesize)
982 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
983 pic_arg->linesize[1], s->linesize, s->uvlinesize);
986 i = ff_find_unused_picture(s, 1);
990 pic = &s->picture[i];
993 if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
995 if (ff_alloc_picture(s, pic, 1) < 0) {
999 i = ff_find_unused_picture(s, 0);
1003 pic = &s->picture[i];
1006 if (ff_alloc_picture(s, pic, 0) < 0) {
1010 if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1011 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1012 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1015 int h_chroma_shift, v_chroma_shift;
1016 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1020 for (i = 0; i < 3; i++) {
1021 int src_stride = pic_arg->linesize[i];
1022 int dst_stride = i ? s->uvlinesize : s->linesize;
1023 int h_shift = i ? h_chroma_shift : 0;
1024 int v_shift = i ? v_chroma_shift : 0;
1025 int w = s->width >> h_shift;
1026 int h = s->height >> v_shift;
1027 uint8_t *src = pic_arg->data[i];
1028 uint8_t *dst = pic->f.data[i];
1030 if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1031 h = ((s->height + 15)/16*16) >> v_shift;
1034 if (!s->avctx->rc_buffer_size)
1035 dst += INPLACE_OFFSET;
1037 if (src_stride == dst_stride)
1038 memcpy(dst, src, src_stride * h);
1041 uint8_t *dst2 = dst;
1043 memcpy(dst2, src, w);
1048 if ((s->width & 15) || (s->height & 15)) {
1049 s->dsp.draw_edges(dst, dst_stride,
1058 ret = av_frame_copy_props(&pic->f, pic_arg);
1062 pic->f.display_picture_number = display_picture_number;
1063 pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
1066 /* shift buffer entries */
1067 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1068 s->input_picture[i - 1] = s->input_picture[i];
1070 s->input_picture[encoding_delay] = (Picture*) pic;
1075 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1079 int64_t score64 = 0;
1081 for (plane = 0; plane < 3; plane++) {
1082 const int stride = p->f.linesize[plane];
1083 const int bw = plane ? 1 : 2;
1084 for (y = 0; y < s->mb_height * bw; y++) {
1085 for (x = 0; x < s->mb_width * bw; x++) {
1086 int off = p->shared ? 0 : 16;
1087 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1088 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1089 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1091 switch (s->avctx->frame_skip_exp) {
1092 case 0: score = FFMAX(score, v); break;
1093 case 1: score += FFABS(v); break;
1094 case 2: score += v * v; break;
1095 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1096 case 4: score64 += v * v * (int64_t)(v * v); break;
1105 if (score64 < s->avctx->frame_skip_threshold)
1107 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1112 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1114 AVPacket pkt = { 0 };
1115 int ret, got_output;
1117 av_init_packet(&pkt);
1118 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1123 av_free_packet(&pkt);
1127 static int estimate_best_b_count(MpegEncContext *s)
1129 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1130 AVCodecContext *c = avcodec_alloc_context3(NULL);
1131 AVFrame input[FF_MAX_B_FRAMES + 2];
1132 const int scale = s->avctx->brd_scale;
1133 int i, j, out_size, p_lambda, b_lambda, lambda2;
1134 int64_t best_rd = INT64_MAX;
1135 int best_b_count = -1;
1137 av_assert0(scale >= 0 && scale <= 3);
1140 //s->next_picture_ptr->quality;
1141 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1142 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1143 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1144 if (!b_lambda) // FIXME we should do this somewhere else
1145 b_lambda = p_lambda;
1146 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1149 c->width = s->width >> scale;
1150 c->height = s->height >> scale;
1151 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1152 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1153 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1154 c->mb_decision = s->avctx->mb_decision;
1155 c->me_cmp = s->avctx->me_cmp;
1156 c->mb_cmp = s->avctx->mb_cmp;
1157 c->me_sub_cmp = s->avctx->me_sub_cmp;
1158 c->pix_fmt = AV_PIX_FMT_YUV420P;
1159 c->time_base = s->avctx->time_base;
1160 c->max_b_frames = s->max_b_frames;
1162 if (avcodec_open2(c, codec, NULL) < 0)
1165 for (i = 0; i < s->max_b_frames + 2; i++) {
1166 int ysize = c->width * c->height;
1167 int csize = (c->width / 2) * (c->height / 2);
1168 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1169 s->next_picture_ptr;
1171 avcodec_get_frame_defaults(&input[i]);
1172 input[i].data[0] = av_malloc(ysize + 2 * csize);
1173 input[i].data[1] = input[i].data[0] + ysize;
1174 input[i].data[2] = input[i].data[1] + csize;
1175 input[i].linesize[0] = c->width;
1176 input[i].linesize[1] =
1177 input[i].linesize[2] = c->width / 2;
1179 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1180 pre_input = *pre_input_ptr;
1182 if (!pre_input.shared && i) {
1183 pre_input.f.data[0] += INPLACE_OFFSET;
1184 pre_input.f.data[1] += INPLACE_OFFSET;
1185 pre_input.f.data[2] += INPLACE_OFFSET;
1188 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1189 pre_input.f.data[0], pre_input.f.linesize[0],
1190 c->width, c->height);
1191 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1192 pre_input.f.data[1], pre_input.f.linesize[1],
1193 c->width >> 1, c->height >> 1);
1194 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1195 pre_input.f.data[2], pre_input.f.linesize[2],
1196 c->width >> 1, c->height >> 1);
1200 for (j = 0; j < s->max_b_frames + 1; j++) {
1203 if (!s->input_picture[j])
1206 c->error[0] = c->error[1] = c->error[2] = 0;
1208 input[0].pict_type = AV_PICTURE_TYPE_I;
1209 input[0].quality = 1 * FF_QP2LAMBDA;
1211 out_size = encode_frame(c, &input[0]);
1213 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1215 for (i = 0; i < s->max_b_frames + 1; i++) {
1216 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1218 input[i + 1].pict_type = is_p ?
1219 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1220 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1222 out_size = encode_frame(c, &input[i + 1]);
1224 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1227 /* get the delayed frames */
1229 out_size = encode_frame(c, NULL);
1230 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1233 rd += c->error[0] + c->error[1] + c->error[2];
1244 for (i = 0; i < s->max_b_frames + 2; i++) {
1245 av_freep(&input[i].data[0]);
1248 return best_b_count;
1251 static int select_input_picture(MpegEncContext *s)
1255 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1256 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1257 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1259 /* set next picture type & ordering */
1260 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1261 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1262 s->next_picture_ptr == NULL || s->intra_only) {
1263 s->reordered_input_picture[0] = s->input_picture[0];
1264 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1265 s->reordered_input_picture[0]->f.coded_picture_number =
1266 s->coded_picture_number++;
1270 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1271 if (s->picture_in_gop_number < s->gop_size &&
1272 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1273 // FIXME check that te gop check above is +-1 correct
1274 av_frame_unref(&s->input_picture[0]->f);
1277 ff_vbv_update(s, 0);
1283 if (s->flags & CODEC_FLAG_PASS2) {
1284 for (i = 0; i < s->max_b_frames + 1; i++) {
1285 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1287 if (pict_num >= s->rc_context.num_entries)
1289 if (!s->input_picture[i]) {
1290 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1294 s->input_picture[i]->f.pict_type =
1295 s->rc_context.entry[pict_num].new_pict_type;
1299 if (s->avctx->b_frame_strategy == 0) {
1300 b_frames = s->max_b_frames;
1301 while (b_frames && !s->input_picture[b_frames])
1303 } else if (s->avctx->b_frame_strategy == 1) {
1304 for (i = 1; i < s->max_b_frames + 1; i++) {
1305 if (s->input_picture[i] &&
1306 s->input_picture[i]->b_frame_score == 0) {
1307 s->input_picture[i]->b_frame_score =
1309 s->input_picture[i ]->f.data[0],
1310 s->input_picture[i - 1]->f.data[0],
1314 for (i = 0; i < s->max_b_frames + 1; i++) {
1315 if (s->input_picture[i] == NULL ||
1316 s->input_picture[i]->b_frame_score - 1 >
1317 s->mb_num / s->avctx->b_sensitivity)
1321 b_frames = FFMAX(0, i - 1);
1324 for (i = 0; i < b_frames + 1; i++) {
1325 s->input_picture[i]->b_frame_score = 0;
1327 } else if (s->avctx->b_frame_strategy == 2) {
1328 b_frames = estimate_best_b_count(s);
1330 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1336 for (i = b_frames - 1; i >= 0; i--) {
1337 int type = s->input_picture[i]->f.pict_type;
1338 if (type && type != AV_PICTURE_TYPE_B)
1341 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1342 b_frames == s->max_b_frames) {
1343 av_log(s->avctx, AV_LOG_ERROR,
1344 "warning, too many b frames in a row\n");
1347 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1348 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1349 s->gop_size > s->picture_in_gop_number) {
1350 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1352 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1354 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1358 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1359 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1362 s->reordered_input_picture[0] = s->input_picture[b_frames];
1363 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1364 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1365 s->reordered_input_picture[0]->f.coded_picture_number =
1366 s->coded_picture_number++;
1367 for (i = 0; i < b_frames; i++) {
1368 s->reordered_input_picture[i + 1] = s->input_picture[i];
1369 s->reordered_input_picture[i + 1]->f.pict_type =
1371 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1372 s->coded_picture_number++;
1377 if (s->reordered_input_picture[0]) {
1378 s->reordered_input_picture[0]->reference =
1379 s->reordered_input_picture[0]->f.pict_type !=
1380 AV_PICTURE_TYPE_B ? 3 : 0;
1382 ff_mpeg_unref_picture(s, &s->new_picture);
1383 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1386 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1387 // input is a shared pix, so we can't modifiy it -> alloc a new
1388 // one & ensure that the shared one is reuseable
1391 int i = ff_find_unused_picture(s, 0);
1394 pic = &s->picture[i];
1396 pic->reference = s->reordered_input_picture[0]->reference;
1397 if (ff_alloc_picture(s, pic, 0) < 0) {
1401 ret = av_frame_copy_props(&pic->f, &s->reordered_input_picture[0]->f);
1405 /* mark us unused / free shared pic */
1406 av_frame_unref(&s->reordered_input_picture[0]->f);
1407 s->reordered_input_picture[0]->shared = 0;
1409 s->current_picture_ptr = pic;
1411 // input is not a shared pix -> reuse buffer for current_pix
1412 s->current_picture_ptr = s->reordered_input_picture[0];
1413 for (i = 0; i < 4; i++) {
1414 s->new_picture.f.data[i] += INPLACE_OFFSET;
1417 ff_mpeg_unref_picture(s, &s->current_picture);
1418 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1419 s->current_picture_ptr)) < 0)
1422 s->picture_number = s->new_picture.f.display_picture_number;
1424 ff_mpeg_unref_picture(s, &s->new_picture);
1429 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1430 AVFrame *pic_arg, int *got_packet)
1432 MpegEncContext *s = avctx->priv_data;
1433 int i, stuffing_count, ret;
1434 int context_count = s->slice_context_count;
1436 s->picture_in_gop_number++;
1438 if (load_input_picture(s, pic_arg) < 0)
1441 if (select_input_picture(s) < 0) {
1446 if (s->new_picture.f.data[0]) {
1447 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1450 s->mb_info_ptr = av_packet_new_side_data(pkt,
1451 AV_PKT_DATA_H263_MB_INFO,
1452 s->mb_width*s->mb_height*12);
1453 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1456 for (i = 0; i < context_count; i++) {
1457 int start_y = s->thread_context[i]->start_mb_y;
1458 int end_y = s->thread_context[i]-> end_mb_y;
1459 int h = s->mb_height;
1460 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1461 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1463 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1466 s->pict_type = s->new_picture.f.pict_type;
1468 if (ff_MPV_frame_start(s, avctx) < 0)
1471 if (encode_picture(s, s->picture_number) < 0)
1474 avctx->header_bits = s->header_bits;
1475 avctx->mv_bits = s->mv_bits;
1476 avctx->misc_bits = s->misc_bits;
1477 avctx->i_tex_bits = s->i_tex_bits;
1478 avctx->p_tex_bits = s->p_tex_bits;
1479 avctx->i_count = s->i_count;
1480 // FIXME f/b_count in avctx
1481 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1482 avctx->skip_count = s->skip_count;
1484 ff_MPV_frame_end(s);
1486 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1487 ff_mjpeg_encode_picture_trailer(s);
1489 if (avctx->rc_buffer_size) {
1490 RateControlContext *rcc = &s->rc_context;
1491 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1493 if (put_bits_count(&s->pb) > max_size &&
1494 s->lambda < s->avctx->lmax) {
1495 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1496 (s->qscale + 1) / s->qscale);
1497 if (s->adaptive_quant) {
1499 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1500 s->lambda_table[i] =
1501 FFMAX(s->lambda_table[i] + 1,
1502 s->lambda_table[i] * (s->qscale + 1) /
1505 s->mb_skipped = 0; // done in MPV_frame_start()
1506 // done in encode_picture() so we must undo it
1507 if (s->pict_type == AV_PICTURE_TYPE_P) {
1508 if (s->flipflop_rounding ||
1509 s->codec_id == AV_CODEC_ID_H263P ||
1510 s->codec_id == AV_CODEC_ID_MPEG4)
1511 s->no_rounding ^= 1;
1513 if (s->pict_type != AV_PICTURE_TYPE_B) {
1514 s->time_base = s->last_time_base;
1515 s->last_non_b_time = s->time - s->pp_time;
1517 for (i = 0; i < context_count; i++) {
1518 PutBitContext *pb = &s->thread_context[i]->pb;
1519 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1524 assert(s->avctx->rc_max_rate);
1527 if (s->flags & CODEC_FLAG_PASS1)
1528 ff_write_pass1_stats(s);
1530 for (i = 0; i < 4; i++) {
1531 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1532 avctx->error[i] += s->current_picture_ptr->f.error[i];
1535 if (s->flags & CODEC_FLAG_PASS1)
1536 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1537 avctx->i_tex_bits + avctx->p_tex_bits ==
1538 put_bits_count(&s->pb));
1539 flush_put_bits(&s->pb);
1540 s->frame_bits = put_bits_count(&s->pb);
1542 stuffing_count = ff_vbv_update(s, s->frame_bits);
1543 s->stuffing_bits = 8*stuffing_count;
1544 if (stuffing_count) {
1545 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1546 stuffing_count + 50) {
1547 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1551 switch (s->codec_id) {
1552 case AV_CODEC_ID_MPEG1VIDEO:
1553 case AV_CODEC_ID_MPEG2VIDEO:
1554 while (stuffing_count--) {
1555 put_bits(&s->pb, 8, 0);
1558 case AV_CODEC_ID_MPEG4:
1559 put_bits(&s->pb, 16, 0);
1560 put_bits(&s->pb, 16, 0x1C3);
1561 stuffing_count -= 4;
1562 while (stuffing_count--) {
1563 put_bits(&s->pb, 8, 0xFF);
1567 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1569 flush_put_bits(&s->pb);
1570 s->frame_bits = put_bits_count(&s->pb);
1573 /* update mpeg1/2 vbv_delay for CBR */
1574 if (s->avctx->rc_max_rate &&
1575 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1576 s->out_format == FMT_MPEG1 &&
1577 90000LL * (avctx->rc_buffer_size - 1) <=
1578 s->avctx->rc_max_rate * 0xFFFFLL) {
1579 int vbv_delay, min_delay;
1580 double inbits = s->avctx->rc_max_rate *
1581 av_q2d(s->avctx->time_base);
1582 int minbits = s->frame_bits - 8 *
1583 (s->vbv_delay_ptr - s->pb.buf - 1);
1584 double bits = s->rc_context.buffer_index + minbits - inbits;
1587 av_log(s->avctx, AV_LOG_ERROR,
1588 "Internal error, negative bits\n");
1590 assert(s->repeat_first_field == 0);
1592 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1593 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1594 s->avctx->rc_max_rate;
1596 vbv_delay = FFMAX(vbv_delay, min_delay);
1598 av_assert0(vbv_delay < 0xFFFF);
1600 s->vbv_delay_ptr[0] &= 0xF8;
1601 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1602 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1603 s->vbv_delay_ptr[2] &= 0x07;
1604 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1605 avctx->vbv_delay = vbv_delay * 300;
1607 s->total_bits += s->frame_bits;
1608 avctx->frame_bits = s->frame_bits;
1610 pkt->pts = s->current_picture.f.pts;
1611 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1612 if (!s->current_picture.f.coded_picture_number)
1613 pkt->dts = pkt->pts - s->dts_delta;
1615 pkt->dts = s->reordered_pts;
1616 s->reordered_pts = pkt->pts;
1618 pkt->dts = pkt->pts;
1619 if (s->current_picture.f.key_frame)
1620 pkt->flags |= AV_PKT_FLAG_KEY;
1622 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1627 /* release non-reference frames */
1628 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1629 if (!s->picture[i].reference)
1630 ff_mpeg_unref_picture(s, &s->picture[i]);
1633 assert((s->frame_bits & 7) == 0);
1635 pkt->size = s->frame_bits / 8;
1636 *got_packet = !!pkt->size;
1640 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1641 int n, int threshold)
1643 static const char tab[64] = {
1644 3, 2, 2, 1, 1, 1, 1, 1,
1645 1, 1, 1, 1, 1, 1, 1, 1,
1646 1, 1, 1, 1, 1, 1, 1, 1,
1647 0, 0, 0, 0, 0, 0, 0, 0,
1648 0, 0, 0, 0, 0, 0, 0, 0,
1649 0, 0, 0, 0, 0, 0, 0, 0,
1650 0, 0, 0, 0, 0, 0, 0, 0,
1651 0, 0, 0, 0, 0, 0, 0, 0
1656 int16_t *block = s->block[n];
1657 const int last_index = s->block_last_index[n];
1660 if (threshold < 0) {
1662 threshold = -threshold;
1666 /* Are all we could set to zero already zero? */
1667 if (last_index <= skip_dc - 1)
1670 for (i = 0; i <= last_index; i++) {
1671 const int j = s->intra_scantable.permutated[i];
1672 const int level = FFABS(block[j]);
1674 if (skip_dc && i == 0)
1678 } else if (level > 1) {
1684 if (score >= threshold)
1686 for (i = skip_dc; i <= last_index; i++) {
1687 const int j = s->intra_scantable.permutated[i];
1691 s->block_last_index[n] = 0;
1693 s->block_last_index[n] = -1;
1696 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1700 const int maxlevel = s->max_qcoeff;
1701 const int minlevel = s->min_qcoeff;
1705 i = 1; // skip clipping of intra dc
1709 for (; i <= last_index; i++) {
1710 const int j = s->intra_scantable.permutated[i];
1711 int level = block[j];
1713 if (level > maxlevel) {
1716 } else if (level < minlevel) {
1724 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1725 av_log(s->avctx, AV_LOG_INFO,
1726 "warning, clipping %d dct coefficients to %d..%d\n",
1727 overflow, minlevel, maxlevel);
1730 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1734 for (y = 0; y < 8; y++) {
1735 for (x = 0; x < 8; x++) {
1741 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1742 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1743 int v = ptr[x2 + y2 * stride];
1749 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1754 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1755 int motion_x, int motion_y,
1756 int mb_block_height,
1760 int16_t weight[12][64];
1761 int16_t orig[12][64];
1762 const int mb_x = s->mb_x;
1763 const int mb_y = s->mb_y;
1766 int dct_offset = s->linesize * 8; // default for progressive frames
1767 int uv_dct_offset = s->uvlinesize * 8;
1768 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1771 for (i = 0; i < mb_block_count; i++)
1772 skip_dct[i] = s->skipdct;
1774 if (s->adaptive_quant) {
1775 const int last_qp = s->qscale;
1776 const int mb_xy = mb_x + mb_y * s->mb_stride;
1778 s->lambda = s->lambda_table[mb_xy];
1781 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1782 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1783 s->dquant = s->qscale - last_qp;
1785 if (s->out_format == FMT_H263) {
1786 s->dquant = av_clip(s->dquant, -2, 2);
1788 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1790 if (s->pict_type == AV_PICTURE_TYPE_B) {
1791 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1794 if (s->mv_type == MV_TYPE_8X8)
1800 ff_set_qscale(s, last_qp + s->dquant);
1801 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1802 ff_set_qscale(s, s->qscale + s->dquant);
1804 wrap_y = s->linesize;
1805 wrap_c = s->uvlinesize;
1806 ptr_y = s->new_picture.f.data[0] +
1807 (mb_y * 16 * wrap_y) + mb_x * 16;
1808 ptr_cb = s->new_picture.f.data[1] +
1809 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1810 ptr_cr = s->new_picture.f.data[2] +
1811 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1813 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1814 uint8_t *ebuf = s->edge_emu_buffer + 32;
1815 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1816 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1817 s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1818 mb_y * 16, s->width, s->height);
1820 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, mb_block_width,
1821 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1823 ptr_cb = ebuf + 18 * wrap_y;
1824 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr, wrap_c, mb_block_width,
1825 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1827 ptr_cr = ebuf + 18 * wrap_y + 16;
1831 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1832 int progressive_score, interlaced_score;
1834 s->interlaced_dct = 0;
1835 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1837 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1838 NULL, wrap_y, 8) - 400;
1840 if (progressive_score > 0) {
1841 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1842 NULL, wrap_y * 2, 8) +
1843 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1844 NULL, wrap_y * 2, 8);
1845 if (progressive_score > interlaced_score) {
1846 s->interlaced_dct = 1;
1848 dct_offset = wrap_y;
1849 uv_dct_offset = wrap_c;
1851 if (s->chroma_format == CHROMA_422 ||
1852 s->chroma_format == CHROMA_444)
1858 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1859 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1860 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1861 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1863 if (s->flags & CODEC_FLAG_GRAY) {
1867 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1868 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1869 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1870 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1871 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1872 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1873 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1874 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1875 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1876 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1877 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1878 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1882 op_pixels_func (*op_pix)[4];
1883 qpel_mc_func (*op_qpix)[16];
1884 uint8_t *dest_y, *dest_cb, *dest_cr;
1886 dest_y = s->dest[0];
1887 dest_cb = s->dest[1];
1888 dest_cr = s->dest[2];
1890 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1891 op_pix = s->hdsp.put_pixels_tab;
1892 op_qpix = s->dsp.put_qpel_pixels_tab;
1894 op_pix = s->hdsp.put_no_rnd_pixels_tab;
1895 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1898 if (s->mv_dir & MV_DIR_FORWARD) {
1899 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1900 s->last_picture.f.data,
1902 op_pix = s->hdsp.avg_pixels_tab;
1903 op_qpix = s->dsp.avg_qpel_pixels_tab;
1905 if (s->mv_dir & MV_DIR_BACKWARD) {
1906 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1907 s->next_picture.f.data,
1911 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1912 int progressive_score, interlaced_score;
1914 s->interlaced_dct = 0;
1915 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1918 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1919 ptr_y + wrap_y * 8, wrap_y,
1922 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1923 progressive_score -= 400;
1925 if (progressive_score > 0) {
1926 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1929 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1933 if (progressive_score > interlaced_score) {
1934 s->interlaced_dct = 1;
1936 dct_offset = wrap_y;
1937 uv_dct_offset = wrap_c;
1939 if (s->chroma_format == CHROMA_422)
1945 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1946 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1947 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1948 dest_y + dct_offset, wrap_y);
1949 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1950 dest_y + dct_offset + 8, wrap_y);
1952 if (s->flags & CODEC_FLAG_GRAY) {
1956 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1957 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1958 if (!s->chroma_y_shift) { /* 422 */
1959 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
1960 dest_cb + uv_dct_offset, wrap_c);
1961 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
1962 dest_cr + uv_dct_offset, wrap_c);
1965 /* pre quantization */
1966 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1967 2 * s->qscale * s->qscale) {
1969 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1970 wrap_y, 8) < 20 * s->qscale)
1972 if (s->dsp.sad[1](NULL, ptr_y + 8,
1973 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1975 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1976 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1978 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1979 dest_y + dct_offset + 8,
1980 wrap_y, 8) < 20 * s->qscale)
1982 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1983 wrap_c, 8) < 20 * s->qscale)
1985 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1986 wrap_c, 8) < 20 * s->qscale)
1988 if (!s->chroma_y_shift) { /* 422 */
1989 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
1990 dest_cb + uv_dct_offset,
1991 wrap_c, 8) < 20 * s->qscale)
1993 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
1994 dest_cr + uv_dct_offset,
1995 wrap_c, 8) < 20 * s->qscale)
2001 if (s->quantizer_noise_shaping) {
2003 get_visual_weight(weight[0], ptr_y , wrap_y);
2005 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2007 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2009 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2011 get_visual_weight(weight[4], ptr_cb , wrap_c);
2013 get_visual_weight(weight[5], ptr_cr , wrap_c);
2014 if (!s->chroma_y_shift) { /* 422 */
2016 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2019 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2022 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2025 /* DCT & quantize */
2026 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2028 for (i = 0; i < mb_block_count; i++) {
2031 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2032 // FIXME we could decide to change to quantizer instead of
2034 // JS: I don't think that would be a good idea it could lower
2035 // quality instead of improve it. Just INTRADC clipping
2036 // deserves changes in quantizer
2038 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2040 s->block_last_index[i] = -1;
2042 if (s->quantizer_noise_shaping) {
2043 for (i = 0; i < mb_block_count; i++) {
2045 s->block_last_index[i] =
2046 dct_quantize_refine(s, s->block[i], weight[i],
2047 orig[i], i, s->qscale);
2052 if (s->luma_elim_threshold && !s->mb_intra)
2053 for (i = 0; i < 4; i++)
2054 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2055 if (s->chroma_elim_threshold && !s->mb_intra)
2056 for (i = 4; i < mb_block_count; i++)
2057 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2059 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2060 for (i = 0; i < mb_block_count; i++) {
2061 if (s->block_last_index[i] == -1)
2062 s->coded_score[i] = INT_MAX / 256;
2067 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2068 s->block_last_index[4] =
2069 s->block_last_index[5] = 0;
2071 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2072 if (!s->chroma_y_shift) { /* 422 / 444 */
2073 for (i=6; i<12; i++) {
2074 s->block_last_index[i] = 0;
2075 s->block[i][0] = s->block[4][0];
2080 // non c quantize code returns incorrect block_last_index FIXME
2081 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2082 for (i = 0; i < mb_block_count; i++) {
2084 if (s->block_last_index[i] > 0) {
2085 for (j = 63; j > 0; j--) {
2086 if (s->block[i][s->intra_scantable.permutated[j]])
2089 s->block_last_index[i] = j;
2094 /* huffman encode */
2095 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2096 case AV_CODEC_ID_MPEG1VIDEO:
2097 case AV_CODEC_ID_MPEG2VIDEO:
2098 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2099 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2101 case AV_CODEC_ID_MPEG4:
2102 if (CONFIG_MPEG4_ENCODER)
2103 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2105 case AV_CODEC_ID_MSMPEG4V2:
2106 case AV_CODEC_ID_MSMPEG4V3:
2107 case AV_CODEC_ID_WMV1:
2108 if (CONFIG_MSMPEG4_ENCODER)
2109 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2111 case AV_CODEC_ID_WMV2:
2112 if (CONFIG_WMV2_ENCODER)
2113 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2115 case AV_CODEC_ID_H261:
2116 if (CONFIG_H261_ENCODER)
2117 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2119 case AV_CODEC_ID_H263:
2120 case AV_CODEC_ID_H263P:
2121 case AV_CODEC_ID_FLV1:
2122 case AV_CODEC_ID_RV10:
2123 case AV_CODEC_ID_RV20:
2124 if (CONFIG_H263_ENCODER)
2125 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2127 case AV_CODEC_ID_MJPEG:
2128 case AV_CODEC_ID_AMV:
2129 if (CONFIG_MJPEG_ENCODER)
2130 ff_mjpeg_encode_mb(s, s->block);
2137 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2139 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2140 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2141 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2144 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2147 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2150 d->mb_skip_run= s->mb_skip_run;
2152 d->last_dc[i] = s->last_dc[i];
2155 d->mv_bits= s->mv_bits;
2156 d->i_tex_bits= s->i_tex_bits;
2157 d->p_tex_bits= s->p_tex_bits;
2158 d->i_count= s->i_count;
2159 d->f_count= s->f_count;
2160 d->b_count= s->b_count;
2161 d->skip_count= s->skip_count;
2162 d->misc_bits= s->misc_bits;
2166 d->qscale= s->qscale;
2167 d->dquant= s->dquant;
2169 d->esc3_level_length= s->esc3_level_length;
2172 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2175 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2176 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2179 d->mb_skip_run= s->mb_skip_run;
2181 d->last_dc[i] = s->last_dc[i];
2184 d->mv_bits= s->mv_bits;
2185 d->i_tex_bits= s->i_tex_bits;
2186 d->p_tex_bits= s->p_tex_bits;
2187 d->i_count= s->i_count;
2188 d->f_count= s->f_count;
2189 d->b_count= s->b_count;
2190 d->skip_count= s->skip_count;
2191 d->misc_bits= s->misc_bits;
2193 d->mb_intra= s->mb_intra;
2194 d->mb_skipped= s->mb_skipped;
2195 d->mv_type= s->mv_type;
2196 d->mv_dir= s->mv_dir;
2198 if(s->data_partitioning){
2200 d->tex_pb= s->tex_pb;
2204 d->block_last_index[i]= s->block_last_index[i];
2205 d->interlaced_dct= s->interlaced_dct;
2206 d->qscale= s->qscale;
2208 d->esc3_level_length= s->esc3_level_length;
2211 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2212 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2213 int *dmin, int *next_block, int motion_x, int motion_y)
2216 uint8_t *dest_backup[3];
2218 copy_context_before_encode(s, backup, type);
2220 s->block= s->blocks[*next_block];
2221 s->pb= pb[*next_block];
2222 if(s->data_partitioning){
2223 s->pb2 = pb2 [*next_block];
2224 s->tex_pb= tex_pb[*next_block];
2228 memcpy(dest_backup, s->dest, sizeof(s->dest));
2229 s->dest[0] = s->rd_scratchpad;
2230 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2231 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2232 assert(s->linesize >= 32); //FIXME
2235 encode_mb(s, motion_x, motion_y);
2237 score= put_bits_count(&s->pb);
2238 if(s->data_partitioning){
2239 score+= put_bits_count(&s->pb2);
2240 score+= put_bits_count(&s->tex_pb);
2243 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2244 ff_MPV_decode_mb(s, s->block);
2246 score *= s->lambda2;
2247 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2251 memcpy(s->dest, dest_backup, sizeof(s->dest));
2258 copy_context_after_encode(best, s, type);
2262 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2263 uint32_t *sq = ff_squareTbl + 256;
2268 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2269 else if(w==8 && h==8)
2270 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2274 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2283 static int sse_mb(MpegEncContext *s){
2287 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2288 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2291 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2292 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)
2293 +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)
2294 +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);
2296 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)
2297 +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)
2298 +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);
2301 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)
2302 +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)
2303 +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);
2306 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2307 MpegEncContext *s= *(void**)arg;
2311 s->me.dia_size= s->avctx->pre_dia_size;
2312 s->first_slice_line=1;
2313 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2314 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2315 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2317 s->first_slice_line=0;
2325 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2326 MpegEncContext *s= *(void**)arg;
2328 ff_check_alignment();
2330 s->me.dia_size= s->avctx->dia_size;
2331 s->first_slice_line=1;
2332 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2333 s->mb_x=0; //for block init below
2334 ff_init_block_index(s);
2335 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2336 s->block_index[0]+=2;
2337 s->block_index[1]+=2;
2338 s->block_index[2]+=2;
2339 s->block_index[3]+=2;
2341 /* compute motion vector & mb_type and store in context */
2342 if(s->pict_type==AV_PICTURE_TYPE_B)
2343 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2345 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2347 s->first_slice_line=0;
2352 static int mb_var_thread(AVCodecContext *c, void *arg){
2353 MpegEncContext *s= *(void**)arg;
2356 ff_check_alignment();
2358 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2359 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2362 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2364 int sum = s->dsp.pix_sum(pix, s->linesize);
2366 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2368 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2369 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2370 s->me.mb_var_sum_temp += varc;
2376 static void write_slice_end(MpegEncContext *s){
2377 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2378 if(s->partitioned_frame){
2379 ff_mpeg4_merge_partitions(s);
2382 ff_mpeg4_stuffing(&s->pb);
2383 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2384 ff_mjpeg_encode_stuffing(s);
2387 avpriv_align_put_bits(&s->pb);
2388 flush_put_bits(&s->pb);
2390 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2391 s->misc_bits+= get_bits_diff(s);
2394 static void write_mb_info(MpegEncContext *s)
2396 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2397 int offset = put_bits_count(&s->pb);
2398 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2399 int gobn = s->mb_y / s->gob_index;
2401 if (CONFIG_H263_ENCODER)
2402 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2403 bytestream_put_le32(&ptr, offset);
2404 bytestream_put_byte(&ptr, s->qscale);
2405 bytestream_put_byte(&ptr, gobn);
2406 bytestream_put_le16(&ptr, mba);
2407 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2408 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2409 /* 4MV not implemented */
2410 bytestream_put_byte(&ptr, 0); /* hmv2 */
2411 bytestream_put_byte(&ptr, 0); /* vmv2 */
2414 static void update_mb_info(MpegEncContext *s, int startcode)
2418 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2419 s->mb_info_size += 12;
2420 s->prev_mb_info = s->last_mb_info;
2423 s->prev_mb_info = put_bits_count(&s->pb)/8;
2424 /* This might have incremented mb_info_size above, and we return without
2425 * actually writing any info into that slot yet. But in that case,
2426 * this will be called again at the start of the after writing the
2427 * start code, actually writing the mb info. */
2431 s->last_mb_info = put_bits_count(&s->pb)/8;
2432 if (!s->mb_info_size)
2433 s->mb_info_size += 12;
2437 static int encode_thread(AVCodecContext *c, void *arg){
2438 MpegEncContext *s= *(void**)arg;
2439 int mb_x, mb_y, pdif = 0;
2440 int chr_h= 16>>s->chroma_y_shift;
2442 MpegEncContext best_s, backup_s;
2443 uint8_t bit_buf[2][MAX_MB_BYTES];
2444 uint8_t bit_buf2[2][MAX_MB_BYTES];
2445 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2446 PutBitContext pb[2], pb2[2], tex_pb[2];
2448 ff_check_alignment();
2451 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2452 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2453 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2456 s->last_bits= put_bits_count(&s->pb);
2467 /* init last dc values */
2468 /* note: quant matrix value (8) is implied here */
2469 s->last_dc[i] = 128 << s->intra_dc_precision;
2471 s->current_picture.f.error[i] = 0;
2473 if(s->codec_id==AV_CODEC_ID_AMV){
2474 s->last_dc[0] = 128*8/13;
2475 s->last_dc[1] = 128*8/14;
2476 s->last_dc[2] = 128*8/14;
2479 memset(s->last_mv, 0, sizeof(s->last_mv));
2483 switch(s->codec_id){
2484 case AV_CODEC_ID_H263:
2485 case AV_CODEC_ID_H263P:
2486 case AV_CODEC_ID_FLV1:
2487 if (CONFIG_H263_ENCODER)
2488 s->gob_index = ff_h263_get_gob_height(s);
2490 case AV_CODEC_ID_MPEG4:
2491 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2492 ff_mpeg4_init_partitions(s);
2498 s->first_slice_line = 1;
2499 s->ptr_lastgob = s->pb.buf;
2500 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2504 ff_set_qscale(s, s->qscale);
2505 ff_init_block_index(s);
2507 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2508 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2509 int mb_type= s->mb_type[xy];
2514 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2515 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2518 if(s->data_partitioning){
2519 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2520 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2521 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2527 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2528 ff_update_block_index(s);
2530 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2531 ff_h261_reorder_mb_index(s);
2532 xy= s->mb_y*s->mb_stride + s->mb_x;
2533 mb_type= s->mb_type[xy];
2536 /* write gob / video packet header */
2538 int current_packet_size, is_gob_start;
2540 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2542 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2544 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2546 switch(s->codec_id){
2547 case AV_CODEC_ID_H263:
2548 case AV_CODEC_ID_H263P:
2549 if(!s->h263_slice_structured)
2550 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2552 case AV_CODEC_ID_MPEG2VIDEO:
2553 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2554 case AV_CODEC_ID_MPEG1VIDEO:
2555 if(s->mb_skip_run) is_gob_start=0;
2557 case AV_CODEC_ID_MJPEG:
2558 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2563 if(s->start_mb_y != mb_y || mb_x!=0){
2565 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2566 ff_mpeg4_init_partitions(s);
2570 av_assert2((put_bits_count(&s->pb)&7) == 0);
2571 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2573 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2574 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2575 int d= 100 / s->avctx->error_rate;
2577 current_packet_size=0;
2578 s->pb.buf_ptr= s->ptr_lastgob;
2579 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2583 if (s->avctx->rtp_callback){
2584 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2585 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2587 update_mb_info(s, 1);
2589 switch(s->codec_id){
2590 case AV_CODEC_ID_MPEG4:
2591 if (CONFIG_MPEG4_ENCODER) {
2592 ff_mpeg4_encode_video_packet_header(s);
2593 ff_mpeg4_clean_buffers(s);
2596 case AV_CODEC_ID_MPEG1VIDEO:
2597 case AV_CODEC_ID_MPEG2VIDEO:
2598 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2599 ff_mpeg1_encode_slice_header(s);
2600 ff_mpeg1_clean_buffers(s);
2603 case AV_CODEC_ID_H263:
2604 case AV_CODEC_ID_H263P:
2605 if (CONFIG_H263_ENCODER)
2606 ff_h263_encode_gob_header(s, mb_y);
2610 if(s->flags&CODEC_FLAG_PASS1){
2611 int bits= put_bits_count(&s->pb);
2612 s->misc_bits+= bits - s->last_bits;
2616 s->ptr_lastgob += current_packet_size;
2617 s->first_slice_line=1;
2618 s->resync_mb_x=mb_x;
2619 s->resync_mb_y=mb_y;
2623 if( (s->resync_mb_x == s->mb_x)
2624 && s->resync_mb_y+1 == s->mb_y){
2625 s->first_slice_line=0;
2629 s->dquant=0; //only for QP_RD
2631 update_mb_info(s, 0);
2633 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
2635 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2637 copy_context_before_encode(&backup_s, s, -1);
2639 best_s.data_partitioning= s->data_partitioning;
2640 best_s.partitioned_frame= s->partitioned_frame;
2641 if(s->data_partitioning){
2642 backup_s.pb2= s->pb2;
2643 backup_s.tex_pb= s->tex_pb;
2646 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2647 s->mv_dir = MV_DIR_FORWARD;
2648 s->mv_type = MV_TYPE_16X16;
2650 s->mv[0][0][0] = s->p_mv_table[xy][0];
2651 s->mv[0][0][1] = s->p_mv_table[xy][1];
2652 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2653 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2655 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2656 s->mv_dir = MV_DIR_FORWARD;
2657 s->mv_type = MV_TYPE_FIELD;
2660 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2661 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2662 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2664 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2665 &dmin, &next_block, 0, 0);
2667 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2668 s->mv_dir = MV_DIR_FORWARD;
2669 s->mv_type = MV_TYPE_16X16;
2673 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2674 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2676 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2677 s->mv_dir = MV_DIR_FORWARD;
2678 s->mv_type = MV_TYPE_8X8;
2681 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2682 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2684 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2685 &dmin, &next_block, 0, 0);
2687 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2688 s->mv_dir = MV_DIR_FORWARD;
2689 s->mv_type = MV_TYPE_16X16;
2691 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2692 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2693 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2694 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2696 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2697 s->mv_dir = MV_DIR_BACKWARD;
2698 s->mv_type = MV_TYPE_16X16;
2700 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2701 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2702 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2703 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2705 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2706 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2707 s->mv_type = MV_TYPE_16X16;
2709 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2710 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2711 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2712 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2713 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2714 &dmin, &next_block, 0, 0);
2716 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2717 s->mv_dir = MV_DIR_FORWARD;
2718 s->mv_type = MV_TYPE_FIELD;
2721 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2722 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2723 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2725 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2726 &dmin, &next_block, 0, 0);
2728 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2729 s->mv_dir = MV_DIR_BACKWARD;
2730 s->mv_type = MV_TYPE_FIELD;
2733 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2734 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2735 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2737 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2738 &dmin, &next_block, 0, 0);
2740 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2741 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2742 s->mv_type = MV_TYPE_FIELD;
2744 for(dir=0; dir<2; dir++){
2746 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2747 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2748 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2751 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2752 &dmin, &next_block, 0, 0);
2754 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2756 s->mv_type = MV_TYPE_16X16;
2760 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2761 &dmin, &next_block, 0, 0);
2762 if(s->h263_pred || s->h263_aic){
2764 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2766 ff_clean_intra_table_entries(s); //old mode?
2770 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2771 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2772 const int last_qp= backup_s.qscale;
2775 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2776 static const int dquant_tab[4]={-1,1,-2,2};
2777 int storecoefs = s->mb_intra && s->dc_val[0];
2779 av_assert2(backup_s.dquant == 0);
2782 s->mv_dir= best_s.mv_dir;
2783 s->mv_type = MV_TYPE_16X16;
2784 s->mb_intra= best_s.mb_intra;
2785 s->mv[0][0][0] = best_s.mv[0][0][0];
2786 s->mv[0][0][1] = best_s.mv[0][0][1];
2787 s->mv[1][0][0] = best_s.mv[1][0][0];
2788 s->mv[1][0][1] = best_s.mv[1][0][1];
2790 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2791 for(; qpi<4; qpi++){
2792 int dquant= dquant_tab[qpi];
2793 qp= last_qp + dquant;
2794 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2796 backup_s.dquant= dquant;
2799 dc[i]= s->dc_val[0][ s->block_index[i] ];
2800 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2804 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2805 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2806 if(best_s.qscale != qp){
2809 s->dc_val[0][ s->block_index[i] ]= dc[i];
2810 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2817 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2818 int mx= s->b_direct_mv_table[xy][0];
2819 int my= s->b_direct_mv_table[xy][1];
2821 backup_s.dquant = 0;
2822 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2824 ff_mpeg4_set_direct_mv(s, mx, my);
2825 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2826 &dmin, &next_block, mx, my);
2828 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2829 backup_s.dquant = 0;
2830 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2832 ff_mpeg4_set_direct_mv(s, 0, 0);
2833 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2834 &dmin, &next_block, 0, 0);
2836 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2839 coded |= s->block_last_index[i];
2842 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2843 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2844 mx=my=0; //FIXME find the one we actually used
2845 ff_mpeg4_set_direct_mv(s, mx, my);
2846 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2854 s->mv_dir= best_s.mv_dir;
2855 s->mv_type = best_s.mv_type;
2857 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2858 s->mv[0][0][1] = best_s.mv[0][0][1];
2859 s->mv[1][0][0] = best_s.mv[1][0][0];
2860 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2863 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2864 &dmin, &next_block, mx, my);
2869 s->current_picture.qscale_table[xy] = best_s.qscale;
2871 copy_context_after_encode(s, &best_s, -1);
2873 pb_bits_count= put_bits_count(&s->pb);
2874 flush_put_bits(&s->pb);
2875 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2878 if(s->data_partitioning){
2879 pb2_bits_count= put_bits_count(&s->pb2);
2880 flush_put_bits(&s->pb2);
2881 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2882 s->pb2= backup_s.pb2;
2884 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2885 flush_put_bits(&s->tex_pb);
2886 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2887 s->tex_pb= backup_s.tex_pb;
2889 s->last_bits= put_bits_count(&s->pb);
2891 if (CONFIG_H263_ENCODER &&
2892 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2893 ff_h263_update_motion_val(s);
2895 if(next_block==0){ //FIXME 16 vs linesize16
2896 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2897 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2898 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2901 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2902 ff_MPV_decode_mb(s, s->block);
2904 int motion_x = 0, motion_y = 0;
2905 s->mv_type=MV_TYPE_16X16;
2906 // only one MB-Type possible
2909 case CANDIDATE_MB_TYPE_INTRA:
2912 motion_x= s->mv[0][0][0] = 0;
2913 motion_y= s->mv[0][0][1] = 0;
2915 case CANDIDATE_MB_TYPE_INTER:
2916 s->mv_dir = MV_DIR_FORWARD;
2918 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2919 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2921 case CANDIDATE_MB_TYPE_INTER_I:
2922 s->mv_dir = MV_DIR_FORWARD;
2923 s->mv_type = MV_TYPE_FIELD;
2926 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2927 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2928 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2931 case CANDIDATE_MB_TYPE_INTER4V:
2932 s->mv_dir = MV_DIR_FORWARD;
2933 s->mv_type = MV_TYPE_8X8;
2936 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2937 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2940 case CANDIDATE_MB_TYPE_DIRECT:
2941 if (CONFIG_MPEG4_ENCODER) {
2942 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2944 motion_x=s->b_direct_mv_table[xy][0];
2945 motion_y=s->b_direct_mv_table[xy][1];
2946 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2949 case CANDIDATE_MB_TYPE_DIRECT0:
2950 if (CONFIG_MPEG4_ENCODER) {
2951 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2953 ff_mpeg4_set_direct_mv(s, 0, 0);
2956 case CANDIDATE_MB_TYPE_BIDIR:
2957 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2959 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2960 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2961 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2962 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2964 case CANDIDATE_MB_TYPE_BACKWARD:
2965 s->mv_dir = MV_DIR_BACKWARD;
2967 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2968 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2970 case CANDIDATE_MB_TYPE_FORWARD:
2971 s->mv_dir = MV_DIR_FORWARD;
2973 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2974 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2976 case CANDIDATE_MB_TYPE_FORWARD_I:
2977 s->mv_dir = MV_DIR_FORWARD;
2978 s->mv_type = MV_TYPE_FIELD;
2981 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2982 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2983 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2986 case CANDIDATE_MB_TYPE_BACKWARD_I:
2987 s->mv_dir = MV_DIR_BACKWARD;
2988 s->mv_type = MV_TYPE_FIELD;
2991 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2992 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2993 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2996 case CANDIDATE_MB_TYPE_BIDIR_I:
2997 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2998 s->mv_type = MV_TYPE_FIELD;
3000 for(dir=0; dir<2; dir++){
3002 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3003 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3004 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3009 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3012 encode_mb(s, motion_x, motion_y);
3014 // RAL: Update last macroblock type
3015 s->last_mv_dir = s->mv_dir;
3017 if (CONFIG_H263_ENCODER &&
3018 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3019 ff_h263_update_motion_val(s);
3021 ff_MPV_decode_mb(s, s->block);
3024 /* clean the MV table in IPS frames for direct mode in B frames */
3025 if(s->mb_intra /* && I,P,S_TYPE */){
3026 s->p_mv_table[xy][0]=0;
3027 s->p_mv_table[xy][1]=0;
3030 if(s->flags&CODEC_FLAG_PSNR){
3034 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3035 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3037 s->current_picture.f.error[0] += sse(
3038 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3039 s->dest[0], w, h, s->linesize);
3040 s->current_picture.f.error[1] += sse(
3041 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3042 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3043 s->current_picture.f.error[2] += sse(
3044 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3045 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3048 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3049 ff_h263_loop_filter(s);
3051 av_dlog(s->avctx, "MB %d %d bits\n",
3052 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3056 //not beautiful here but we must write it before flushing so it has to be here
3057 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3058 ff_msmpeg4_encode_ext_header(s);
3062 /* Send the last GOB if RTP */
3063 if (s->avctx->rtp_callback) {
3064 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3065 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3066 /* Call the RTP callback to send the last GOB */
3068 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3074 #define MERGE(field) dst->field += src->field; src->field=0
3075 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3076 MERGE(me.scene_change_score);
3077 MERGE(me.mc_mb_var_sum_temp);
3078 MERGE(me.mb_var_sum_temp);
3081 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3084 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3085 MERGE(dct_count[1]);
3094 MERGE(er.error_count);
3095 MERGE(padding_bug_score);
3096 MERGE(current_picture.f.error[0]);
3097 MERGE(current_picture.f.error[1]);
3098 MERGE(current_picture.f.error[2]);
3100 if(dst->avctx->noise_reduction){
3101 for(i=0; i<64; i++){
3102 MERGE(dct_error_sum[0][i]);
3103 MERGE(dct_error_sum[1][i]);
3107 assert(put_bits_count(&src->pb) % 8 ==0);
3108 assert(put_bits_count(&dst->pb) % 8 ==0);
3109 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3110 flush_put_bits(&dst->pb);
3113 static int estimate_qp(MpegEncContext *s, int dry_run){
3114 if (s->next_lambda){
3115 s->current_picture_ptr->f.quality =
3116 s->current_picture.f.quality = s->next_lambda;
3117 if(!dry_run) s->next_lambda= 0;
3118 } else if (!s->fixed_qscale) {
3119 s->current_picture_ptr->f.quality =
3120 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3121 if (s->current_picture.f.quality < 0)
3125 if(s->adaptive_quant){
3126 switch(s->codec_id){
3127 case AV_CODEC_ID_MPEG4:
3128 if (CONFIG_MPEG4_ENCODER)
3129 ff_clean_mpeg4_qscales(s);
3131 case AV_CODEC_ID_H263:
3132 case AV_CODEC_ID_H263P:
3133 case AV_CODEC_ID_FLV1:
3134 if (CONFIG_H263_ENCODER)
3135 ff_clean_h263_qscales(s);
3138 ff_init_qscale_tab(s);
3141 s->lambda= s->lambda_table[0];
3144 s->lambda = s->current_picture.f.quality;
3149 /* must be called before writing the header */
3150 static void set_frame_distances(MpegEncContext * s){
3151 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3152 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3154 if(s->pict_type==AV_PICTURE_TYPE_B){
3155 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3156 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3158 s->pp_time= s->time - s->last_non_b_time;
3159 s->last_non_b_time= s->time;
3160 assert(s->picture_number==0 || s->pp_time > 0);
3164 static int encode_picture(MpegEncContext *s, int picture_number)
3168 int context_count = s->slice_context_count;
3170 s->picture_number = picture_number;
3172 /* Reset the average MB variance */
3173 s->me.mb_var_sum_temp =
3174 s->me.mc_mb_var_sum_temp = 0;
3176 /* we need to initialize some time vars before we can encode b-frames */
3177 // RAL: Condition added for MPEG1VIDEO
3178 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3179 set_frame_distances(s);
3180 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3181 ff_set_mpeg4_time(s);
3183 s->me.scene_change_score=0;
3185 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3187 if(s->pict_type==AV_PICTURE_TYPE_I){
3188 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3189 else s->no_rounding=0;
3190 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3191 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3192 s->no_rounding ^= 1;
3195 if(s->flags & CODEC_FLAG_PASS2){
3196 if (estimate_qp(s,1) < 0)
3198 ff_get_2pass_fcode(s);
3199 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3200 if(s->pict_type==AV_PICTURE_TYPE_B)
3201 s->lambda= s->last_lambda_for[s->pict_type];
3203 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3207 if(s->codec_id != AV_CODEC_ID_AMV){
3208 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3209 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3210 s->q_chroma_intra_matrix = s->q_intra_matrix;
3211 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3214 s->mb_intra=0; //for the rate distortion & bit compare functions
3215 for(i=1; i<context_count; i++){
3216 ret = ff_update_duplicate_context(s->thread_context[i], s);
3224 /* Estimate motion for every MB */
3225 if(s->pict_type != AV_PICTURE_TYPE_I){
3226 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3227 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3228 if (s->pict_type != AV_PICTURE_TYPE_B) {
3229 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3230 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3234 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3235 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3237 for(i=0; i<s->mb_stride*s->mb_height; i++)
3238 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3240 if(!s->fixed_qscale){
3241 /* finding spatial complexity for I-frame rate control */
3242 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3245 for(i=1; i<context_count; i++){
3246 merge_context_after_me(s, s->thread_context[i]);
3248 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3249 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3252 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3253 s->pict_type= AV_PICTURE_TYPE_I;
3254 for(i=0; i<s->mb_stride*s->mb_height; i++)
3255 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3256 if(s->msmpeg4_version >= 3)
3258 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3259 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3263 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3264 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3266 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3268 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3269 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3270 s->f_code= FFMAX3(s->f_code, a, b);
3273 ff_fix_long_p_mvs(s);
3274 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3275 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3279 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3280 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3285 if(s->pict_type==AV_PICTURE_TYPE_B){
3288 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3289 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3290 s->f_code = FFMAX(a, b);
3292 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3293 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3294 s->b_code = FFMAX(a, b);
3296 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3297 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3298 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3299 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3300 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3302 for(dir=0; dir<2; dir++){
3305 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3306 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3307 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3308 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3316 if (estimate_qp(s, 0) < 0)
3319 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3320 s->qscale= 3; //reduce clipping problems
3322 if (s->out_format == FMT_MJPEG) {
3323 /* for mjpeg, we do include qscale in the matrix */
3325 int j= s->dsp.idct_permutation[i];
3327 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3329 s->y_dc_scale_table=
3330 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3331 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3332 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3333 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3336 if(s->codec_id == AV_CODEC_ID_AMV){
3337 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};
3338 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};
3340 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3342 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3343 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3345 s->y_dc_scale_table= y;
3346 s->c_dc_scale_table= c;
3347 s->intra_matrix[0] = 13;
3348 s->chroma_intra_matrix[0] = 14;
3349 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3350 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3351 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3352 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3356 //FIXME var duplication
3357 s->current_picture_ptr->f.key_frame =
3358 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3359 s->current_picture_ptr->f.pict_type =
3360 s->current_picture.f.pict_type = s->pict_type;
3362 if (s->current_picture.f.key_frame)
3363 s->picture_in_gop_number=0;
3365 s->mb_x = s->mb_y = 0;
3366 s->last_bits= put_bits_count(&s->pb);
3367 switch(s->out_format) {
3369 if (CONFIG_MJPEG_ENCODER)
3370 ff_mjpeg_encode_picture_header(s);
3373 if (CONFIG_H261_ENCODER)
3374 ff_h261_encode_picture_header(s, picture_number);
3377 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3378 ff_wmv2_encode_picture_header(s, picture_number);
3379 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3380 ff_msmpeg4_encode_picture_header(s, picture_number);
3381 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3382 ff_mpeg4_encode_picture_header(s, picture_number);
3383 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3384 ff_rv10_encode_picture_header(s, picture_number);
3385 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3386 ff_rv20_encode_picture_header(s, picture_number);
3387 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3388 ff_flv_encode_picture_header(s, picture_number);
3389 else if (CONFIG_H263_ENCODER)
3390 ff_h263_encode_picture_header(s, picture_number);
3393 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3394 ff_mpeg1_encode_picture_header(s, picture_number);
3399 bits= put_bits_count(&s->pb);
3400 s->header_bits= bits - s->last_bits;
3402 for(i=1; i<context_count; i++){
3403 update_duplicate_context_after_me(s->thread_context[i], s);
3405 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3406 for(i=1; i<context_count; i++){
3407 merge_context_after_encode(s, s->thread_context[i]);
3413 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3414 const int intra= s->mb_intra;
3417 s->dct_count[intra]++;
3419 for(i=0; i<64; i++){
3420 int level= block[i];
3424 s->dct_error_sum[intra][i] += level;
3425 level -= s->dct_offset[intra][i];
3426 if(level<0) level=0;
3428 s->dct_error_sum[intra][i] -= level;
3429 level += s->dct_offset[intra][i];
3430 if(level>0) level=0;
3437 static int dct_quantize_trellis_c(MpegEncContext *s,
3438 int16_t *block, int n,
3439 int qscale, int *overflow){
3441 const uint8_t *scantable= s->intra_scantable.scantable;
3442 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3444 unsigned int threshold1, threshold2;
3456 int coeff_count[64];
3457 int qmul, qadd, start_i, last_non_zero, i, dc;
3458 const int esc_length= s->ac_esc_length;
3460 uint8_t * last_length;
3461 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3463 s->dsp.fdct (block);
3465 if(s->dct_error_sum)
3466 s->denoise_dct(s, block);
3468 qadd= ((qscale-1)|1)*8;
3479 /* For AIC we skip quant/dequant of INTRADC */
3484 /* note: block[0] is assumed to be positive */
3485 block[0] = (block[0] + (q >> 1)) / q;
3488 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3489 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3490 bias= 1<<(QMAT_SHIFT-1);
3491 length = s->intra_ac_vlc_length;
3492 last_length= s->intra_ac_vlc_last_length;
3496 qmat = s->q_inter_matrix[qscale];
3497 length = s->inter_ac_vlc_length;
3498 last_length= s->inter_ac_vlc_last_length;
3502 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3503 threshold2= (threshold1<<1);
3505 for(i=63; i>=start_i; i--) {
3506 const int j = scantable[i];
3507 int level = block[j] * qmat[j];
3509 if(((unsigned)(level+threshold1))>threshold2){
3515 for(i=start_i; i<=last_non_zero; i++) {
3516 const int j = scantable[i];
3517 int level = block[j] * qmat[j];
3519 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3520 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3521 if(((unsigned)(level+threshold1))>threshold2){
3523 level= (bias + level)>>QMAT_SHIFT;
3525 coeff[1][i]= level-1;
3526 // coeff[2][k]= level-2;
3528 level= (bias - level)>>QMAT_SHIFT;
3529 coeff[0][i]= -level;
3530 coeff[1][i]= -level+1;
3531 // coeff[2][k]= -level+2;
3533 coeff_count[i]= FFMIN(level, 2);
3534 av_assert2(coeff_count[i]);
3537 coeff[0][i]= (level>>31)|1;
3542 *overflow= s->max_qcoeff < max; //overflow might have happened
3544 if(last_non_zero < start_i){
3545 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3546 return last_non_zero;
3549 score_tab[start_i]= 0;
3550 survivor[0]= start_i;
3553 for(i=start_i; i<=last_non_zero; i++){
3554 int level_index, j, zero_distortion;
3555 int dct_coeff= FFABS(block[ scantable[i] ]);
3556 int best_score=256*256*256*120;
3558 if (s->dsp.fdct == ff_fdct_ifast)
3559 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3560 zero_distortion= dct_coeff*dct_coeff;
3562 for(level_index=0; level_index < coeff_count[i]; level_index++){
3564 int level= coeff[level_index][i];
3565 const int alevel= FFABS(level);
3570 if(s->out_format == FMT_H263){
3571 unquant_coeff= alevel*qmul + qadd;
3573 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3575 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3576 unquant_coeff = (unquant_coeff - 1) | 1;
3578 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3579 unquant_coeff = (unquant_coeff - 1) | 1;
3584 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3586 if((level&(~127)) == 0){
3587 for(j=survivor_count-1; j>=0; j--){
3588 int run= i - survivor[j];
3589 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3590 score += score_tab[i-run];
3592 if(score < best_score){
3595 level_tab[i+1]= level-64;
3599 if(s->out_format == FMT_H263){
3600 for(j=survivor_count-1; j>=0; j--){
3601 int run= i - survivor[j];
3602 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3603 score += score_tab[i-run];
3604 if(score < last_score){
3607 last_level= level-64;
3613 distortion += esc_length*lambda;
3614 for(j=survivor_count-1; j>=0; j--){
3615 int run= i - survivor[j];
3616 int score= distortion + score_tab[i-run];
3618 if(score < best_score){
3621 level_tab[i+1]= level-64;
3625 if(s->out_format == FMT_H263){
3626 for(j=survivor_count-1; j>=0; j--){
3627 int run= i - survivor[j];
3628 int score= distortion + score_tab[i-run];
3629 if(score < last_score){
3632 last_level= level-64;
3640 score_tab[i+1]= best_score;
3642 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3643 if(last_non_zero <= 27){
3644 for(; survivor_count; survivor_count--){
3645 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3649 for(; survivor_count; survivor_count--){
3650 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3655 survivor[ survivor_count++ ]= i+1;
3658 if(s->out_format != FMT_H263){
3659 last_score= 256*256*256*120;
3660 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3661 int score= score_tab[i];
3662 if(i) score += lambda*2; //FIXME exacter?
3664 if(score < last_score){
3667 last_level= level_tab[i];
3668 last_run= run_tab[i];
3673 s->coded_score[n] = last_score;
3675 dc= FFABS(block[0]);
3676 last_non_zero= last_i - 1;
3677 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3679 if(last_non_zero < start_i)
3680 return last_non_zero;
3682 if(last_non_zero == 0 && start_i == 0){
3684 int best_score= dc * dc;
3686 for(i=0; i<coeff_count[0]; i++){
3687 int level= coeff[i][0];
3688 int alevel= FFABS(level);
3689 int unquant_coeff, score, distortion;
3691 if(s->out_format == FMT_H263){
3692 unquant_coeff= (alevel*qmul + qadd)>>3;
3694 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3695 unquant_coeff = (unquant_coeff - 1) | 1;
3697 unquant_coeff = (unquant_coeff + 4) >> 3;
3698 unquant_coeff<<= 3 + 3;
3700 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3702 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3703 else score= distortion + esc_length*lambda;
3705 if(score < best_score){
3707 best_level= level - 64;
3710 block[0]= best_level;
3711 s->coded_score[n] = best_score - dc*dc;
3712 if(best_level == 0) return -1;
3713 else return last_non_zero;
3717 av_assert2(last_level);
3719 block[ perm_scantable[last_non_zero] ]= last_level;
3722 for(; i>start_i; i -= run_tab[i] + 1){
3723 block[ perm_scantable[i-1] ]= level_tab[i];
3726 return last_non_zero;
3729 //#define REFINE_STATS 1
3730 static int16_t basis[64][64];
3732 static void build_basis(uint8_t *perm){
3739 double s= 0.25*(1<<BASIS_SHIFT);
3741 int perm_index= perm[index];
3742 if(i==0) s*= sqrt(0.5);
3743 if(j==0) s*= sqrt(0.5);
3744 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)));
3751 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3752 int16_t *block, int16_t *weight, int16_t *orig,
3755 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3756 const uint8_t *scantable= s->intra_scantable.scantable;
3757 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3758 // unsigned int threshold1, threshold2;
3763 int qmul, qadd, start_i, last_non_zero, i, dc;
3765 uint8_t * last_length;
3767 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3770 static int after_last=0;
3771 static int to_zero=0;
3772 static int from_zero=0;
3775 static int messed_sign=0;
3778 if(basis[0][0] == 0)
3779 build_basis(s->dsp.idct_permutation);
3790 /* For AIC we skip quant/dequant of INTRADC */
3794 q <<= RECON_SHIFT-3;
3795 /* note: block[0] is assumed to be positive */
3797 // block[0] = (block[0] + (q >> 1)) / q;
3799 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3800 // bias= 1<<(QMAT_SHIFT-1);
3801 length = s->intra_ac_vlc_length;
3802 last_length= s->intra_ac_vlc_last_length;
3806 length = s->inter_ac_vlc_length;
3807 last_length= s->inter_ac_vlc_last_length;
3809 last_non_zero = s->block_last_index[n];
3814 dc += (1<<(RECON_SHIFT-1));
3815 for(i=0; i<64; i++){
3816 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3819 STOP_TIMER("memset rem[]")}
3822 for(i=0; i<64; i++){
3827 w= FFABS(weight[i]) + qns*one;
3828 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3831 // w=weight[i] = (63*qns + (w/2)) / w;
3834 av_assert2(w<(1<<6));
3837 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3843 for(i=start_i; i<=last_non_zero; i++){
3844 int j= perm_scantable[i];
3845 const int level= block[j];
3849 if(level<0) coeff= qmul*level - qadd;
3850 else coeff= qmul*level + qadd;
3851 run_tab[rle_index++]=run;
3854 s->dsp.add_8x8basis(rem, basis[j], coeff);
3860 if(last_non_zero>0){
3861 STOP_TIMER("init rem[]")
3868 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3871 int run2, best_unquant_change=0, analyze_gradient;
3875 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3877 if(analyze_gradient){
3881 for(i=0; i<64; i++){
3884 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3887 STOP_TIMER("rem*w*w")}
3897 const int level= block[0];
3898 int change, old_coeff;
3900 av_assert2(s->mb_intra);
3904 for(change=-1; change<=1; change+=2){
3905 int new_level= level + change;
3906 int score, new_coeff;
3908 new_coeff= q*new_level;
3909 if(new_coeff >= 2048 || new_coeff < 0)
3912 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3913 if(score<best_score){
3916 best_change= change;
3917 best_unquant_change= new_coeff - old_coeff;
3924 run2= run_tab[rle_index++];
3928 for(i=start_i; i<64; i++){
3929 int j= perm_scantable[i];
3930 const int level= block[j];
3931 int change, old_coeff;
3933 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3937 if(level<0) old_coeff= qmul*level - qadd;
3938 else old_coeff= qmul*level + qadd;
3939 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3943 av_assert2(run2>=0 || i >= last_non_zero );
3946 for(change=-1; change<=1; change+=2){
3947 int new_level= level + change;
3948 int score, new_coeff, unquant_change;
3951 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3955 if(new_level<0) new_coeff= qmul*new_level - qadd;
3956 else new_coeff= qmul*new_level + qadd;
3957 if(new_coeff >= 2048 || new_coeff <= -2048)
3959 //FIXME check for overflow
3962 if(level < 63 && level > -63){
3963 if(i < last_non_zero)
3964 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3965 - length[UNI_AC_ENC_INDEX(run, level+64)];
3967 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3968 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3971 av_assert2(FFABS(new_level)==1);
3973 if(analyze_gradient){
3974 int g= d1[ scantable[i] ];
3975 if(g && (g^new_level) >= 0)
3979 if(i < last_non_zero){
3980 int next_i= i + run2 + 1;
3981 int next_level= block[ perm_scantable[next_i] ] + 64;
3983 if(next_level&(~127))
3986 if(next_i < last_non_zero)
3987 score += length[UNI_AC_ENC_INDEX(run, 65)]
3988 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3989 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3991 score += length[UNI_AC_ENC_INDEX(run, 65)]
3992 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3993 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3995 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
3997 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3998 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4004 av_assert2(FFABS(level)==1);
4006 if(i < last_non_zero){
4007 int next_i= i + run2 + 1;
4008 int next_level= block[ perm_scantable[next_i] ] + 64;
4010 if(next_level&(~127))
4013 if(next_i < last_non_zero)
4014 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4015 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4016 - length[UNI_AC_ENC_INDEX(run, 65)];
4018 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4019 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4020 - length[UNI_AC_ENC_INDEX(run, 65)];
4022 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4024 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4025 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4032 unquant_change= new_coeff - old_coeff;
4033 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4035 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4036 if(score<best_score){
4039 best_change= change;
4040 best_unquant_change= unquant_change;
4044 prev_level= level + 64;
4045 if(prev_level&(~127))
4054 STOP_TIMER("iterative step")}
4058 int j= perm_scantable[ best_coeff ];
4060 block[j] += best_change;
4062 if(best_coeff > last_non_zero){
4063 last_non_zero= best_coeff;
4064 av_assert2(block[j]);
4071 if(block[j] - best_change){
4072 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4084 for(; last_non_zero>=start_i; last_non_zero--){
4085 if(block[perm_scantable[last_non_zero]])
4091 if(256*256*256*64 % count == 0){
4092 av_log(s->avctx, AV_LOG_DEBUG, "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);
4097 for(i=start_i; i<=last_non_zero; i++){
4098 int j= perm_scantable[i];
4099 const int level= block[j];
4102 run_tab[rle_index++]=run;
4109 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4115 if(last_non_zero>0){
4116 STOP_TIMER("iterative search")
4121 return last_non_zero;
4124 int ff_dct_quantize_c(MpegEncContext *s,
4125 int16_t *block, int n,
4126 int qscale, int *overflow)
4128 int i, j, level, last_non_zero, q, start_i;
4130 const uint8_t *scantable= s->intra_scantable.scantable;
4133 unsigned int threshold1, threshold2;
4135 s->dsp.fdct (block);
4137 if(s->dct_error_sum)
4138 s->denoise_dct(s, block);
4148 /* For AIC we skip quant/dequant of INTRADC */
4151 /* note: block[0] is assumed to be positive */
4152 block[0] = (block[0] + (q >> 1)) / q;
4155 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4156 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4160 qmat = s->q_inter_matrix[qscale];
4161 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4163 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4164 threshold2= (threshold1<<1);
4165 for(i=63;i>=start_i;i--) {
4167 level = block[j] * qmat[j];
4169 if(((unsigned)(level+threshold1))>threshold2){
4176 for(i=start_i; i<=last_non_zero; i++) {
4178 level = block[j] * qmat[j];
4180 // if( bias+level >= (1<<QMAT_SHIFT)
4181 // || bias-level >= (1<<QMAT_SHIFT)){
4182 if(((unsigned)(level+threshold1))>threshold2){
4184 level= (bias + level)>>QMAT_SHIFT;
4187 level= (bias - level)>>QMAT_SHIFT;
4195 *overflow= s->max_qcoeff < max; //overflow might have happened
4197 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4198 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4199 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4201 return last_non_zero;
4204 #define OFFSET(x) offsetof(MpegEncContext, x)
4205 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4206 static const AVOption h263_options[] = {
4207 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4208 { "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},
4209 { "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 },
4214 static const AVClass h263_class = {
4215 .class_name = "H.263 encoder",
4216 .item_name = av_default_item_name,
4217 .option = h263_options,
4218 .version = LIBAVUTIL_VERSION_INT,
4221 AVCodec ff_h263_encoder = {
4223 .type = AVMEDIA_TYPE_VIDEO,
4224 .id = AV_CODEC_ID_H263,
4225 .priv_data_size = sizeof(MpegEncContext),
4226 .init = ff_MPV_encode_init,
4227 .encode2 = ff_MPV_encode_picture,
4228 .close = ff_MPV_encode_end,
4229 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4230 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4231 .priv_class = &h263_class,
4234 static const AVOption h263p_options[] = {
4235 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4236 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4237 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4238 { "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},
4242 static const AVClass h263p_class = {
4243 .class_name = "H.263p encoder",
4244 .item_name = av_default_item_name,
4245 .option = h263p_options,
4246 .version = LIBAVUTIL_VERSION_INT,
4249 AVCodec ff_h263p_encoder = {
4251 .type = AVMEDIA_TYPE_VIDEO,
4252 .id = AV_CODEC_ID_H263P,
4253 .priv_data_size = sizeof(MpegEncContext),
4254 .init = ff_MPV_encode_init,
4255 .encode2 = ff_MPV_encode_picture,
4256 .close = ff_MPV_encode_end,
4257 .capabilities = CODEC_CAP_SLICE_THREADS,
4258 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4259 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4260 .priv_class = &h263p_class,
4263 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4265 AVCodec ff_msmpeg4v2_encoder = {
4266 .name = "msmpeg4v2",
4267 .type = AVMEDIA_TYPE_VIDEO,
4268 .id = AV_CODEC_ID_MSMPEG4V2,
4269 .priv_data_size = sizeof(MpegEncContext),
4270 .init = ff_MPV_encode_init,
4271 .encode2 = ff_MPV_encode_picture,
4272 .close = ff_MPV_encode_end,
4273 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4274 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4275 .priv_class = &msmpeg4v2_class,
4278 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4280 AVCodec ff_msmpeg4v3_encoder = {
4282 .type = AVMEDIA_TYPE_VIDEO,
4283 .id = AV_CODEC_ID_MSMPEG4V3,
4284 .priv_data_size = sizeof(MpegEncContext),
4285 .init = ff_MPV_encode_init,
4286 .encode2 = ff_MPV_encode_picture,
4287 .close = ff_MPV_encode_end,
4288 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4289 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4290 .priv_class = &msmpeg4v3_class,
4293 FF_MPV_GENERIC_CLASS(wmv1)
4295 AVCodec ff_wmv1_encoder = {
4297 .type = AVMEDIA_TYPE_VIDEO,
4298 .id = AV_CODEC_ID_WMV1,
4299 .priv_data_size = sizeof(MpegEncContext),
4300 .init = ff_MPV_encode_init,
4301 .encode2 = ff_MPV_encode_picture,
4302 .close = ff_MPV_encode_end,
4303 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4304 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4305 .priv_class = &wmv1_class,