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!).
32 #include "libavutil/internal.h"
33 #include "libavutil/intmath.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/opt.h"
41 #include "mpegvideo.h"
49 #include "aandcttab.h"
51 #include "mpeg4video.h"
53 #include "bytestream.h"
57 static int encode_picture(MpegEncContext *s, int picture_number);
58 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
59 static int sse_mb(MpegEncContext *s);
60 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
61 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
63 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
64 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
66 const AVOption ff_mpv_generic_options[] = {
71 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
72 uint16_t (*qmat16)[2][64],
73 const uint16_t *quant_matrix,
74 int bias, int qmin, int qmax, int intra)
79 for (qscale = qmin; qscale <= qmax; qscale++) {
81 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
82 dsp->fdct == ff_jpeg_fdct_islow_10 ||
83 dsp->fdct == ff_faandct) {
84 for (i = 0; i < 64; i++) {
85 const int j = dsp->idct_permutation[i];
86 /* 16 <= qscale * quant_matrix[i] <= 7905
87 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
88 * 19952 <= x <= 249205026
89 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
90 * 3444240 >= (1 << 36) / (x) >= 275 */
92 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
93 (qscale * quant_matrix[j]));
95 } else if (dsp->fdct == ff_fdct_ifast) {
96 for (i = 0; i < 64; i++) {
97 const int j = dsp->idct_permutation[i];
98 /* 16 <= qscale * quant_matrix[i] <= 7905
99 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
100 * 19952 <= x <= 249205026
101 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
102 * 3444240 >= (1 << 36) / (x) >= 275 */
104 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
105 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
108 for (i = 0; i < 64; i++) {
109 const int j = dsp->idct_permutation[i];
110 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
111 * Assume x = qscale * quant_matrix[i]
113 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
114 * so 32768 >= (1 << 19) / (x) >= 67 */
115 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
116 (qscale * quant_matrix[j]));
117 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
118 // (qscale * quant_matrix[i]);
119 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
120 (qscale * quant_matrix[j]);
122 if (qmat16[qscale][0][i] == 0 ||
123 qmat16[qscale][0][i] == 128 * 256)
124 qmat16[qscale][0][i] = 128 * 256 - 1;
125 qmat16[qscale][1][i] =
126 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
127 qmat16[qscale][0][i]);
131 for (i = intra; i < 64; i++) {
133 if (dsp->fdct == ff_fdct_ifast) {
134 max = (8191LL * ff_aanscales[i]) >> 14;
136 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
142 av_log(NULL, AV_LOG_INFO,
143 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
148 static inline void update_qscale(MpegEncContext *s)
150 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
151 (FF_LAMBDA_SHIFT + 7);
152 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
154 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
158 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
164 for (i = 0; i < 64; i++) {
165 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
172 * init s->current_picture.qscale_table from s->lambda_table
174 void ff_init_qscale_tab(MpegEncContext *s)
176 int8_t * const qscale_table = s->current_picture.qscale_table;
179 for (i = 0; i < s->mb_num; i++) {
180 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
181 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
182 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
187 static void update_duplicate_context_after_me(MpegEncContext *dst,
190 #define COPY(a) dst->a= src->a
192 COPY(current_picture);
198 COPY(picture_in_gop_number);
199 COPY(gop_picture_number);
200 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
201 COPY(progressive_frame); // FIXME don't set in encode_header
202 COPY(partitioned_frame); // FIXME don't set in encode_header
207 * Set the given MpegEncContext to defaults for encoding.
208 * the changed fields will not depend upon the prior state of the MpegEncContext.
210 static void MPV_encode_defaults(MpegEncContext *s)
213 ff_MPV_common_defaults(s);
215 for (i = -16; i < 16; i++) {
216 default_fcode_tab[i + MAX_MV] = 1;
218 s->me.mv_penalty = default_mv_penalty;
219 s->fcode_tab = default_fcode_tab;
222 av_cold int ff_dct_encode_init(MpegEncContext *s) {
224 ff_dct_encode_init_x86(s);
226 ff_h263dsp_init(&s->h263dsp);
227 if (!s->dct_quantize)
228 s->dct_quantize = ff_dct_quantize_c;
230 s->denoise_dct = denoise_dct_c;
231 s->fast_dct_quantize = s->dct_quantize;
232 if (s->avctx->trellis)
233 s->dct_quantize = dct_quantize_trellis_c;
238 /* init video encoder */
239 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
241 MpegEncContext *s = avctx->priv_data;
243 int chroma_h_shift, chroma_v_shift;
245 MPV_encode_defaults(s);
247 switch (avctx->codec_id) {
248 case AV_CODEC_ID_MPEG2VIDEO:
249 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
250 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
251 av_log(avctx, AV_LOG_ERROR,
252 "only YUV420 and YUV422 are supported\n");
256 case AV_CODEC_ID_LJPEG:
257 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
258 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
259 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
260 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
261 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
262 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
263 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
264 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
265 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
266 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
267 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
271 case AV_CODEC_ID_MJPEG:
272 case AV_CODEC_ID_AMV:
273 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
274 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
275 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
276 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
277 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
278 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
279 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
280 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
285 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
286 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
291 switch (avctx->pix_fmt) {
292 case AV_PIX_FMT_YUVJ444P:
293 case AV_PIX_FMT_YUV444P:
294 s->chroma_format = CHROMA_444;
296 case AV_PIX_FMT_YUVJ422P:
297 case AV_PIX_FMT_YUV422P:
298 s->chroma_format = CHROMA_422;
300 case AV_PIX_FMT_YUVJ420P:
301 case AV_PIX_FMT_YUV420P:
303 s->chroma_format = CHROMA_420;
307 s->bit_rate = avctx->bit_rate;
308 s->width = avctx->width;
309 s->height = avctx->height;
310 if (avctx->gop_size > 600 &&
311 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
312 av_log(avctx, AV_LOG_WARNING,
313 "keyframe interval too large!, reducing it from %d to %d\n",
314 avctx->gop_size, 600);
315 avctx->gop_size = 600;
317 s->gop_size = avctx->gop_size;
319 s->flags = avctx->flags;
320 s->flags2 = avctx->flags2;
321 if (avctx->max_b_frames > MAX_B_FRAMES) {
322 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
323 "is %d.\n", MAX_B_FRAMES);
324 avctx->max_b_frames = MAX_B_FRAMES;
326 s->max_b_frames = avctx->max_b_frames;
327 s->codec_id = avctx->codec->id;
328 s->strict_std_compliance = avctx->strict_std_compliance;
329 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
330 s->mpeg_quant = avctx->mpeg_quant;
331 s->rtp_mode = !!avctx->rtp_payload_size;
332 s->intra_dc_precision = avctx->intra_dc_precision;
333 s->user_specified_pts = AV_NOPTS_VALUE;
335 if (s->gop_size <= 1) {
342 s->me_method = avctx->me_method;
345 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
347 s->adaptive_quant = (s->avctx->lumi_masking ||
348 s->avctx->dark_masking ||
349 s->avctx->temporal_cplx_masking ||
350 s->avctx->spatial_cplx_masking ||
351 s->avctx->p_masking ||
352 s->avctx->border_masking ||
353 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
356 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
358 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
359 switch(avctx->codec_id) {
360 case AV_CODEC_ID_MPEG1VIDEO:
361 case AV_CODEC_ID_MPEG2VIDEO:
362 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
364 case AV_CODEC_ID_MPEG4:
365 case AV_CODEC_ID_MSMPEG4V1:
366 case AV_CODEC_ID_MSMPEG4V2:
367 case AV_CODEC_ID_MSMPEG4V3:
368 if (avctx->rc_max_rate >= 15000000) {
369 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
370 } else if(avctx->rc_max_rate >= 2000000) {
371 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
372 } else if(avctx->rc_max_rate >= 384000) {
373 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
375 avctx->rc_buffer_size = 40;
376 avctx->rc_buffer_size *= 16384;
379 if (avctx->rc_buffer_size) {
380 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
384 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
385 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
386 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
390 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
391 av_log(avctx, AV_LOG_INFO,
392 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
395 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
396 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
400 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
401 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
405 if (avctx->rc_max_rate &&
406 avctx->rc_max_rate == avctx->bit_rate &&
407 avctx->rc_max_rate != avctx->rc_min_rate) {
408 av_log(avctx, AV_LOG_INFO,
409 "impossible bitrate constraints, this will fail\n");
412 if (avctx->rc_buffer_size &&
413 avctx->bit_rate * (int64_t)avctx->time_base.num >
414 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
415 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
419 if (!s->fixed_qscale &&
420 avctx->bit_rate * av_q2d(avctx->time_base) >
421 avctx->bit_rate_tolerance) {
422 av_log(avctx, AV_LOG_ERROR,
423 "bitrate tolerance too small for bitrate\n");
427 if (s->avctx->rc_max_rate &&
428 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
429 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
430 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
431 90000LL * (avctx->rc_buffer_size - 1) >
432 s->avctx->rc_max_rate * 0xFFFFLL) {
433 av_log(avctx, AV_LOG_INFO,
434 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
435 "specified vbv buffer is too large for the given bitrate!\n");
438 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
439 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
440 s->codec_id != AV_CODEC_ID_FLV1) {
441 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
445 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
446 av_log(avctx, AV_LOG_ERROR,
447 "OBMC is only supported with simple mb decision\n");
451 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
452 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
456 if (s->max_b_frames &&
457 s->codec_id != AV_CODEC_ID_MPEG4 &&
458 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
459 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
460 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
463 if (s->max_b_frames < 0) {
464 av_log(avctx, AV_LOG_ERROR,
465 "max b frames must be 0 or positive for mpegvideo based encoders\n");
469 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
470 s->codec_id == AV_CODEC_ID_H263 ||
471 s->codec_id == AV_CODEC_ID_H263P) &&
472 (avctx->sample_aspect_ratio.num > 255 ||
473 avctx->sample_aspect_ratio.den > 255)) {
474 av_log(avctx, AV_LOG_WARNING,
475 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
476 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
477 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
478 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
481 if ((s->codec_id == AV_CODEC_ID_H263 ||
482 s->codec_id == AV_CODEC_ID_H263P) &&
483 (avctx->width > 2048 ||
484 avctx->height > 1152 )) {
485 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
488 if ((s->codec_id == AV_CODEC_ID_H263 ||
489 s->codec_id == AV_CODEC_ID_H263P) &&
490 ((avctx->width &3) ||
491 (avctx->height&3) )) {
492 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
496 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
497 (avctx->width > 4095 ||
498 avctx->height > 4095 )) {
499 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
503 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
504 (avctx->width > 16383 ||
505 avctx->height > 16383 )) {
506 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
510 if (s->codec_id == AV_CODEC_ID_RV10 &&
512 avctx->height&15 )) {
513 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
514 return AVERROR(EINVAL);
517 if (s->codec_id == AV_CODEC_ID_RV20 &&
520 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
521 return AVERROR(EINVAL);
524 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
525 s->codec_id == AV_CODEC_ID_WMV2) &&
527 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
531 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
532 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
533 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
537 // FIXME mpeg2 uses that too
538 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
539 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
540 av_log(avctx, AV_LOG_ERROR,
541 "mpeg2 style quantization not supported by codec\n");
545 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
546 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
550 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
551 s->avctx->mb_decision != FF_MB_DECISION_RD) {
552 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
556 if (s->avctx->scenechange_threshold < 1000000000 &&
557 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
558 av_log(avctx, AV_LOG_ERROR,
559 "closed gop with scene change detection are not supported yet, "
560 "set threshold to 1000000000\n");
564 if (s->flags & CODEC_FLAG_LOW_DELAY) {
565 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
566 av_log(avctx, AV_LOG_ERROR,
567 "low delay forcing is only available for mpeg2\n");
570 if (s->max_b_frames != 0) {
571 av_log(avctx, AV_LOG_ERROR,
572 "b frames cannot be used with low delay\n");
577 if (s->q_scale_type == 1) {
578 if (avctx->qmax > 12) {
579 av_log(avctx, AV_LOG_ERROR,
580 "non linear quant only supports qmax <= 12 currently\n");
585 if (s->avctx->thread_count > 1 &&
586 s->codec_id != AV_CODEC_ID_MPEG4 &&
587 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
588 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
589 s->codec_id != AV_CODEC_ID_MJPEG &&
590 (s->codec_id != AV_CODEC_ID_H263P)) {
591 av_log(avctx, AV_LOG_ERROR,
592 "multi threaded encoding not supported by codec\n");
596 if (s->avctx->thread_count < 1) {
597 av_log(avctx, AV_LOG_ERROR,
598 "automatic thread number detection not supported by codec, "
603 if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
606 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
607 s->h263_slice_structured = 1;
609 if (!avctx->time_base.den || !avctx->time_base.num) {
610 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
614 i = (INT_MAX / 2 + 128) >> 8;
615 if (avctx->mb_threshold >= i) {
616 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
621 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
622 av_log(avctx, AV_LOG_INFO,
623 "notice: b_frame_strategy only affects the first pass\n");
624 avctx->b_frame_strategy = 0;
627 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
629 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
630 avctx->time_base.den /= i;
631 avctx->time_base.num /= i;
635 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) {
636 // (a + x * 3 / 8) / x
637 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
638 s->inter_quant_bias = 0;
640 s->intra_quant_bias = 0;
642 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
645 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
646 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
647 return AVERROR(EINVAL);
650 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
651 s->intra_quant_bias = avctx->intra_quant_bias;
652 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
653 s->inter_quant_bias = avctx->inter_quant_bias;
655 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
657 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
659 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
660 s->avctx->time_base.den > (1 << 16) - 1) {
661 av_log(avctx, AV_LOG_ERROR,
662 "timebase %d/%d not supported by MPEG 4 standard, "
663 "the maximum admitted value for the timebase denominator "
664 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
668 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
670 switch (avctx->codec->id) {
671 case AV_CODEC_ID_MPEG1VIDEO:
672 s->out_format = FMT_MPEG1;
673 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
674 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
676 case AV_CODEC_ID_MPEG2VIDEO:
677 s->out_format = FMT_MPEG1;
678 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
679 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
682 case AV_CODEC_ID_LJPEG:
683 case AV_CODEC_ID_MJPEG:
684 case AV_CODEC_ID_AMV:
685 s->out_format = FMT_MJPEG;
686 s->intra_only = 1; /* force intra only for jpeg */
687 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
688 (avctx->pix_fmt == AV_PIX_FMT_BGR0
689 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
690 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
691 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
692 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
693 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
694 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
695 s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
696 s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
698 s->mjpeg_vsample[0] = 2;
699 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
700 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
701 s->mjpeg_hsample[0] = 2;
702 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
703 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
705 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
706 ff_mjpeg_encode_init(s) < 0)
711 case AV_CODEC_ID_H261:
712 if (!CONFIG_H261_ENCODER)
714 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
715 av_log(avctx, AV_LOG_ERROR,
716 "The specified picture size of %dx%d is not valid for the "
717 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
718 s->width, s->height);
721 s->out_format = FMT_H261;
725 case AV_CODEC_ID_H263:
726 if (!CONFIG_H263_ENCODER)
728 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
729 s->width, s->height) == 8) {
730 av_log(avctx, AV_LOG_ERROR,
731 "The specified picture size of %dx%d is not valid for "
732 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
733 "352x288, 704x576, and 1408x1152. "
734 "Try H.263+.\n", s->width, s->height);
737 s->out_format = FMT_H263;
741 case AV_CODEC_ID_H263P:
742 s->out_format = FMT_H263;
745 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
746 s->modified_quant = s->h263_aic;
747 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
748 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
751 /* These are just to be sure */
755 case AV_CODEC_ID_FLV1:
756 s->out_format = FMT_H263;
757 s->h263_flv = 2; /* format = 1; 11-bit codes */
758 s->unrestricted_mv = 1;
759 s->rtp_mode = 0; /* don't allow GOB */
763 case AV_CODEC_ID_RV10:
764 s->out_format = FMT_H263;
768 case AV_CODEC_ID_RV20:
769 s->out_format = FMT_H263;
772 s->modified_quant = 1;
776 s->unrestricted_mv = 0;
778 case AV_CODEC_ID_MPEG4:
779 s->out_format = FMT_H263;
781 s->unrestricted_mv = 1;
782 s->low_delay = s->max_b_frames ? 0 : 1;
783 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
785 case AV_CODEC_ID_MSMPEG4V2:
786 s->out_format = FMT_H263;
788 s->unrestricted_mv = 1;
789 s->msmpeg4_version = 2;
793 case AV_CODEC_ID_MSMPEG4V3:
794 s->out_format = FMT_H263;
796 s->unrestricted_mv = 1;
797 s->msmpeg4_version = 3;
798 s->flipflop_rounding = 1;
802 case AV_CODEC_ID_WMV1:
803 s->out_format = FMT_H263;
805 s->unrestricted_mv = 1;
806 s->msmpeg4_version = 4;
807 s->flipflop_rounding = 1;
811 case AV_CODEC_ID_WMV2:
812 s->out_format = FMT_H263;
814 s->unrestricted_mv = 1;
815 s->msmpeg4_version = 5;
816 s->flipflop_rounding = 1;
824 avctx->has_b_frames = !s->low_delay;
828 s->progressive_frame =
829 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
830 CODEC_FLAG_INTERLACED_ME) ||
834 if (ff_MPV_common_init(s) < 0)
837 ff_dct_encode_init(s);
839 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
840 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
842 s->quant_precision = 5;
844 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
845 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
847 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
848 ff_h261_encode_init(s);
849 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
850 ff_h263_encode_init(s);
851 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
852 ff_msmpeg4_encode_init(s);
853 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
854 && s->out_format == FMT_MPEG1)
855 ff_mpeg1_encode_init(s);
858 for (i = 0; i < 64; i++) {
859 int j = s->dsp.idct_permutation[i];
860 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
862 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
863 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
864 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
866 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
869 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
870 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
872 if (s->avctx->intra_matrix)
873 s->intra_matrix[j] = s->avctx->intra_matrix[i];
874 if (s->avctx->inter_matrix)
875 s->inter_matrix[j] = s->avctx->inter_matrix[i];
878 /* precompute matrix */
879 /* for mjpeg, we do include qscale in the matrix */
880 if (s->out_format != FMT_MJPEG) {
881 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
882 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
884 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
885 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
889 if (ff_rate_control_init(s) < 0)
892 #if FF_API_ERROR_RATE
893 FF_DISABLE_DEPRECATION_WARNINGS
894 if (avctx->error_rate)
895 s->error_rate = avctx->error_rate;
896 FF_ENABLE_DEPRECATION_WARNINGS;
899 if (avctx->b_frame_strategy == 2) {
900 for (i = 0; i < s->max_b_frames + 2; i++) {
901 s->tmp_frames[i] = av_frame_alloc();
902 if (!s->tmp_frames[i])
903 return AVERROR(ENOMEM);
905 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
906 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
907 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
909 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
918 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
920 MpegEncContext *s = avctx->priv_data;
923 ff_rate_control_uninit(s);
925 ff_MPV_common_end(s);
926 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
927 s->out_format == FMT_MJPEG)
928 ff_mjpeg_encode_close(s);
930 av_freep(&avctx->extradata);
932 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
933 av_frame_free(&s->tmp_frames[i]);
938 static int get_sae(uint8_t *src, int ref, int stride)
943 for (y = 0; y < 16; y++) {
944 for (x = 0; x < 16; x++) {
945 acc += FFABS(src[x + y * stride] - ref);
952 static int get_intra_count(MpegEncContext *s, uint8_t *src,
953 uint8_t *ref, int stride)
961 for (y = 0; y < h; y += 16) {
962 for (x = 0; x < w; x += 16) {
963 int offset = x + y * stride;
964 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
966 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
967 int sae = get_sae(src + offset, mean, stride);
969 acc += sae + 500 < sad;
976 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
980 int i, display_picture_number = 0, ret;
981 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
982 (s->low_delay ? 0 : 1);
987 display_picture_number = s->input_picture_number++;
989 if (pts != AV_NOPTS_VALUE) {
990 if (s->user_specified_pts != AV_NOPTS_VALUE) {
991 int64_t last = s->user_specified_pts;
994 av_log(s->avctx, AV_LOG_ERROR,
995 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
997 return AVERROR(EINVAL);
1000 if (!s->low_delay && display_picture_number == 1)
1001 s->dts_delta = pts - last;
1003 s->user_specified_pts = pts;
1005 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1006 s->user_specified_pts =
1007 pts = s->user_specified_pts + 1;
1008 av_log(s->avctx, AV_LOG_INFO,
1009 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1012 pts = display_picture_number;
1018 if (!pic_arg->buf[0])
1020 if (pic_arg->linesize[0] != s->linesize)
1022 if (pic_arg->linesize[1] != s->uvlinesize)
1024 if (pic_arg->linesize[2] != s->uvlinesize)
1027 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
1028 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1031 i = ff_find_unused_picture(s, 1);
1035 pic = &s->picture[i];
1038 if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
1040 if (ff_alloc_picture(s, pic, 1) < 0) {
1044 i = ff_find_unused_picture(s, 0);
1048 pic = &s->picture[i];
1051 if (ff_alloc_picture(s, pic, 0) < 0) {
1055 if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1056 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1057 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1060 int h_chroma_shift, v_chroma_shift;
1061 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1065 for (i = 0; i < 3; i++) {
1066 int src_stride = pic_arg->linesize[i];
1067 int dst_stride = i ? s->uvlinesize : s->linesize;
1068 int h_shift = i ? h_chroma_shift : 0;
1069 int v_shift = i ? v_chroma_shift : 0;
1070 int w = s->width >> h_shift;
1071 int h = s->height >> v_shift;
1072 uint8_t *src = pic_arg->data[i];
1073 uint8_t *dst = pic->f.data[i];
1075 if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1076 h = ((s->height + 15)/16*16) >> v_shift;
1079 if (!s->avctx->rc_buffer_size)
1080 dst += INPLACE_OFFSET;
1082 if (src_stride == dst_stride)
1083 memcpy(dst, src, src_stride * h);
1086 uint8_t *dst2 = dst;
1088 memcpy(dst2, src, w);
1093 if ((s->width & 15) || (s->height & 15)) {
1094 s->dsp.draw_edges(dst, dst_stride,
1103 ret = av_frame_copy_props(&pic->f, pic_arg);
1107 pic->f.display_picture_number = display_picture_number;
1108 pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
1111 /* shift buffer entries */
1112 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1113 s->input_picture[i - 1] = s->input_picture[i];
1115 s->input_picture[encoding_delay] = (Picture*) pic;
1120 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1124 int64_t score64 = 0;
1126 for (plane = 0; plane < 3; plane++) {
1127 const int stride = p->f.linesize[plane];
1128 const int bw = plane ? 1 : 2;
1129 for (y = 0; y < s->mb_height * bw; y++) {
1130 for (x = 0; x < s->mb_width * bw; x++) {
1131 int off = p->shared ? 0 : 16;
1132 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1133 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1134 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1136 switch (s->avctx->frame_skip_exp) {
1137 case 0: score = FFMAX(score, v); break;
1138 case 1: score += FFABS(v); break;
1139 case 2: score += v * v; break;
1140 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1141 case 4: score64 += v * v * (int64_t)(v * v); break;
1150 if (score64 < s->avctx->frame_skip_threshold)
1152 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1157 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1159 AVPacket pkt = { 0 };
1160 int ret, got_output;
1162 av_init_packet(&pkt);
1163 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1168 av_free_packet(&pkt);
1172 static int estimate_best_b_count(MpegEncContext *s)
1174 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1175 AVCodecContext *c = avcodec_alloc_context3(NULL);
1176 const int scale = s->avctx->brd_scale;
1177 int i, j, out_size, p_lambda, b_lambda, lambda2;
1178 int64_t best_rd = INT64_MAX;
1179 int best_b_count = -1;
1181 av_assert0(scale >= 0 && scale <= 3);
1184 //s->next_picture_ptr->quality;
1185 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1186 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1187 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1188 if (!b_lambda) // FIXME we should do this somewhere else
1189 b_lambda = p_lambda;
1190 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1193 c->width = s->width >> scale;
1194 c->height = s->height >> scale;
1195 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1196 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1197 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1198 c->mb_decision = s->avctx->mb_decision;
1199 c->me_cmp = s->avctx->me_cmp;
1200 c->mb_cmp = s->avctx->mb_cmp;
1201 c->me_sub_cmp = s->avctx->me_sub_cmp;
1202 c->pix_fmt = AV_PIX_FMT_YUV420P;
1203 c->time_base = s->avctx->time_base;
1204 c->max_b_frames = s->max_b_frames;
1206 if (avcodec_open2(c, codec, NULL) < 0)
1209 for (i = 0; i < s->max_b_frames + 2; i++) {
1210 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1211 s->next_picture_ptr;
1213 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1214 pre_input = *pre_input_ptr;
1216 if (!pre_input.shared && i) {
1217 pre_input.f.data[0] += INPLACE_OFFSET;
1218 pre_input.f.data[1] += INPLACE_OFFSET;
1219 pre_input.f.data[2] += INPLACE_OFFSET;
1222 s->dsp.shrink[scale](s->tmp_frames[i]->data[0], s->tmp_frames[i]->linesize[0],
1223 pre_input.f.data[0], pre_input.f.linesize[0],
1224 c->width, c->height);
1225 s->dsp.shrink[scale](s->tmp_frames[i]->data[1], s->tmp_frames[i]->linesize[1],
1226 pre_input.f.data[1], pre_input.f.linesize[1],
1227 c->width >> 1, c->height >> 1);
1228 s->dsp.shrink[scale](s->tmp_frames[i]->data[2], s->tmp_frames[i]->linesize[2],
1229 pre_input.f.data[2], pre_input.f.linesize[2],
1230 c->width >> 1, c->height >> 1);
1234 for (j = 0; j < s->max_b_frames + 1; j++) {
1237 if (!s->input_picture[j])
1240 c->error[0] = c->error[1] = c->error[2] = 0;
1242 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1243 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1245 out_size = encode_frame(c, s->tmp_frames[0]);
1247 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1249 for (i = 0; i < s->max_b_frames + 1; i++) {
1250 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1252 s->tmp_frames[i + 1]->pict_type = is_p ?
1253 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1254 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1256 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1258 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1261 /* get the delayed frames */
1263 out_size = encode_frame(c, NULL);
1264 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1267 rd += c->error[0] + c->error[1] + c->error[2];
1278 return best_b_count;
1281 static int select_input_picture(MpegEncContext *s)
1285 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1286 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1287 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1289 /* set next picture type & ordering */
1290 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1291 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1292 s->next_picture_ptr == NULL || s->intra_only) {
1293 s->reordered_input_picture[0] = s->input_picture[0];
1294 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1295 s->reordered_input_picture[0]->f.coded_picture_number =
1296 s->coded_picture_number++;
1300 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1301 if (s->picture_in_gop_number < s->gop_size &&
1302 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1303 // FIXME check that te gop check above is +-1 correct
1304 av_frame_unref(&s->input_picture[0]->f);
1307 ff_vbv_update(s, 0);
1313 if (s->flags & CODEC_FLAG_PASS2) {
1314 for (i = 0; i < s->max_b_frames + 1; i++) {
1315 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1317 if (pict_num >= s->rc_context.num_entries)
1319 if (!s->input_picture[i]) {
1320 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1324 s->input_picture[i]->f.pict_type =
1325 s->rc_context.entry[pict_num].new_pict_type;
1329 if (s->avctx->b_frame_strategy == 0) {
1330 b_frames = s->max_b_frames;
1331 while (b_frames && !s->input_picture[b_frames])
1333 } else if (s->avctx->b_frame_strategy == 1) {
1334 for (i = 1; i < s->max_b_frames + 1; i++) {
1335 if (s->input_picture[i] &&
1336 s->input_picture[i]->b_frame_score == 0) {
1337 s->input_picture[i]->b_frame_score =
1339 s->input_picture[i ]->f.data[0],
1340 s->input_picture[i - 1]->f.data[0],
1344 for (i = 0; i < s->max_b_frames + 1; i++) {
1345 if (s->input_picture[i] == NULL ||
1346 s->input_picture[i]->b_frame_score - 1 >
1347 s->mb_num / s->avctx->b_sensitivity)
1351 b_frames = FFMAX(0, i - 1);
1354 for (i = 0; i < b_frames + 1; i++) {
1355 s->input_picture[i]->b_frame_score = 0;
1357 } else if (s->avctx->b_frame_strategy == 2) {
1358 b_frames = estimate_best_b_count(s);
1360 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1366 for (i = b_frames - 1; i >= 0; i--) {
1367 int type = s->input_picture[i]->f.pict_type;
1368 if (type && type != AV_PICTURE_TYPE_B)
1371 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1372 b_frames == s->max_b_frames) {
1373 av_log(s->avctx, AV_LOG_ERROR,
1374 "warning, too many b frames in a row\n");
1377 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1378 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1379 s->gop_size > s->picture_in_gop_number) {
1380 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1382 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1384 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1388 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1389 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1392 s->reordered_input_picture[0] = s->input_picture[b_frames];
1393 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1394 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1395 s->reordered_input_picture[0]->f.coded_picture_number =
1396 s->coded_picture_number++;
1397 for (i = 0; i < b_frames; i++) {
1398 s->reordered_input_picture[i + 1] = s->input_picture[i];
1399 s->reordered_input_picture[i + 1]->f.pict_type =
1401 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1402 s->coded_picture_number++;
1407 if (s->reordered_input_picture[0]) {
1408 s->reordered_input_picture[0]->reference =
1409 s->reordered_input_picture[0]->f.pict_type !=
1410 AV_PICTURE_TYPE_B ? 3 : 0;
1412 ff_mpeg_unref_picture(s, &s->new_picture);
1413 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1416 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1417 // input is a shared pix, so we can't modifiy it -> alloc a new
1418 // one & ensure that the shared one is reuseable
1421 int i = ff_find_unused_picture(s, 0);
1424 pic = &s->picture[i];
1426 pic->reference = s->reordered_input_picture[0]->reference;
1427 if (ff_alloc_picture(s, pic, 0) < 0) {
1431 ret = av_frame_copy_props(&pic->f, &s->reordered_input_picture[0]->f);
1435 /* mark us unused / free shared pic */
1436 av_frame_unref(&s->reordered_input_picture[0]->f);
1437 s->reordered_input_picture[0]->shared = 0;
1439 s->current_picture_ptr = pic;
1441 // input is not a shared pix -> reuse buffer for current_pix
1442 s->current_picture_ptr = s->reordered_input_picture[0];
1443 for (i = 0; i < 4; i++) {
1444 s->new_picture.f.data[i] += INPLACE_OFFSET;
1447 ff_mpeg_unref_picture(s, &s->current_picture);
1448 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1449 s->current_picture_ptr)) < 0)
1452 s->picture_number = s->new_picture.f.display_picture_number;
1454 ff_mpeg_unref_picture(s, &s->new_picture);
1459 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1460 AVFrame *pic_arg, int *got_packet)
1462 MpegEncContext *s = avctx->priv_data;
1463 int i, stuffing_count, ret;
1464 int context_count = s->slice_context_count;
1466 s->picture_in_gop_number++;
1468 if (load_input_picture(s, pic_arg) < 0)
1471 if (select_input_picture(s) < 0) {
1476 if (s->new_picture.f.data[0]) {
1477 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1480 s->mb_info_ptr = av_packet_new_side_data(pkt,
1481 AV_PKT_DATA_H263_MB_INFO,
1482 s->mb_width*s->mb_height*12);
1483 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1486 for (i = 0; i < context_count; i++) {
1487 int start_y = s->thread_context[i]->start_mb_y;
1488 int end_y = s->thread_context[i]-> end_mb_y;
1489 int h = s->mb_height;
1490 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1491 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1493 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1496 s->pict_type = s->new_picture.f.pict_type;
1498 if (ff_MPV_frame_start(s, avctx) < 0)
1501 if (encode_picture(s, s->picture_number) < 0)
1504 avctx->header_bits = s->header_bits;
1505 avctx->mv_bits = s->mv_bits;
1506 avctx->misc_bits = s->misc_bits;
1507 avctx->i_tex_bits = s->i_tex_bits;
1508 avctx->p_tex_bits = s->p_tex_bits;
1509 avctx->i_count = s->i_count;
1510 // FIXME f/b_count in avctx
1511 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1512 avctx->skip_count = s->skip_count;
1514 ff_MPV_frame_end(s);
1516 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1517 ff_mjpeg_encode_picture_trailer(s);
1519 if (avctx->rc_buffer_size) {
1520 RateControlContext *rcc = &s->rc_context;
1521 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1523 if (put_bits_count(&s->pb) > max_size &&
1524 s->lambda < s->avctx->lmax) {
1525 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1526 (s->qscale + 1) / s->qscale);
1527 if (s->adaptive_quant) {
1529 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1530 s->lambda_table[i] =
1531 FFMAX(s->lambda_table[i] + 1,
1532 s->lambda_table[i] * (s->qscale + 1) /
1535 s->mb_skipped = 0; // done in MPV_frame_start()
1536 // done in encode_picture() so we must undo it
1537 if (s->pict_type == AV_PICTURE_TYPE_P) {
1538 if (s->flipflop_rounding ||
1539 s->codec_id == AV_CODEC_ID_H263P ||
1540 s->codec_id == AV_CODEC_ID_MPEG4)
1541 s->no_rounding ^= 1;
1543 if (s->pict_type != AV_PICTURE_TYPE_B) {
1544 s->time_base = s->last_time_base;
1545 s->last_non_b_time = s->time - s->pp_time;
1547 for (i = 0; i < context_count; i++) {
1548 PutBitContext *pb = &s->thread_context[i]->pb;
1549 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1554 assert(s->avctx->rc_max_rate);
1557 if (s->flags & CODEC_FLAG_PASS1)
1558 ff_write_pass1_stats(s);
1560 for (i = 0; i < 4; i++) {
1561 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1562 avctx->error[i] += s->current_picture_ptr->f.error[i];
1565 if (s->flags & CODEC_FLAG_PASS1)
1566 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1567 avctx->i_tex_bits + avctx->p_tex_bits ==
1568 put_bits_count(&s->pb));
1569 flush_put_bits(&s->pb);
1570 s->frame_bits = put_bits_count(&s->pb);
1572 stuffing_count = ff_vbv_update(s, s->frame_bits);
1573 s->stuffing_bits = 8*stuffing_count;
1574 if (stuffing_count) {
1575 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1576 stuffing_count + 50) {
1577 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1581 switch (s->codec_id) {
1582 case AV_CODEC_ID_MPEG1VIDEO:
1583 case AV_CODEC_ID_MPEG2VIDEO:
1584 while (stuffing_count--) {
1585 put_bits(&s->pb, 8, 0);
1588 case AV_CODEC_ID_MPEG4:
1589 put_bits(&s->pb, 16, 0);
1590 put_bits(&s->pb, 16, 0x1C3);
1591 stuffing_count -= 4;
1592 while (stuffing_count--) {
1593 put_bits(&s->pb, 8, 0xFF);
1597 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1599 flush_put_bits(&s->pb);
1600 s->frame_bits = put_bits_count(&s->pb);
1603 /* update mpeg1/2 vbv_delay for CBR */
1604 if (s->avctx->rc_max_rate &&
1605 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1606 s->out_format == FMT_MPEG1 &&
1607 90000LL * (avctx->rc_buffer_size - 1) <=
1608 s->avctx->rc_max_rate * 0xFFFFLL) {
1609 int vbv_delay, min_delay;
1610 double inbits = s->avctx->rc_max_rate *
1611 av_q2d(s->avctx->time_base);
1612 int minbits = s->frame_bits - 8 *
1613 (s->vbv_delay_ptr - s->pb.buf - 1);
1614 double bits = s->rc_context.buffer_index + minbits - inbits;
1617 av_log(s->avctx, AV_LOG_ERROR,
1618 "Internal error, negative bits\n");
1620 assert(s->repeat_first_field == 0);
1622 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1623 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1624 s->avctx->rc_max_rate;
1626 vbv_delay = FFMAX(vbv_delay, min_delay);
1628 av_assert0(vbv_delay < 0xFFFF);
1630 s->vbv_delay_ptr[0] &= 0xF8;
1631 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1632 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1633 s->vbv_delay_ptr[2] &= 0x07;
1634 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1635 avctx->vbv_delay = vbv_delay * 300;
1637 s->total_bits += s->frame_bits;
1638 avctx->frame_bits = s->frame_bits;
1640 pkt->pts = s->current_picture.f.pts;
1641 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1642 if (!s->current_picture.f.coded_picture_number)
1643 pkt->dts = pkt->pts - s->dts_delta;
1645 pkt->dts = s->reordered_pts;
1646 s->reordered_pts = pkt->pts;
1648 pkt->dts = pkt->pts;
1649 if (s->current_picture.f.key_frame)
1650 pkt->flags |= AV_PKT_FLAG_KEY;
1652 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1657 /* release non-reference frames */
1658 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1659 if (!s->picture[i].reference)
1660 ff_mpeg_unref_picture(s, &s->picture[i]);
1663 assert((s->frame_bits & 7) == 0);
1665 pkt->size = s->frame_bits / 8;
1666 *got_packet = !!pkt->size;
1670 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1671 int n, int threshold)
1673 static const char tab[64] = {
1674 3, 2, 2, 1, 1, 1, 1, 1,
1675 1, 1, 1, 1, 1, 1, 1, 1,
1676 1, 1, 1, 1, 1, 1, 1, 1,
1677 0, 0, 0, 0, 0, 0, 0, 0,
1678 0, 0, 0, 0, 0, 0, 0, 0,
1679 0, 0, 0, 0, 0, 0, 0, 0,
1680 0, 0, 0, 0, 0, 0, 0, 0,
1681 0, 0, 0, 0, 0, 0, 0, 0
1686 int16_t *block = s->block[n];
1687 const int last_index = s->block_last_index[n];
1690 if (threshold < 0) {
1692 threshold = -threshold;
1696 /* Are all we could set to zero already zero? */
1697 if (last_index <= skip_dc - 1)
1700 for (i = 0; i <= last_index; i++) {
1701 const int j = s->intra_scantable.permutated[i];
1702 const int level = FFABS(block[j]);
1704 if (skip_dc && i == 0)
1708 } else if (level > 1) {
1714 if (score >= threshold)
1716 for (i = skip_dc; i <= last_index; i++) {
1717 const int j = s->intra_scantable.permutated[i];
1721 s->block_last_index[n] = 0;
1723 s->block_last_index[n] = -1;
1726 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1730 const int maxlevel = s->max_qcoeff;
1731 const int minlevel = s->min_qcoeff;
1735 i = 1; // skip clipping of intra dc
1739 for (; i <= last_index; i++) {
1740 const int j = s->intra_scantable.permutated[i];
1741 int level = block[j];
1743 if (level > maxlevel) {
1746 } else if (level < minlevel) {
1754 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1755 av_log(s->avctx, AV_LOG_INFO,
1756 "warning, clipping %d dct coefficients to %d..%d\n",
1757 overflow, minlevel, maxlevel);
1760 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1764 for (y = 0; y < 8; y++) {
1765 for (x = 0; x < 8; x++) {
1771 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1772 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1773 int v = ptr[x2 + y2 * stride];
1779 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1784 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1785 int motion_x, int motion_y,
1786 int mb_block_height,
1790 int16_t weight[12][64];
1791 int16_t orig[12][64];
1792 const int mb_x = s->mb_x;
1793 const int mb_y = s->mb_y;
1796 int dct_offset = s->linesize * 8; // default for progressive frames
1797 int uv_dct_offset = s->uvlinesize * 8;
1798 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1799 ptrdiff_t wrap_y, wrap_c;
1801 for (i = 0; i < mb_block_count; i++)
1802 skip_dct[i] = s->skipdct;
1804 if (s->adaptive_quant) {
1805 const int last_qp = s->qscale;
1806 const int mb_xy = mb_x + mb_y * s->mb_stride;
1808 s->lambda = s->lambda_table[mb_xy];
1811 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1812 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1813 s->dquant = s->qscale - last_qp;
1815 if (s->out_format == FMT_H263) {
1816 s->dquant = av_clip(s->dquant, -2, 2);
1818 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1820 if (s->pict_type == AV_PICTURE_TYPE_B) {
1821 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1824 if (s->mv_type == MV_TYPE_8X8)
1830 ff_set_qscale(s, last_qp + s->dquant);
1831 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1832 ff_set_qscale(s, s->qscale + s->dquant);
1834 wrap_y = s->linesize;
1835 wrap_c = s->uvlinesize;
1836 ptr_y = s->new_picture.f.data[0] +
1837 (mb_y * 16 * wrap_y) + mb_x * 16;
1838 ptr_cb = s->new_picture.f.data[1] +
1839 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1840 ptr_cr = s->new_picture.f.data[2] +
1841 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1843 if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1844 uint8_t *ebuf = s->edge_emu_buffer + 32;
1845 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1846 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1847 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1849 16, 16, mb_x * 16, mb_y * 16,
1850 s->width, s->height);
1852 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1854 mb_block_width, mb_block_height,
1855 mb_x * mb_block_width, mb_y * mb_block_height,
1857 ptr_cb = ebuf + 18 * wrap_y;
1858 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr,
1860 mb_block_width, mb_block_height,
1861 mb_x * mb_block_width, mb_y * mb_block_height,
1863 ptr_cr = ebuf + 18 * wrap_y + 16;
1867 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1868 int progressive_score, interlaced_score;
1870 s->interlaced_dct = 0;
1871 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1873 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1874 NULL, wrap_y, 8) - 400;
1876 if (progressive_score > 0) {
1877 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1878 NULL, wrap_y * 2, 8) +
1879 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1880 NULL, wrap_y * 2, 8);
1881 if (progressive_score > interlaced_score) {
1882 s->interlaced_dct = 1;
1884 dct_offset = wrap_y;
1885 uv_dct_offset = wrap_c;
1887 if (s->chroma_format == CHROMA_422 ||
1888 s->chroma_format == CHROMA_444)
1894 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1895 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1896 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1897 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1899 if (s->flags & CODEC_FLAG_GRAY) {
1903 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1904 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1905 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1906 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1907 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1908 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1909 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1910 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1911 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1912 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1913 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1914 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1918 op_pixels_func (*op_pix)[4];
1919 qpel_mc_func (*op_qpix)[16];
1920 uint8_t *dest_y, *dest_cb, *dest_cr;
1922 dest_y = s->dest[0];
1923 dest_cb = s->dest[1];
1924 dest_cr = s->dest[2];
1926 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1927 op_pix = s->hdsp.put_pixels_tab;
1928 op_qpix = s->dsp.put_qpel_pixels_tab;
1930 op_pix = s->hdsp.put_no_rnd_pixels_tab;
1931 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1934 if (s->mv_dir & MV_DIR_FORWARD) {
1935 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1936 s->last_picture.f.data,
1938 op_pix = s->hdsp.avg_pixels_tab;
1939 op_qpix = s->dsp.avg_qpel_pixels_tab;
1941 if (s->mv_dir & MV_DIR_BACKWARD) {
1942 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1943 s->next_picture.f.data,
1947 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1948 int progressive_score, interlaced_score;
1950 s->interlaced_dct = 0;
1951 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1954 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1955 ptr_y + wrap_y * 8, wrap_y,
1958 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1959 progressive_score -= 400;
1961 if (progressive_score > 0) {
1962 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1965 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1969 if (progressive_score > interlaced_score) {
1970 s->interlaced_dct = 1;
1972 dct_offset = wrap_y;
1973 uv_dct_offset = wrap_c;
1975 if (s->chroma_format == CHROMA_422)
1981 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1982 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1983 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1984 dest_y + dct_offset, wrap_y);
1985 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1986 dest_y + dct_offset + 8, wrap_y);
1988 if (s->flags & CODEC_FLAG_GRAY) {
1992 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1993 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1994 if (!s->chroma_y_shift) { /* 422 */
1995 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
1996 dest_cb + uv_dct_offset, wrap_c);
1997 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
1998 dest_cr + uv_dct_offset, wrap_c);
2001 /* pre quantization */
2002 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2003 2 * s->qscale * s->qscale) {
2005 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
2006 wrap_y, 8) < 20 * s->qscale)
2008 if (s->dsp.sad[1](NULL, ptr_y + 8,
2009 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2011 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
2012 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
2014 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
2015 dest_y + dct_offset + 8,
2016 wrap_y, 8) < 20 * s->qscale)
2018 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2019 wrap_c, 8) < 20 * s->qscale)
2021 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2022 wrap_c, 8) < 20 * s->qscale)
2024 if (!s->chroma_y_shift) { /* 422 */
2025 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
2026 dest_cb + uv_dct_offset,
2027 wrap_c, 8) < 20 * s->qscale)
2029 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
2030 dest_cr + uv_dct_offset,
2031 wrap_c, 8) < 20 * s->qscale)
2037 if (s->quantizer_noise_shaping) {
2039 get_visual_weight(weight[0], ptr_y , wrap_y);
2041 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2043 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2045 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2047 get_visual_weight(weight[4], ptr_cb , wrap_c);
2049 get_visual_weight(weight[5], ptr_cr , wrap_c);
2050 if (!s->chroma_y_shift) { /* 422 */
2052 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2055 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2058 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2061 /* DCT & quantize */
2062 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2064 for (i = 0; i < mb_block_count; i++) {
2067 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2068 // FIXME we could decide to change to quantizer instead of
2070 // JS: I don't think that would be a good idea it could lower
2071 // quality instead of improve it. Just INTRADC clipping
2072 // deserves changes in quantizer
2074 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2076 s->block_last_index[i] = -1;
2078 if (s->quantizer_noise_shaping) {
2079 for (i = 0; i < mb_block_count; i++) {
2081 s->block_last_index[i] =
2082 dct_quantize_refine(s, s->block[i], weight[i],
2083 orig[i], i, s->qscale);
2088 if (s->luma_elim_threshold && !s->mb_intra)
2089 for (i = 0; i < 4; i++)
2090 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2091 if (s->chroma_elim_threshold && !s->mb_intra)
2092 for (i = 4; i < mb_block_count; i++)
2093 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2095 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2096 for (i = 0; i < mb_block_count; i++) {
2097 if (s->block_last_index[i] == -1)
2098 s->coded_score[i] = INT_MAX / 256;
2103 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2104 s->block_last_index[4] =
2105 s->block_last_index[5] = 0;
2107 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2108 if (!s->chroma_y_shift) { /* 422 / 444 */
2109 for (i=6; i<12; i++) {
2110 s->block_last_index[i] = 0;
2111 s->block[i][0] = s->block[4][0];
2116 // non c quantize code returns incorrect block_last_index FIXME
2117 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2118 for (i = 0; i < mb_block_count; i++) {
2120 if (s->block_last_index[i] > 0) {
2121 for (j = 63; j > 0; j--) {
2122 if (s->block[i][s->intra_scantable.permutated[j]])
2125 s->block_last_index[i] = j;
2130 /* huffman encode */
2131 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2132 case AV_CODEC_ID_MPEG1VIDEO:
2133 case AV_CODEC_ID_MPEG2VIDEO:
2134 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2135 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2137 case AV_CODEC_ID_MPEG4:
2138 if (CONFIG_MPEG4_ENCODER)
2139 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2141 case AV_CODEC_ID_MSMPEG4V2:
2142 case AV_CODEC_ID_MSMPEG4V3:
2143 case AV_CODEC_ID_WMV1:
2144 if (CONFIG_MSMPEG4_ENCODER)
2145 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2147 case AV_CODEC_ID_WMV2:
2148 if (CONFIG_WMV2_ENCODER)
2149 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2151 case AV_CODEC_ID_H261:
2152 if (CONFIG_H261_ENCODER)
2153 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2155 case AV_CODEC_ID_H263:
2156 case AV_CODEC_ID_H263P:
2157 case AV_CODEC_ID_FLV1:
2158 case AV_CODEC_ID_RV10:
2159 case AV_CODEC_ID_RV20:
2160 if (CONFIG_H263_ENCODER)
2161 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2163 case AV_CODEC_ID_MJPEG:
2164 case AV_CODEC_ID_AMV:
2165 if (CONFIG_MJPEG_ENCODER)
2166 ff_mjpeg_encode_mb(s, s->block);
2173 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2175 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2176 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2177 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2180 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2183 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2186 d->mb_skip_run= s->mb_skip_run;
2188 d->last_dc[i] = s->last_dc[i];
2191 d->mv_bits= s->mv_bits;
2192 d->i_tex_bits= s->i_tex_bits;
2193 d->p_tex_bits= s->p_tex_bits;
2194 d->i_count= s->i_count;
2195 d->f_count= s->f_count;
2196 d->b_count= s->b_count;
2197 d->skip_count= s->skip_count;
2198 d->misc_bits= s->misc_bits;
2202 d->qscale= s->qscale;
2203 d->dquant= s->dquant;
2205 d->esc3_level_length= s->esc3_level_length;
2208 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2211 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2212 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2215 d->mb_skip_run= s->mb_skip_run;
2217 d->last_dc[i] = s->last_dc[i];
2220 d->mv_bits= s->mv_bits;
2221 d->i_tex_bits= s->i_tex_bits;
2222 d->p_tex_bits= s->p_tex_bits;
2223 d->i_count= s->i_count;
2224 d->f_count= s->f_count;
2225 d->b_count= s->b_count;
2226 d->skip_count= s->skip_count;
2227 d->misc_bits= s->misc_bits;
2229 d->mb_intra= s->mb_intra;
2230 d->mb_skipped= s->mb_skipped;
2231 d->mv_type= s->mv_type;
2232 d->mv_dir= s->mv_dir;
2234 if(s->data_partitioning){
2236 d->tex_pb= s->tex_pb;
2240 d->block_last_index[i]= s->block_last_index[i];
2241 d->interlaced_dct= s->interlaced_dct;
2242 d->qscale= s->qscale;
2244 d->esc3_level_length= s->esc3_level_length;
2247 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2248 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2249 int *dmin, int *next_block, int motion_x, int motion_y)
2252 uint8_t *dest_backup[3];
2254 copy_context_before_encode(s, backup, type);
2256 s->block= s->blocks[*next_block];
2257 s->pb= pb[*next_block];
2258 if(s->data_partitioning){
2259 s->pb2 = pb2 [*next_block];
2260 s->tex_pb= tex_pb[*next_block];
2264 memcpy(dest_backup, s->dest, sizeof(s->dest));
2265 s->dest[0] = s->rd_scratchpad;
2266 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2267 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2268 assert(s->linesize >= 32); //FIXME
2271 encode_mb(s, motion_x, motion_y);
2273 score= put_bits_count(&s->pb);
2274 if(s->data_partitioning){
2275 score+= put_bits_count(&s->pb2);
2276 score+= put_bits_count(&s->tex_pb);
2279 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2280 ff_MPV_decode_mb(s, s->block);
2282 score *= s->lambda2;
2283 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2287 memcpy(s->dest, dest_backup, sizeof(s->dest));
2294 copy_context_after_encode(best, s, type);
2298 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2299 uint32_t *sq = ff_squareTbl + 256;
2304 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2305 else if(w==8 && h==8)
2306 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2310 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2319 static int sse_mb(MpegEncContext *s){
2323 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2324 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2327 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2328 return s->dsp.nsse[0](s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
2329 +s->dsp.nsse[1](s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
2330 +s->dsp.nsse[1](s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2332 return s->dsp.sse[0](NULL, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
2333 +s->dsp.sse[1](NULL, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
2334 +s->dsp.sse[1](NULL, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2337 return sse(s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
2338 +sse(s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
2339 +sse(s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
2342 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2343 MpegEncContext *s= *(void**)arg;
2347 s->me.dia_size= s->avctx->pre_dia_size;
2348 s->first_slice_line=1;
2349 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2350 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2351 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2353 s->first_slice_line=0;
2361 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2362 MpegEncContext *s= *(void**)arg;
2364 ff_check_alignment();
2366 s->me.dia_size= s->avctx->dia_size;
2367 s->first_slice_line=1;
2368 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2369 s->mb_x=0; //for block init below
2370 ff_init_block_index(s);
2371 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2372 s->block_index[0]+=2;
2373 s->block_index[1]+=2;
2374 s->block_index[2]+=2;
2375 s->block_index[3]+=2;
2377 /* compute motion vector & mb_type and store in context */
2378 if(s->pict_type==AV_PICTURE_TYPE_B)
2379 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2381 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2383 s->first_slice_line=0;
2388 static int mb_var_thread(AVCodecContext *c, void *arg){
2389 MpegEncContext *s= *(void**)arg;
2392 ff_check_alignment();
2394 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2395 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2398 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2400 int sum = s->dsp.pix_sum(pix, s->linesize);
2402 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2404 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2405 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2406 s->me.mb_var_sum_temp += varc;
2412 static void write_slice_end(MpegEncContext *s){
2413 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2414 if(s->partitioned_frame){
2415 ff_mpeg4_merge_partitions(s);
2418 ff_mpeg4_stuffing(&s->pb);
2419 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2420 ff_mjpeg_encode_stuffing(s);
2423 avpriv_align_put_bits(&s->pb);
2424 flush_put_bits(&s->pb);
2426 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2427 s->misc_bits+= get_bits_diff(s);
2430 static void write_mb_info(MpegEncContext *s)
2432 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2433 int offset = put_bits_count(&s->pb);
2434 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2435 int gobn = s->mb_y / s->gob_index;
2437 if (CONFIG_H263_ENCODER)
2438 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2439 bytestream_put_le32(&ptr, offset);
2440 bytestream_put_byte(&ptr, s->qscale);
2441 bytestream_put_byte(&ptr, gobn);
2442 bytestream_put_le16(&ptr, mba);
2443 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2444 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2445 /* 4MV not implemented */
2446 bytestream_put_byte(&ptr, 0); /* hmv2 */
2447 bytestream_put_byte(&ptr, 0); /* vmv2 */
2450 static void update_mb_info(MpegEncContext *s, int startcode)
2454 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2455 s->mb_info_size += 12;
2456 s->prev_mb_info = s->last_mb_info;
2459 s->prev_mb_info = put_bits_count(&s->pb)/8;
2460 /* This might have incremented mb_info_size above, and we return without
2461 * actually writing any info into that slot yet. But in that case,
2462 * this will be called again at the start of the after writing the
2463 * start code, actually writing the mb info. */
2467 s->last_mb_info = put_bits_count(&s->pb)/8;
2468 if (!s->mb_info_size)
2469 s->mb_info_size += 12;
2473 static int encode_thread(AVCodecContext *c, void *arg){
2474 MpegEncContext *s= *(void**)arg;
2475 int mb_x, mb_y, pdif = 0;
2476 int chr_h= 16>>s->chroma_y_shift;
2478 MpegEncContext best_s, backup_s;
2479 uint8_t bit_buf[2][MAX_MB_BYTES];
2480 uint8_t bit_buf2[2][MAX_MB_BYTES];
2481 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2482 PutBitContext pb[2], pb2[2], tex_pb[2];
2484 ff_check_alignment();
2487 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2488 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2489 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2492 s->last_bits= put_bits_count(&s->pb);
2503 /* init last dc values */
2504 /* note: quant matrix value (8) is implied here */
2505 s->last_dc[i] = 128 << s->intra_dc_precision;
2507 s->current_picture.f.error[i] = 0;
2509 if(s->codec_id==AV_CODEC_ID_AMV){
2510 s->last_dc[0] = 128*8/13;
2511 s->last_dc[1] = 128*8/14;
2512 s->last_dc[2] = 128*8/14;
2515 memset(s->last_mv, 0, sizeof(s->last_mv));
2519 switch(s->codec_id){
2520 case AV_CODEC_ID_H263:
2521 case AV_CODEC_ID_H263P:
2522 case AV_CODEC_ID_FLV1:
2523 if (CONFIG_H263_ENCODER)
2524 s->gob_index = ff_h263_get_gob_height(s);
2526 case AV_CODEC_ID_MPEG4:
2527 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2528 ff_mpeg4_init_partitions(s);
2534 s->first_slice_line = 1;
2535 s->ptr_lastgob = s->pb.buf;
2536 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2540 ff_set_qscale(s, s->qscale);
2541 ff_init_block_index(s);
2543 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2544 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2545 int mb_type= s->mb_type[xy];
2550 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2551 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2554 if(s->data_partitioning){
2555 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2556 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2557 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2563 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2564 ff_update_block_index(s);
2566 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2567 ff_h261_reorder_mb_index(s);
2568 xy= s->mb_y*s->mb_stride + s->mb_x;
2569 mb_type= s->mb_type[xy];
2572 /* write gob / video packet header */
2574 int current_packet_size, is_gob_start;
2576 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2578 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2580 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2582 switch(s->codec_id){
2583 case AV_CODEC_ID_H263:
2584 case AV_CODEC_ID_H263P:
2585 if(!s->h263_slice_structured)
2586 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2588 case AV_CODEC_ID_MPEG2VIDEO:
2589 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2590 case AV_CODEC_ID_MPEG1VIDEO:
2591 if(s->mb_skip_run) is_gob_start=0;
2593 case AV_CODEC_ID_MJPEG:
2594 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2599 if(s->start_mb_y != mb_y || mb_x!=0){
2602 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2603 ff_mpeg4_init_partitions(s);
2607 av_assert2((put_bits_count(&s->pb)&7) == 0);
2608 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2610 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2611 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2612 int d = 100 / s->error_rate;
2614 current_packet_size=0;
2615 s->pb.buf_ptr= s->ptr_lastgob;
2616 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2620 if (s->avctx->rtp_callback){
2621 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2622 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2624 update_mb_info(s, 1);
2626 switch(s->codec_id){
2627 case AV_CODEC_ID_MPEG4:
2628 if (CONFIG_MPEG4_ENCODER) {
2629 ff_mpeg4_encode_video_packet_header(s);
2630 ff_mpeg4_clean_buffers(s);
2633 case AV_CODEC_ID_MPEG1VIDEO:
2634 case AV_CODEC_ID_MPEG2VIDEO:
2635 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2636 ff_mpeg1_encode_slice_header(s);
2637 ff_mpeg1_clean_buffers(s);
2640 case AV_CODEC_ID_H263:
2641 case AV_CODEC_ID_H263P:
2642 if (CONFIG_H263_ENCODER)
2643 ff_h263_encode_gob_header(s, mb_y);
2647 if(s->flags&CODEC_FLAG_PASS1){
2648 int bits= put_bits_count(&s->pb);
2649 s->misc_bits+= bits - s->last_bits;
2653 s->ptr_lastgob += current_packet_size;
2654 s->first_slice_line=1;
2655 s->resync_mb_x=mb_x;
2656 s->resync_mb_y=mb_y;
2660 if( (s->resync_mb_x == s->mb_x)
2661 && s->resync_mb_y+1 == s->mb_y){
2662 s->first_slice_line=0;
2666 s->dquant=0; //only for QP_RD
2668 update_mb_info(s, 0);
2670 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
2672 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2674 copy_context_before_encode(&backup_s, s, -1);
2676 best_s.data_partitioning= s->data_partitioning;
2677 best_s.partitioned_frame= s->partitioned_frame;
2678 if(s->data_partitioning){
2679 backup_s.pb2= s->pb2;
2680 backup_s.tex_pb= s->tex_pb;
2683 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2684 s->mv_dir = MV_DIR_FORWARD;
2685 s->mv_type = MV_TYPE_16X16;
2687 s->mv[0][0][0] = s->p_mv_table[xy][0];
2688 s->mv[0][0][1] = s->p_mv_table[xy][1];
2689 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2690 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2692 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2693 s->mv_dir = MV_DIR_FORWARD;
2694 s->mv_type = MV_TYPE_FIELD;
2697 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2698 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2699 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2701 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2702 &dmin, &next_block, 0, 0);
2704 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2705 s->mv_dir = MV_DIR_FORWARD;
2706 s->mv_type = MV_TYPE_16X16;
2710 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2711 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2713 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2714 s->mv_dir = MV_DIR_FORWARD;
2715 s->mv_type = MV_TYPE_8X8;
2718 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2719 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2721 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2722 &dmin, &next_block, 0, 0);
2724 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2725 s->mv_dir = MV_DIR_FORWARD;
2726 s->mv_type = MV_TYPE_16X16;
2728 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2729 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2730 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2731 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2733 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2734 s->mv_dir = MV_DIR_BACKWARD;
2735 s->mv_type = MV_TYPE_16X16;
2737 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2738 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2739 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2740 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2742 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2743 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2744 s->mv_type = MV_TYPE_16X16;
2746 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2747 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2748 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2749 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2750 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2751 &dmin, &next_block, 0, 0);
2753 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2754 s->mv_dir = MV_DIR_FORWARD;
2755 s->mv_type = MV_TYPE_FIELD;
2758 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2759 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2760 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2762 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2763 &dmin, &next_block, 0, 0);
2765 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2766 s->mv_dir = MV_DIR_BACKWARD;
2767 s->mv_type = MV_TYPE_FIELD;
2770 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2771 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2772 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2774 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2775 &dmin, &next_block, 0, 0);
2777 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2778 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2779 s->mv_type = MV_TYPE_FIELD;
2781 for(dir=0; dir<2; dir++){
2783 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2784 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2785 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2788 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2789 &dmin, &next_block, 0, 0);
2791 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2793 s->mv_type = MV_TYPE_16X16;
2797 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2798 &dmin, &next_block, 0, 0);
2799 if(s->h263_pred || s->h263_aic){
2801 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2803 ff_clean_intra_table_entries(s); //old mode?
2807 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2808 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2809 const int last_qp= backup_s.qscale;
2812 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2813 static const int dquant_tab[4]={-1,1,-2,2};
2814 int storecoefs = s->mb_intra && s->dc_val[0];
2816 av_assert2(backup_s.dquant == 0);
2819 s->mv_dir= best_s.mv_dir;
2820 s->mv_type = MV_TYPE_16X16;
2821 s->mb_intra= best_s.mb_intra;
2822 s->mv[0][0][0] = best_s.mv[0][0][0];
2823 s->mv[0][0][1] = best_s.mv[0][0][1];
2824 s->mv[1][0][0] = best_s.mv[1][0][0];
2825 s->mv[1][0][1] = best_s.mv[1][0][1];
2827 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2828 for(; qpi<4; qpi++){
2829 int dquant= dquant_tab[qpi];
2830 qp= last_qp + dquant;
2831 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2833 backup_s.dquant= dquant;
2836 dc[i]= s->dc_val[0][ s->block_index[i] ];
2837 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2841 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2842 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2843 if(best_s.qscale != qp){
2846 s->dc_val[0][ s->block_index[i] ]= dc[i];
2847 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2854 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2855 int mx= s->b_direct_mv_table[xy][0];
2856 int my= s->b_direct_mv_table[xy][1];
2858 backup_s.dquant = 0;
2859 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2861 ff_mpeg4_set_direct_mv(s, mx, my);
2862 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2863 &dmin, &next_block, mx, my);
2865 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2866 backup_s.dquant = 0;
2867 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2869 ff_mpeg4_set_direct_mv(s, 0, 0);
2870 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2871 &dmin, &next_block, 0, 0);
2873 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2876 coded |= s->block_last_index[i];
2879 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2880 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2881 mx=my=0; //FIXME find the one we actually used
2882 ff_mpeg4_set_direct_mv(s, mx, my);
2883 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2891 s->mv_dir= best_s.mv_dir;
2892 s->mv_type = best_s.mv_type;
2894 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2895 s->mv[0][0][1] = best_s.mv[0][0][1];
2896 s->mv[1][0][0] = best_s.mv[1][0][0];
2897 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2900 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2901 &dmin, &next_block, mx, my);
2906 s->current_picture.qscale_table[xy] = best_s.qscale;
2908 copy_context_after_encode(s, &best_s, -1);
2910 pb_bits_count= put_bits_count(&s->pb);
2911 flush_put_bits(&s->pb);
2912 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2915 if(s->data_partitioning){
2916 pb2_bits_count= put_bits_count(&s->pb2);
2917 flush_put_bits(&s->pb2);
2918 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2919 s->pb2= backup_s.pb2;
2921 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2922 flush_put_bits(&s->tex_pb);
2923 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2924 s->tex_pb= backup_s.tex_pb;
2926 s->last_bits= put_bits_count(&s->pb);
2928 if (CONFIG_H263_ENCODER &&
2929 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2930 ff_h263_update_motion_val(s);
2932 if(next_block==0){ //FIXME 16 vs linesize16
2933 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2934 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2935 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2938 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2939 ff_MPV_decode_mb(s, s->block);
2941 int motion_x = 0, motion_y = 0;
2942 s->mv_type=MV_TYPE_16X16;
2943 // only one MB-Type possible
2946 case CANDIDATE_MB_TYPE_INTRA:
2949 motion_x= s->mv[0][0][0] = 0;
2950 motion_y= s->mv[0][0][1] = 0;
2952 case CANDIDATE_MB_TYPE_INTER:
2953 s->mv_dir = MV_DIR_FORWARD;
2955 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2956 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2958 case CANDIDATE_MB_TYPE_INTER_I:
2959 s->mv_dir = MV_DIR_FORWARD;
2960 s->mv_type = MV_TYPE_FIELD;
2963 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2964 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2965 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2968 case CANDIDATE_MB_TYPE_INTER4V:
2969 s->mv_dir = MV_DIR_FORWARD;
2970 s->mv_type = MV_TYPE_8X8;
2973 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2974 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2977 case CANDIDATE_MB_TYPE_DIRECT:
2978 if (CONFIG_MPEG4_ENCODER) {
2979 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2981 motion_x=s->b_direct_mv_table[xy][0];
2982 motion_y=s->b_direct_mv_table[xy][1];
2983 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2986 case CANDIDATE_MB_TYPE_DIRECT0:
2987 if (CONFIG_MPEG4_ENCODER) {
2988 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2990 ff_mpeg4_set_direct_mv(s, 0, 0);
2993 case CANDIDATE_MB_TYPE_BIDIR:
2994 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2996 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2997 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2998 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2999 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3001 case CANDIDATE_MB_TYPE_BACKWARD:
3002 s->mv_dir = MV_DIR_BACKWARD;
3004 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3005 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3007 case CANDIDATE_MB_TYPE_FORWARD:
3008 s->mv_dir = MV_DIR_FORWARD;
3010 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3011 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3013 case CANDIDATE_MB_TYPE_FORWARD_I:
3014 s->mv_dir = MV_DIR_FORWARD;
3015 s->mv_type = MV_TYPE_FIELD;
3018 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3019 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3020 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3023 case CANDIDATE_MB_TYPE_BACKWARD_I:
3024 s->mv_dir = MV_DIR_BACKWARD;
3025 s->mv_type = MV_TYPE_FIELD;
3028 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3029 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3030 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3033 case CANDIDATE_MB_TYPE_BIDIR_I:
3034 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3035 s->mv_type = MV_TYPE_FIELD;
3037 for(dir=0; dir<2; dir++){
3039 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3040 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3041 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3046 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3049 encode_mb(s, motion_x, motion_y);
3051 // RAL: Update last macroblock type
3052 s->last_mv_dir = s->mv_dir;
3054 if (CONFIG_H263_ENCODER &&
3055 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3056 ff_h263_update_motion_val(s);
3058 ff_MPV_decode_mb(s, s->block);
3061 /* clean the MV table in IPS frames for direct mode in B frames */
3062 if(s->mb_intra /* && I,P,S_TYPE */){
3063 s->p_mv_table[xy][0]=0;
3064 s->p_mv_table[xy][1]=0;
3067 if(s->flags&CODEC_FLAG_PSNR){
3071 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3072 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3074 s->current_picture.f.error[0] += sse(
3075 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3076 s->dest[0], w, h, s->linesize);
3077 s->current_picture.f.error[1] += sse(
3078 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3079 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3080 s->current_picture.f.error[2] += sse(
3081 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3082 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3085 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3086 ff_h263_loop_filter(s);
3088 av_dlog(s->avctx, "MB %d %d bits\n",
3089 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3093 //not beautiful here but we must write it before flushing so it has to be here
3094 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3095 ff_msmpeg4_encode_ext_header(s);
3099 /* Send the last GOB if RTP */
3100 if (s->avctx->rtp_callback) {
3101 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3102 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3103 /* Call the RTP callback to send the last GOB */
3105 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3111 #define MERGE(field) dst->field += src->field; src->field=0
3112 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3113 MERGE(me.scene_change_score);
3114 MERGE(me.mc_mb_var_sum_temp);
3115 MERGE(me.mb_var_sum_temp);
3118 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3121 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3122 MERGE(dct_count[1]);
3131 MERGE(er.error_count);
3132 MERGE(padding_bug_score);
3133 MERGE(current_picture.f.error[0]);
3134 MERGE(current_picture.f.error[1]);
3135 MERGE(current_picture.f.error[2]);
3137 if(dst->avctx->noise_reduction){
3138 for(i=0; i<64; i++){
3139 MERGE(dct_error_sum[0][i]);
3140 MERGE(dct_error_sum[1][i]);
3144 assert(put_bits_count(&src->pb) % 8 ==0);
3145 assert(put_bits_count(&dst->pb) % 8 ==0);
3146 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3147 flush_put_bits(&dst->pb);
3150 static int estimate_qp(MpegEncContext *s, int dry_run){
3151 if (s->next_lambda){
3152 s->current_picture_ptr->f.quality =
3153 s->current_picture.f.quality = s->next_lambda;
3154 if(!dry_run) s->next_lambda= 0;
3155 } else if (!s->fixed_qscale) {
3156 s->current_picture_ptr->f.quality =
3157 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3158 if (s->current_picture.f.quality < 0)
3162 if(s->adaptive_quant){
3163 switch(s->codec_id){
3164 case AV_CODEC_ID_MPEG4:
3165 if (CONFIG_MPEG4_ENCODER)
3166 ff_clean_mpeg4_qscales(s);
3168 case AV_CODEC_ID_H263:
3169 case AV_CODEC_ID_H263P:
3170 case AV_CODEC_ID_FLV1:
3171 if (CONFIG_H263_ENCODER)
3172 ff_clean_h263_qscales(s);
3175 ff_init_qscale_tab(s);
3178 s->lambda= s->lambda_table[0];
3181 s->lambda = s->current_picture.f.quality;
3186 /* must be called before writing the header */
3187 static void set_frame_distances(MpegEncContext * s){
3188 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3189 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3191 if(s->pict_type==AV_PICTURE_TYPE_B){
3192 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3193 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3195 s->pp_time= s->time - s->last_non_b_time;
3196 s->last_non_b_time= s->time;
3197 assert(s->picture_number==0 || s->pp_time > 0);
3201 static int encode_picture(MpegEncContext *s, int picture_number)
3205 int context_count = s->slice_context_count;
3207 s->picture_number = picture_number;
3209 /* Reset the average MB variance */
3210 s->me.mb_var_sum_temp =
3211 s->me.mc_mb_var_sum_temp = 0;
3213 /* we need to initialize some time vars before we can encode b-frames */
3214 // RAL: Condition added for MPEG1VIDEO
3215 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3216 set_frame_distances(s);
3217 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3218 ff_set_mpeg4_time(s);
3220 s->me.scene_change_score=0;
3222 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3224 if(s->pict_type==AV_PICTURE_TYPE_I){
3225 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3226 else s->no_rounding=0;
3227 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3228 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3229 s->no_rounding ^= 1;
3232 if(s->flags & CODEC_FLAG_PASS2){
3233 if (estimate_qp(s,1) < 0)
3235 ff_get_2pass_fcode(s);
3236 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3237 if(s->pict_type==AV_PICTURE_TYPE_B)
3238 s->lambda= s->last_lambda_for[s->pict_type];
3240 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3244 if(s->codec_id != AV_CODEC_ID_AMV){
3245 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3246 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3247 s->q_chroma_intra_matrix = s->q_intra_matrix;
3248 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3251 s->mb_intra=0; //for the rate distortion & bit compare functions
3252 for(i=1; i<context_count; i++){
3253 ret = ff_update_duplicate_context(s->thread_context[i], s);
3261 /* Estimate motion for every MB */
3262 if(s->pict_type != AV_PICTURE_TYPE_I){
3263 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3264 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3265 if (s->pict_type != AV_PICTURE_TYPE_B) {
3266 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3267 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3271 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3272 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3274 for(i=0; i<s->mb_stride*s->mb_height; i++)
3275 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3277 if(!s->fixed_qscale){
3278 /* finding spatial complexity for I-frame rate control */
3279 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3282 for(i=1; i<context_count; i++){
3283 merge_context_after_me(s, s->thread_context[i]);
3285 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3286 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3289 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3290 s->pict_type= AV_PICTURE_TYPE_I;
3291 for(i=0; i<s->mb_stride*s->mb_height; i++)
3292 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3293 if(s->msmpeg4_version >= 3)
3295 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3296 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3300 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3301 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3303 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3305 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3306 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3307 s->f_code= FFMAX3(s->f_code, a, b);
3310 ff_fix_long_p_mvs(s);
3311 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3312 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3316 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3317 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3322 if(s->pict_type==AV_PICTURE_TYPE_B){
3325 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3326 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3327 s->f_code = FFMAX(a, b);
3329 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3330 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3331 s->b_code = FFMAX(a, b);
3333 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3334 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3335 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3336 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3337 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3339 for(dir=0; dir<2; dir++){
3342 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3343 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3344 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3345 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3353 if (estimate_qp(s, 0) < 0)
3356 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3357 s->qscale= 3; //reduce clipping problems
3359 if (s->out_format == FMT_MJPEG) {
3360 /* for mjpeg, we do include qscale in the matrix */
3362 int j= s->dsp.idct_permutation[i];
3364 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3366 s->y_dc_scale_table=
3367 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3368 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3369 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3370 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3373 if(s->codec_id == AV_CODEC_ID_AMV){
3374 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};
3375 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};
3377 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3379 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3380 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3382 s->y_dc_scale_table= y;
3383 s->c_dc_scale_table= c;
3384 s->intra_matrix[0] = 13;
3385 s->chroma_intra_matrix[0] = 14;
3386 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3387 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3388 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3389 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3393 //FIXME var duplication
3394 s->current_picture_ptr->f.key_frame =
3395 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3396 s->current_picture_ptr->f.pict_type =
3397 s->current_picture.f.pict_type = s->pict_type;
3399 if (s->current_picture.f.key_frame)
3400 s->picture_in_gop_number=0;
3402 s->mb_x = s->mb_y = 0;
3403 s->last_bits= put_bits_count(&s->pb);
3404 switch(s->out_format) {
3406 if (CONFIG_MJPEG_ENCODER)
3407 ff_mjpeg_encode_picture_header(s);
3410 if (CONFIG_H261_ENCODER)
3411 ff_h261_encode_picture_header(s, picture_number);
3414 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3415 ff_wmv2_encode_picture_header(s, picture_number);
3416 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3417 ff_msmpeg4_encode_picture_header(s, picture_number);
3418 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3419 ff_mpeg4_encode_picture_header(s, picture_number);
3420 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3421 ff_rv10_encode_picture_header(s, picture_number);
3422 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3423 ff_rv20_encode_picture_header(s, picture_number);
3424 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3425 ff_flv_encode_picture_header(s, picture_number);
3426 else if (CONFIG_H263_ENCODER)
3427 ff_h263_encode_picture_header(s, picture_number);
3430 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3431 ff_mpeg1_encode_picture_header(s, picture_number);
3436 bits= put_bits_count(&s->pb);
3437 s->header_bits= bits - s->last_bits;
3439 for(i=1; i<context_count; i++){
3440 update_duplicate_context_after_me(s->thread_context[i], s);
3442 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3443 for(i=1; i<context_count; i++){
3444 merge_context_after_encode(s, s->thread_context[i]);
3450 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3451 const int intra= s->mb_intra;
3454 s->dct_count[intra]++;
3456 for(i=0; i<64; i++){
3457 int level= block[i];
3461 s->dct_error_sum[intra][i] += level;
3462 level -= s->dct_offset[intra][i];
3463 if(level<0) level=0;
3465 s->dct_error_sum[intra][i] -= level;
3466 level += s->dct_offset[intra][i];
3467 if(level>0) level=0;
3474 static int dct_quantize_trellis_c(MpegEncContext *s,
3475 int16_t *block, int n,
3476 int qscale, int *overflow){
3478 const uint8_t *scantable= s->intra_scantable.scantable;
3479 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3481 unsigned int threshold1, threshold2;
3493 int coeff_count[64];
3494 int qmul, qadd, start_i, last_non_zero, i, dc;
3495 const int esc_length= s->ac_esc_length;
3497 uint8_t * last_length;
3498 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3500 s->dsp.fdct (block);
3502 if(s->dct_error_sum)
3503 s->denoise_dct(s, block);
3505 qadd= ((qscale-1)|1)*8;
3516 /* For AIC we skip quant/dequant of INTRADC */
3521 /* note: block[0] is assumed to be positive */
3522 block[0] = (block[0] + (q >> 1)) / q;
3525 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3526 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3527 bias= 1<<(QMAT_SHIFT-1);
3528 length = s->intra_ac_vlc_length;
3529 last_length= s->intra_ac_vlc_last_length;
3533 qmat = s->q_inter_matrix[qscale];
3534 length = s->inter_ac_vlc_length;
3535 last_length= s->inter_ac_vlc_last_length;
3539 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3540 threshold2= (threshold1<<1);
3542 for(i=63; i>=start_i; i--) {
3543 const int j = scantable[i];
3544 int level = block[j] * qmat[j];
3546 if(((unsigned)(level+threshold1))>threshold2){
3552 for(i=start_i; i<=last_non_zero; i++) {
3553 const int j = scantable[i];
3554 int level = block[j] * qmat[j];
3556 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3557 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3558 if(((unsigned)(level+threshold1))>threshold2){
3560 level= (bias + level)>>QMAT_SHIFT;
3562 coeff[1][i]= level-1;
3563 // coeff[2][k]= level-2;
3565 level= (bias - level)>>QMAT_SHIFT;
3566 coeff[0][i]= -level;
3567 coeff[1][i]= -level+1;
3568 // coeff[2][k]= -level+2;
3570 coeff_count[i]= FFMIN(level, 2);
3571 av_assert2(coeff_count[i]);
3574 coeff[0][i]= (level>>31)|1;
3579 *overflow= s->max_qcoeff < max; //overflow might have happened
3581 if(last_non_zero < start_i){
3582 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3583 return last_non_zero;
3586 score_tab[start_i]= 0;
3587 survivor[0]= start_i;
3590 for(i=start_i; i<=last_non_zero; i++){
3591 int level_index, j, zero_distortion;
3592 int dct_coeff= FFABS(block[ scantable[i] ]);
3593 int best_score=256*256*256*120;
3595 if (s->dsp.fdct == ff_fdct_ifast)
3596 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3597 zero_distortion= dct_coeff*dct_coeff;
3599 for(level_index=0; level_index < coeff_count[i]; level_index++){
3601 int level= coeff[level_index][i];
3602 const int alevel= FFABS(level);
3607 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
3608 unquant_coeff= alevel*qmul + qadd;
3610 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3612 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3613 unquant_coeff = (unquant_coeff - 1) | 1;
3615 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3616 unquant_coeff = (unquant_coeff - 1) | 1;
3621 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3623 if((level&(~127)) == 0){
3624 for(j=survivor_count-1; j>=0; j--){
3625 int run= i - survivor[j];
3626 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3627 score += score_tab[i-run];
3629 if(score < best_score){
3632 level_tab[i+1]= level-64;
3636 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
3637 for(j=survivor_count-1; j>=0; j--){
3638 int run= i - survivor[j];
3639 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3640 score += score_tab[i-run];
3641 if(score < last_score){
3644 last_level= level-64;
3650 distortion += esc_length*lambda;
3651 for(j=survivor_count-1; j>=0; j--){
3652 int run= i - survivor[j];
3653 int score= distortion + score_tab[i-run];
3655 if(score < best_score){
3658 level_tab[i+1]= level-64;
3662 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
3663 for(j=survivor_count-1; j>=0; j--){
3664 int run= i - survivor[j];
3665 int score= distortion + score_tab[i-run];
3666 if(score < last_score){
3669 last_level= level-64;
3677 score_tab[i+1]= best_score;
3679 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3680 if(last_non_zero <= 27){
3681 for(; survivor_count; survivor_count--){
3682 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3686 for(; survivor_count; survivor_count--){
3687 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3692 survivor[ survivor_count++ ]= i+1;
3695 if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
3696 last_score= 256*256*256*120;
3697 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3698 int score= score_tab[i];
3699 if(i) score += lambda*2; //FIXME exacter?
3701 if(score < last_score){
3704 last_level= level_tab[i];
3705 last_run= run_tab[i];
3710 s->coded_score[n] = last_score;
3712 dc= FFABS(block[0]);
3713 last_non_zero= last_i - 1;
3714 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3716 if(last_non_zero < start_i)
3717 return last_non_zero;
3719 if(last_non_zero == 0 && start_i == 0){
3721 int best_score= dc * dc;
3723 for(i=0; i<coeff_count[0]; i++){
3724 int level= coeff[i][0];
3725 int alevel= FFABS(level);
3726 int unquant_coeff, score, distortion;
3728 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
3729 unquant_coeff= (alevel*qmul + qadd)>>3;
3731 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3732 unquant_coeff = (unquant_coeff - 1) | 1;
3734 unquant_coeff = (unquant_coeff + 4) >> 3;
3735 unquant_coeff<<= 3 + 3;
3737 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3739 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3740 else score= distortion + esc_length*lambda;
3742 if(score < best_score){
3744 best_level= level - 64;
3747 block[0]= best_level;
3748 s->coded_score[n] = best_score - dc*dc;
3749 if(best_level == 0) return -1;
3750 else return last_non_zero;
3754 av_assert2(last_level);
3756 block[ perm_scantable[last_non_zero] ]= last_level;
3759 for(; i>start_i; i -= run_tab[i] + 1){
3760 block[ perm_scantable[i-1] ]= level_tab[i];
3763 return last_non_zero;
3766 //#define REFINE_STATS 1
3767 static int16_t basis[64][64];
3769 static void build_basis(uint8_t *perm){
3776 double s= 0.25*(1<<BASIS_SHIFT);
3778 int perm_index= perm[index];
3779 if(i==0) s*= sqrt(0.5);
3780 if(j==0) s*= sqrt(0.5);
3781 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)));
3788 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3789 int16_t *block, int16_t *weight, int16_t *orig,
3792 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3793 const uint8_t *scantable= s->intra_scantable.scantable;
3794 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3795 // unsigned int threshold1, threshold2;
3800 int qmul, qadd, start_i, last_non_zero, i, dc;
3802 uint8_t * last_length;
3804 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3807 static int after_last=0;
3808 static int to_zero=0;
3809 static int from_zero=0;
3812 static int messed_sign=0;
3815 if(basis[0][0] == 0)
3816 build_basis(s->dsp.idct_permutation);
3827 /* For AIC we skip quant/dequant of INTRADC */
3831 q <<= RECON_SHIFT-3;
3832 /* note: block[0] is assumed to be positive */
3834 // block[0] = (block[0] + (q >> 1)) / q;
3836 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3837 // bias= 1<<(QMAT_SHIFT-1);
3838 length = s->intra_ac_vlc_length;
3839 last_length= s->intra_ac_vlc_last_length;
3843 length = s->inter_ac_vlc_length;
3844 last_length= s->inter_ac_vlc_last_length;
3846 last_non_zero = s->block_last_index[n];
3851 dc += (1<<(RECON_SHIFT-1));
3852 for(i=0; i<64; i++){
3853 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3856 STOP_TIMER("memset rem[]")}
3859 for(i=0; i<64; i++){
3864 w= FFABS(weight[i]) + qns*one;
3865 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3868 // w=weight[i] = (63*qns + (w/2)) / w;
3871 av_assert2(w<(1<<6));
3874 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3880 for(i=start_i; i<=last_non_zero; i++){
3881 int j= perm_scantable[i];
3882 const int level= block[j];
3886 if(level<0) coeff= qmul*level - qadd;
3887 else coeff= qmul*level + qadd;
3888 run_tab[rle_index++]=run;
3891 s->dsp.add_8x8basis(rem, basis[j], coeff);
3897 if(last_non_zero>0){
3898 STOP_TIMER("init rem[]")
3905 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3908 int run2, best_unquant_change=0, analyze_gradient;
3912 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3914 if(analyze_gradient){
3918 for(i=0; i<64; i++){
3921 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3924 STOP_TIMER("rem*w*w")}
3934 const int level= block[0];
3935 int change, old_coeff;
3937 av_assert2(s->mb_intra);
3941 for(change=-1; change<=1; change+=2){
3942 int new_level= level + change;
3943 int score, new_coeff;
3945 new_coeff= q*new_level;
3946 if(new_coeff >= 2048 || new_coeff < 0)
3949 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3950 if(score<best_score){
3953 best_change= change;
3954 best_unquant_change= new_coeff - old_coeff;
3961 run2= run_tab[rle_index++];
3965 for(i=start_i; i<64; i++){
3966 int j= perm_scantable[i];
3967 const int level= block[j];
3968 int change, old_coeff;
3970 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3974 if(level<0) old_coeff= qmul*level - qadd;
3975 else old_coeff= qmul*level + qadd;
3976 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3980 av_assert2(run2>=0 || i >= last_non_zero );
3983 for(change=-1; change<=1; change+=2){
3984 int new_level= level + change;
3985 int score, new_coeff, unquant_change;
3988 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3992 if(new_level<0) new_coeff= qmul*new_level - qadd;
3993 else new_coeff= qmul*new_level + qadd;
3994 if(new_coeff >= 2048 || new_coeff <= -2048)
3996 //FIXME check for overflow
3999 if(level < 63 && level > -63){
4000 if(i < last_non_zero)
4001 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4002 - length[UNI_AC_ENC_INDEX(run, level+64)];
4004 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4005 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4008 av_assert2(FFABS(new_level)==1);
4010 if(analyze_gradient){
4011 int g= d1[ scantable[i] ];
4012 if(g && (g^new_level) >= 0)
4016 if(i < last_non_zero){
4017 int next_i= i + run2 + 1;
4018 int next_level= block[ perm_scantable[next_i] ] + 64;
4020 if(next_level&(~127))
4023 if(next_i < last_non_zero)
4024 score += length[UNI_AC_ENC_INDEX(run, 65)]
4025 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4026 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4028 score += length[UNI_AC_ENC_INDEX(run, 65)]
4029 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4030 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4032 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4034 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4035 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4041 av_assert2(FFABS(level)==1);
4043 if(i < last_non_zero){
4044 int next_i= i + run2 + 1;
4045 int next_level= block[ perm_scantable[next_i] ] + 64;
4047 if(next_level&(~127))
4050 if(next_i < last_non_zero)
4051 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4052 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4053 - length[UNI_AC_ENC_INDEX(run, 65)];
4055 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4056 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4057 - length[UNI_AC_ENC_INDEX(run, 65)];
4059 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4061 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4062 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4069 unquant_change= new_coeff - old_coeff;
4070 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4072 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4073 if(score<best_score){
4076 best_change= change;
4077 best_unquant_change= unquant_change;
4081 prev_level= level + 64;
4082 if(prev_level&(~127))
4091 STOP_TIMER("iterative step")}
4095 int j= perm_scantable[ best_coeff ];
4097 block[j] += best_change;
4099 if(best_coeff > last_non_zero){
4100 last_non_zero= best_coeff;
4101 av_assert2(block[j]);
4108 if(block[j] - best_change){
4109 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4121 for(; last_non_zero>=start_i; last_non_zero--){
4122 if(block[perm_scantable[last_non_zero]])
4128 if(256*256*256*64 % count == 0){
4129 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);
4134 for(i=start_i; i<=last_non_zero; i++){
4135 int j= perm_scantable[i];
4136 const int level= block[j];
4139 run_tab[rle_index++]=run;
4146 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4152 if(last_non_zero>0){
4153 STOP_TIMER("iterative search")
4158 return last_non_zero;
4161 int ff_dct_quantize_c(MpegEncContext *s,
4162 int16_t *block, int n,
4163 int qscale, int *overflow)
4165 int i, j, level, last_non_zero, q, start_i;
4167 const uint8_t *scantable= s->intra_scantable.scantable;
4170 unsigned int threshold1, threshold2;
4172 s->dsp.fdct (block);
4174 if(s->dct_error_sum)
4175 s->denoise_dct(s, block);
4185 /* For AIC we skip quant/dequant of INTRADC */
4188 /* note: block[0] is assumed to be positive */
4189 block[0] = (block[0] + (q >> 1)) / q;
4192 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4193 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4197 qmat = s->q_inter_matrix[qscale];
4198 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4200 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4201 threshold2= (threshold1<<1);
4202 for(i=63;i>=start_i;i--) {
4204 level = block[j] * qmat[j];
4206 if(((unsigned)(level+threshold1))>threshold2){
4213 for(i=start_i; i<=last_non_zero; i++) {
4215 level = block[j] * qmat[j];
4217 // if( bias+level >= (1<<QMAT_SHIFT)
4218 // || bias-level >= (1<<QMAT_SHIFT)){
4219 if(((unsigned)(level+threshold1))>threshold2){
4221 level= (bias + level)>>QMAT_SHIFT;
4224 level= (bias - level)>>QMAT_SHIFT;
4232 *overflow= s->max_qcoeff < max; //overflow might have happened
4234 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4235 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4236 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4238 return last_non_zero;
4241 #define OFFSET(x) offsetof(MpegEncContext, x)
4242 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4243 static const AVOption h263_options[] = {
4244 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4245 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4246 { "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 },
4251 static const AVClass h263_class = {
4252 .class_name = "H.263 encoder",
4253 .item_name = av_default_item_name,
4254 .option = h263_options,
4255 .version = LIBAVUTIL_VERSION_INT,
4258 AVCodec ff_h263_encoder = {
4260 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4261 .type = AVMEDIA_TYPE_VIDEO,
4262 .id = AV_CODEC_ID_H263,
4263 .priv_data_size = sizeof(MpegEncContext),
4264 .init = ff_MPV_encode_init,
4265 .encode2 = ff_MPV_encode_picture,
4266 .close = ff_MPV_encode_end,
4267 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4268 .priv_class = &h263_class,
4271 static const AVOption h263p_options[] = {
4272 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4273 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4274 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4275 { "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},
4279 static const AVClass h263p_class = {
4280 .class_name = "H.263p encoder",
4281 .item_name = av_default_item_name,
4282 .option = h263p_options,
4283 .version = LIBAVUTIL_VERSION_INT,
4286 AVCodec ff_h263p_encoder = {
4288 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4289 .type = AVMEDIA_TYPE_VIDEO,
4290 .id = AV_CODEC_ID_H263P,
4291 .priv_data_size = sizeof(MpegEncContext),
4292 .init = ff_MPV_encode_init,
4293 .encode2 = ff_MPV_encode_picture,
4294 .close = ff_MPV_encode_end,
4295 .capabilities = CODEC_CAP_SLICE_THREADS,
4296 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4297 .priv_class = &h263p_class,
4300 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4302 AVCodec ff_msmpeg4v2_encoder = {
4303 .name = "msmpeg4v2",
4304 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4305 .type = AVMEDIA_TYPE_VIDEO,
4306 .id = AV_CODEC_ID_MSMPEG4V2,
4307 .priv_data_size = sizeof(MpegEncContext),
4308 .init = ff_MPV_encode_init,
4309 .encode2 = ff_MPV_encode_picture,
4310 .close = ff_MPV_encode_end,
4311 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4312 .priv_class = &msmpeg4v2_class,
4315 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4317 AVCodec ff_msmpeg4v3_encoder = {
4319 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4320 .type = AVMEDIA_TYPE_VIDEO,
4321 .id = AV_CODEC_ID_MSMPEG4V3,
4322 .priv_data_size = sizeof(MpegEncContext),
4323 .init = ff_MPV_encode_init,
4324 .encode2 = ff_MPV_encode_picture,
4325 .close = ff_MPV_encode_end,
4326 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4327 .priv_class = &msmpeg4v3_class,
4330 FF_MPV_GENERIC_CLASS(wmv1)
4332 AVCodec ff_wmv1_encoder = {
4334 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4335 .type = AVMEDIA_TYPE_VIDEO,
4336 .id = AV_CODEC_ID_WMV1,
4337 .priv_data_size = sizeof(MpegEncContext),
4338 .init = ff_MPV_encode_init,
4339 .encode2 = ff_MPV_encode_picture,
4340 .close = ff_MPV_encode_end,
4341 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4342 .priv_class = &wmv1_class,