2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/internal.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/opt.h"
39 #include "mpegvideo.h"
47 #include "aandcttab.h"
49 #include "mpeg4video.h"
51 #include "bytestream.h"
55 static int encode_picture(MpegEncContext *s, int picture_number);
56 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
57 static int sse_mb(MpegEncContext *s);
58 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
59 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
61 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
62 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
64 const AVOption ff_mpv_generic_options[] = {
69 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
70 uint16_t (*qmat16)[2][64],
71 const uint16_t *quant_matrix,
72 int bias, int qmin, int qmax, int intra)
77 for (qscale = qmin; qscale <= qmax; qscale++) {
79 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
80 dsp->fdct == ff_jpeg_fdct_islow_10 ||
81 dsp->fdct == ff_faandct) {
82 for (i = 0; i < 64; i++) {
83 const int j = dsp->idct_permutation[i];
84 /* 16 <= qscale * quant_matrix[i] <= 7905
85 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
86 * 19952 <= x <= 249205026
87 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
88 * 3444240 >= (1 << 36) / (x) >= 275 */
90 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
91 (qscale * quant_matrix[j]));
93 } else if (dsp->fdct == ff_fdct_ifast) {
94 for (i = 0; i < 64; i++) {
95 const int j = dsp->idct_permutation[i];
96 /* 16 <= qscale * quant_matrix[i] <= 7905
97 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
98 * 19952 <= x <= 249205026
99 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
100 * 3444240 >= (1 << 36) / (x) >= 275 */
102 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
103 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
106 for (i = 0; i < 64; i++) {
107 const int j = dsp->idct_permutation[i];
108 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
109 * Assume x = qscale * quant_matrix[i]
111 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
112 * so 32768 >= (1 << 19) / (x) >= 67 */
113 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
114 (qscale * quant_matrix[j]));
115 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
116 // (qscale * quant_matrix[i]);
117 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
118 (qscale * quant_matrix[j]);
120 if (qmat16[qscale][0][i] == 0 ||
121 qmat16[qscale][0][i] == 128 * 256)
122 qmat16[qscale][0][i] = 128 * 256 - 1;
123 qmat16[qscale][1][i] =
124 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
125 qmat16[qscale][0][i]);
129 for (i = intra; i < 64; i++) {
131 if (dsp->fdct == ff_fdct_ifast) {
132 max = (8191LL * ff_aanscales[i]) >> 14;
134 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
140 av_log(NULL, AV_LOG_INFO,
141 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
146 static inline void update_qscale(MpegEncContext *s)
148 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
149 (FF_LAMBDA_SHIFT + 7);
150 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
152 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
156 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
162 for (i = 0; i < 64; i++) {
163 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
170 * init s->current_picture.qscale_table from s->lambda_table
172 void ff_init_qscale_tab(MpegEncContext *s)
174 int8_t * const qscale_table = s->current_picture.qscale_table;
177 for (i = 0; i < s->mb_num; i++) {
178 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
179 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
180 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
185 static void update_duplicate_context_after_me(MpegEncContext *dst,
188 #define COPY(a) dst->a= src->a
190 COPY(current_picture);
196 COPY(picture_in_gop_number);
197 COPY(gop_picture_number);
198 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
199 COPY(progressive_frame); // FIXME don't set in encode_header
200 COPY(partitioned_frame); // FIXME don't set in encode_header
205 * Set the given MpegEncContext to defaults for encoding.
206 * the changed fields will not depend upon the prior state of the MpegEncContext.
208 static void MPV_encode_defaults(MpegEncContext *s)
211 ff_MPV_common_defaults(s);
213 for (i = -16; i < 16; i++) {
214 default_fcode_tab[i + MAX_MV] = 1;
216 s->me.mv_penalty = default_mv_penalty;
217 s->fcode_tab = default_fcode_tab;
220 av_cold int ff_dct_encode_init(MpegEncContext *s) {
222 ff_dct_encode_init_x86(s);
224 ff_h263dsp_init(&s->h263dsp);
225 if (!s->dct_quantize)
226 s->dct_quantize = ff_dct_quantize_c;
228 s->denoise_dct = denoise_dct_c;
229 s->fast_dct_quantize = s->dct_quantize;
230 if (s->avctx->trellis)
231 s->dct_quantize = dct_quantize_trellis_c;
236 /* init video encoder */
237 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
239 MpegEncContext *s = avctx->priv_data;
241 int chroma_h_shift, chroma_v_shift;
243 MPV_encode_defaults(s);
245 switch (avctx->codec_id) {
246 case AV_CODEC_ID_MPEG2VIDEO:
247 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
248 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
249 av_log(avctx, AV_LOG_ERROR,
250 "only YUV420 and YUV422 are supported\n");
254 case AV_CODEC_ID_LJPEG:
255 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
256 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
257 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
258 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
259 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
260 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
261 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
262 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
263 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
264 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
265 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
269 case AV_CODEC_ID_MJPEG:
270 case AV_CODEC_ID_AMV:
271 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
272 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
273 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
274 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
275 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
276 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
277 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
278 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
283 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
284 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
289 switch (avctx->pix_fmt) {
290 case AV_PIX_FMT_YUVJ444P:
291 case AV_PIX_FMT_YUV444P:
292 s->chroma_format = CHROMA_444;
294 case AV_PIX_FMT_YUVJ422P:
295 case AV_PIX_FMT_YUV422P:
296 s->chroma_format = CHROMA_422;
298 case AV_PIX_FMT_YUVJ420P:
299 case AV_PIX_FMT_YUV420P:
301 s->chroma_format = CHROMA_420;
305 s->bit_rate = avctx->bit_rate;
306 s->width = avctx->width;
307 s->height = avctx->height;
308 if (avctx->gop_size > 600 &&
309 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
310 av_log(avctx, AV_LOG_WARNING,
311 "keyframe interval too large!, reducing it from %d to %d\n",
312 avctx->gop_size, 600);
313 avctx->gop_size = 600;
315 s->gop_size = avctx->gop_size;
317 s->flags = avctx->flags;
318 s->flags2 = avctx->flags2;
319 s->max_b_frames = avctx->max_b_frames;
320 s->codec_id = avctx->codec->id;
321 s->strict_std_compliance = avctx->strict_std_compliance;
322 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
323 s->mpeg_quant = avctx->mpeg_quant;
324 s->rtp_mode = !!avctx->rtp_payload_size;
325 s->intra_dc_precision = avctx->intra_dc_precision;
326 s->user_specified_pts = AV_NOPTS_VALUE;
328 if (s->gop_size <= 1) {
335 s->me_method = avctx->me_method;
338 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
340 s->adaptive_quant = (s->avctx->lumi_masking ||
341 s->avctx->dark_masking ||
342 s->avctx->temporal_cplx_masking ||
343 s->avctx->spatial_cplx_masking ||
344 s->avctx->p_masking ||
345 s->avctx->border_masking ||
346 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
349 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
351 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
352 switch(avctx->codec_id) {
353 case AV_CODEC_ID_MPEG1VIDEO:
354 case AV_CODEC_ID_MPEG2VIDEO:
355 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
357 case AV_CODEC_ID_MPEG4:
358 case AV_CODEC_ID_MSMPEG4V1:
359 case AV_CODEC_ID_MSMPEG4V2:
360 case AV_CODEC_ID_MSMPEG4V3:
361 if (avctx->rc_max_rate >= 15000000) {
362 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
363 } else if(avctx->rc_max_rate >= 2000000) {
364 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
365 } else if(avctx->rc_max_rate >= 384000) {
366 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
368 avctx->rc_buffer_size = 40;
369 avctx->rc_buffer_size *= 16384;
372 if (avctx->rc_buffer_size) {
373 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
377 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
378 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
379 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
383 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
384 av_log(avctx, AV_LOG_INFO,
385 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
388 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
389 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
393 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
394 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
398 if (avctx->rc_max_rate &&
399 avctx->rc_max_rate == avctx->bit_rate &&
400 avctx->rc_max_rate != avctx->rc_min_rate) {
401 av_log(avctx, AV_LOG_INFO,
402 "impossible bitrate constraints, this will fail\n");
405 if (avctx->rc_buffer_size &&
406 avctx->bit_rate * (int64_t)avctx->time_base.num >
407 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
408 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
412 if (!s->fixed_qscale &&
413 avctx->bit_rate * av_q2d(avctx->time_base) >
414 avctx->bit_rate_tolerance) {
415 av_log(avctx, AV_LOG_ERROR,
416 "bitrate tolerance too small for bitrate\n");
420 if (s->avctx->rc_max_rate &&
421 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
422 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
423 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
424 90000LL * (avctx->rc_buffer_size - 1) >
425 s->avctx->rc_max_rate * 0xFFFFLL) {
426 av_log(avctx, AV_LOG_INFO,
427 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
428 "specified vbv buffer is too large for the given bitrate!\n");
431 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
432 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
433 s->codec_id != AV_CODEC_ID_FLV1) {
434 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
438 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
439 av_log(avctx, AV_LOG_ERROR,
440 "OBMC is only supported with simple mb decision\n");
444 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
445 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
449 if (s->max_b_frames &&
450 s->codec_id != AV_CODEC_ID_MPEG4 &&
451 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
452 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
453 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
456 if (s->max_b_frames < 0) {
457 av_log(avctx, AV_LOG_ERROR,
458 "max b frames must be 0 or positive for mpegvideo based encoders\n");
462 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
463 s->codec_id == AV_CODEC_ID_H263 ||
464 s->codec_id == AV_CODEC_ID_H263P) &&
465 (avctx->sample_aspect_ratio.num > 255 ||
466 avctx->sample_aspect_ratio.den > 255)) {
467 av_log(avctx, AV_LOG_WARNING,
468 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
469 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
470 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
471 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
474 if ((s->codec_id == AV_CODEC_ID_H263 ||
475 s->codec_id == AV_CODEC_ID_H263P) &&
476 (avctx->width > 2048 ||
477 avctx->height > 1152 )) {
478 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
481 if ((s->codec_id == AV_CODEC_ID_H263 ||
482 s->codec_id == AV_CODEC_ID_H263P) &&
483 ((avctx->width &3) ||
484 (avctx->height&3) )) {
485 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
489 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
490 (avctx->width > 4095 ||
491 avctx->height > 4095 )) {
492 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
496 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
497 (avctx->width > 16383 ||
498 avctx->height > 16383 )) {
499 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
503 if (s->codec_id == AV_CODEC_ID_RV10 &&
505 avctx->height&15 )) {
506 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
507 return AVERROR(EINVAL);
510 if (s->codec_id == AV_CODEC_ID_RV20 &&
513 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
514 return AVERROR(EINVAL);
517 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
518 s->codec_id == AV_CODEC_ID_WMV2) &&
520 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
524 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
525 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
526 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
530 // FIXME mpeg2 uses that too
531 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
532 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
533 av_log(avctx, AV_LOG_ERROR,
534 "mpeg2 style quantization not supported by codec\n");
538 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
539 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
543 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
544 s->avctx->mb_decision != FF_MB_DECISION_RD) {
545 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
549 if (s->avctx->scenechange_threshold < 1000000000 &&
550 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
551 av_log(avctx, AV_LOG_ERROR,
552 "closed gop with scene change detection are not supported yet, "
553 "set threshold to 1000000000\n");
557 if (s->flags & CODEC_FLAG_LOW_DELAY) {
558 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
559 av_log(avctx, AV_LOG_ERROR,
560 "low delay forcing is only available for mpeg2\n");
563 if (s->max_b_frames != 0) {
564 av_log(avctx, AV_LOG_ERROR,
565 "b frames cannot be used with low delay\n");
570 if (s->q_scale_type == 1) {
571 if (avctx->qmax > 12) {
572 av_log(avctx, AV_LOG_ERROR,
573 "non linear quant only supports qmax <= 12 currently\n");
578 if (s->avctx->thread_count > 1 &&
579 s->codec_id != AV_CODEC_ID_MPEG4 &&
580 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
581 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
582 s->codec_id != AV_CODEC_ID_MJPEG &&
583 (s->codec_id != AV_CODEC_ID_H263P)) {
584 av_log(avctx, AV_LOG_ERROR,
585 "multi threaded encoding not supported by codec\n");
589 if (s->avctx->thread_count < 1) {
590 av_log(avctx, AV_LOG_ERROR,
591 "automatic thread number detection not supported by codec, "
596 if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
599 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
600 s->h263_slice_structured = 1;
602 if (!avctx->time_base.den || !avctx->time_base.num) {
603 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
607 i = (INT_MAX / 2 + 128) >> 8;
608 if (avctx->mb_threshold >= i) {
609 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
614 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
615 av_log(avctx, AV_LOG_INFO,
616 "notice: b_frame_strategy only affects the first pass\n");
617 avctx->b_frame_strategy = 0;
620 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
622 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
623 avctx->time_base.den /= i;
624 avctx->time_base.num /= i;
628 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) {
629 // (a + x * 3 / 8) / x
630 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
631 s->inter_quant_bias = 0;
633 s->intra_quant_bias = 0;
635 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
638 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
639 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
640 return AVERROR(EINVAL);
643 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
644 s->intra_quant_bias = avctx->intra_quant_bias;
645 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
646 s->inter_quant_bias = avctx->inter_quant_bias;
648 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
650 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
652 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
653 s->avctx->time_base.den > (1 << 16) - 1) {
654 av_log(avctx, AV_LOG_ERROR,
655 "timebase %d/%d not supported by MPEG 4 standard, "
656 "the maximum admitted value for the timebase denominator "
657 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
661 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
663 switch (avctx->codec->id) {
664 case AV_CODEC_ID_MPEG1VIDEO:
665 s->out_format = FMT_MPEG1;
666 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
667 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
669 case AV_CODEC_ID_MPEG2VIDEO:
670 s->out_format = FMT_MPEG1;
671 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
672 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
675 case AV_CODEC_ID_LJPEG:
676 case AV_CODEC_ID_MJPEG:
677 case AV_CODEC_ID_AMV:
678 s->out_format = FMT_MJPEG;
679 s->intra_only = 1; /* force intra only for jpeg */
680 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
681 (avctx->pix_fmt == AV_PIX_FMT_BGR0
682 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
683 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
684 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
685 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
686 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
687 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
688 s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
689 s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
691 s->mjpeg_vsample[0] = 2;
692 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
693 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
694 s->mjpeg_hsample[0] = 2;
695 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
696 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
698 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
699 ff_mjpeg_encode_init(s) < 0)
704 case AV_CODEC_ID_H261:
705 if (!CONFIG_H261_ENCODER)
707 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
708 av_log(avctx, AV_LOG_ERROR,
709 "The specified picture size of %dx%d is not valid for the "
710 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
711 s->width, s->height);
714 s->out_format = FMT_H261;
718 case AV_CODEC_ID_H263:
719 if (!CONFIG_H263_ENCODER)
721 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
722 s->width, s->height) == 8) {
723 av_log(avctx, AV_LOG_ERROR,
724 "The specified picture size of %dx%d is not valid for "
725 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
726 "352x288, 704x576, and 1408x1152. "
727 "Try H.263+.\n", s->width, s->height);
730 s->out_format = FMT_H263;
734 case AV_CODEC_ID_H263P:
735 s->out_format = FMT_H263;
738 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
739 s->modified_quant = s->h263_aic;
740 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
741 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
744 /* These are just to be sure */
748 case AV_CODEC_ID_FLV1:
749 s->out_format = FMT_H263;
750 s->h263_flv = 2; /* format = 1; 11-bit codes */
751 s->unrestricted_mv = 1;
752 s->rtp_mode = 0; /* don't allow GOB */
756 case AV_CODEC_ID_RV10:
757 s->out_format = FMT_H263;
761 case AV_CODEC_ID_RV20:
762 s->out_format = FMT_H263;
765 s->modified_quant = 1;
769 s->unrestricted_mv = 0;
771 case AV_CODEC_ID_MPEG4:
772 s->out_format = FMT_H263;
774 s->unrestricted_mv = 1;
775 s->low_delay = s->max_b_frames ? 0 : 1;
776 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
778 case AV_CODEC_ID_MSMPEG4V2:
779 s->out_format = FMT_H263;
781 s->unrestricted_mv = 1;
782 s->msmpeg4_version = 2;
786 case AV_CODEC_ID_MSMPEG4V3:
787 s->out_format = FMT_H263;
789 s->unrestricted_mv = 1;
790 s->msmpeg4_version = 3;
791 s->flipflop_rounding = 1;
795 case AV_CODEC_ID_WMV1:
796 s->out_format = FMT_H263;
798 s->unrestricted_mv = 1;
799 s->msmpeg4_version = 4;
800 s->flipflop_rounding = 1;
804 case AV_CODEC_ID_WMV2:
805 s->out_format = FMT_H263;
807 s->unrestricted_mv = 1;
808 s->msmpeg4_version = 5;
809 s->flipflop_rounding = 1;
817 avctx->has_b_frames = !s->low_delay;
821 s->progressive_frame =
822 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
823 CODEC_FLAG_INTERLACED_ME) ||
827 if (ff_MPV_common_init(s) < 0)
830 ff_dct_encode_init(s);
832 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
833 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
835 s->quant_precision = 5;
837 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
838 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
840 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
841 ff_h261_encode_init(s);
842 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
843 ff_h263_encode_init(s);
844 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
845 ff_msmpeg4_encode_init(s);
846 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
847 && s->out_format == FMT_MPEG1)
848 ff_mpeg1_encode_init(s);
851 for (i = 0; i < 64; i++) {
852 int j = s->dsp.idct_permutation[i];
853 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
855 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
856 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
857 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
859 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
862 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
863 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
865 if (s->avctx->intra_matrix)
866 s->intra_matrix[j] = s->avctx->intra_matrix[i];
867 if (s->avctx->inter_matrix)
868 s->inter_matrix[j] = s->avctx->inter_matrix[i];
871 /* precompute matrix */
872 /* for mjpeg, we do include qscale in the matrix */
873 if (s->out_format != FMT_MJPEG) {
874 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
875 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
877 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
878 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
882 if (ff_rate_control_init(s) < 0)
888 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
890 MpegEncContext *s = avctx->priv_data;
892 ff_rate_control_uninit(s);
894 ff_MPV_common_end(s);
895 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
896 s->out_format == FMT_MJPEG)
897 ff_mjpeg_encode_close(s);
899 av_freep(&avctx->extradata);
904 static int get_sae(uint8_t *src, int ref, int stride)
909 for (y = 0; y < 16; y++) {
910 for (x = 0; x < 16; x++) {
911 acc += FFABS(src[x + y * stride] - ref);
918 static int get_intra_count(MpegEncContext *s, uint8_t *src,
919 uint8_t *ref, int stride)
927 for (y = 0; y < h; y += 16) {
928 for (x = 0; x < w; x += 16) {
929 int offset = x + y * stride;
930 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
932 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
933 int sae = get_sae(src + offset, mean, stride);
935 acc += sae + 500 < sad;
942 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
946 int i, display_picture_number = 0, ret;
947 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
948 (s->low_delay ? 0 : 1);
953 display_picture_number = s->input_picture_number++;
955 if (pts != AV_NOPTS_VALUE) {
956 if (s->user_specified_pts != AV_NOPTS_VALUE) {
957 int64_t last = s->user_specified_pts;
960 av_log(s->avctx, AV_LOG_ERROR,
961 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
963 return AVERROR(EINVAL);
966 if (!s->low_delay && display_picture_number == 1)
967 s->dts_delta = pts - last;
969 s->user_specified_pts = pts;
971 if (s->user_specified_pts != AV_NOPTS_VALUE) {
972 s->user_specified_pts =
973 pts = s->user_specified_pts + 1;
974 av_log(s->avctx, AV_LOG_INFO,
975 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
978 pts = display_picture_number;
984 if (!pic_arg->buf[0])
986 if (pic_arg->linesize[0] != s->linesize)
988 if (pic_arg->linesize[1] != s->uvlinesize)
990 if (pic_arg->linesize[2] != s->uvlinesize)
993 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
994 pic_arg->linesize[1], s->linesize, s->uvlinesize);
997 i = ff_find_unused_picture(s, 1);
1001 pic = &s->picture[i];
1004 if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
1006 if (ff_alloc_picture(s, pic, 1) < 0) {
1010 i = ff_find_unused_picture(s, 0);
1014 pic = &s->picture[i];
1017 if (ff_alloc_picture(s, pic, 0) < 0) {
1021 if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1022 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1023 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1026 int h_chroma_shift, v_chroma_shift;
1027 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1031 for (i = 0; i < 3; i++) {
1032 int src_stride = pic_arg->linesize[i];
1033 int dst_stride = i ? s->uvlinesize : s->linesize;
1034 int h_shift = i ? h_chroma_shift : 0;
1035 int v_shift = i ? v_chroma_shift : 0;
1036 int w = s->width >> h_shift;
1037 int h = s->height >> v_shift;
1038 uint8_t *src = pic_arg->data[i];
1039 uint8_t *dst = pic->f.data[i];
1041 if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1042 h = ((s->height + 15)/16*16) >> v_shift;
1045 if (!s->avctx->rc_buffer_size)
1046 dst += INPLACE_OFFSET;
1048 if (src_stride == dst_stride)
1049 memcpy(dst, src, src_stride * h);
1052 uint8_t *dst2 = dst;
1054 memcpy(dst2, src, w);
1059 if ((s->width & 15) || (s->height & 15)) {
1060 s->dsp.draw_edges(dst, dst_stride,
1069 ret = av_frame_copy_props(&pic->f, pic_arg);
1073 pic->f.display_picture_number = display_picture_number;
1074 pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
1077 /* shift buffer entries */
1078 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1079 s->input_picture[i - 1] = s->input_picture[i];
1081 s->input_picture[encoding_delay] = (Picture*) pic;
1086 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1090 int64_t score64 = 0;
1092 for (plane = 0; plane < 3; plane++) {
1093 const int stride = p->f.linesize[plane];
1094 const int bw = plane ? 1 : 2;
1095 for (y = 0; y < s->mb_height * bw; y++) {
1096 for (x = 0; x < s->mb_width * bw; x++) {
1097 int off = p->shared ? 0 : 16;
1098 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1099 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1100 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1102 switch (s->avctx->frame_skip_exp) {
1103 case 0: score = FFMAX(score, v); break;
1104 case 1: score += FFABS(v); break;
1105 case 2: score += v * v; break;
1106 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1107 case 4: score64 += v * v * (int64_t)(v * v); break;
1116 if (score64 < s->avctx->frame_skip_threshold)
1118 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1123 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1125 AVPacket pkt = { 0 };
1126 int ret, got_output;
1128 av_init_packet(&pkt);
1129 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1134 av_free_packet(&pkt);
1138 static int estimate_best_b_count(MpegEncContext *s)
1140 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1141 AVCodecContext *c = avcodec_alloc_context3(NULL);
1142 AVFrame input[FF_MAX_B_FRAMES + 2];
1143 const int scale = s->avctx->brd_scale;
1144 int i, j, out_size, p_lambda, b_lambda, lambda2;
1145 int64_t best_rd = INT64_MAX;
1146 int best_b_count = -1;
1148 av_assert0(scale >= 0 && scale <= 3);
1151 //s->next_picture_ptr->quality;
1152 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1153 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1154 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1155 if (!b_lambda) // FIXME we should do this somewhere else
1156 b_lambda = p_lambda;
1157 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1160 c->width = s->width >> scale;
1161 c->height = s->height >> scale;
1162 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1163 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1164 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1165 c->mb_decision = s->avctx->mb_decision;
1166 c->me_cmp = s->avctx->me_cmp;
1167 c->mb_cmp = s->avctx->mb_cmp;
1168 c->me_sub_cmp = s->avctx->me_sub_cmp;
1169 c->pix_fmt = AV_PIX_FMT_YUV420P;
1170 c->time_base = s->avctx->time_base;
1171 c->max_b_frames = s->max_b_frames;
1173 if (avcodec_open2(c, codec, NULL) < 0)
1176 for (i = 0; i < s->max_b_frames + 2; i++) {
1177 int ysize = c->width * c->height;
1178 int csize = (c->width / 2) * (c->height / 2);
1179 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1180 s->next_picture_ptr;
1182 avcodec_get_frame_defaults(&input[i]);
1183 input[i].data[0] = av_malloc(ysize + 2 * csize);
1184 input[i].data[1] = input[i].data[0] + ysize;
1185 input[i].data[2] = input[i].data[1] + csize;
1186 input[i].linesize[0] = c->width;
1187 input[i].linesize[1] =
1188 input[i].linesize[2] = c->width / 2;
1190 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1191 pre_input = *pre_input_ptr;
1193 if (!pre_input.shared && i) {
1194 pre_input.f.data[0] += INPLACE_OFFSET;
1195 pre_input.f.data[1] += INPLACE_OFFSET;
1196 pre_input.f.data[2] += INPLACE_OFFSET;
1199 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1200 pre_input.f.data[0], pre_input.f.linesize[0],
1201 c->width, c->height);
1202 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1203 pre_input.f.data[1], pre_input.f.linesize[1],
1204 c->width >> 1, c->height >> 1);
1205 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1206 pre_input.f.data[2], pre_input.f.linesize[2],
1207 c->width >> 1, c->height >> 1);
1211 for (j = 0; j < s->max_b_frames + 1; j++) {
1214 if (!s->input_picture[j])
1217 c->error[0] = c->error[1] = c->error[2] = 0;
1219 input[0].pict_type = AV_PICTURE_TYPE_I;
1220 input[0].quality = 1 * FF_QP2LAMBDA;
1222 out_size = encode_frame(c, &input[0]);
1224 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1226 for (i = 0; i < s->max_b_frames + 1; i++) {
1227 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1229 input[i + 1].pict_type = is_p ?
1230 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1231 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1233 out_size = encode_frame(c, &input[i + 1]);
1235 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1238 /* get the delayed frames */
1240 out_size = encode_frame(c, NULL);
1241 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1244 rd += c->error[0] + c->error[1] + c->error[2];
1255 for (i = 0; i < s->max_b_frames + 2; i++) {
1256 av_freep(&input[i].data[0]);
1259 return best_b_count;
1262 static int select_input_picture(MpegEncContext *s)
1266 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1267 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1268 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1270 /* set next picture type & ordering */
1271 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1272 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1273 s->next_picture_ptr == NULL || s->intra_only) {
1274 s->reordered_input_picture[0] = s->input_picture[0];
1275 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1276 s->reordered_input_picture[0]->f.coded_picture_number =
1277 s->coded_picture_number++;
1281 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1282 if (s->picture_in_gop_number < s->gop_size &&
1283 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1284 // FIXME check that te gop check above is +-1 correct
1285 av_frame_unref(&s->input_picture[0]->f);
1288 ff_vbv_update(s, 0);
1294 if (s->flags & CODEC_FLAG_PASS2) {
1295 for (i = 0; i < s->max_b_frames + 1; i++) {
1296 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1298 if (pict_num >= s->rc_context.num_entries)
1300 if (!s->input_picture[i]) {
1301 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1305 s->input_picture[i]->f.pict_type =
1306 s->rc_context.entry[pict_num].new_pict_type;
1310 if (s->avctx->b_frame_strategy == 0) {
1311 b_frames = s->max_b_frames;
1312 while (b_frames && !s->input_picture[b_frames])
1314 } else if (s->avctx->b_frame_strategy == 1) {
1315 for (i = 1; i < s->max_b_frames + 1; i++) {
1316 if (s->input_picture[i] &&
1317 s->input_picture[i]->b_frame_score == 0) {
1318 s->input_picture[i]->b_frame_score =
1320 s->input_picture[i ]->f.data[0],
1321 s->input_picture[i - 1]->f.data[0],
1325 for (i = 0; i < s->max_b_frames + 1; i++) {
1326 if (s->input_picture[i] == NULL ||
1327 s->input_picture[i]->b_frame_score - 1 >
1328 s->mb_num / s->avctx->b_sensitivity)
1332 b_frames = FFMAX(0, i - 1);
1335 for (i = 0; i < b_frames + 1; i++) {
1336 s->input_picture[i]->b_frame_score = 0;
1338 } else if (s->avctx->b_frame_strategy == 2) {
1339 b_frames = estimate_best_b_count(s);
1341 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1347 for (i = b_frames - 1; i >= 0; i--) {
1348 int type = s->input_picture[i]->f.pict_type;
1349 if (type && type != AV_PICTURE_TYPE_B)
1352 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1353 b_frames == s->max_b_frames) {
1354 av_log(s->avctx, AV_LOG_ERROR,
1355 "warning, too many b frames in a row\n");
1358 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1359 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1360 s->gop_size > s->picture_in_gop_number) {
1361 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1363 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1365 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1369 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1370 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1373 s->reordered_input_picture[0] = s->input_picture[b_frames];
1374 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1375 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1376 s->reordered_input_picture[0]->f.coded_picture_number =
1377 s->coded_picture_number++;
1378 for (i = 0; i < b_frames; i++) {
1379 s->reordered_input_picture[i + 1] = s->input_picture[i];
1380 s->reordered_input_picture[i + 1]->f.pict_type =
1382 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1383 s->coded_picture_number++;
1388 if (s->reordered_input_picture[0]) {
1389 s->reordered_input_picture[0]->reference =
1390 s->reordered_input_picture[0]->f.pict_type !=
1391 AV_PICTURE_TYPE_B ? 3 : 0;
1393 ff_mpeg_unref_picture(s, &s->new_picture);
1394 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1397 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1398 // input is a shared pix, so we can't modifiy it -> alloc a new
1399 // one & ensure that the shared one is reuseable
1402 int i = ff_find_unused_picture(s, 0);
1405 pic = &s->picture[i];
1407 pic->reference = s->reordered_input_picture[0]->reference;
1408 if (ff_alloc_picture(s, pic, 0) < 0) {
1412 ret = av_frame_copy_props(&pic->f, &s->reordered_input_picture[0]->f);
1416 /* mark us unused / free shared pic */
1417 av_frame_unref(&s->reordered_input_picture[0]->f);
1418 s->reordered_input_picture[0]->shared = 0;
1420 s->current_picture_ptr = pic;
1422 // input is not a shared pix -> reuse buffer for current_pix
1423 s->current_picture_ptr = s->reordered_input_picture[0];
1424 for (i = 0; i < 4; i++) {
1425 s->new_picture.f.data[i] += INPLACE_OFFSET;
1428 ff_mpeg_unref_picture(s, &s->current_picture);
1429 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1430 s->current_picture_ptr)) < 0)
1433 s->picture_number = s->new_picture.f.display_picture_number;
1435 ff_mpeg_unref_picture(s, &s->new_picture);
1440 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1441 AVFrame *pic_arg, int *got_packet)
1443 MpegEncContext *s = avctx->priv_data;
1444 int i, stuffing_count, ret;
1445 int context_count = s->slice_context_count;
1447 s->picture_in_gop_number++;
1449 if (load_input_picture(s, pic_arg) < 0)
1452 if (select_input_picture(s) < 0) {
1457 if (s->new_picture.f.data[0]) {
1458 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1461 s->mb_info_ptr = av_packet_new_side_data(pkt,
1462 AV_PKT_DATA_H263_MB_INFO,
1463 s->mb_width*s->mb_height*12);
1464 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1467 for (i = 0; i < context_count; i++) {
1468 int start_y = s->thread_context[i]->start_mb_y;
1469 int end_y = s->thread_context[i]-> end_mb_y;
1470 int h = s->mb_height;
1471 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1472 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1474 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1477 s->pict_type = s->new_picture.f.pict_type;
1479 if (ff_MPV_frame_start(s, avctx) < 0)
1482 if (encode_picture(s, s->picture_number) < 0)
1485 avctx->header_bits = s->header_bits;
1486 avctx->mv_bits = s->mv_bits;
1487 avctx->misc_bits = s->misc_bits;
1488 avctx->i_tex_bits = s->i_tex_bits;
1489 avctx->p_tex_bits = s->p_tex_bits;
1490 avctx->i_count = s->i_count;
1491 // FIXME f/b_count in avctx
1492 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1493 avctx->skip_count = s->skip_count;
1495 ff_MPV_frame_end(s);
1497 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1498 ff_mjpeg_encode_picture_trailer(s);
1500 if (avctx->rc_buffer_size) {
1501 RateControlContext *rcc = &s->rc_context;
1502 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1504 if (put_bits_count(&s->pb) > max_size &&
1505 s->lambda < s->avctx->lmax) {
1506 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1507 (s->qscale + 1) / s->qscale);
1508 if (s->adaptive_quant) {
1510 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1511 s->lambda_table[i] =
1512 FFMAX(s->lambda_table[i] + 1,
1513 s->lambda_table[i] * (s->qscale + 1) /
1516 s->mb_skipped = 0; // done in MPV_frame_start()
1517 // done in encode_picture() so we must undo it
1518 if (s->pict_type == AV_PICTURE_TYPE_P) {
1519 if (s->flipflop_rounding ||
1520 s->codec_id == AV_CODEC_ID_H263P ||
1521 s->codec_id == AV_CODEC_ID_MPEG4)
1522 s->no_rounding ^= 1;
1524 if (s->pict_type != AV_PICTURE_TYPE_B) {
1525 s->time_base = s->last_time_base;
1526 s->last_non_b_time = s->time - s->pp_time;
1528 for (i = 0; i < context_count; i++) {
1529 PutBitContext *pb = &s->thread_context[i]->pb;
1530 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1535 assert(s->avctx->rc_max_rate);
1538 if (s->flags & CODEC_FLAG_PASS1)
1539 ff_write_pass1_stats(s);
1541 for (i = 0; i < 4; i++) {
1542 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1543 avctx->error[i] += s->current_picture_ptr->f.error[i];
1546 if (s->flags & CODEC_FLAG_PASS1)
1547 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1548 avctx->i_tex_bits + avctx->p_tex_bits ==
1549 put_bits_count(&s->pb));
1550 flush_put_bits(&s->pb);
1551 s->frame_bits = put_bits_count(&s->pb);
1553 stuffing_count = ff_vbv_update(s, s->frame_bits);
1554 s->stuffing_bits = 8*stuffing_count;
1555 if (stuffing_count) {
1556 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1557 stuffing_count + 50) {
1558 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1562 switch (s->codec_id) {
1563 case AV_CODEC_ID_MPEG1VIDEO:
1564 case AV_CODEC_ID_MPEG2VIDEO:
1565 while (stuffing_count--) {
1566 put_bits(&s->pb, 8, 0);
1569 case AV_CODEC_ID_MPEG4:
1570 put_bits(&s->pb, 16, 0);
1571 put_bits(&s->pb, 16, 0x1C3);
1572 stuffing_count -= 4;
1573 while (stuffing_count--) {
1574 put_bits(&s->pb, 8, 0xFF);
1578 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1580 flush_put_bits(&s->pb);
1581 s->frame_bits = put_bits_count(&s->pb);
1584 /* update mpeg1/2 vbv_delay for CBR */
1585 if (s->avctx->rc_max_rate &&
1586 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1587 s->out_format == FMT_MPEG1 &&
1588 90000LL * (avctx->rc_buffer_size - 1) <=
1589 s->avctx->rc_max_rate * 0xFFFFLL) {
1590 int vbv_delay, min_delay;
1591 double inbits = s->avctx->rc_max_rate *
1592 av_q2d(s->avctx->time_base);
1593 int minbits = s->frame_bits - 8 *
1594 (s->vbv_delay_ptr - s->pb.buf - 1);
1595 double bits = s->rc_context.buffer_index + minbits - inbits;
1598 av_log(s->avctx, AV_LOG_ERROR,
1599 "Internal error, negative bits\n");
1601 assert(s->repeat_first_field == 0);
1603 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1604 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1605 s->avctx->rc_max_rate;
1607 vbv_delay = FFMAX(vbv_delay, min_delay);
1609 av_assert0(vbv_delay < 0xFFFF);
1611 s->vbv_delay_ptr[0] &= 0xF8;
1612 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1613 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1614 s->vbv_delay_ptr[2] &= 0x07;
1615 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1616 avctx->vbv_delay = vbv_delay * 300;
1618 s->total_bits += s->frame_bits;
1619 avctx->frame_bits = s->frame_bits;
1621 pkt->pts = s->current_picture.f.pts;
1622 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1623 if (!s->current_picture.f.coded_picture_number)
1624 pkt->dts = pkt->pts - s->dts_delta;
1626 pkt->dts = s->reordered_pts;
1627 s->reordered_pts = pkt->pts;
1629 pkt->dts = pkt->pts;
1630 if (s->current_picture.f.key_frame)
1631 pkt->flags |= AV_PKT_FLAG_KEY;
1633 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1638 /* release non-reference frames */
1639 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1640 if (!s->picture[i].reference)
1641 ff_mpeg_unref_picture(s, &s->picture[i]);
1644 assert((s->frame_bits & 7) == 0);
1646 pkt->size = s->frame_bits / 8;
1647 *got_packet = !!pkt->size;
1651 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1652 int n, int threshold)
1654 static const char tab[64] = {
1655 3, 2, 2, 1, 1, 1, 1, 1,
1656 1, 1, 1, 1, 1, 1, 1, 1,
1657 1, 1, 1, 1, 1, 1, 1, 1,
1658 0, 0, 0, 0, 0, 0, 0, 0,
1659 0, 0, 0, 0, 0, 0, 0, 0,
1660 0, 0, 0, 0, 0, 0, 0, 0,
1661 0, 0, 0, 0, 0, 0, 0, 0,
1662 0, 0, 0, 0, 0, 0, 0, 0
1667 int16_t *block = s->block[n];
1668 const int last_index = s->block_last_index[n];
1671 if (threshold < 0) {
1673 threshold = -threshold;
1677 /* Are all we could set to zero already zero? */
1678 if (last_index <= skip_dc - 1)
1681 for (i = 0; i <= last_index; i++) {
1682 const int j = s->intra_scantable.permutated[i];
1683 const int level = FFABS(block[j]);
1685 if (skip_dc && i == 0)
1689 } else if (level > 1) {
1695 if (score >= threshold)
1697 for (i = skip_dc; i <= last_index; i++) {
1698 const int j = s->intra_scantable.permutated[i];
1702 s->block_last_index[n] = 0;
1704 s->block_last_index[n] = -1;
1707 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1711 const int maxlevel = s->max_qcoeff;
1712 const int minlevel = s->min_qcoeff;
1716 i = 1; // skip clipping of intra dc
1720 for (; i <= last_index; i++) {
1721 const int j = s->intra_scantable.permutated[i];
1722 int level = block[j];
1724 if (level > maxlevel) {
1727 } else if (level < minlevel) {
1735 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1736 av_log(s->avctx, AV_LOG_INFO,
1737 "warning, clipping %d dct coefficients to %d..%d\n",
1738 overflow, minlevel, maxlevel);
1741 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1745 for (y = 0; y < 8; y++) {
1746 for (x = 0; x < 8; x++) {
1752 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1753 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1754 int v = ptr[x2 + y2 * stride];
1760 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1765 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1766 int motion_x, int motion_y,
1767 int mb_block_height,
1771 int16_t weight[12][64];
1772 int16_t orig[12][64];
1773 const int mb_x = s->mb_x;
1774 const int mb_y = s->mb_y;
1777 int dct_offset = s->linesize * 8; // default for progressive frames
1778 int uv_dct_offset = s->uvlinesize * 8;
1779 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1780 ptrdiff_t wrap_y, wrap_c;
1782 for (i = 0; i < mb_block_count; i++)
1783 skip_dct[i] = s->skipdct;
1785 if (s->adaptive_quant) {
1786 const int last_qp = s->qscale;
1787 const int mb_xy = mb_x + mb_y * s->mb_stride;
1789 s->lambda = s->lambda_table[mb_xy];
1792 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1793 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1794 s->dquant = s->qscale - last_qp;
1796 if (s->out_format == FMT_H263) {
1797 s->dquant = av_clip(s->dquant, -2, 2);
1799 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1801 if (s->pict_type == AV_PICTURE_TYPE_B) {
1802 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1805 if (s->mv_type == MV_TYPE_8X8)
1811 ff_set_qscale(s, last_qp + s->dquant);
1812 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1813 ff_set_qscale(s, s->qscale + s->dquant);
1815 wrap_y = s->linesize;
1816 wrap_c = s->uvlinesize;
1817 ptr_y = s->new_picture.f.data[0] +
1818 (mb_y * 16 * wrap_y) + mb_x * 16;
1819 ptr_cb = s->new_picture.f.data[1] +
1820 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1821 ptr_cr = s->new_picture.f.data[2] +
1822 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1824 if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1825 uint8_t *ebuf = s->edge_emu_buffer + 32;
1826 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1827 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1828 s->vdsp.emulated_edge_mc(ebuf, wrap_y, ptr_y, wrap_y, 16, 16, mb_x * 16,
1829 mb_y * 16, s->width, s->height);
1831 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, wrap_c, ptr_cb, wrap_c, mb_block_width,
1832 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1834 ptr_cb = ebuf + 18 * wrap_y;
1835 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, wrap_c, ptr_cr, wrap_c, mb_block_width,
1836 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1838 ptr_cr = ebuf + 18 * wrap_y + 16;
1842 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1843 int progressive_score, interlaced_score;
1845 s->interlaced_dct = 0;
1846 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1848 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1849 NULL, wrap_y, 8) - 400;
1851 if (progressive_score > 0) {
1852 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1853 NULL, wrap_y * 2, 8) +
1854 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1855 NULL, wrap_y * 2, 8);
1856 if (progressive_score > interlaced_score) {
1857 s->interlaced_dct = 1;
1859 dct_offset = wrap_y;
1860 uv_dct_offset = wrap_c;
1862 if (s->chroma_format == CHROMA_422 ||
1863 s->chroma_format == CHROMA_444)
1869 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1870 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1871 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1872 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1874 if (s->flags & CODEC_FLAG_GRAY) {
1878 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1879 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1880 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1881 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1882 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1883 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1884 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1885 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1886 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1887 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1888 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1889 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1893 op_pixels_func (*op_pix)[4];
1894 qpel_mc_func (*op_qpix)[16];
1895 uint8_t *dest_y, *dest_cb, *dest_cr;
1897 dest_y = s->dest[0];
1898 dest_cb = s->dest[1];
1899 dest_cr = s->dest[2];
1901 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1902 op_pix = s->hdsp.put_pixels_tab;
1903 op_qpix = s->dsp.put_qpel_pixels_tab;
1905 op_pix = s->hdsp.put_no_rnd_pixels_tab;
1906 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1909 if (s->mv_dir & MV_DIR_FORWARD) {
1910 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1911 s->last_picture.f.data,
1913 op_pix = s->hdsp.avg_pixels_tab;
1914 op_qpix = s->dsp.avg_qpel_pixels_tab;
1916 if (s->mv_dir & MV_DIR_BACKWARD) {
1917 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1918 s->next_picture.f.data,
1922 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1923 int progressive_score, interlaced_score;
1925 s->interlaced_dct = 0;
1926 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1929 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1930 ptr_y + wrap_y * 8, wrap_y,
1933 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1934 progressive_score -= 400;
1936 if (progressive_score > 0) {
1937 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1940 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1944 if (progressive_score > interlaced_score) {
1945 s->interlaced_dct = 1;
1947 dct_offset = wrap_y;
1948 uv_dct_offset = wrap_c;
1950 if (s->chroma_format == CHROMA_422)
1956 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1957 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1958 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1959 dest_y + dct_offset, wrap_y);
1960 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1961 dest_y + dct_offset + 8, wrap_y);
1963 if (s->flags & CODEC_FLAG_GRAY) {
1967 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1968 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1969 if (!s->chroma_y_shift) { /* 422 */
1970 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
1971 dest_cb + uv_dct_offset, wrap_c);
1972 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
1973 dest_cr + uv_dct_offset, wrap_c);
1976 /* pre quantization */
1977 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1978 2 * s->qscale * s->qscale) {
1980 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1981 wrap_y, 8) < 20 * s->qscale)
1983 if (s->dsp.sad[1](NULL, ptr_y + 8,
1984 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1986 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1987 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1989 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1990 dest_y + dct_offset + 8,
1991 wrap_y, 8) < 20 * s->qscale)
1993 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1994 wrap_c, 8) < 20 * s->qscale)
1996 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1997 wrap_c, 8) < 20 * s->qscale)
1999 if (!s->chroma_y_shift) { /* 422 */
2000 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
2001 dest_cb + uv_dct_offset,
2002 wrap_c, 8) < 20 * s->qscale)
2004 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
2005 dest_cr + uv_dct_offset,
2006 wrap_c, 8) < 20 * s->qscale)
2012 if (s->quantizer_noise_shaping) {
2014 get_visual_weight(weight[0], ptr_y , wrap_y);
2016 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2018 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2020 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2022 get_visual_weight(weight[4], ptr_cb , wrap_c);
2024 get_visual_weight(weight[5], ptr_cr , wrap_c);
2025 if (!s->chroma_y_shift) { /* 422 */
2027 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2030 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2033 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2036 /* DCT & quantize */
2037 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2039 for (i = 0; i < mb_block_count; i++) {
2042 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2043 // FIXME we could decide to change to quantizer instead of
2045 // JS: I don't think that would be a good idea it could lower
2046 // quality instead of improve it. Just INTRADC clipping
2047 // deserves changes in quantizer
2049 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2051 s->block_last_index[i] = -1;
2053 if (s->quantizer_noise_shaping) {
2054 for (i = 0; i < mb_block_count; i++) {
2056 s->block_last_index[i] =
2057 dct_quantize_refine(s, s->block[i], weight[i],
2058 orig[i], i, s->qscale);
2063 if (s->luma_elim_threshold && !s->mb_intra)
2064 for (i = 0; i < 4; i++)
2065 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2066 if (s->chroma_elim_threshold && !s->mb_intra)
2067 for (i = 4; i < mb_block_count; i++)
2068 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2070 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2071 for (i = 0; i < mb_block_count; i++) {
2072 if (s->block_last_index[i] == -1)
2073 s->coded_score[i] = INT_MAX / 256;
2078 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2079 s->block_last_index[4] =
2080 s->block_last_index[5] = 0;
2082 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2083 if (!s->chroma_y_shift) { /* 422 / 444 */
2084 for (i=6; i<12; i++) {
2085 s->block_last_index[i] = 0;
2086 s->block[i][0] = s->block[4][0];
2091 // non c quantize code returns incorrect block_last_index FIXME
2092 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2093 for (i = 0; i < mb_block_count; i++) {
2095 if (s->block_last_index[i] > 0) {
2096 for (j = 63; j > 0; j--) {
2097 if (s->block[i][s->intra_scantable.permutated[j]])
2100 s->block_last_index[i] = j;
2105 /* huffman encode */
2106 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2107 case AV_CODEC_ID_MPEG1VIDEO:
2108 case AV_CODEC_ID_MPEG2VIDEO:
2109 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2110 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2112 case AV_CODEC_ID_MPEG4:
2113 if (CONFIG_MPEG4_ENCODER)
2114 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2116 case AV_CODEC_ID_MSMPEG4V2:
2117 case AV_CODEC_ID_MSMPEG4V3:
2118 case AV_CODEC_ID_WMV1:
2119 if (CONFIG_MSMPEG4_ENCODER)
2120 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2122 case AV_CODEC_ID_WMV2:
2123 if (CONFIG_WMV2_ENCODER)
2124 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2126 case AV_CODEC_ID_H261:
2127 if (CONFIG_H261_ENCODER)
2128 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2130 case AV_CODEC_ID_H263:
2131 case AV_CODEC_ID_H263P:
2132 case AV_CODEC_ID_FLV1:
2133 case AV_CODEC_ID_RV10:
2134 case AV_CODEC_ID_RV20:
2135 if (CONFIG_H263_ENCODER)
2136 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2138 case AV_CODEC_ID_MJPEG:
2139 case AV_CODEC_ID_AMV:
2140 if (CONFIG_MJPEG_ENCODER)
2141 ff_mjpeg_encode_mb(s, s->block);
2148 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2150 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2151 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2152 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2155 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2158 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2161 d->mb_skip_run= s->mb_skip_run;
2163 d->last_dc[i] = s->last_dc[i];
2166 d->mv_bits= s->mv_bits;
2167 d->i_tex_bits= s->i_tex_bits;
2168 d->p_tex_bits= s->p_tex_bits;
2169 d->i_count= s->i_count;
2170 d->f_count= s->f_count;
2171 d->b_count= s->b_count;
2172 d->skip_count= s->skip_count;
2173 d->misc_bits= s->misc_bits;
2177 d->qscale= s->qscale;
2178 d->dquant= s->dquant;
2180 d->esc3_level_length= s->esc3_level_length;
2183 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2186 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2187 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2190 d->mb_skip_run= s->mb_skip_run;
2192 d->last_dc[i] = s->last_dc[i];
2195 d->mv_bits= s->mv_bits;
2196 d->i_tex_bits= s->i_tex_bits;
2197 d->p_tex_bits= s->p_tex_bits;
2198 d->i_count= s->i_count;
2199 d->f_count= s->f_count;
2200 d->b_count= s->b_count;
2201 d->skip_count= s->skip_count;
2202 d->misc_bits= s->misc_bits;
2204 d->mb_intra= s->mb_intra;
2205 d->mb_skipped= s->mb_skipped;
2206 d->mv_type= s->mv_type;
2207 d->mv_dir= s->mv_dir;
2209 if(s->data_partitioning){
2211 d->tex_pb= s->tex_pb;
2215 d->block_last_index[i]= s->block_last_index[i];
2216 d->interlaced_dct= s->interlaced_dct;
2217 d->qscale= s->qscale;
2219 d->esc3_level_length= s->esc3_level_length;
2222 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2223 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2224 int *dmin, int *next_block, int motion_x, int motion_y)
2227 uint8_t *dest_backup[3];
2229 copy_context_before_encode(s, backup, type);
2231 s->block= s->blocks[*next_block];
2232 s->pb= pb[*next_block];
2233 if(s->data_partitioning){
2234 s->pb2 = pb2 [*next_block];
2235 s->tex_pb= tex_pb[*next_block];
2239 memcpy(dest_backup, s->dest, sizeof(s->dest));
2240 s->dest[0] = s->rd_scratchpad;
2241 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2242 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2243 assert(s->linesize >= 32); //FIXME
2246 encode_mb(s, motion_x, motion_y);
2248 score= put_bits_count(&s->pb);
2249 if(s->data_partitioning){
2250 score+= put_bits_count(&s->pb2);
2251 score+= put_bits_count(&s->tex_pb);
2254 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2255 ff_MPV_decode_mb(s, s->block);
2257 score *= s->lambda2;
2258 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2262 memcpy(s->dest, dest_backup, sizeof(s->dest));
2269 copy_context_after_encode(best, s, type);
2273 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2274 uint32_t *sq = ff_squareTbl + 256;
2279 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2280 else if(w==8 && h==8)
2281 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2285 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2294 static int sse_mb(MpegEncContext *s){
2298 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2299 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2302 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2303 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)
2304 +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)
2305 +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);
2307 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)
2308 +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)
2309 +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);
2312 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)
2313 +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)
2314 +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);
2317 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2318 MpegEncContext *s= *(void**)arg;
2322 s->me.dia_size= s->avctx->pre_dia_size;
2323 s->first_slice_line=1;
2324 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2325 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2326 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2328 s->first_slice_line=0;
2336 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2337 MpegEncContext *s= *(void**)arg;
2339 ff_check_alignment();
2341 s->me.dia_size= s->avctx->dia_size;
2342 s->first_slice_line=1;
2343 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2344 s->mb_x=0; //for block init below
2345 ff_init_block_index(s);
2346 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2347 s->block_index[0]+=2;
2348 s->block_index[1]+=2;
2349 s->block_index[2]+=2;
2350 s->block_index[3]+=2;
2352 /* compute motion vector & mb_type and store in context */
2353 if(s->pict_type==AV_PICTURE_TYPE_B)
2354 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2356 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2358 s->first_slice_line=0;
2363 static int mb_var_thread(AVCodecContext *c, void *arg){
2364 MpegEncContext *s= *(void**)arg;
2367 ff_check_alignment();
2369 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2370 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2373 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2375 int sum = s->dsp.pix_sum(pix, s->linesize);
2377 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2379 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2380 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2381 s->me.mb_var_sum_temp += varc;
2387 static void write_slice_end(MpegEncContext *s){
2388 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2389 if(s->partitioned_frame){
2390 ff_mpeg4_merge_partitions(s);
2393 ff_mpeg4_stuffing(&s->pb);
2394 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2395 ff_mjpeg_encode_stuffing(s);
2398 avpriv_align_put_bits(&s->pb);
2399 flush_put_bits(&s->pb);
2401 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2402 s->misc_bits+= get_bits_diff(s);
2405 static void write_mb_info(MpegEncContext *s)
2407 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2408 int offset = put_bits_count(&s->pb);
2409 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2410 int gobn = s->mb_y / s->gob_index;
2412 if (CONFIG_H263_ENCODER)
2413 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2414 bytestream_put_le32(&ptr, offset);
2415 bytestream_put_byte(&ptr, s->qscale);
2416 bytestream_put_byte(&ptr, gobn);
2417 bytestream_put_le16(&ptr, mba);
2418 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2419 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2420 /* 4MV not implemented */
2421 bytestream_put_byte(&ptr, 0); /* hmv2 */
2422 bytestream_put_byte(&ptr, 0); /* vmv2 */
2425 static void update_mb_info(MpegEncContext *s, int startcode)
2429 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2430 s->mb_info_size += 12;
2431 s->prev_mb_info = s->last_mb_info;
2434 s->prev_mb_info = put_bits_count(&s->pb)/8;
2435 /* This might have incremented mb_info_size above, and we return without
2436 * actually writing any info into that slot yet. But in that case,
2437 * this will be called again at the start of the after writing the
2438 * start code, actually writing the mb info. */
2442 s->last_mb_info = put_bits_count(&s->pb)/8;
2443 if (!s->mb_info_size)
2444 s->mb_info_size += 12;
2448 static int encode_thread(AVCodecContext *c, void *arg){
2449 MpegEncContext *s= *(void**)arg;
2450 int mb_x, mb_y, pdif = 0;
2451 int chr_h= 16>>s->chroma_y_shift;
2453 MpegEncContext best_s, backup_s;
2454 uint8_t bit_buf[2][MAX_MB_BYTES];
2455 uint8_t bit_buf2[2][MAX_MB_BYTES];
2456 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2457 PutBitContext pb[2], pb2[2], tex_pb[2];
2459 ff_check_alignment();
2462 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2463 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2464 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2467 s->last_bits= put_bits_count(&s->pb);
2478 /* init last dc values */
2479 /* note: quant matrix value (8) is implied here */
2480 s->last_dc[i] = 128 << s->intra_dc_precision;
2482 s->current_picture.f.error[i] = 0;
2484 if(s->codec_id==AV_CODEC_ID_AMV){
2485 s->last_dc[0] = 128*8/13;
2486 s->last_dc[1] = 128*8/14;
2487 s->last_dc[2] = 128*8/14;
2490 memset(s->last_mv, 0, sizeof(s->last_mv));
2494 switch(s->codec_id){
2495 case AV_CODEC_ID_H263:
2496 case AV_CODEC_ID_H263P:
2497 case AV_CODEC_ID_FLV1:
2498 if (CONFIG_H263_ENCODER)
2499 s->gob_index = ff_h263_get_gob_height(s);
2501 case AV_CODEC_ID_MPEG4:
2502 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2503 ff_mpeg4_init_partitions(s);
2509 s->first_slice_line = 1;
2510 s->ptr_lastgob = s->pb.buf;
2511 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2515 ff_set_qscale(s, s->qscale);
2516 ff_init_block_index(s);
2518 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2519 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2520 int mb_type= s->mb_type[xy];
2525 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2526 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2529 if(s->data_partitioning){
2530 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2531 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2532 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2538 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2539 ff_update_block_index(s);
2541 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2542 ff_h261_reorder_mb_index(s);
2543 xy= s->mb_y*s->mb_stride + s->mb_x;
2544 mb_type= s->mb_type[xy];
2547 /* write gob / video packet header */
2549 int current_packet_size, is_gob_start;
2551 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2553 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2555 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2557 switch(s->codec_id){
2558 case AV_CODEC_ID_H263:
2559 case AV_CODEC_ID_H263P:
2560 if(!s->h263_slice_structured)
2561 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2563 case AV_CODEC_ID_MPEG2VIDEO:
2564 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2565 case AV_CODEC_ID_MPEG1VIDEO:
2566 if(s->mb_skip_run) is_gob_start=0;
2568 case AV_CODEC_ID_MJPEG:
2569 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2574 if(s->start_mb_y != mb_y || mb_x!=0){
2577 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2578 ff_mpeg4_init_partitions(s);
2582 av_assert2((put_bits_count(&s->pb)&7) == 0);
2583 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2585 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2586 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2587 int d= 100 / s->avctx->error_rate;
2589 current_packet_size=0;
2590 s->pb.buf_ptr= s->ptr_lastgob;
2591 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2595 if (s->avctx->rtp_callback){
2596 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2597 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2599 update_mb_info(s, 1);
2601 switch(s->codec_id){
2602 case AV_CODEC_ID_MPEG4:
2603 if (CONFIG_MPEG4_ENCODER) {
2604 ff_mpeg4_encode_video_packet_header(s);
2605 ff_mpeg4_clean_buffers(s);
2608 case AV_CODEC_ID_MPEG1VIDEO:
2609 case AV_CODEC_ID_MPEG2VIDEO:
2610 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2611 ff_mpeg1_encode_slice_header(s);
2612 ff_mpeg1_clean_buffers(s);
2615 case AV_CODEC_ID_H263:
2616 case AV_CODEC_ID_H263P:
2617 if (CONFIG_H263_ENCODER)
2618 ff_h263_encode_gob_header(s, mb_y);
2622 if(s->flags&CODEC_FLAG_PASS1){
2623 int bits= put_bits_count(&s->pb);
2624 s->misc_bits+= bits - s->last_bits;
2628 s->ptr_lastgob += current_packet_size;
2629 s->first_slice_line=1;
2630 s->resync_mb_x=mb_x;
2631 s->resync_mb_y=mb_y;
2635 if( (s->resync_mb_x == s->mb_x)
2636 && s->resync_mb_y+1 == s->mb_y){
2637 s->first_slice_line=0;
2641 s->dquant=0; //only for QP_RD
2643 update_mb_info(s, 0);
2645 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
2647 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2649 copy_context_before_encode(&backup_s, s, -1);
2651 best_s.data_partitioning= s->data_partitioning;
2652 best_s.partitioned_frame= s->partitioned_frame;
2653 if(s->data_partitioning){
2654 backup_s.pb2= s->pb2;
2655 backup_s.tex_pb= s->tex_pb;
2658 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2659 s->mv_dir = MV_DIR_FORWARD;
2660 s->mv_type = MV_TYPE_16X16;
2662 s->mv[0][0][0] = s->p_mv_table[xy][0];
2663 s->mv[0][0][1] = s->p_mv_table[xy][1];
2664 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2665 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2667 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2668 s->mv_dir = MV_DIR_FORWARD;
2669 s->mv_type = MV_TYPE_FIELD;
2672 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2673 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2674 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2676 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2677 &dmin, &next_block, 0, 0);
2679 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2680 s->mv_dir = MV_DIR_FORWARD;
2681 s->mv_type = MV_TYPE_16X16;
2685 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2686 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2688 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2689 s->mv_dir = MV_DIR_FORWARD;
2690 s->mv_type = MV_TYPE_8X8;
2693 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2694 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2696 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2697 &dmin, &next_block, 0, 0);
2699 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2700 s->mv_dir = MV_DIR_FORWARD;
2701 s->mv_type = MV_TYPE_16X16;
2703 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2704 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2705 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2706 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2708 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2709 s->mv_dir = MV_DIR_BACKWARD;
2710 s->mv_type = MV_TYPE_16X16;
2712 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2713 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2714 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2715 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2717 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2718 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2719 s->mv_type = MV_TYPE_16X16;
2721 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2722 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2723 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2724 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2725 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2726 &dmin, &next_block, 0, 0);
2728 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2729 s->mv_dir = MV_DIR_FORWARD;
2730 s->mv_type = MV_TYPE_FIELD;
2733 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2734 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2735 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2737 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2738 &dmin, &next_block, 0, 0);
2740 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2741 s->mv_dir = MV_DIR_BACKWARD;
2742 s->mv_type = MV_TYPE_FIELD;
2745 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2746 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2747 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2749 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2750 &dmin, &next_block, 0, 0);
2752 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2753 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2754 s->mv_type = MV_TYPE_FIELD;
2756 for(dir=0; dir<2; dir++){
2758 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2759 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2760 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2763 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2764 &dmin, &next_block, 0, 0);
2766 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2768 s->mv_type = MV_TYPE_16X16;
2772 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2773 &dmin, &next_block, 0, 0);
2774 if(s->h263_pred || s->h263_aic){
2776 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2778 ff_clean_intra_table_entries(s); //old mode?
2782 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2783 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2784 const int last_qp= backup_s.qscale;
2787 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2788 static const int dquant_tab[4]={-1,1,-2,2};
2789 int storecoefs = s->mb_intra && s->dc_val[0];
2791 av_assert2(backup_s.dquant == 0);
2794 s->mv_dir= best_s.mv_dir;
2795 s->mv_type = MV_TYPE_16X16;
2796 s->mb_intra= best_s.mb_intra;
2797 s->mv[0][0][0] = best_s.mv[0][0][0];
2798 s->mv[0][0][1] = best_s.mv[0][0][1];
2799 s->mv[1][0][0] = best_s.mv[1][0][0];
2800 s->mv[1][0][1] = best_s.mv[1][0][1];
2802 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2803 for(; qpi<4; qpi++){
2804 int dquant= dquant_tab[qpi];
2805 qp= last_qp + dquant;
2806 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2808 backup_s.dquant= dquant;
2811 dc[i]= s->dc_val[0][ s->block_index[i] ];
2812 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2816 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2817 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2818 if(best_s.qscale != qp){
2821 s->dc_val[0][ s->block_index[i] ]= dc[i];
2822 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2829 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2830 int mx= s->b_direct_mv_table[xy][0];
2831 int my= s->b_direct_mv_table[xy][1];
2833 backup_s.dquant = 0;
2834 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2836 ff_mpeg4_set_direct_mv(s, mx, my);
2837 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2838 &dmin, &next_block, mx, my);
2840 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2841 backup_s.dquant = 0;
2842 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2844 ff_mpeg4_set_direct_mv(s, 0, 0);
2845 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2846 &dmin, &next_block, 0, 0);
2848 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2851 coded |= s->block_last_index[i];
2854 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2855 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2856 mx=my=0; //FIXME find the one we actually used
2857 ff_mpeg4_set_direct_mv(s, mx, my);
2858 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2866 s->mv_dir= best_s.mv_dir;
2867 s->mv_type = best_s.mv_type;
2869 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2870 s->mv[0][0][1] = best_s.mv[0][0][1];
2871 s->mv[1][0][0] = best_s.mv[1][0][0];
2872 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2875 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2876 &dmin, &next_block, mx, my);
2881 s->current_picture.qscale_table[xy] = best_s.qscale;
2883 copy_context_after_encode(s, &best_s, -1);
2885 pb_bits_count= put_bits_count(&s->pb);
2886 flush_put_bits(&s->pb);
2887 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2890 if(s->data_partitioning){
2891 pb2_bits_count= put_bits_count(&s->pb2);
2892 flush_put_bits(&s->pb2);
2893 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2894 s->pb2= backup_s.pb2;
2896 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2897 flush_put_bits(&s->tex_pb);
2898 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2899 s->tex_pb= backup_s.tex_pb;
2901 s->last_bits= put_bits_count(&s->pb);
2903 if (CONFIG_H263_ENCODER &&
2904 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2905 ff_h263_update_motion_val(s);
2907 if(next_block==0){ //FIXME 16 vs linesize16
2908 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2909 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2910 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2913 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2914 ff_MPV_decode_mb(s, s->block);
2916 int motion_x = 0, motion_y = 0;
2917 s->mv_type=MV_TYPE_16X16;
2918 // only one MB-Type possible
2921 case CANDIDATE_MB_TYPE_INTRA:
2924 motion_x= s->mv[0][0][0] = 0;
2925 motion_y= s->mv[0][0][1] = 0;
2927 case CANDIDATE_MB_TYPE_INTER:
2928 s->mv_dir = MV_DIR_FORWARD;
2930 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2931 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2933 case CANDIDATE_MB_TYPE_INTER_I:
2934 s->mv_dir = MV_DIR_FORWARD;
2935 s->mv_type = MV_TYPE_FIELD;
2938 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2939 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2940 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2943 case CANDIDATE_MB_TYPE_INTER4V:
2944 s->mv_dir = MV_DIR_FORWARD;
2945 s->mv_type = MV_TYPE_8X8;
2948 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2949 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2952 case CANDIDATE_MB_TYPE_DIRECT:
2953 if (CONFIG_MPEG4_ENCODER) {
2954 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2956 motion_x=s->b_direct_mv_table[xy][0];
2957 motion_y=s->b_direct_mv_table[xy][1];
2958 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2961 case CANDIDATE_MB_TYPE_DIRECT0:
2962 if (CONFIG_MPEG4_ENCODER) {
2963 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2965 ff_mpeg4_set_direct_mv(s, 0, 0);
2968 case CANDIDATE_MB_TYPE_BIDIR:
2969 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2971 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2972 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2973 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2974 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2976 case CANDIDATE_MB_TYPE_BACKWARD:
2977 s->mv_dir = MV_DIR_BACKWARD;
2979 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2980 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2982 case CANDIDATE_MB_TYPE_FORWARD:
2983 s->mv_dir = MV_DIR_FORWARD;
2985 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2986 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2988 case CANDIDATE_MB_TYPE_FORWARD_I:
2989 s->mv_dir = MV_DIR_FORWARD;
2990 s->mv_type = MV_TYPE_FIELD;
2993 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2994 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2995 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2998 case CANDIDATE_MB_TYPE_BACKWARD_I:
2999 s->mv_dir = MV_DIR_BACKWARD;
3000 s->mv_type = MV_TYPE_FIELD;
3003 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3004 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3005 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3008 case CANDIDATE_MB_TYPE_BIDIR_I:
3009 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3010 s->mv_type = MV_TYPE_FIELD;
3012 for(dir=0; dir<2; dir++){
3014 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3015 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3016 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3021 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3024 encode_mb(s, motion_x, motion_y);
3026 // RAL: Update last macroblock type
3027 s->last_mv_dir = s->mv_dir;
3029 if (CONFIG_H263_ENCODER &&
3030 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3031 ff_h263_update_motion_val(s);
3033 ff_MPV_decode_mb(s, s->block);
3036 /* clean the MV table in IPS frames for direct mode in B frames */
3037 if(s->mb_intra /* && I,P,S_TYPE */){
3038 s->p_mv_table[xy][0]=0;
3039 s->p_mv_table[xy][1]=0;
3042 if(s->flags&CODEC_FLAG_PSNR){
3046 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3047 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3049 s->current_picture.f.error[0] += sse(
3050 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3051 s->dest[0], w, h, s->linesize);
3052 s->current_picture.f.error[1] += sse(
3053 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3054 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3055 s->current_picture.f.error[2] += sse(
3056 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3057 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3060 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3061 ff_h263_loop_filter(s);
3063 av_dlog(s->avctx, "MB %d %d bits\n",
3064 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3068 //not beautiful here but we must write it before flushing so it has to be here
3069 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3070 ff_msmpeg4_encode_ext_header(s);
3074 /* Send the last GOB if RTP */
3075 if (s->avctx->rtp_callback) {
3076 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3077 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3078 /* Call the RTP callback to send the last GOB */
3080 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3086 #define MERGE(field) dst->field += src->field; src->field=0
3087 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3088 MERGE(me.scene_change_score);
3089 MERGE(me.mc_mb_var_sum_temp);
3090 MERGE(me.mb_var_sum_temp);
3093 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3096 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3097 MERGE(dct_count[1]);
3106 MERGE(er.error_count);
3107 MERGE(padding_bug_score);
3108 MERGE(current_picture.f.error[0]);
3109 MERGE(current_picture.f.error[1]);
3110 MERGE(current_picture.f.error[2]);
3112 if(dst->avctx->noise_reduction){
3113 for(i=0; i<64; i++){
3114 MERGE(dct_error_sum[0][i]);
3115 MERGE(dct_error_sum[1][i]);
3119 assert(put_bits_count(&src->pb) % 8 ==0);
3120 assert(put_bits_count(&dst->pb) % 8 ==0);
3121 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3122 flush_put_bits(&dst->pb);
3125 static int estimate_qp(MpegEncContext *s, int dry_run){
3126 if (s->next_lambda){
3127 s->current_picture_ptr->f.quality =
3128 s->current_picture.f.quality = s->next_lambda;
3129 if(!dry_run) s->next_lambda= 0;
3130 } else if (!s->fixed_qscale) {
3131 s->current_picture_ptr->f.quality =
3132 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3133 if (s->current_picture.f.quality < 0)
3137 if(s->adaptive_quant){
3138 switch(s->codec_id){
3139 case AV_CODEC_ID_MPEG4:
3140 if (CONFIG_MPEG4_ENCODER)
3141 ff_clean_mpeg4_qscales(s);
3143 case AV_CODEC_ID_H263:
3144 case AV_CODEC_ID_H263P:
3145 case AV_CODEC_ID_FLV1:
3146 if (CONFIG_H263_ENCODER)
3147 ff_clean_h263_qscales(s);
3150 ff_init_qscale_tab(s);
3153 s->lambda= s->lambda_table[0];
3156 s->lambda = s->current_picture.f.quality;
3161 /* must be called before writing the header */
3162 static void set_frame_distances(MpegEncContext * s){
3163 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3164 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3166 if(s->pict_type==AV_PICTURE_TYPE_B){
3167 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3168 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3170 s->pp_time= s->time - s->last_non_b_time;
3171 s->last_non_b_time= s->time;
3172 assert(s->picture_number==0 || s->pp_time > 0);
3176 static int encode_picture(MpegEncContext *s, int picture_number)
3180 int context_count = s->slice_context_count;
3182 s->picture_number = picture_number;
3184 /* Reset the average MB variance */
3185 s->me.mb_var_sum_temp =
3186 s->me.mc_mb_var_sum_temp = 0;
3188 /* we need to initialize some time vars before we can encode b-frames */
3189 // RAL: Condition added for MPEG1VIDEO
3190 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3191 set_frame_distances(s);
3192 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3193 ff_set_mpeg4_time(s);
3195 s->me.scene_change_score=0;
3197 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3199 if(s->pict_type==AV_PICTURE_TYPE_I){
3200 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3201 else s->no_rounding=0;
3202 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3203 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3204 s->no_rounding ^= 1;
3207 if(s->flags & CODEC_FLAG_PASS2){
3208 if (estimate_qp(s,1) < 0)
3210 ff_get_2pass_fcode(s);
3211 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3212 if(s->pict_type==AV_PICTURE_TYPE_B)
3213 s->lambda= s->last_lambda_for[s->pict_type];
3215 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3219 if(s->codec_id != AV_CODEC_ID_AMV){
3220 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3221 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3222 s->q_chroma_intra_matrix = s->q_intra_matrix;
3223 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3226 s->mb_intra=0; //for the rate distortion & bit compare functions
3227 for(i=1; i<context_count; i++){
3228 ret = ff_update_duplicate_context(s->thread_context[i], s);
3236 /* Estimate motion for every MB */
3237 if(s->pict_type != AV_PICTURE_TYPE_I){
3238 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3239 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3240 if (s->pict_type != AV_PICTURE_TYPE_B) {
3241 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3242 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3246 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3247 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3249 for(i=0; i<s->mb_stride*s->mb_height; i++)
3250 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3252 if(!s->fixed_qscale){
3253 /* finding spatial complexity for I-frame rate control */
3254 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3257 for(i=1; i<context_count; i++){
3258 merge_context_after_me(s, s->thread_context[i]);
3260 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3261 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3264 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3265 s->pict_type= AV_PICTURE_TYPE_I;
3266 for(i=0; i<s->mb_stride*s->mb_height; i++)
3267 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3268 if(s->msmpeg4_version >= 3)
3270 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3271 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3275 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3276 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3278 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3280 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3281 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3282 s->f_code= FFMAX3(s->f_code, a, b);
3285 ff_fix_long_p_mvs(s);
3286 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3287 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3291 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3292 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3297 if(s->pict_type==AV_PICTURE_TYPE_B){
3300 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3301 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3302 s->f_code = FFMAX(a, b);
3304 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3305 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3306 s->b_code = FFMAX(a, b);
3308 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3309 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3310 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3311 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3312 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3314 for(dir=0; dir<2; dir++){
3317 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3318 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3319 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3320 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3328 if (estimate_qp(s, 0) < 0)
3331 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3332 s->qscale= 3; //reduce clipping problems
3334 if (s->out_format == FMT_MJPEG) {
3335 /* for mjpeg, we do include qscale in the matrix */
3337 int j= s->dsp.idct_permutation[i];
3339 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3341 s->y_dc_scale_table=
3342 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3343 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3344 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3345 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3348 if(s->codec_id == AV_CODEC_ID_AMV){
3349 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};
3350 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};
3352 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3354 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3355 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3357 s->y_dc_scale_table= y;
3358 s->c_dc_scale_table= c;
3359 s->intra_matrix[0] = 13;
3360 s->chroma_intra_matrix[0] = 14;
3361 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3362 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3363 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3364 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3368 //FIXME var duplication
3369 s->current_picture_ptr->f.key_frame =
3370 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3371 s->current_picture_ptr->f.pict_type =
3372 s->current_picture.f.pict_type = s->pict_type;
3374 if (s->current_picture.f.key_frame)
3375 s->picture_in_gop_number=0;
3377 s->mb_x = s->mb_y = 0;
3378 s->last_bits= put_bits_count(&s->pb);
3379 switch(s->out_format) {
3381 if (CONFIG_MJPEG_ENCODER)
3382 ff_mjpeg_encode_picture_header(s);
3385 if (CONFIG_H261_ENCODER)
3386 ff_h261_encode_picture_header(s, picture_number);
3389 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3390 ff_wmv2_encode_picture_header(s, picture_number);
3391 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3392 ff_msmpeg4_encode_picture_header(s, picture_number);
3393 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3394 ff_mpeg4_encode_picture_header(s, picture_number);
3395 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3396 ff_rv10_encode_picture_header(s, picture_number);
3397 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3398 ff_rv20_encode_picture_header(s, picture_number);
3399 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3400 ff_flv_encode_picture_header(s, picture_number);
3401 else if (CONFIG_H263_ENCODER)
3402 ff_h263_encode_picture_header(s, picture_number);
3405 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3406 ff_mpeg1_encode_picture_header(s, picture_number);
3411 bits= put_bits_count(&s->pb);
3412 s->header_bits= bits - s->last_bits;
3414 for(i=1; i<context_count; i++){
3415 update_duplicate_context_after_me(s->thread_context[i], s);
3417 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3418 for(i=1; i<context_count; i++){
3419 merge_context_after_encode(s, s->thread_context[i]);
3425 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3426 const int intra= s->mb_intra;
3429 s->dct_count[intra]++;
3431 for(i=0; i<64; i++){
3432 int level= block[i];
3436 s->dct_error_sum[intra][i] += level;
3437 level -= s->dct_offset[intra][i];
3438 if(level<0) level=0;
3440 s->dct_error_sum[intra][i] -= level;
3441 level += s->dct_offset[intra][i];
3442 if(level>0) level=0;
3449 static int dct_quantize_trellis_c(MpegEncContext *s,
3450 int16_t *block, int n,
3451 int qscale, int *overflow){
3453 const uint8_t *scantable= s->intra_scantable.scantable;
3454 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3456 unsigned int threshold1, threshold2;
3468 int coeff_count[64];
3469 int qmul, qadd, start_i, last_non_zero, i, dc;
3470 const int esc_length= s->ac_esc_length;
3472 uint8_t * last_length;
3473 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3475 s->dsp.fdct (block);
3477 if(s->dct_error_sum)
3478 s->denoise_dct(s, block);
3480 qadd= ((qscale-1)|1)*8;
3491 /* For AIC we skip quant/dequant of INTRADC */
3496 /* note: block[0] is assumed to be positive */
3497 block[0] = (block[0] + (q >> 1)) / q;
3500 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3501 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3502 bias= 1<<(QMAT_SHIFT-1);
3503 length = s->intra_ac_vlc_length;
3504 last_length= s->intra_ac_vlc_last_length;
3508 qmat = s->q_inter_matrix[qscale];
3509 length = s->inter_ac_vlc_length;
3510 last_length= s->inter_ac_vlc_last_length;
3514 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3515 threshold2= (threshold1<<1);
3517 for(i=63; i>=start_i; i--) {
3518 const int j = scantable[i];
3519 int level = block[j] * qmat[j];
3521 if(((unsigned)(level+threshold1))>threshold2){
3527 for(i=start_i; i<=last_non_zero; i++) {
3528 const int j = scantable[i];
3529 int level = block[j] * qmat[j];
3531 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3532 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3533 if(((unsigned)(level+threshold1))>threshold2){
3535 level= (bias + level)>>QMAT_SHIFT;
3537 coeff[1][i]= level-1;
3538 // coeff[2][k]= level-2;
3540 level= (bias - level)>>QMAT_SHIFT;
3541 coeff[0][i]= -level;
3542 coeff[1][i]= -level+1;
3543 // coeff[2][k]= -level+2;
3545 coeff_count[i]= FFMIN(level, 2);
3546 av_assert2(coeff_count[i]);
3549 coeff[0][i]= (level>>31)|1;
3554 *overflow= s->max_qcoeff < max; //overflow might have happened
3556 if(last_non_zero < start_i){
3557 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3558 return last_non_zero;
3561 score_tab[start_i]= 0;
3562 survivor[0]= start_i;
3565 for(i=start_i; i<=last_non_zero; i++){
3566 int level_index, j, zero_distortion;
3567 int dct_coeff= FFABS(block[ scantable[i] ]);
3568 int best_score=256*256*256*120;
3570 if (s->dsp.fdct == ff_fdct_ifast)
3571 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3572 zero_distortion= dct_coeff*dct_coeff;
3574 for(level_index=0; level_index < coeff_count[i]; level_index++){
3576 int level= coeff[level_index][i];
3577 const int alevel= FFABS(level);
3582 if(s->out_format == FMT_H263){
3583 unquant_coeff= alevel*qmul + qadd;
3585 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3587 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3588 unquant_coeff = (unquant_coeff - 1) | 1;
3590 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3591 unquant_coeff = (unquant_coeff - 1) | 1;
3596 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3598 if((level&(~127)) == 0){
3599 for(j=survivor_count-1; j>=0; j--){
3600 int run= i - survivor[j];
3601 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3602 score += score_tab[i-run];
3604 if(score < best_score){
3607 level_tab[i+1]= level-64;
3611 if(s->out_format == FMT_H263){
3612 for(j=survivor_count-1; j>=0; j--){
3613 int run= i - survivor[j];
3614 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3615 score += score_tab[i-run];
3616 if(score < last_score){
3619 last_level= level-64;
3625 distortion += esc_length*lambda;
3626 for(j=survivor_count-1; j>=0; j--){
3627 int run= i - survivor[j];
3628 int score= distortion + score_tab[i-run];
3630 if(score < best_score){
3633 level_tab[i+1]= level-64;
3637 if(s->out_format == FMT_H263){
3638 for(j=survivor_count-1; j>=0; j--){
3639 int run= i - survivor[j];
3640 int score= distortion + score_tab[i-run];
3641 if(score < last_score){
3644 last_level= level-64;
3652 score_tab[i+1]= best_score;
3654 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3655 if(last_non_zero <= 27){
3656 for(; survivor_count; survivor_count--){
3657 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3661 for(; survivor_count; survivor_count--){
3662 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3667 survivor[ survivor_count++ ]= i+1;
3670 if(s->out_format != FMT_H263){
3671 last_score= 256*256*256*120;
3672 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3673 int score= score_tab[i];
3674 if(i) score += lambda*2; //FIXME exacter?
3676 if(score < last_score){
3679 last_level= level_tab[i];
3680 last_run= run_tab[i];
3685 s->coded_score[n] = last_score;
3687 dc= FFABS(block[0]);
3688 last_non_zero= last_i - 1;
3689 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3691 if(last_non_zero < start_i)
3692 return last_non_zero;
3694 if(last_non_zero == 0 && start_i == 0){
3696 int best_score= dc * dc;
3698 for(i=0; i<coeff_count[0]; i++){
3699 int level= coeff[i][0];
3700 int alevel= FFABS(level);
3701 int unquant_coeff, score, distortion;
3703 if(s->out_format == FMT_H263){
3704 unquant_coeff= (alevel*qmul + qadd)>>3;
3706 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3707 unquant_coeff = (unquant_coeff - 1) | 1;
3709 unquant_coeff = (unquant_coeff + 4) >> 3;
3710 unquant_coeff<<= 3 + 3;
3712 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3714 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3715 else score= distortion + esc_length*lambda;
3717 if(score < best_score){
3719 best_level= level - 64;
3722 block[0]= best_level;
3723 s->coded_score[n] = best_score - dc*dc;
3724 if(best_level == 0) return -1;
3725 else return last_non_zero;
3729 av_assert2(last_level);
3731 block[ perm_scantable[last_non_zero] ]= last_level;
3734 for(; i>start_i; i -= run_tab[i] + 1){
3735 block[ perm_scantable[i-1] ]= level_tab[i];
3738 return last_non_zero;
3741 //#define REFINE_STATS 1
3742 static int16_t basis[64][64];
3744 static void build_basis(uint8_t *perm){
3751 double s= 0.25*(1<<BASIS_SHIFT);
3753 int perm_index= perm[index];
3754 if(i==0) s*= sqrt(0.5);
3755 if(j==0) s*= sqrt(0.5);
3756 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)));
3763 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3764 int16_t *block, int16_t *weight, int16_t *orig,
3767 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3768 const uint8_t *scantable= s->intra_scantable.scantable;
3769 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3770 // unsigned int threshold1, threshold2;
3775 int qmul, qadd, start_i, last_non_zero, i, dc;
3777 uint8_t * last_length;
3779 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3782 static int after_last=0;
3783 static int to_zero=0;
3784 static int from_zero=0;
3787 static int messed_sign=0;
3790 if(basis[0][0] == 0)
3791 build_basis(s->dsp.idct_permutation);
3802 /* For AIC we skip quant/dequant of INTRADC */
3806 q <<= RECON_SHIFT-3;
3807 /* note: block[0] is assumed to be positive */
3809 // block[0] = (block[0] + (q >> 1)) / q;
3811 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3812 // bias= 1<<(QMAT_SHIFT-1);
3813 length = s->intra_ac_vlc_length;
3814 last_length= s->intra_ac_vlc_last_length;
3818 length = s->inter_ac_vlc_length;
3819 last_length= s->inter_ac_vlc_last_length;
3821 last_non_zero = s->block_last_index[n];
3826 dc += (1<<(RECON_SHIFT-1));
3827 for(i=0; i<64; i++){
3828 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3831 STOP_TIMER("memset rem[]")}
3834 for(i=0; i<64; i++){
3839 w= FFABS(weight[i]) + qns*one;
3840 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3843 // w=weight[i] = (63*qns + (w/2)) / w;
3846 av_assert2(w<(1<<6));
3849 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3855 for(i=start_i; i<=last_non_zero; i++){
3856 int j= perm_scantable[i];
3857 const int level= block[j];
3861 if(level<0) coeff= qmul*level - qadd;
3862 else coeff= qmul*level + qadd;
3863 run_tab[rle_index++]=run;
3866 s->dsp.add_8x8basis(rem, basis[j], coeff);
3872 if(last_non_zero>0){
3873 STOP_TIMER("init rem[]")
3880 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3883 int run2, best_unquant_change=0, analyze_gradient;
3887 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3889 if(analyze_gradient){
3893 for(i=0; i<64; i++){
3896 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3899 STOP_TIMER("rem*w*w")}
3909 const int level= block[0];
3910 int change, old_coeff;
3912 av_assert2(s->mb_intra);
3916 for(change=-1; change<=1; change+=2){
3917 int new_level= level + change;
3918 int score, new_coeff;
3920 new_coeff= q*new_level;
3921 if(new_coeff >= 2048 || new_coeff < 0)
3924 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3925 if(score<best_score){
3928 best_change= change;
3929 best_unquant_change= new_coeff - old_coeff;
3936 run2= run_tab[rle_index++];
3940 for(i=start_i; i<64; i++){
3941 int j= perm_scantable[i];
3942 const int level= block[j];
3943 int change, old_coeff;
3945 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3949 if(level<0) old_coeff= qmul*level - qadd;
3950 else old_coeff= qmul*level + qadd;
3951 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3955 av_assert2(run2>=0 || i >= last_non_zero );
3958 for(change=-1; change<=1; change+=2){
3959 int new_level= level + change;
3960 int score, new_coeff, unquant_change;
3963 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3967 if(new_level<0) new_coeff= qmul*new_level - qadd;
3968 else new_coeff= qmul*new_level + qadd;
3969 if(new_coeff >= 2048 || new_coeff <= -2048)
3971 //FIXME check for overflow
3974 if(level < 63 && level > -63){
3975 if(i < last_non_zero)
3976 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3977 - length[UNI_AC_ENC_INDEX(run, level+64)];
3979 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3980 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3983 av_assert2(FFABS(new_level)==1);
3985 if(analyze_gradient){
3986 int g= d1[ scantable[i] ];
3987 if(g && (g^new_level) >= 0)
3991 if(i < last_non_zero){
3992 int next_i= i + run2 + 1;
3993 int next_level= block[ perm_scantable[next_i] ] + 64;
3995 if(next_level&(~127))
3998 if(next_i < last_non_zero)
3999 score += length[UNI_AC_ENC_INDEX(run, 65)]
4000 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4001 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4003 score += length[UNI_AC_ENC_INDEX(run, 65)]
4004 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4005 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4007 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4009 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4010 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4016 av_assert2(FFABS(level)==1);
4018 if(i < last_non_zero){
4019 int next_i= i + run2 + 1;
4020 int next_level= block[ perm_scantable[next_i] ] + 64;
4022 if(next_level&(~127))
4025 if(next_i < last_non_zero)
4026 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4027 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4028 - length[UNI_AC_ENC_INDEX(run, 65)];
4030 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4031 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4032 - length[UNI_AC_ENC_INDEX(run, 65)];
4034 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4036 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4037 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4044 unquant_change= new_coeff - old_coeff;
4045 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4047 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4048 if(score<best_score){
4051 best_change= change;
4052 best_unquant_change= unquant_change;
4056 prev_level= level + 64;
4057 if(prev_level&(~127))
4066 STOP_TIMER("iterative step")}
4070 int j= perm_scantable[ best_coeff ];
4072 block[j] += best_change;
4074 if(best_coeff > last_non_zero){
4075 last_non_zero= best_coeff;
4076 av_assert2(block[j]);
4083 if(block[j] - best_change){
4084 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4096 for(; last_non_zero>=start_i; last_non_zero--){
4097 if(block[perm_scantable[last_non_zero]])
4103 if(256*256*256*64 % count == 0){
4104 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);
4109 for(i=start_i; i<=last_non_zero; i++){
4110 int j= perm_scantable[i];
4111 const int level= block[j];
4114 run_tab[rle_index++]=run;
4121 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4127 if(last_non_zero>0){
4128 STOP_TIMER("iterative search")
4133 return last_non_zero;
4136 int ff_dct_quantize_c(MpegEncContext *s,
4137 int16_t *block, int n,
4138 int qscale, int *overflow)
4140 int i, j, level, last_non_zero, q, start_i;
4142 const uint8_t *scantable= s->intra_scantable.scantable;
4145 unsigned int threshold1, threshold2;
4147 s->dsp.fdct (block);
4149 if(s->dct_error_sum)
4150 s->denoise_dct(s, block);
4160 /* For AIC we skip quant/dequant of INTRADC */
4163 /* note: block[0] is assumed to be positive */
4164 block[0] = (block[0] + (q >> 1)) / q;
4167 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4168 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4172 qmat = s->q_inter_matrix[qscale];
4173 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4175 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4176 threshold2= (threshold1<<1);
4177 for(i=63;i>=start_i;i--) {
4179 level = block[j] * qmat[j];
4181 if(((unsigned)(level+threshold1))>threshold2){
4188 for(i=start_i; i<=last_non_zero; i++) {
4190 level = block[j] * qmat[j];
4192 // if( bias+level >= (1<<QMAT_SHIFT)
4193 // || bias-level >= (1<<QMAT_SHIFT)){
4194 if(((unsigned)(level+threshold1))>threshold2){
4196 level= (bias + level)>>QMAT_SHIFT;
4199 level= (bias - level)>>QMAT_SHIFT;
4207 *overflow= s->max_qcoeff < max; //overflow might have happened
4209 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4210 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4211 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4213 return last_non_zero;
4216 #define OFFSET(x) offsetof(MpegEncContext, x)
4217 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4218 static const AVOption h263_options[] = {
4219 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4220 { "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},
4221 { "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 },
4226 static const AVClass h263_class = {
4227 .class_name = "H.263 encoder",
4228 .item_name = av_default_item_name,
4229 .option = h263_options,
4230 .version = LIBAVUTIL_VERSION_INT,
4233 AVCodec ff_h263_encoder = {
4235 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4236 .type = AVMEDIA_TYPE_VIDEO,
4237 .id = AV_CODEC_ID_H263,
4238 .priv_data_size = sizeof(MpegEncContext),
4239 .init = ff_MPV_encode_init,
4240 .encode2 = ff_MPV_encode_picture,
4241 .close = ff_MPV_encode_end,
4242 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4243 .priv_class = &h263_class,
4246 static const AVOption h263p_options[] = {
4247 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4248 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4249 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4250 { "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},
4254 static const AVClass h263p_class = {
4255 .class_name = "H.263p encoder",
4256 .item_name = av_default_item_name,
4257 .option = h263p_options,
4258 .version = LIBAVUTIL_VERSION_INT,
4261 AVCodec ff_h263p_encoder = {
4263 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4264 .type = AVMEDIA_TYPE_VIDEO,
4265 .id = AV_CODEC_ID_H263P,
4266 .priv_data_size = sizeof(MpegEncContext),
4267 .init = ff_MPV_encode_init,
4268 .encode2 = ff_MPV_encode_picture,
4269 .close = ff_MPV_encode_end,
4270 .capabilities = CODEC_CAP_SLICE_THREADS,
4271 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4272 .priv_class = &h263p_class,
4275 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4277 AVCodec ff_msmpeg4v2_encoder = {
4278 .name = "msmpeg4v2",
4279 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4280 .type = AVMEDIA_TYPE_VIDEO,
4281 .id = AV_CODEC_ID_MSMPEG4V2,
4282 .priv_data_size = sizeof(MpegEncContext),
4283 .init = ff_MPV_encode_init,
4284 .encode2 = ff_MPV_encode_picture,
4285 .close = ff_MPV_encode_end,
4286 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4287 .priv_class = &msmpeg4v2_class,
4290 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4292 AVCodec ff_msmpeg4v3_encoder = {
4294 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4295 .type = AVMEDIA_TYPE_VIDEO,
4296 .id = AV_CODEC_ID_MSMPEG4V3,
4297 .priv_data_size = sizeof(MpegEncContext),
4298 .init = ff_MPV_encode_init,
4299 .encode2 = ff_MPV_encode_picture,
4300 .close = ff_MPV_encode_end,
4301 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4302 .priv_class = &msmpeg4v3_class,
4305 FF_MPV_GENERIC_CLASS(wmv1)
4307 AVCodec ff_wmv1_encoder = {
4309 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4310 .type = AVMEDIA_TYPE_VIDEO,
4311 .id = AV_CODEC_ID_WMV1,
4312 .priv_data_size = sizeof(MpegEncContext),
4313 .init = ff_MPV_encode_init,
4314 .encode2 = ff_MPV_encode_picture,
4315 .close = ff_MPV_encode_end,
4316 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4317 .priv_class = &wmv1_class,