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 Libav.
10 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "libavutil/internal.h"
33 #include "libavutil/intmath.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/timer.h"
42 #include "mpegvideo.h"
45 #include "mjpegenc_common.h"
47 #include "mpegutils.h"
50 #include "pixblockdsp.h"
54 #include "aandcttab.h"
56 #include "mpeg4video.h"
58 #include "bytestream.h"
61 #define QUANT_BIAS_SHIFT 8
63 #define QMAT_SHIFT_MMX 16
66 static int encode_picture(MpegEncContext *s, int picture_number);
67 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
68 static int sse_mb(MpegEncContext *s);
69 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
70 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
72 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
73 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
75 const AVOption ff_mpv_generic_options[] = {
80 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
81 uint16_t (*qmat16)[2][64],
82 const uint16_t *quant_matrix,
83 int bias, int qmin, int qmax, int intra)
85 FDCTDSPContext *fdsp = &s->fdsp;
89 for (qscale = qmin; qscale <= qmax; qscale++) {
91 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
93 fdsp->fdct == ff_faandct ||
94 #endif /* CONFIG_FAANDCT */
95 fdsp->fdct == ff_jpeg_fdct_islow_10) {
96 for (i = 0; i < 64; i++) {
97 const int j = s->idsp.idct_permutation[i];
98 /* 16 <= qscale * quant_matrix[i] <= 7905
99 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
100 * 19952 <= x <= 249205026
101 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
102 * 3444240 >= (1 << 36) / (x) >= 275 */
104 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
105 (qscale * quant_matrix[j]));
107 } else if (fdsp->fdct == ff_fdct_ifast) {
108 for (i = 0; i < 64; i++) {
109 const int j = s->idsp.idct_permutation[i];
110 /* 16 <= qscale * quant_matrix[i] <= 7905
111 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
112 * 19952 <= x <= 249205026
113 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
114 * 3444240 >= (1 << 36) / (x) >= 275 */
116 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
117 (ff_aanscales[i] * qscale *
121 for (i = 0; i < 64; i++) {
122 const int j = s->idsp.idct_permutation[i];
123 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
124 * Assume x = qscale * quant_matrix[i]
126 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
127 * so 32768 >= (1 << 19) / (x) >= 67 */
128 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
129 (qscale * quant_matrix[j]));
130 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
131 // (qscale * quant_matrix[i]);
132 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
133 (qscale * quant_matrix[j]);
135 if (qmat16[qscale][0][i] == 0 ||
136 qmat16[qscale][0][i] == 128 * 256)
137 qmat16[qscale][0][i] = 128 * 256 - 1;
138 qmat16[qscale][1][i] =
139 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
140 qmat16[qscale][0][i]);
144 for (i = intra; i < 64; i++) {
146 if (fdsp->fdct == ff_fdct_ifast) {
147 max = (8191LL * ff_aanscales[i]) >> 14;
149 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
155 av_log(NULL, AV_LOG_INFO,
156 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
161 static inline void update_qscale(MpegEncContext *s)
163 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
164 (FF_LAMBDA_SHIFT + 7);
165 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
167 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
171 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
177 for (i = 0; i < 64; i++) {
178 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
185 * init s->current_picture.qscale_table from s->lambda_table
187 void ff_init_qscale_tab(MpegEncContext *s)
189 int8_t * const qscale_table = s->current_picture.qscale_table;
192 for (i = 0; i < s->mb_num; i++) {
193 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
194 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
195 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
200 static void update_duplicate_context_after_me(MpegEncContext *dst,
203 #define COPY(a) dst->a= src->a
205 COPY(current_picture);
211 COPY(picture_in_gop_number);
212 COPY(gop_picture_number);
213 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
214 COPY(progressive_frame); // FIXME don't set in encode_header
215 COPY(partitioned_frame); // FIXME don't set in encode_header
220 * Set the given MpegEncContext to defaults for encoding.
221 * the changed fields will not depend upon the prior state of the MpegEncContext.
223 static void mpv_encode_defaults(MpegEncContext *s)
226 ff_mpv_common_defaults(s);
228 for (i = -16; i < 16; i++) {
229 default_fcode_tab[i + MAX_MV] = 1;
231 s->me.mv_penalty = default_mv_penalty;
232 s->fcode_tab = default_fcode_tab;
234 s->input_picture_number = 0;
235 s->picture_in_gop_number = 0;
238 /* init video encoder */
239 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
241 MpegEncContext *s = avctx->priv_data;
242 int i, ret, format_supported;
244 mpv_encode_defaults(s);
246 switch (avctx->codec_id) {
247 case AV_CODEC_ID_MPEG2VIDEO:
248 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
249 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
250 av_log(avctx, AV_LOG_ERROR,
251 "only YUV420 and YUV422 are supported\n");
255 case AV_CODEC_ID_MJPEG:
256 format_supported = 0;
257 /* JPEG color space */
258 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
259 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
260 (avctx->color_range == AVCOL_RANGE_JPEG &&
261 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
262 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
263 format_supported = 1;
264 /* MPEG color space */
265 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
266 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
267 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
268 format_supported = 1;
270 if (!format_supported) {
271 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
276 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
277 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
282 switch (avctx->pix_fmt) {
283 case AV_PIX_FMT_YUVJ422P:
284 case AV_PIX_FMT_YUV422P:
285 s->chroma_format = CHROMA_422;
287 case AV_PIX_FMT_YUVJ420P:
288 case AV_PIX_FMT_YUV420P:
290 s->chroma_format = CHROMA_420;
294 s->bit_rate = avctx->bit_rate;
295 s->width = avctx->width;
296 s->height = avctx->height;
297 if (avctx->gop_size > 600 &&
298 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
299 av_log(avctx, AV_LOG_ERROR,
300 "Warning keyframe interval too large! reducing it ...\n");
301 avctx->gop_size = 600;
303 s->gop_size = avctx->gop_size;
305 s->flags = avctx->flags;
306 s->flags2 = avctx->flags2;
307 if (avctx->max_b_frames > MAX_B_FRAMES) {
308 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
309 "is %d.\n", MAX_B_FRAMES);
311 s->max_b_frames = avctx->max_b_frames;
312 s->codec_id = avctx->codec->id;
313 s->strict_std_compliance = avctx->strict_std_compliance;
314 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
315 s->mpeg_quant = avctx->mpeg_quant;
316 s->rtp_mode = !!avctx->rtp_payload_size;
317 s->intra_dc_precision = avctx->intra_dc_precision;
318 s->user_specified_pts = AV_NOPTS_VALUE;
320 if (s->gop_size <= 1) {
327 s->me_method = avctx->me_method;
330 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
332 s->adaptive_quant = (s->avctx->lumi_masking ||
333 s->avctx->dark_masking ||
334 s->avctx->temporal_cplx_masking ||
335 s->avctx->spatial_cplx_masking ||
336 s->avctx->p_masking ||
337 s->avctx->border_masking ||
338 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
341 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
343 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
344 av_log(avctx, AV_LOG_ERROR,
345 "a vbv buffer size is needed, "
346 "for encoding with a maximum bitrate\n");
350 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
351 av_log(avctx, AV_LOG_INFO,
352 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
355 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
356 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
360 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
361 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
365 if (avctx->rc_max_rate &&
366 avctx->rc_max_rate == avctx->bit_rate &&
367 avctx->rc_max_rate != avctx->rc_min_rate) {
368 av_log(avctx, AV_LOG_INFO,
369 "impossible bitrate constraints, this will fail\n");
372 if (avctx->rc_buffer_size &&
373 avctx->bit_rate * (int64_t)avctx->time_base.num >
374 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
375 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
379 if (!s->fixed_qscale &&
380 avctx->bit_rate * av_q2d(avctx->time_base) >
381 avctx->bit_rate_tolerance) {
382 av_log(avctx, AV_LOG_ERROR,
383 "bitrate tolerance too small for bitrate\n");
387 if (s->avctx->rc_max_rate &&
388 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
389 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
390 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
391 90000LL * (avctx->rc_buffer_size - 1) >
392 s->avctx->rc_max_rate * 0xFFFFLL) {
393 av_log(avctx, AV_LOG_INFO,
394 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
395 "specified vbv buffer is too large for the given bitrate!\n");
398 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
399 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
400 s->codec_id != AV_CODEC_ID_FLV1) {
401 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
405 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
406 av_log(avctx, AV_LOG_ERROR,
407 "OBMC is only supported with simple mb decision\n");
411 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
412 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
416 if (s->max_b_frames &&
417 s->codec_id != AV_CODEC_ID_MPEG4 &&
418 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
419 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
420 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
424 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
425 s->codec_id == AV_CODEC_ID_H263 ||
426 s->codec_id == AV_CODEC_ID_H263P) &&
427 (avctx->sample_aspect_ratio.num > 255 ||
428 avctx->sample_aspect_ratio.den > 255)) {
429 av_log(avctx, AV_LOG_ERROR,
430 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
431 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
435 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
436 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
437 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
441 // FIXME mpeg2 uses that too
442 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
443 av_log(avctx, AV_LOG_ERROR,
444 "mpeg2 style quantization not supported by codec\n");
448 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
449 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
453 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
454 s->avctx->mb_decision != FF_MB_DECISION_RD) {
455 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
459 if (s->avctx->scenechange_threshold < 1000000000 &&
460 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
461 av_log(avctx, AV_LOG_ERROR,
462 "closed gop with scene change detection are not supported yet, "
463 "set threshold to 1000000000\n");
467 if (s->flags & CODEC_FLAG_LOW_DELAY) {
468 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
469 av_log(avctx, AV_LOG_ERROR,
470 "low delay forcing is only available for mpeg2\n");
473 if (s->max_b_frames != 0) {
474 av_log(avctx, AV_LOG_ERROR,
475 "b frames cannot be used with low delay\n");
480 if (s->q_scale_type == 1) {
481 if (avctx->qmax > 12) {
482 av_log(avctx, AV_LOG_ERROR,
483 "non linear quant only supports qmax <= 12 currently\n");
488 if (s->avctx->thread_count > 1 &&
489 s->codec_id != AV_CODEC_ID_MPEG4 &&
490 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
491 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
492 (s->codec_id != AV_CODEC_ID_H263P)) {
493 av_log(avctx, AV_LOG_ERROR,
494 "multi threaded encoding not supported by codec\n");
498 if (s->avctx->thread_count < 1) {
499 av_log(avctx, AV_LOG_ERROR,
500 "automatic thread number detection not supported by codec,"
505 if (s->avctx->thread_count > 1)
508 if (!avctx->time_base.den || !avctx->time_base.num) {
509 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
513 i = (INT_MAX / 2 + 128) >> 8;
514 if (avctx->mb_threshold >= i) {
515 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
520 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
521 av_log(avctx, AV_LOG_INFO,
522 "notice: b_frame_strategy only affects the first pass\n");
523 avctx->b_frame_strategy = 0;
526 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
528 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
529 avctx->time_base.den /= i;
530 avctx->time_base.num /= i;
534 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
535 s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
536 // (a + x * 3 / 8) / x
537 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
538 s->inter_quant_bias = 0;
540 s->intra_quant_bias = 0;
542 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
545 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
546 s->intra_quant_bias = avctx->intra_quant_bias;
547 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
548 s->inter_quant_bias = avctx->inter_quant_bias;
550 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
551 s->avctx->time_base.den > (1 << 16) - 1) {
552 av_log(avctx, AV_LOG_ERROR,
553 "timebase %d/%d not supported by MPEG 4 standard, "
554 "the maximum admitted value for the timebase denominator "
555 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
559 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
561 switch (avctx->codec->id) {
562 case AV_CODEC_ID_MPEG1VIDEO:
563 s->out_format = FMT_MPEG1;
564 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
565 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
567 case AV_CODEC_ID_MPEG2VIDEO:
568 s->out_format = FMT_MPEG1;
569 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
570 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
573 case AV_CODEC_ID_MJPEG:
574 s->out_format = FMT_MJPEG;
575 s->intra_only = 1; /* force intra only for jpeg */
576 if (!CONFIG_MJPEG_ENCODER ||
577 ff_mjpeg_encode_init(s) < 0)
582 case AV_CODEC_ID_H261:
583 if (!CONFIG_H261_ENCODER)
585 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
586 av_log(avctx, AV_LOG_ERROR,
587 "The specified picture size of %dx%d is not valid for the "
588 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
589 s->width, s->height);
592 s->out_format = FMT_H261;
596 case AV_CODEC_ID_H263:
597 if (!CONFIG_H263_ENCODER)
599 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
600 s->width, s->height) == 8) {
601 av_log(avctx, AV_LOG_INFO,
602 "The specified picture size of %dx%d is not valid for "
603 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
604 "352x288, 704x576, and 1408x1152."
605 "Try H.263+.\n", s->width, s->height);
608 s->out_format = FMT_H263;
612 case AV_CODEC_ID_H263P:
613 s->out_format = FMT_H263;
616 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
617 s->modified_quant = s->h263_aic;
618 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
619 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
622 /* These are just to be sure */
626 case AV_CODEC_ID_FLV1:
627 s->out_format = FMT_H263;
628 s->h263_flv = 2; /* format = 1; 11-bit codes */
629 s->unrestricted_mv = 1;
630 s->rtp_mode = 0; /* don't allow GOB */
634 case AV_CODEC_ID_RV10:
635 s->out_format = FMT_H263;
639 case AV_CODEC_ID_RV20:
640 s->out_format = FMT_H263;
643 s->modified_quant = 1;
647 s->unrestricted_mv = 0;
649 case AV_CODEC_ID_MPEG4:
650 s->out_format = FMT_H263;
652 s->unrestricted_mv = 1;
653 s->low_delay = s->max_b_frames ? 0 : 1;
654 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
656 case AV_CODEC_ID_MSMPEG4V2:
657 s->out_format = FMT_H263;
659 s->unrestricted_mv = 1;
660 s->msmpeg4_version = 2;
664 case AV_CODEC_ID_MSMPEG4V3:
665 s->out_format = FMT_H263;
667 s->unrestricted_mv = 1;
668 s->msmpeg4_version = 3;
669 s->flipflop_rounding = 1;
673 case AV_CODEC_ID_WMV1:
674 s->out_format = FMT_H263;
676 s->unrestricted_mv = 1;
677 s->msmpeg4_version = 4;
678 s->flipflop_rounding = 1;
682 case AV_CODEC_ID_WMV2:
683 s->out_format = FMT_H263;
685 s->unrestricted_mv = 1;
686 s->msmpeg4_version = 5;
687 s->flipflop_rounding = 1;
695 avctx->has_b_frames = !s->low_delay;
699 s->progressive_frame =
700 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
701 CODEC_FLAG_INTERLACED_ME) ||
706 if (ff_mpv_common_init(s) < 0)
710 ff_mpv_encode_init_x86(s);
712 ff_fdctdsp_init(&s->fdsp, avctx);
713 ff_me_cmp_init(&s->mecc, avctx);
714 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
715 ff_pixblockdsp_init(&s->pdsp, avctx);
716 ff_qpeldsp_init(&s->qdsp);
718 s->avctx->coded_frame = s->current_picture.f;
720 if (s->msmpeg4_version) {
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
722 2 * 2 * (MAX_LEVEL + 1) *
723 (MAX_RUN + 1) * 2 * sizeof(int), fail);
725 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
728 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
729 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
730 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
731 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
732 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
733 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
734 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
736 if (s->avctx->noise_reduction) {
737 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
738 2 * 64 * sizeof(uint16_t), fail);
741 if (CONFIG_H263_ENCODER)
742 ff_h263dsp_init(&s->h263dsp);
743 if (!s->dct_quantize)
744 s->dct_quantize = ff_dct_quantize_c;
746 s->denoise_dct = denoise_dct_c;
747 s->fast_dct_quantize = s->dct_quantize;
749 s->dct_quantize = dct_quantize_trellis_c;
751 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
752 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
754 s->quant_precision = 5;
756 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, s->avctx->ildct_cmp);
757 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->avctx->frame_skip_cmp);
759 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
760 ff_h261_encode_init(s);
761 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
762 ff_h263_encode_init(s);
763 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
764 ff_msmpeg4_encode_init(s);
765 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
766 && s->out_format == FMT_MPEG1)
767 ff_mpeg1_encode_init(s);
770 for (i = 0; i < 64; i++) {
771 int j = s->idsp.idct_permutation[i];
772 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
774 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
775 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
776 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
778 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
781 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
782 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
784 if (s->avctx->intra_matrix)
785 s->intra_matrix[j] = s->avctx->intra_matrix[i];
786 if (s->avctx->inter_matrix)
787 s->inter_matrix[j] = s->avctx->inter_matrix[i];
790 /* precompute matrix */
791 /* for mjpeg, we do include qscale in the matrix */
792 if (s->out_format != FMT_MJPEG) {
793 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
794 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
796 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
797 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
801 if (ff_rate_control_init(s) < 0)
804 #if FF_API_ERROR_RATE
805 FF_DISABLE_DEPRECATION_WARNINGS
806 if (avctx->error_rate)
807 s->error_rate = avctx->error_rate;
808 FF_ENABLE_DEPRECATION_WARNINGS;
811 #if FF_API_NORMALIZE_AQP
812 FF_DISABLE_DEPRECATION_WARNINGS
813 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
814 s->mpv_flags |= FF_MPV_FLAG_NAQ;
815 FF_ENABLE_DEPRECATION_WARNINGS;
819 FF_DISABLE_DEPRECATION_WARNINGS
820 if (avctx->flags & CODEC_FLAG_MV0)
821 s->mpv_flags |= FF_MPV_FLAG_MV0;
822 FF_ENABLE_DEPRECATION_WARNINGS
825 if (avctx->b_frame_strategy == 2) {
826 for (i = 0; i < s->max_b_frames + 2; i++) {
827 s->tmp_frames[i] = av_frame_alloc();
828 if (!s->tmp_frames[i])
829 return AVERROR(ENOMEM);
831 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
832 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
833 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
835 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
843 ff_mpv_encode_end(avctx);
844 return AVERROR_UNKNOWN;
847 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
849 MpegEncContext *s = avctx->priv_data;
852 ff_rate_control_uninit(s);
854 ff_mpv_common_end(s);
855 if (CONFIG_MJPEG_ENCODER &&
856 s->out_format == FMT_MJPEG)
857 ff_mjpeg_encode_close(s);
859 av_freep(&avctx->extradata);
861 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
862 av_frame_free(&s->tmp_frames[i]);
864 ff_free_picture_tables(&s->new_picture);
865 ff_mpeg_unref_picture(s, &s->new_picture);
867 av_freep(&s->avctx->stats_out);
868 av_freep(&s->ac_stats);
870 av_freep(&s->q_intra_matrix);
871 av_freep(&s->q_inter_matrix);
872 av_freep(&s->q_intra_matrix16);
873 av_freep(&s->q_inter_matrix16);
874 av_freep(&s->input_picture);
875 av_freep(&s->reordered_input_picture);
876 av_freep(&s->dct_offset);
881 static int get_sae(uint8_t *src, int ref, int stride)
886 for (y = 0; y < 16; y++) {
887 for (x = 0; x < 16; x++) {
888 acc += FFABS(src[x + y * stride] - ref);
895 static int get_intra_count(MpegEncContext *s, uint8_t *src,
896 uint8_t *ref, int stride)
904 for (y = 0; y < h; y += 16) {
905 for (x = 0; x < w; x += 16) {
906 int offset = x + y * stride;
907 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
909 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
910 int sae = get_sae(src + offset, mean, stride);
912 acc += sae + 500 < sad;
919 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
923 int i, display_picture_number = 0, ret;
924 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
925 (s->low_delay ? 0 : 1);
930 display_picture_number = s->input_picture_number++;
932 if (pts != AV_NOPTS_VALUE) {
933 if (s->user_specified_pts != AV_NOPTS_VALUE) {
935 int64_t last = s->user_specified_pts;
938 av_log(s->avctx, AV_LOG_ERROR,
939 "Error, Invalid timestamp=%"PRId64", "
940 "last=%"PRId64"\n", pts, s->user_specified_pts);
944 if (!s->low_delay && display_picture_number == 1)
945 s->dts_delta = time - last;
947 s->user_specified_pts = pts;
949 if (s->user_specified_pts != AV_NOPTS_VALUE) {
950 s->user_specified_pts =
951 pts = s->user_specified_pts + 1;
952 av_log(s->avctx, AV_LOG_INFO,
953 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
956 pts = display_picture_number;
962 if (!pic_arg->buf[0]);
964 if (pic_arg->linesize[0] != s->linesize)
966 if (pic_arg->linesize[1] != s->uvlinesize)
968 if (pic_arg->linesize[2] != s->uvlinesize)
971 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
972 pic_arg->linesize[1], s->linesize, s->uvlinesize);
975 i = ff_find_unused_picture(s, 1);
979 pic = &s->picture[i];
982 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
984 if (ff_alloc_picture(s, pic, 1) < 0) {
988 i = ff_find_unused_picture(s, 0);
992 pic = &s->picture[i];
995 if (ff_alloc_picture(s, pic, 0) < 0) {
999 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1000 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1001 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1004 int h_chroma_shift, v_chroma_shift;
1005 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1009 for (i = 0; i < 3; i++) {
1010 int src_stride = pic_arg->linesize[i];
1011 int dst_stride = i ? s->uvlinesize : s->linesize;
1012 int h_shift = i ? h_chroma_shift : 0;
1013 int v_shift = i ? v_chroma_shift : 0;
1014 int w = s->width >> h_shift;
1015 int h = s->height >> v_shift;
1016 uint8_t *src = pic_arg->data[i];
1017 uint8_t *dst = pic->f->data[i];
1019 if (!s->avctx->rc_buffer_size)
1020 dst += INPLACE_OFFSET;
1022 if (src_stride == dst_stride)
1023 memcpy(dst, src, src_stride * h);
1026 memcpy(dst, src, w);
1034 ret = av_frame_copy_props(pic->f, pic_arg);
1038 pic->f->display_picture_number = display_picture_number;
1039 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1042 /* shift buffer entries */
1043 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1044 s->input_picture[i - 1] = s->input_picture[i];
1046 s->input_picture[encoding_delay] = (Picture*) pic;
1051 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1055 int64_t score64 = 0;
1057 for (plane = 0; plane < 3; plane++) {
1058 const int stride = p->f->linesize[plane];
1059 const int bw = plane ? 1 : 2;
1060 for (y = 0; y < s->mb_height * bw; y++) {
1061 for (x = 0; x < s->mb_width * bw; x++) {
1062 int off = p->shared ? 0 : 16;
1063 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1064 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1065 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1067 switch (s->avctx->frame_skip_exp) {
1068 case 0: score = FFMAX(score, v); break;
1069 case 1: score += FFABS(v); break;
1070 case 2: score += v * v; break;
1071 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1072 case 4: score64 += v * v * (int64_t)(v * v); break;
1081 if (score64 < s->avctx->frame_skip_threshold)
1083 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1088 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1090 AVPacket pkt = { 0 };
1091 int ret, got_output;
1093 av_init_packet(&pkt);
1094 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1099 av_free_packet(&pkt);
1103 static int estimate_best_b_count(MpegEncContext *s)
1105 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1106 AVCodecContext *c = avcodec_alloc_context3(NULL);
1107 const int scale = s->avctx->brd_scale;
1108 int i, j, out_size, p_lambda, b_lambda, lambda2;
1109 int64_t best_rd = INT64_MAX;
1110 int best_b_count = -1;
1112 assert(scale >= 0 && scale <= 3);
1115 //s->next_picture_ptr->quality;
1116 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1117 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1118 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1119 if (!b_lambda) // FIXME we should do this somewhere else
1120 b_lambda = p_lambda;
1121 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1124 c->width = s->width >> scale;
1125 c->height = s->height >> scale;
1126 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
1127 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1128 c->mb_decision = s->avctx->mb_decision;
1129 c->me_cmp = s->avctx->me_cmp;
1130 c->mb_cmp = s->avctx->mb_cmp;
1131 c->me_sub_cmp = s->avctx->me_sub_cmp;
1132 c->pix_fmt = AV_PIX_FMT_YUV420P;
1133 c->time_base = s->avctx->time_base;
1134 c->max_b_frames = s->max_b_frames;
1136 if (avcodec_open2(c, codec, NULL) < 0)
1139 for (i = 0; i < s->max_b_frames + 2; i++) {
1140 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1141 s->next_picture_ptr;
1143 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1144 pre_input = *pre_input_ptr;
1146 if (!pre_input.shared && i) {
1147 pre_input.f->data[0] += INPLACE_OFFSET;
1148 pre_input.f->data[1] += INPLACE_OFFSET;
1149 pre_input.f->data[2] += INPLACE_OFFSET;
1152 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1153 s->tmp_frames[i]->linesize[0],
1154 pre_input.f->data[0],
1155 pre_input.f->linesize[0],
1156 c->width, c->height);
1157 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1158 s->tmp_frames[i]->linesize[1],
1159 pre_input.f->data[1],
1160 pre_input.f->linesize[1],
1161 c->width >> 1, c->height >> 1);
1162 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1163 s->tmp_frames[i]->linesize[2],
1164 pre_input.f->data[2],
1165 pre_input.f->linesize[2],
1166 c->width >> 1, c->height >> 1);
1170 for (j = 0; j < s->max_b_frames + 1; j++) {
1173 if (!s->input_picture[j])
1176 c->error[0] = c->error[1] = c->error[2] = 0;
1178 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1179 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1181 out_size = encode_frame(c, s->tmp_frames[0]);
1183 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1185 for (i = 0; i < s->max_b_frames + 1; i++) {
1186 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1188 s->tmp_frames[i + 1]->pict_type = is_p ?
1189 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1190 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1192 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1194 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1197 /* get the delayed frames */
1199 out_size = encode_frame(c, NULL);
1200 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1203 rd += c->error[0] + c->error[1] + c->error[2];
1214 return best_b_count;
1217 static int select_input_picture(MpegEncContext *s)
1221 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1222 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1223 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1225 /* set next picture type & ordering */
1226 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1227 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1228 !s->next_picture_ptr || s->intra_only) {
1229 s->reordered_input_picture[0] = s->input_picture[0];
1230 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1231 s->reordered_input_picture[0]->f->coded_picture_number =
1232 s->coded_picture_number++;
1236 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1237 if (s->picture_in_gop_number < s->gop_size &&
1238 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1239 // FIXME check that te gop check above is +-1 correct
1240 av_frame_unref(s->input_picture[0]->f);
1243 ff_vbv_update(s, 0);
1249 if (s->flags & CODEC_FLAG_PASS2) {
1250 for (i = 0; i < s->max_b_frames + 1; i++) {
1251 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1253 if (pict_num >= s->rc_context.num_entries)
1255 if (!s->input_picture[i]) {
1256 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1260 s->input_picture[i]->f->pict_type =
1261 s->rc_context.entry[pict_num].new_pict_type;
1265 if (s->avctx->b_frame_strategy == 0) {
1266 b_frames = s->max_b_frames;
1267 while (b_frames && !s->input_picture[b_frames])
1269 } else if (s->avctx->b_frame_strategy == 1) {
1270 for (i = 1; i < s->max_b_frames + 1; i++) {
1271 if (s->input_picture[i] &&
1272 s->input_picture[i]->b_frame_score == 0) {
1273 s->input_picture[i]->b_frame_score =
1275 s->input_picture[i ]->f->data[0],
1276 s->input_picture[i - 1]->f->data[0],
1280 for (i = 0; i < s->max_b_frames + 1; i++) {
1281 if (!s->input_picture[i] ||
1282 s->input_picture[i]->b_frame_score - 1 >
1283 s->mb_num / s->avctx->b_sensitivity)
1287 b_frames = FFMAX(0, i - 1);
1290 for (i = 0; i < b_frames + 1; i++) {
1291 s->input_picture[i]->b_frame_score = 0;
1293 } else if (s->avctx->b_frame_strategy == 2) {
1294 b_frames = estimate_best_b_count(s);
1296 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1302 for (i = b_frames - 1; i >= 0; i--) {
1303 int type = s->input_picture[i]->f->pict_type;
1304 if (type && type != AV_PICTURE_TYPE_B)
1307 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1308 b_frames == s->max_b_frames) {
1309 av_log(s->avctx, AV_LOG_ERROR,
1310 "warning, too many b frames in a row\n");
1313 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1314 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1315 s->gop_size > s->picture_in_gop_number) {
1316 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1318 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1320 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1324 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1325 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1328 s->reordered_input_picture[0] = s->input_picture[b_frames];
1329 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1330 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1331 s->reordered_input_picture[0]->f->coded_picture_number =
1332 s->coded_picture_number++;
1333 for (i = 0; i < b_frames; i++) {
1334 s->reordered_input_picture[i + 1] = s->input_picture[i];
1335 s->reordered_input_picture[i + 1]->f->pict_type =
1337 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1338 s->coded_picture_number++;
1343 if (s->reordered_input_picture[0]) {
1344 s->reordered_input_picture[0]->reference =
1345 s->reordered_input_picture[0]->f->pict_type !=
1346 AV_PICTURE_TYPE_B ? 3 : 0;
1348 ff_mpeg_unref_picture(s, &s->new_picture);
1349 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1352 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1353 // input is a shared pix, so we can't modifiy it -> alloc a new
1354 // one & ensure that the shared one is reuseable
1357 int i = ff_find_unused_picture(s, 0);
1360 pic = &s->picture[i];
1362 pic->reference = s->reordered_input_picture[0]->reference;
1363 if (ff_alloc_picture(s, pic, 0) < 0) {
1367 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1371 /* mark us unused / free shared pic */
1372 av_frame_unref(s->reordered_input_picture[0]->f);
1373 s->reordered_input_picture[0]->shared = 0;
1375 s->current_picture_ptr = pic;
1377 // input is not a shared pix -> reuse buffer for current_pix
1378 s->current_picture_ptr = s->reordered_input_picture[0];
1379 for (i = 0; i < 4; i++) {
1380 s->new_picture.f->data[i] += INPLACE_OFFSET;
1383 ff_mpeg_unref_picture(s, &s->current_picture);
1384 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1385 s->current_picture_ptr)) < 0)
1388 s->picture_number = s->new_picture.f->display_picture_number;
1390 ff_mpeg_unref_picture(s, &s->new_picture);
1395 static void frame_end(MpegEncContext *s)
1399 if (s->unrestricted_mv &&
1400 s->current_picture.reference &&
1402 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1403 int hshift = desc->log2_chroma_w;
1404 int vshift = desc->log2_chroma_h;
1405 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1406 s->h_edge_pos, s->v_edge_pos,
1407 EDGE_WIDTH, EDGE_WIDTH,
1408 EDGE_TOP | EDGE_BOTTOM);
1409 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1410 s->h_edge_pos >> hshift,
1411 s->v_edge_pos >> vshift,
1412 EDGE_WIDTH >> hshift,
1413 EDGE_WIDTH >> vshift,
1414 EDGE_TOP | EDGE_BOTTOM);
1415 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1416 s->h_edge_pos >> hshift,
1417 s->v_edge_pos >> vshift,
1418 EDGE_WIDTH >> hshift,
1419 EDGE_WIDTH >> vshift,
1420 EDGE_TOP | EDGE_BOTTOM);
1425 s->last_pict_type = s->pict_type;
1426 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1427 if (s->pict_type!= AV_PICTURE_TYPE_B)
1428 s->last_non_b_pict_type = s->pict_type;
1431 /* release non-reference frames */
1432 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1433 if (!s->picture[i].reference)
1434 ff_mpeg_unref_picture(s, &s->picture[i]);
1438 s->avctx->coded_frame = s->current_picture_ptr->f;
1442 static void update_noise_reduction(MpegEncContext *s)
1446 for (intra = 0; intra < 2; intra++) {
1447 if (s->dct_count[intra] > (1 << 16)) {
1448 for (i = 0; i < 64; i++) {
1449 s->dct_error_sum[intra][i] >>= 1;
1451 s->dct_count[intra] >>= 1;
1454 for (i = 0; i < 64; i++) {
1455 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1456 s->dct_count[intra] +
1457 s->dct_error_sum[intra][i] / 2) /
1458 (s->dct_error_sum[intra][i] + 1);
1463 static int frame_start(MpegEncContext *s)
1467 /* mark & release old frames */
1468 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1469 s->last_picture_ptr != s->next_picture_ptr &&
1470 s->last_picture_ptr->f->buf[0]) {
1471 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1474 s->current_picture_ptr->f->pict_type = s->pict_type;
1475 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1477 ff_mpeg_unref_picture(s, &s->current_picture);
1478 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1479 s->current_picture_ptr)) < 0)
1482 if (s->pict_type != AV_PICTURE_TYPE_B) {
1483 s->last_picture_ptr = s->next_picture_ptr;
1485 s->next_picture_ptr = s->current_picture_ptr;
1488 if (s->last_picture_ptr) {
1489 ff_mpeg_unref_picture(s, &s->last_picture);
1490 if (s->last_picture_ptr->f->buf[0] &&
1491 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1492 s->last_picture_ptr)) < 0)
1495 if (s->next_picture_ptr) {
1496 ff_mpeg_unref_picture(s, &s->next_picture);
1497 if (s->next_picture_ptr->f->buf[0] &&
1498 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1499 s->next_picture_ptr)) < 0)
1503 if (s->picture_structure!= PICT_FRAME) {
1505 for (i = 0; i < 4; i++) {
1506 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1507 s->current_picture.f->data[i] +=
1508 s->current_picture.f->linesize[i];
1510 s->current_picture.f->linesize[i] *= 2;
1511 s->last_picture.f->linesize[i] *= 2;
1512 s->next_picture.f->linesize[i] *= 2;
1516 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1517 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1518 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1519 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1520 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1521 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1523 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1524 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1527 if (s->dct_error_sum) {
1528 assert(s->avctx->noise_reduction && s->encoding);
1529 update_noise_reduction(s);
1535 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1536 const AVFrame *pic_arg, int *got_packet)
1538 MpegEncContext *s = avctx->priv_data;
1539 int i, stuffing_count, ret;
1540 int context_count = s->slice_context_count;
1542 s->picture_in_gop_number++;
1544 if (load_input_picture(s, pic_arg) < 0)
1547 if (select_input_picture(s) < 0) {
1552 if (s->new_picture.f->data[0]) {
1554 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1557 s->mb_info_ptr = av_packet_new_side_data(pkt,
1558 AV_PKT_DATA_H263_MB_INFO,
1559 s->mb_width*s->mb_height*12);
1560 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1563 for (i = 0; i < context_count; i++) {
1564 int start_y = s->thread_context[i]->start_mb_y;
1565 int end_y = s->thread_context[i]-> end_mb_y;
1566 int h = s->mb_height;
1567 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1568 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1570 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1573 s->pict_type = s->new_picture.f->pict_type;
1575 ret = frame_start(s);
1579 if (encode_picture(s, s->picture_number) < 0)
1582 avctx->header_bits = s->header_bits;
1583 avctx->mv_bits = s->mv_bits;
1584 avctx->misc_bits = s->misc_bits;
1585 avctx->i_tex_bits = s->i_tex_bits;
1586 avctx->p_tex_bits = s->p_tex_bits;
1587 avctx->i_count = s->i_count;
1588 // FIXME f/b_count in avctx
1589 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1590 avctx->skip_count = s->skip_count;
1594 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1595 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1597 if (avctx->rc_buffer_size) {
1598 RateControlContext *rcc = &s->rc_context;
1599 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1601 if (put_bits_count(&s->pb) > max_size &&
1602 s->lambda < s->avctx->lmax) {
1603 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1604 (s->qscale + 1) / s->qscale);
1605 if (s->adaptive_quant) {
1607 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1608 s->lambda_table[i] =
1609 FFMAX(s->lambda_table[i] + 1,
1610 s->lambda_table[i] * (s->qscale + 1) /
1613 s->mb_skipped = 0; // done in frame_start()
1614 // done in encode_picture() so we must undo it
1615 if (s->pict_type == AV_PICTURE_TYPE_P) {
1616 if (s->flipflop_rounding ||
1617 s->codec_id == AV_CODEC_ID_H263P ||
1618 s->codec_id == AV_CODEC_ID_MPEG4)
1619 s->no_rounding ^= 1;
1621 if (s->pict_type != AV_PICTURE_TYPE_B) {
1622 s->time_base = s->last_time_base;
1623 s->last_non_b_time = s->time - s->pp_time;
1625 for (i = 0; i < context_count; i++) {
1626 PutBitContext *pb = &s->thread_context[i]->pb;
1627 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1632 assert(s->avctx->rc_max_rate);
1635 if (s->flags & CODEC_FLAG_PASS1)
1636 ff_write_pass1_stats(s);
1638 for (i = 0; i < 4; i++) {
1639 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1640 avctx->error[i] += s->current_picture_ptr->f->error[i];
1643 if (s->flags & CODEC_FLAG_PASS1)
1644 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1645 avctx->i_tex_bits + avctx->p_tex_bits ==
1646 put_bits_count(&s->pb));
1647 flush_put_bits(&s->pb);
1648 s->frame_bits = put_bits_count(&s->pb);
1650 stuffing_count = ff_vbv_update(s, s->frame_bits);
1651 if (stuffing_count) {
1652 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1653 stuffing_count + 50) {
1654 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1658 switch (s->codec_id) {
1659 case AV_CODEC_ID_MPEG1VIDEO:
1660 case AV_CODEC_ID_MPEG2VIDEO:
1661 while (stuffing_count--) {
1662 put_bits(&s->pb, 8, 0);
1665 case AV_CODEC_ID_MPEG4:
1666 put_bits(&s->pb, 16, 0);
1667 put_bits(&s->pb, 16, 0x1C3);
1668 stuffing_count -= 4;
1669 while (stuffing_count--) {
1670 put_bits(&s->pb, 8, 0xFF);
1674 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1676 flush_put_bits(&s->pb);
1677 s->frame_bits = put_bits_count(&s->pb);
1680 /* update mpeg1/2 vbv_delay for CBR */
1681 if (s->avctx->rc_max_rate &&
1682 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1683 s->out_format == FMT_MPEG1 &&
1684 90000LL * (avctx->rc_buffer_size - 1) <=
1685 s->avctx->rc_max_rate * 0xFFFFLL) {
1686 int vbv_delay, min_delay;
1687 double inbits = s->avctx->rc_max_rate *
1688 av_q2d(s->avctx->time_base);
1689 int minbits = s->frame_bits - 8 *
1690 (s->vbv_delay_ptr - s->pb.buf - 1);
1691 double bits = s->rc_context.buffer_index + minbits - inbits;
1694 av_log(s->avctx, AV_LOG_ERROR,
1695 "Internal error, negative bits\n");
1697 assert(s->repeat_first_field == 0);
1699 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1700 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1701 s->avctx->rc_max_rate;
1703 vbv_delay = FFMAX(vbv_delay, min_delay);
1705 assert(vbv_delay < 0xFFFF);
1707 s->vbv_delay_ptr[0] &= 0xF8;
1708 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1709 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1710 s->vbv_delay_ptr[2] &= 0x07;
1711 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1712 avctx->vbv_delay = vbv_delay * 300;
1714 s->total_bits += s->frame_bits;
1715 avctx->frame_bits = s->frame_bits;
1717 pkt->pts = s->current_picture.f->pts;
1718 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1719 if (!s->current_picture.f->coded_picture_number)
1720 pkt->dts = pkt->pts - s->dts_delta;
1722 pkt->dts = s->reordered_pts;
1723 s->reordered_pts = pkt->pts;
1725 pkt->dts = pkt->pts;
1726 if (s->current_picture.f->key_frame)
1727 pkt->flags |= AV_PKT_FLAG_KEY;
1729 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1733 assert((s->frame_bits & 7) == 0);
1735 pkt->size = s->frame_bits / 8;
1736 *got_packet = !!pkt->size;
1740 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1741 int n, int threshold)
1743 static const char tab[64] = {
1744 3, 2, 2, 1, 1, 1, 1, 1,
1745 1, 1, 1, 1, 1, 1, 1, 1,
1746 1, 1, 1, 1, 1, 1, 1, 1,
1747 0, 0, 0, 0, 0, 0, 0, 0,
1748 0, 0, 0, 0, 0, 0, 0, 0,
1749 0, 0, 0, 0, 0, 0, 0, 0,
1750 0, 0, 0, 0, 0, 0, 0, 0,
1751 0, 0, 0, 0, 0, 0, 0, 0
1756 int16_t *block = s->block[n];
1757 const int last_index = s->block_last_index[n];
1760 if (threshold < 0) {
1762 threshold = -threshold;
1766 /* Are all we could set to zero already zero? */
1767 if (last_index <= skip_dc - 1)
1770 for (i = 0; i <= last_index; i++) {
1771 const int j = s->intra_scantable.permutated[i];
1772 const int level = FFABS(block[j]);
1774 if (skip_dc && i == 0)
1778 } else if (level > 1) {
1784 if (score >= threshold)
1786 for (i = skip_dc; i <= last_index; i++) {
1787 const int j = s->intra_scantable.permutated[i];
1791 s->block_last_index[n] = 0;
1793 s->block_last_index[n] = -1;
1796 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1800 const int maxlevel = s->max_qcoeff;
1801 const int minlevel = s->min_qcoeff;
1805 i = 1; // skip clipping of intra dc
1809 for (; i <= last_index; i++) {
1810 const int j = s->intra_scantable.permutated[i];
1811 int level = block[j];
1813 if (level > maxlevel) {
1816 } else if (level < minlevel) {
1824 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1825 av_log(s->avctx, AV_LOG_INFO,
1826 "warning, clipping %d dct coefficients to %d..%d\n",
1827 overflow, minlevel, maxlevel);
1830 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1834 for (y = 0; y < 8; y++) {
1835 for (x = 0; x < 8; x++) {
1841 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1842 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1843 int v = ptr[x2 + y2 * stride];
1849 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1854 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1855 int motion_x, int motion_y,
1856 int mb_block_height,
1859 int16_t weight[8][64];
1860 int16_t orig[8][64];
1861 const int mb_x = s->mb_x;
1862 const int mb_y = s->mb_y;
1865 int dct_offset = s->linesize * 8; // default for progressive frames
1866 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1867 ptrdiff_t wrap_y, wrap_c;
1869 for (i = 0; i < mb_block_count; i++)
1870 skip_dct[i] = s->skipdct;
1872 if (s->adaptive_quant) {
1873 const int last_qp = s->qscale;
1874 const int mb_xy = mb_x + mb_y * s->mb_stride;
1876 s->lambda = s->lambda_table[mb_xy];
1879 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1880 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1881 s->dquant = s->qscale - last_qp;
1883 if (s->out_format == FMT_H263) {
1884 s->dquant = av_clip(s->dquant, -2, 2);
1886 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1888 if (s->pict_type == AV_PICTURE_TYPE_B) {
1889 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1892 if (s->mv_type == MV_TYPE_8X8)
1898 ff_set_qscale(s, last_qp + s->dquant);
1899 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1900 ff_set_qscale(s, s->qscale + s->dquant);
1902 wrap_y = s->linesize;
1903 wrap_c = s->uvlinesize;
1904 ptr_y = s->new_picture.f->data[0] +
1905 (mb_y * 16 * wrap_y) + mb_x * 16;
1906 ptr_cb = s->new_picture.f->data[1] +
1907 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1908 ptr_cr = s->new_picture.f->data[2] +
1909 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1911 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1912 uint8_t *ebuf = s->edge_emu_buffer + 32;
1913 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1915 16, 16, mb_x * 16, mb_y * 16,
1916 s->width, s->height);
1918 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1920 8, mb_block_height, mb_x * 8, mb_y * 8,
1921 s->width >> 1, s->height >> 1);
1922 ptr_cb = ebuf + 18 * wrap_y;
1923 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1925 8, mb_block_height, mb_x * 8, mb_y * 8,
1926 s->width >> 1, s->height >> 1);
1927 ptr_cr = ebuf + 18 * wrap_y + 8;
1931 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1932 int progressive_score, interlaced_score;
1934 s->interlaced_dct = 0;
1935 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1936 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1937 NULL, wrap_y, 8) - 400;
1939 if (progressive_score > 0) {
1940 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1941 NULL, wrap_y * 2, 8) +
1942 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
1943 NULL, wrap_y * 2, 8);
1944 if (progressive_score > interlaced_score) {
1945 s->interlaced_dct = 1;
1947 dct_offset = wrap_y;
1949 if (s->chroma_format == CHROMA_422)
1955 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
1956 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
1957 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
1958 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
1960 if (s->flags & CODEC_FLAG_GRAY) {
1964 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1965 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1966 if (!s->chroma_y_shift) { /* 422 */
1967 s->pdsp.get_pixels(s->block[6],
1968 ptr_cb + (dct_offset >> 1), wrap_c);
1969 s->pdsp.get_pixels(s->block[7],
1970 ptr_cr + (dct_offset >> 1), wrap_c);
1974 op_pixels_func (*op_pix)[4];
1975 qpel_mc_func (*op_qpix)[16];
1976 uint8_t *dest_y, *dest_cb, *dest_cr;
1978 dest_y = s->dest[0];
1979 dest_cb = s->dest[1];
1980 dest_cr = s->dest[2];
1982 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1983 op_pix = s->hdsp.put_pixels_tab;
1984 op_qpix = s->qdsp.put_qpel_pixels_tab;
1986 op_pix = s->hdsp.put_no_rnd_pixels_tab;
1987 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
1990 if (s->mv_dir & MV_DIR_FORWARD) {
1991 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
1992 s->last_picture.f->data,
1994 op_pix = s->hdsp.avg_pixels_tab;
1995 op_qpix = s->qdsp.avg_qpel_pixels_tab;
1997 if (s->mv_dir & MV_DIR_BACKWARD) {
1998 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
1999 s->next_picture.f->data,
2003 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
2004 int progressive_score, interlaced_score;
2006 s->interlaced_dct = 0;
2007 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2008 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2012 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2013 progressive_score -= 400;
2015 if (progressive_score > 0) {
2016 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2018 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2022 if (progressive_score > interlaced_score) {
2023 s->interlaced_dct = 1;
2025 dct_offset = wrap_y;
2027 if (s->chroma_format == CHROMA_422)
2033 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2034 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2035 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2036 dest_y + dct_offset, wrap_y);
2037 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2038 dest_y + dct_offset + 8, wrap_y);
2040 if (s->flags & CODEC_FLAG_GRAY) {
2044 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2045 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2046 if (!s->chroma_y_shift) { /* 422 */
2047 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2048 dest_cb + (dct_offset >> 1), wrap_c);
2049 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2050 dest_cr + (dct_offset >> 1), wrap_c);
2053 /* pre quantization */
2054 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2055 2 * s->qscale * s->qscale) {
2057 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2059 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2061 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2062 wrap_y, 8) < 20 * s->qscale)
2064 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2065 wrap_y, 8) < 20 * s->qscale)
2067 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2069 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2071 if (!s->chroma_y_shift) { /* 422 */
2072 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2073 dest_cb + (dct_offset >> 1),
2074 wrap_c, 8) < 20 * s->qscale)
2076 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2077 dest_cr + (dct_offset >> 1),
2078 wrap_c, 8) < 20 * s->qscale)
2084 if (s->quantizer_noise_shaping) {
2086 get_visual_weight(weight[0], ptr_y , wrap_y);
2088 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2090 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2092 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2094 get_visual_weight(weight[4], ptr_cb , wrap_c);
2096 get_visual_weight(weight[5], ptr_cr , wrap_c);
2097 if (!s->chroma_y_shift) { /* 422 */
2099 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2102 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2105 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2108 /* DCT & quantize */
2109 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2111 for (i = 0; i < mb_block_count; i++) {
2114 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2115 // FIXME we could decide to change to quantizer instead of
2117 // JS: I don't think that would be a good idea it could lower
2118 // quality instead of improve it. Just INTRADC clipping
2119 // deserves changes in quantizer
2121 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2123 s->block_last_index[i] = -1;
2125 if (s->quantizer_noise_shaping) {
2126 for (i = 0; i < mb_block_count; i++) {
2128 s->block_last_index[i] =
2129 dct_quantize_refine(s, s->block[i], weight[i],
2130 orig[i], i, s->qscale);
2135 if (s->luma_elim_threshold && !s->mb_intra)
2136 for (i = 0; i < 4; i++)
2137 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2138 if (s->chroma_elim_threshold && !s->mb_intra)
2139 for (i = 4; i < mb_block_count; i++)
2140 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2142 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2143 for (i = 0; i < mb_block_count; i++) {
2144 if (s->block_last_index[i] == -1)
2145 s->coded_score[i] = INT_MAX / 256;
2150 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2151 s->block_last_index[4] =
2152 s->block_last_index[5] = 0;
2154 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2157 // non c quantize code returns incorrect block_last_index FIXME
2158 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2159 for (i = 0; i < mb_block_count; i++) {
2161 if (s->block_last_index[i] > 0) {
2162 for (j = 63; j > 0; j--) {
2163 if (s->block[i][s->intra_scantable.permutated[j]])
2166 s->block_last_index[i] = j;
2171 /* huffman encode */
2172 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2173 case AV_CODEC_ID_MPEG1VIDEO:
2174 case AV_CODEC_ID_MPEG2VIDEO:
2175 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2176 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2178 case AV_CODEC_ID_MPEG4:
2179 if (CONFIG_MPEG4_ENCODER)
2180 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2182 case AV_CODEC_ID_MSMPEG4V2:
2183 case AV_CODEC_ID_MSMPEG4V3:
2184 case AV_CODEC_ID_WMV1:
2185 if (CONFIG_MSMPEG4_ENCODER)
2186 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2188 case AV_CODEC_ID_WMV2:
2189 if (CONFIG_WMV2_ENCODER)
2190 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2192 case AV_CODEC_ID_H261:
2193 if (CONFIG_H261_ENCODER)
2194 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2196 case AV_CODEC_ID_H263:
2197 case AV_CODEC_ID_H263P:
2198 case AV_CODEC_ID_FLV1:
2199 case AV_CODEC_ID_RV10:
2200 case AV_CODEC_ID_RV20:
2201 if (CONFIG_H263_ENCODER)
2202 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2204 case AV_CODEC_ID_MJPEG:
2205 if (CONFIG_MJPEG_ENCODER)
2206 ff_mjpeg_encode_mb(s, s->block);
2213 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2215 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2216 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2219 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2222 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2225 d->mb_skip_run= s->mb_skip_run;
2227 d->last_dc[i] = s->last_dc[i];
2230 d->mv_bits= s->mv_bits;
2231 d->i_tex_bits= s->i_tex_bits;
2232 d->p_tex_bits= s->p_tex_bits;
2233 d->i_count= s->i_count;
2234 d->f_count= s->f_count;
2235 d->b_count= s->b_count;
2236 d->skip_count= s->skip_count;
2237 d->misc_bits= s->misc_bits;
2241 d->qscale= s->qscale;
2242 d->dquant= s->dquant;
2244 d->esc3_level_length= s->esc3_level_length;
2247 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2250 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2251 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2254 d->mb_skip_run= s->mb_skip_run;
2256 d->last_dc[i] = s->last_dc[i];
2259 d->mv_bits= s->mv_bits;
2260 d->i_tex_bits= s->i_tex_bits;
2261 d->p_tex_bits= s->p_tex_bits;
2262 d->i_count= s->i_count;
2263 d->f_count= s->f_count;
2264 d->b_count= s->b_count;
2265 d->skip_count= s->skip_count;
2266 d->misc_bits= s->misc_bits;
2268 d->mb_intra= s->mb_intra;
2269 d->mb_skipped= s->mb_skipped;
2270 d->mv_type= s->mv_type;
2271 d->mv_dir= s->mv_dir;
2273 if(s->data_partitioning){
2275 d->tex_pb= s->tex_pb;
2279 d->block_last_index[i]= s->block_last_index[i];
2280 d->interlaced_dct= s->interlaced_dct;
2281 d->qscale= s->qscale;
2283 d->esc3_level_length= s->esc3_level_length;
2286 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2287 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2288 int *dmin, int *next_block, int motion_x, int motion_y)
2291 uint8_t *dest_backup[3];
2293 copy_context_before_encode(s, backup, type);
2295 s->block= s->blocks[*next_block];
2296 s->pb= pb[*next_block];
2297 if(s->data_partitioning){
2298 s->pb2 = pb2 [*next_block];
2299 s->tex_pb= tex_pb[*next_block];
2303 memcpy(dest_backup, s->dest, sizeof(s->dest));
2304 s->dest[0] = s->rd_scratchpad;
2305 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2306 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2307 assert(s->linesize >= 32); //FIXME
2310 encode_mb(s, motion_x, motion_y);
2312 score= put_bits_count(&s->pb);
2313 if(s->data_partitioning){
2314 score+= put_bits_count(&s->pb2);
2315 score+= put_bits_count(&s->tex_pb);
2318 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2319 ff_mpv_decode_mb(s, s->block);
2321 score *= s->lambda2;
2322 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2326 memcpy(s->dest, dest_backup, sizeof(s->dest));
2333 copy_context_after_encode(best, s, type);
2337 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2338 uint32_t *sq = ff_square_tab + 256;
2343 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2344 else if(w==8 && h==8)
2345 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2349 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2358 static int sse_mb(MpegEncContext *s){
2362 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2363 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2366 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2367 return s->mecc.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) +
2368 s->mecc.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) +
2369 s->mecc.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);
2371 return s->mecc.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) +
2372 s->mecc.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) +
2373 s->mecc.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);
2376 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)
2377 +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)
2378 +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);
2381 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2382 MpegEncContext *s= *(void**)arg;
2386 s->me.dia_size= s->avctx->pre_dia_size;
2387 s->first_slice_line=1;
2388 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2389 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2390 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2392 s->first_slice_line=0;
2400 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2401 MpegEncContext *s= *(void**)arg;
2403 s->me.dia_size= s->avctx->dia_size;
2404 s->first_slice_line=1;
2405 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2406 s->mb_x=0; //for block init below
2407 ff_init_block_index(s);
2408 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2409 s->block_index[0]+=2;
2410 s->block_index[1]+=2;
2411 s->block_index[2]+=2;
2412 s->block_index[3]+=2;
2414 /* compute motion vector & mb_type and store in context */
2415 if(s->pict_type==AV_PICTURE_TYPE_B)
2416 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2418 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2420 s->first_slice_line=0;
2425 static int mb_var_thread(AVCodecContext *c, void *arg){
2426 MpegEncContext *s= *(void**)arg;
2429 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2430 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2433 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2435 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2437 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2438 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2440 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2441 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2442 s->me.mb_var_sum_temp += varc;
2448 static void write_slice_end(MpegEncContext *s){
2449 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2450 if(s->partitioned_frame){
2451 ff_mpeg4_merge_partitions(s);
2454 ff_mpeg4_stuffing(&s->pb);
2455 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2456 ff_mjpeg_encode_stuffing(&s->pb);
2459 avpriv_align_put_bits(&s->pb);
2460 flush_put_bits(&s->pb);
2462 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2463 s->misc_bits+= get_bits_diff(s);
2466 static void write_mb_info(MpegEncContext *s)
2468 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2469 int offset = put_bits_count(&s->pb);
2470 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2471 int gobn = s->mb_y / s->gob_index;
2473 if (CONFIG_H263_ENCODER)
2474 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2475 bytestream_put_le32(&ptr, offset);
2476 bytestream_put_byte(&ptr, s->qscale);
2477 bytestream_put_byte(&ptr, gobn);
2478 bytestream_put_le16(&ptr, mba);
2479 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2480 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2481 /* 4MV not implemented */
2482 bytestream_put_byte(&ptr, 0); /* hmv2 */
2483 bytestream_put_byte(&ptr, 0); /* vmv2 */
2486 static void update_mb_info(MpegEncContext *s, int startcode)
2490 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2491 s->mb_info_size += 12;
2492 s->prev_mb_info = s->last_mb_info;
2495 s->prev_mb_info = put_bits_count(&s->pb)/8;
2496 /* This might have incremented mb_info_size above, and we return without
2497 * actually writing any info into that slot yet. But in that case,
2498 * this will be called again at the start of the after writing the
2499 * start code, actually writing the mb info. */
2503 s->last_mb_info = put_bits_count(&s->pb)/8;
2504 if (!s->mb_info_size)
2505 s->mb_info_size += 12;
2509 static int encode_thread(AVCodecContext *c, void *arg){
2510 MpegEncContext *s= *(void**)arg;
2511 int mb_x, mb_y, pdif = 0;
2512 int chr_h= 16>>s->chroma_y_shift;
2514 MpegEncContext best_s, backup_s;
2515 uint8_t bit_buf[2][MAX_MB_BYTES];
2516 uint8_t bit_buf2[2][MAX_MB_BYTES];
2517 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2518 PutBitContext pb[2], pb2[2], tex_pb[2];
2521 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2522 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2523 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2526 s->last_bits= put_bits_count(&s->pb);
2537 /* init last dc values */
2538 /* note: quant matrix value (8) is implied here */
2539 s->last_dc[i] = 128 << s->intra_dc_precision;
2541 s->current_picture.f->error[i] = 0;
2544 memset(s->last_mv, 0, sizeof(s->last_mv));
2548 switch(s->codec_id){
2549 case AV_CODEC_ID_H263:
2550 case AV_CODEC_ID_H263P:
2551 case AV_CODEC_ID_FLV1:
2552 if (CONFIG_H263_ENCODER)
2553 s->gob_index = ff_h263_get_gob_height(s);
2555 case AV_CODEC_ID_MPEG4:
2556 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2557 ff_mpeg4_init_partitions(s);
2563 s->first_slice_line = 1;
2564 s->ptr_lastgob = s->pb.buf;
2565 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2569 ff_set_qscale(s, s->qscale);
2570 ff_init_block_index(s);
2572 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2573 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2574 int mb_type= s->mb_type[xy];
2579 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2580 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2583 if(s->data_partitioning){
2584 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2585 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2586 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2592 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2593 ff_update_block_index(s);
2595 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2596 ff_h261_reorder_mb_index(s);
2597 xy= s->mb_y*s->mb_stride + s->mb_x;
2598 mb_type= s->mb_type[xy];
2601 /* write gob / video packet header */
2603 int current_packet_size, is_gob_start;
2605 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2607 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2609 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2611 switch(s->codec_id){
2612 case AV_CODEC_ID_H263:
2613 case AV_CODEC_ID_H263P:
2614 if(!s->h263_slice_structured)
2615 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2617 case AV_CODEC_ID_MPEG2VIDEO:
2618 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2619 case AV_CODEC_ID_MPEG1VIDEO:
2620 if(s->mb_skip_run) is_gob_start=0;
2625 if(s->start_mb_y != mb_y || mb_x!=0){
2628 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2629 ff_mpeg4_init_partitions(s);
2633 assert((put_bits_count(&s->pb)&7) == 0);
2634 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2636 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2637 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2638 int d = 100 / s->error_rate;
2640 current_packet_size=0;
2641 s->pb.buf_ptr= s->ptr_lastgob;
2642 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2646 if (s->avctx->rtp_callback){
2647 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2648 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2650 update_mb_info(s, 1);
2652 switch(s->codec_id){
2653 case AV_CODEC_ID_MPEG4:
2654 if (CONFIG_MPEG4_ENCODER) {
2655 ff_mpeg4_encode_video_packet_header(s);
2656 ff_mpeg4_clean_buffers(s);
2659 case AV_CODEC_ID_MPEG1VIDEO:
2660 case AV_CODEC_ID_MPEG2VIDEO:
2661 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2662 ff_mpeg1_encode_slice_header(s);
2663 ff_mpeg1_clean_buffers(s);
2666 case AV_CODEC_ID_H263:
2667 case AV_CODEC_ID_H263P:
2668 if (CONFIG_H263_ENCODER)
2669 ff_h263_encode_gob_header(s, mb_y);
2673 if(s->flags&CODEC_FLAG_PASS1){
2674 int bits= put_bits_count(&s->pb);
2675 s->misc_bits+= bits - s->last_bits;
2679 s->ptr_lastgob += current_packet_size;
2680 s->first_slice_line=1;
2681 s->resync_mb_x=mb_x;
2682 s->resync_mb_y=mb_y;
2686 if( (s->resync_mb_x == s->mb_x)
2687 && s->resync_mb_y+1 == s->mb_y){
2688 s->first_slice_line=0;
2692 s->dquant=0; //only for QP_RD
2694 update_mb_info(s, 0);
2696 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
2698 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2700 copy_context_before_encode(&backup_s, s, -1);
2702 best_s.data_partitioning= s->data_partitioning;
2703 best_s.partitioned_frame= s->partitioned_frame;
2704 if(s->data_partitioning){
2705 backup_s.pb2= s->pb2;
2706 backup_s.tex_pb= s->tex_pb;
2709 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2710 s->mv_dir = MV_DIR_FORWARD;
2711 s->mv_type = MV_TYPE_16X16;
2713 s->mv[0][0][0] = s->p_mv_table[xy][0];
2714 s->mv[0][0][1] = s->p_mv_table[xy][1];
2715 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2716 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2718 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2719 s->mv_dir = MV_DIR_FORWARD;
2720 s->mv_type = MV_TYPE_FIELD;
2723 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2724 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2725 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2727 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2728 &dmin, &next_block, 0, 0);
2730 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2731 s->mv_dir = MV_DIR_FORWARD;
2732 s->mv_type = MV_TYPE_16X16;
2736 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2737 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2739 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2740 s->mv_dir = MV_DIR_FORWARD;
2741 s->mv_type = MV_TYPE_8X8;
2744 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2745 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2747 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2748 &dmin, &next_block, 0, 0);
2750 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2751 s->mv_dir = MV_DIR_FORWARD;
2752 s->mv_type = MV_TYPE_16X16;
2754 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2755 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2756 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2757 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2759 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2760 s->mv_dir = MV_DIR_BACKWARD;
2761 s->mv_type = MV_TYPE_16X16;
2763 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2764 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2765 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2766 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2768 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2769 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2770 s->mv_type = MV_TYPE_16X16;
2772 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2773 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2774 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2775 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2776 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2777 &dmin, &next_block, 0, 0);
2779 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2780 s->mv_dir = MV_DIR_FORWARD;
2781 s->mv_type = MV_TYPE_FIELD;
2784 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2785 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2786 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2788 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2789 &dmin, &next_block, 0, 0);
2791 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2792 s->mv_dir = MV_DIR_BACKWARD;
2793 s->mv_type = MV_TYPE_FIELD;
2796 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2797 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2798 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2800 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2801 &dmin, &next_block, 0, 0);
2803 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2804 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2805 s->mv_type = MV_TYPE_FIELD;
2807 for(dir=0; dir<2; dir++){
2809 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2810 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2811 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2814 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2815 &dmin, &next_block, 0, 0);
2817 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2819 s->mv_type = MV_TYPE_16X16;
2823 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2824 &dmin, &next_block, 0, 0);
2825 if(s->h263_pred || s->h263_aic){
2827 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2829 ff_clean_intra_table_entries(s); //old mode?
2833 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2834 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2835 const int last_qp= backup_s.qscale;
2838 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2839 static const int dquant_tab[4]={-1,1,-2,2};
2841 assert(backup_s.dquant == 0);
2844 s->mv_dir= best_s.mv_dir;
2845 s->mv_type = MV_TYPE_16X16;
2846 s->mb_intra= best_s.mb_intra;
2847 s->mv[0][0][0] = best_s.mv[0][0][0];
2848 s->mv[0][0][1] = best_s.mv[0][0][1];
2849 s->mv[1][0][0] = best_s.mv[1][0][0];
2850 s->mv[1][0][1] = best_s.mv[1][0][1];
2852 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2853 for(; qpi<4; qpi++){
2854 int dquant= dquant_tab[qpi];
2855 qp= last_qp + dquant;
2856 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2858 backup_s.dquant= dquant;
2859 if(s->mb_intra && s->dc_val[0]){
2861 dc[i]= s->dc_val[0][ s->block_index[i] ];
2862 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2866 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2867 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2868 if(best_s.qscale != qp){
2869 if(s->mb_intra && s->dc_val[0]){
2871 s->dc_val[0][ s->block_index[i] ]= dc[i];
2872 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2879 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2880 int mx= s->b_direct_mv_table[xy][0];
2881 int my= s->b_direct_mv_table[xy][1];
2883 backup_s.dquant = 0;
2884 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2886 ff_mpeg4_set_direct_mv(s, mx, my);
2887 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2888 &dmin, &next_block, mx, my);
2890 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2891 backup_s.dquant = 0;
2892 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2894 ff_mpeg4_set_direct_mv(s, 0, 0);
2895 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2896 &dmin, &next_block, 0, 0);
2898 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2901 coded |= s->block_last_index[i];
2904 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2905 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2906 mx=my=0; //FIXME find the one we actually used
2907 ff_mpeg4_set_direct_mv(s, mx, my);
2908 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2916 s->mv_dir= best_s.mv_dir;
2917 s->mv_type = best_s.mv_type;
2919 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2920 s->mv[0][0][1] = best_s.mv[0][0][1];
2921 s->mv[1][0][0] = best_s.mv[1][0][0];
2922 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2925 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2926 &dmin, &next_block, mx, my);
2931 s->current_picture.qscale_table[xy] = best_s.qscale;
2933 copy_context_after_encode(s, &best_s, -1);
2935 pb_bits_count= put_bits_count(&s->pb);
2936 flush_put_bits(&s->pb);
2937 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2940 if(s->data_partitioning){
2941 pb2_bits_count= put_bits_count(&s->pb2);
2942 flush_put_bits(&s->pb2);
2943 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2944 s->pb2= backup_s.pb2;
2946 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2947 flush_put_bits(&s->tex_pb);
2948 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2949 s->tex_pb= backup_s.tex_pb;
2951 s->last_bits= put_bits_count(&s->pb);
2953 if (CONFIG_H263_ENCODER &&
2954 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2955 ff_h263_update_motion_val(s);
2957 if(next_block==0){ //FIXME 16 vs linesize16
2958 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2959 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2960 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2963 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2964 ff_mpv_decode_mb(s, s->block);
2966 int motion_x = 0, motion_y = 0;
2967 s->mv_type=MV_TYPE_16X16;
2968 // only one MB-Type possible
2971 case CANDIDATE_MB_TYPE_INTRA:
2974 motion_x= s->mv[0][0][0] = 0;
2975 motion_y= s->mv[0][0][1] = 0;
2977 case CANDIDATE_MB_TYPE_INTER:
2978 s->mv_dir = MV_DIR_FORWARD;
2980 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2981 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2983 case CANDIDATE_MB_TYPE_INTER_I:
2984 s->mv_dir = MV_DIR_FORWARD;
2985 s->mv_type = MV_TYPE_FIELD;
2988 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2989 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2990 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2993 case CANDIDATE_MB_TYPE_INTER4V:
2994 s->mv_dir = MV_DIR_FORWARD;
2995 s->mv_type = MV_TYPE_8X8;
2998 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2999 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3002 case CANDIDATE_MB_TYPE_DIRECT:
3003 if (CONFIG_MPEG4_ENCODER) {
3004 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3006 motion_x=s->b_direct_mv_table[xy][0];
3007 motion_y=s->b_direct_mv_table[xy][1];
3008 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3011 case CANDIDATE_MB_TYPE_DIRECT0:
3012 if (CONFIG_MPEG4_ENCODER) {
3013 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3015 ff_mpeg4_set_direct_mv(s, 0, 0);
3018 case CANDIDATE_MB_TYPE_BIDIR:
3019 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3021 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3022 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3023 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3024 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3026 case CANDIDATE_MB_TYPE_BACKWARD:
3027 s->mv_dir = MV_DIR_BACKWARD;
3029 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3030 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3032 case CANDIDATE_MB_TYPE_FORWARD:
3033 s->mv_dir = MV_DIR_FORWARD;
3035 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3036 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3038 case CANDIDATE_MB_TYPE_FORWARD_I:
3039 s->mv_dir = MV_DIR_FORWARD;
3040 s->mv_type = MV_TYPE_FIELD;
3043 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3044 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3045 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3048 case CANDIDATE_MB_TYPE_BACKWARD_I:
3049 s->mv_dir = MV_DIR_BACKWARD;
3050 s->mv_type = MV_TYPE_FIELD;
3053 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3054 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3055 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3058 case CANDIDATE_MB_TYPE_BIDIR_I:
3059 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3060 s->mv_type = MV_TYPE_FIELD;
3062 for(dir=0; dir<2; dir++){
3064 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3065 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3066 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3071 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3074 encode_mb(s, motion_x, motion_y);
3076 // RAL: Update last macroblock type
3077 s->last_mv_dir = s->mv_dir;
3079 if (CONFIG_H263_ENCODER &&
3080 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3081 ff_h263_update_motion_val(s);
3083 ff_mpv_decode_mb(s, s->block);
3086 /* clean the MV table in IPS frames for direct mode in B frames */
3087 if(s->mb_intra /* && I,P,S_TYPE */){
3088 s->p_mv_table[xy][0]=0;
3089 s->p_mv_table[xy][1]=0;
3092 if(s->flags&CODEC_FLAG_PSNR){
3096 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3097 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3099 s->current_picture.f->error[0] += sse(
3100 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3101 s->dest[0], w, h, s->linesize);
3102 s->current_picture.f->error[1] += sse(
3103 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3104 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3105 s->current_picture.f->error[2] += sse(
3106 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3107 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3110 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3111 ff_h263_loop_filter(s);
3113 av_dlog(s->avctx, "MB %d %d bits\n",
3114 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3118 //not beautiful here but we must write it before flushing so it has to be here
3119 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3120 ff_msmpeg4_encode_ext_header(s);
3124 /* Send the last GOB if RTP */
3125 if (s->avctx->rtp_callback) {
3126 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3127 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3128 /* Call the RTP callback to send the last GOB */
3130 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3136 #define MERGE(field) dst->field += src->field; src->field=0
3137 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3138 MERGE(me.scene_change_score);
3139 MERGE(me.mc_mb_var_sum_temp);
3140 MERGE(me.mb_var_sum_temp);
3143 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3146 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3147 MERGE(dct_count[1]);
3156 MERGE(er.error_count);
3157 MERGE(padding_bug_score);
3158 MERGE(current_picture.f->error[0]);
3159 MERGE(current_picture.f->error[1]);
3160 MERGE(current_picture.f->error[2]);
3162 if(dst->avctx->noise_reduction){
3163 for(i=0; i<64; i++){
3164 MERGE(dct_error_sum[0][i]);
3165 MERGE(dct_error_sum[1][i]);
3169 assert(put_bits_count(&src->pb) % 8 ==0);
3170 assert(put_bits_count(&dst->pb) % 8 ==0);
3171 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3172 flush_put_bits(&dst->pb);
3175 static int estimate_qp(MpegEncContext *s, int dry_run){
3176 if (s->next_lambda){
3177 s->current_picture_ptr->f->quality =
3178 s->current_picture.f->quality = s->next_lambda;
3179 if(!dry_run) s->next_lambda= 0;
3180 } else if (!s->fixed_qscale) {
3181 s->current_picture_ptr->f->quality =
3182 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3183 if (s->current_picture.f->quality < 0)
3187 if(s->adaptive_quant){
3188 switch(s->codec_id){
3189 case AV_CODEC_ID_MPEG4:
3190 if (CONFIG_MPEG4_ENCODER)
3191 ff_clean_mpeg4_qscales(s);
3193 case AV_CODEC_ID_H263:
3194 case AV_CODEC_ID_H263P:
3195 case AV_CODEC_ID_FLV1:
3196 if (CONFIG_H263_ENCODER)
3197 ff_clean_h263_qscales(s);
3200 ff_init_qscale_tab(s);
3203 s->lambda= s->lambda_table[0];
3206 s->lambda = s->current_picture.f->quality;
3211 /* must be called before writing the header */
3212 static void set_frame_distances(MpegEncContext * s){
3213 assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3214 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3216 if(s->pict_type==AV_PICTURE_TYPE_B){
3217 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3218 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3220 s->pp_time= s->time - s->last_non_b_time;
3221 s->last_non_b_time= s->time;
3222 assert(s->picture_number==0 || s->pp_time > 0);
3226 static int encode_picture(MpegEncContext *s, int picture_number)
3230 int context_count = s->slice_context_count;
3232 s->picture_number = picture_number;
3234 /* Reset the average MB variance */
3235 s->me.mb_var_sum_temp =
3236 s->me.mc_mb_var_sum_temp = 0;
3238 /* we need to initialize some time vars before we can encode b-frames */
3239 // RAL: Condition added for MPEG1VIDEO
3240 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3241 set_frame_distances(s);
3242 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3243 ff_set_mpeg4_time(s);
3245 s->me.scene_change_score=0;
3247 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3249 if(s->pict_type==AV_PICTURE_TYPE_I){
3250 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3251 else s->no_rounding=0;
3252 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3253 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3254 s->no_rounding ^= 1;
3257 if(s->flags & CODEC_FLAG_PASS2){
3258 if (estimate_qp(s,1) < 0)
3260 ff_get_2pass_fcode(s);
3261 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3262 if(s->pict_type==AV_PICTURE_TYPE_B)
3263 s->lambda= s->last_lambda_for[s->pict_type];
3265 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3269 s->mb_intra=0; //for the rate distortion & bit compare functions
3270 for(i=1; i<context_count; i++){
3271 ret = ff_update_duplicate_context(s->thread_context[i], s);
3279 /* Estimate motion for every MB */
3280 if(s->pict_type != AV_PICTURE_TYPE_I){
3281 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3282 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3283 if (s->pict_type != AV_PICTURE_TYPE_B) {
3284 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3285 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3289 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3290 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3292 for(i=0; i<s->mb_stride*s->mb_height; i++)
3293 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3295 if(!s->fixed_qscale){
3296 /* finding spatial complexity for I-frame rate control */
3297 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3300 for(i=1; i<context_count; i++){
3301 merge_context_after_me(s, s->thread_context[i]);
3303 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3304 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3307 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3308 s->pict_type= AV_PICTURE_TYPE_I;
3309 for(i=0; i<s->mb_stride*s->mb_height; i++)
3310 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3311 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3312 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3316 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3317 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3319 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3321 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3322 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3323 s->f_code= FFMAX3(s->f_code, a, b);
3326 ff_fix_long_p_mvs(s);
3327 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3328 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3332 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3333 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3338 if(s->pict_type==AV_PICTURE_TYPE_B){
3341 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3342 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3343 s->f_code = FFMAX(a, b);
3345 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3346 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3347 s->b_code = FFMAX(a, b);
3349 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3350 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3351 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3352 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3353 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3355 for(dir=0; dir<2; dir++){
3358 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3359 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3360 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3361 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3369 if (estimate_qp(s, 0) < 0)
3372 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3373 s->qscale= 3; //reduce clipping problems
3375 if (s->out_format == FMT_MJPEG) {
3376 /* for mjpeg, we do include qscale in the matrix */
3378 int j = s->idsp.idct_permutation[i];
3380 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3382 s->y_dc_scale_table=
3383 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3384 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3385 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3386 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3390 //FIXME var duplication
3391 s->current_picture_ptr->f->key_frame =
3392 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3393 s->current_picture_ptr->f->pict_type =
3394 s->current_picture.f->pict_type = s->pict_type;
3396 if (s->current_picture.f->key_frame)
3397 s->picture_in_gop_number=0;
3399 s->last_bits= put_bits_count(&s->pb);
3400 switch(s->out_format) {
3402 if (CONFIG_MJPEG_ENCODER)
3403 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3407 if (CONFIG_H261_ENCODER)
3408 ff_h261_encode_picture_header(s, picture_number);
3411 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3412 ff_wmv2_encode_picture_header(s, picture_number);
3413 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3414 ff_msmpeg4_encode_picture_header(s, picture_number);
3415 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3416 ff_mpeg4_encode_picture_header(s, picture_number);
3417 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3418 ff_rv10_encode_picture_header(s, picture_number);
3419 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3420 ff_rv20_encode_picture_header(s, picture_number);
3421 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3422 ff_flv_encode_picture_header(s, picture_number);
3423 else if (CONFIG_H263_ENCODER)
3424 ff_h263_encode_picture_header(s, picture_number);
3427 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3428 ff_mpeg1_encode_picture_header(s, picture_number);
3433 bits= put_bits_count(&s->pb);
3434 s->header_bits= bits - s->last_bits;
3436 for(i=1; i<context_count; i++){
3437 update_duplicate_context_after_me(s->thread_context[i], s);
3439 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3440 for(i=1; i<context_count; i++){
3441 merge_context_after_encode(s, s->thread_context[i]);
3447 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3448 const int intra= s->mb_intra;
3451 s->dct_count[intra]++;
3453 for(i=0; i<64; i++){
3454 int level= block[i];
3458 s->dct_error_sum[intra][i] += level;
3459 level -= s->dct_offset[intra][i];
3460 if(level<0) level=0;
3462 s->dct_error_sum[intra][i] -= level;
3463 level += s->dct_offset[intra][i];
3464 if(level>0) level=0;
3471 static int dct_quantize_trellis_c(MpegEncContext *s,
3472 int16_t *block, int n,
3473 int qscale, int *overflow){
3475 const uint8_t *scantable= s->intra_scantable.scantable;
3476 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3478 unsigned int threshold1, threshold2;
3490 int coeff_count[64];
3491 int qmul, qadd, start_i, last_non_zero, i, dc;
3492 const int esc_length= s->ac_esc_length;
3494 uint8_t * last_length;
3495 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3497 s->fdsp.fdct(block);
3499 if(s->dct_error_sum)
3500 s->denoise_dct(s, block);
3502 qadd= ((qscale-1)|1)*8;
3513 /* For AIC we skip quant/dequant of INTRADC */
3518 /* note: block[0] is assumed to be positive */
3519 block[0] = (block[0] + (q >> 1)) / q;
3522 qmat = s->q_intra_matrix[qscale];
3523 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3524 bias= 1<<(QMAT_SHIFT-1);
3525 length = s->intra_ac_vlc_length;
3526 last_length= s->intra_ac_vlc_last_length;
3530 qmat = s->q_inter_matrix[qscale];
3531 length = s->inter_ac_vlc_length;
3532 last_length= s->inter_ac_vlc_last_length;
3536 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3537 threshold2= (threshold1<<1);
3539 for(i=63; i>=start_i; i--) {
3540 const int j = scantable[i];
3541 int level = block[j] * qmat[j];
3543 if(((unsigned)(level+threshold1))>threshold2){
3549 for(i=start_i; i<=last_non_zero; i++) {
3550 const int j = scantable[i];
3551 int level = block[j] * qmat[j];
3553 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3554 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3555 if(((unsigned)(level+threshold1))>threshold2){
3557 level= (bias + level)>>QMAT_SHIFT;
3559 coeff[1][i]= level-1;
3560 // coeff[2][k]= level-2;
3562 level= (bias - level)>>QMAT_SHIFT;
3563 coeff[0][i]= -level;
3564 coeff[1][i]= -level+1;
3565 // coeff[2][k]= -level+2;
3567 coeff_count[i]= FFMIN(level, 2);
3568 assert(coeff_count[i]);
3571 coeff[0][i]= (level>>31)|1;
3576 *overflow= s->max_qcoeff < max; //overflow might have happened
3578 if(last_non_zero < start_i){
3579 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3580 return last_non_zero;
3583 score_tab[start_i]= 0;
3584 survivor[0]= start_i;
3587 for(i=start_i; i<=last_non_zero; i++){
3588 int level_index, j, zero_distortion;
3589 int dct_coeff= FFABS(block[ scantable[i] ]);
3590 int best_score=256*256*256*120;
3592 if (s->fdsp.fdct == ff_fdct_ifast)
3593 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3594 zero_distortion= dct_coeff*dct_coeff;
3596 for(level_index=0; level_index < coeff_count[i]; level_index++){
3598 int level= coeff[level_index][i];
3599 const int alevel= FFABS(level);
3604 if(s->out_format == FMT_H263){
3605 unquant_coeff= alevel*qmul + qadd;
3607 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3609 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3610 unquant_coeff = (unquant_coeff - 1) | 1;
3612 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3613 unquant_coeff = (unquant_coeff - 1) | 1;
3618 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3620 if((level&(~127)) == 0){
3621 for(j=survivor_count-1; j>=0; j--){
3622 int run= i - survivor[j];
3623 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3624 score += score_tab[i-run];
3626 if(score < best_score){
3629 level_tab[i+1]= level-64;
3633 if(s->out_format == FMT_H263){
3634 for(j=survivor_count-1; j>=0; j--){
3635 int run= i - survivor[j];
3636 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3637 score += score_tab[i-run];
3638 if(score < last_score){
3641 last_level= level-64;
3647 distortion += esc_length*lambda;
3648 for(j=survivor_count-1; j>=0; j--){
3649 int run= i - survivor[j];
3650 int score= distortion + score_tab[i-run];
3652 if(score < best_score){
3655 level_tab[i+1]= level-64;
3659 if(s->out_format == FMT_H263){
3660 for(j=survivor_count-1; j>=0; j--){
3661 int run= i - survivor[j];
3662 int score= distortion + score_tab[i-run];
3663 if(score < last_score){
3666 last_level= level-64;
3674 score_tab[i+1]= best_score;
3676 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3677 if(last_non_zero <= 27){
3678 for(; survivor_count; survivor_count--){
3679 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3683 for(; survivor_count; survivor_count--){
3684 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3689 survivor[ survivor_count++ ]= i+1;
3692 if(s->out_format != FMT_H263){
3693 last_score= 256*256*256*120;
3694 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3695 int score= score_tab[i];
3696 if(i) score += lambda*2; //FIXME exacter?
3698 if(score < last_score){
3701 last_level= level_tab[i];
3702 last_run= run_tab[i];
3707 s->coded_score[n] = last_score;
3709 dc= FFABS(block[0]);
3710 last_non_zero= last_i - 1;
3711 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3713 if(last_non_zero < start_i)
3714 return last_non_zero;
3716 if(last_non_zero == 0 && start_i == 0){
3718 int best_score= dc * dc;
3720 for(i=0; i<coeff_count[0]; i++){
3721 int level= coeff[i][0];
3722 int alevel= FFABS(level);
3723 int unquant_coeff, score, distortion;
3725 if(s->out_format == FMT_H263){
3726 unquant_coeff= (alevel*qmul + qadd)>>3;
3728 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3729 unquant_coeff = (unquant_coeff - 1) | 1;
3731 unquant_coeff = (unquant_coeff + 4) >> 3;
3732 unquant_coeff<<= 3 + 3;
3734 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3736 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3737 else score= distortion + esc_length*lambda;
3739 if(score < best_score){
3741 best_level= level - 64;
3744 block[0]= best_level;
3745 s->coded_score[n] = best_score - dc*dc;
3746 if(best_level == 0) return -1;
3747 else return last_non_zero;
3753 block[ perm_scantable[last_non_zero] ]= last_level;
3756 for(; i>start_i; i -= run_tab[i] + 1){
3757 block[ perm_scantable[i-1] ]= level_tab[i];
3760 return last_non_zero;
3763 //#define REFINE_STATS 1
3764 static int16_t basis[64][64];
3766 static void build_basis(uint8_t *perm){
3773 double s= 0.25*(1<<BASIS_SHIFT);
3775 int perm_index= perm[index];
3776 if(i==0) s*= sqrt(0.5);
3777 if(j==0) s*= sqrt(0.5);
3778 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)));
3785 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3786 int16_t *block, int16_t *weight, int16_t *orig,
3789 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3790 const uint8_t *scantable= s->intra_scantable.scantable;
3791 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3792 // unsigned int threshold1, threshold2;
3797 int qmul, qadd, start_i, last_non_zero, i, dc;
3799 uint8_t * last_length;
3801 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3804 static int after_last=0;
3805 static int to_zero=0;
3806 static int from_zero=0;
3809 static int messed_sign=0;
3812 if(basis[0][0] == 0)
3813 build_basis(s->idsp.idct_permutation);
3824 /* For AIC we skip quant/dequant of INTRADC */
3828 q <<= RECON_SHIFT-3;
3829 /* note: block[0] is assumed to be positive */
3831 // block[0] = (block[0] + (q >> 1)) / q;
3833 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3834 // bias= 1<<(QMAT_SHIFT-1);
3835 length = s->intra_ac_vlc_length;
3836 last_length= s->intra_ac_vlc_last_length;
3840 length = s->inter_ac_vlc_length;
3841 last_length= s->inter_ac_vlc_last_length;
3843 last_non_zero = s->block_last_index[n];
3848 dc += (1<<(RECON_SHIFT-1));
3849 for(i=0; i<64; i++){
3850 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3853 STOP_TIMER("memset rem[]")}
3856 for(i=0; i<64; i++){
3861 w= FFABS(weight[i]) + qns*one;
3862 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3865 // w=weight[i] = (63*qns + (w/2)) / w;
3871 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3877 for(i=start_i; i<=last_non_zero; i++){
3878 int j= perm_scantable[i];
3879 const int level= block[j];
3883 if(level<0) coeff= qmul*level - qadd;
3884 else coeff= qmul*level + qadd;
3885 run_tab[rle_index++]=run;
3888 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
3894 if(last_non_zero>0){
3895 STOP_TIMER("init rem[]")
3902 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
3905 int run2, best_unquant_change=0, analyze_gradient;
3909 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3911 if(analyze_gradient){
3915 for(i=0; i<64; i++){
3918 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3921 STOP_TIMER("rem*w*w")}
3931 const int level= block[0];
3932 int change, old_coeff;
3934 assert(s->mb_intra);
3938 for(change=-1; change<=1; change+=2){
3939 int new_level= level + change;
3940 int score, new_coeff;
3942 new_coeff= q*new_level;
3943 if(new_coeff >= 2048 || new_coeff < 0)
3946 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
3947 new_coeff - old_coeff);
3948 if(score<best_score){
3951 best_change= change;
3952 best_unquant_change= new_coeff - old_coeff;
3959 run2= run_tab[rle_index++];
3963 for(i=start_i; i<64; i++){
3964 int j= perm_scantable[i];
3965 const int level= block[j];
3966 int change, old_coeff;
3968 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3972 if(level<0) old_coeff= qmul*level - qadd;
3973 else old_coeff= qmul*level + qadd;
3974 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3978 assert(run2>=0 || i >= last_non_zero );
3981 for(change=-1; change<=1; change+=2){
3982 int new_level= level + change;
3983 int score, new_coeff, unquant_change;
3986 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3990 if(new_level<0) new_coeff= qmul*new_level - qadd;
3991 else new_coeff= qmul*new_level + qadd;
3992 if(new_coeff >= 2048 || new_coeff <= -2048)
3994 //FIXME check for overflow
3997 if(level < 63 && level > -63){
3998 if(i < last_non_zero)
3999 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4000 - length[UNI_AC_ENC_INDEX(run, level+64)];
4002 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4003 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4006 assert(FFABS(new_level)==1);
4008 if(analyze_gradient){
4009 int g= d1[ scantable[i] ];
4010 if(g && (g^new_level) >= 0)
4014 if(i < last_non_zero){
4015 int next_i= i + run2 + 1;
4016 int next_level= block[ perm_scantable[next_i] ] + 64;
4018 if(next_level&(~127))
4021 if(next_i < last_non_zero)
4022 score += length[UNI_AC_ENC_INDEX(run, 65)]
4023 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4024 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4026 score += length[UNI_AC_ENC_INDEX(run, 65)]
4027 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4028 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4030 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4032 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4033 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4039 assert(FFABS(level)==1);
4041 if(i < last_non_zero){
4042 int next_i= i + run2 + 1;
4043 int next_level= block[ perm_scantable[next_i] ] + 64;
4045 if(next_level&(~127))
4048 if(next_i < last_non_zero)
4049 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4050 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4051 - length[UNI_AC_ENC_INDEX(run, 65)];
4053 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4054 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4055 - length[UNI_AC_ENC_INDEX(run, 65)];
4057 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4059 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4060 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4067 unquant_change= new_coeff - old_coeff;
4068 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4070 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4072 if(score<best_score){
4075 best_change= change;
4076 best_unquant_change= unquant_change;
4080 prev_level= level + 64;
4081 if(prev_level&(~127))
4090 STOP_TIMER("iterative step")}
4094 int j= perm_scantable[ best_coeff ];
4096 block[j] += best_change;
4098 if(best_coeff > last_non_zero){
4099 last_non_zero= best_coeff;
4107 if(block[j] - best_change){
4108 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4120 for(; last_non_zero>=start_i; last_non_zero--){
4121 if(block[perm_scantable[last_non_zero]])
4127 if(256*256*256*64 % count == 0){
4128 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4133 for(i=start_i; i<=last_non_zero; i++){
4134 int j= perm_scantable[i];
4135 const int level= block[j];
4138 run_tab[rle_index++]=run;
4145 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4151 if(last_non_zero>0){
4152 STOP_TIMER("iterative search")
4157 return last_non_zero;
4160 int ff_dct_quantize_c(MpegEncContext *s,
4161 int16_t *block, int n,
4162 int qscale, int *overflow)
4164 int i, j, level, last_non_zero, q, start_i;
4166 const uint8_t *scantable= s->intra_scantable.scantable;
4169 unsigned int threshold1, threshold2;
4171 s->fdsp.fdct(block);
4173 if(s->dct_error_sum)
4174 s->denoise_dct(s, block);
4184 /* For AIC we skip quant/dequant of INTRADC */
4187 /* note: block[0] is assumed to be positive */
4188 block[0] = (block[0] + (q >> 1)) / q;
4191 qmat = s->q_intra_matrix[qscale];
4192 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4196 qmat = s->q_inter_matrix[qscale];
4197 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4199 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4200 threshold2= (threshold1<<1);
4201 for(i=63;i>=start_i;i--) {
4203 level = block[j] * qmat[j];
4205 if(((unsigned)(level+threshold1))>threshold2){
4212 for(i=start_i; i<=last_non_zero; i++) {
4214 level = block[j] * qmat[j];
4216 // if( bias+level >= (1<<QMAT_SHIFT)
4217 // || bias-level >= (1<<QMAT_SHIFT)){
4218 if(((unsigned)(level+threshold1))>threshold2){
4220 level= (bias + level)>>QMAT_SHIFT;
4223 level= (bias - level)>>QMAT_SHIFT;
4231 *overflow= s->max_qcoeff < max; //overflow might have happened
4233 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4234 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4235 ff_block_permute(block, s->idsp.idct_permutation,
4236 scantable, last_non_zero);
4238 return last_non_zero;
4241 #define OFFSET(x) offsetof(MpegEncContext, x)
4242 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4243 static const AVOption h263_options[] = {
4244 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4245 { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4246 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4251 static const AVClass h263_class = {
4252 .class_name = "H.263 encoder",
4253 .item_name = av_default_item_name,
4254 .option = h263_options,
4255 .version = LIBAVUTIL_VERSION_INT,
4258 AVCodec ff_h263_encoder = {
4260 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4261 .type = AVMEDIA_TYPE_VIDEO,
4262 .id = AV_CODEC_ID_H263,
4263 .priv_data_size = sizeof(MpegEncContext),
4264 .init = ff_mpv_encode_init,
4265 .encode2 = ff_mpv_encode_picture,
4266 .close = ff_mpv_encode_end,
4267 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4268 .priv_class = &h263_class,
4271 static const AVOption h263p_options[] = {
4272 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4273 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4274 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4275 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4279 static const AVClass h263p_class = {
4280 .class_name = "H.263p encoder",
4281 .item_name = av_default_item_name,
4282 .option = h263p_options,
4283 .version = LIBAVUTIL_VERSION_INT,
4286 AVCodec ff_h263p_encoder = {
4288 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4289 .type = AVMEDIA_TYPE_VIDEO,
4290 .id = AV_CODEC_ID_H263P,
4291 .priv_data_size = sizeof(MpegEncContext),
4292 .init = ff_mpv_encode_init,
4293 .encode2 = ff_mpv_encode_picture,
4294 .close = ff_mpv_encode_end,
4295 .capabilities = CODEC_CAP_SLICE_THREADS,
4296 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4297 .priv_class = &h263p_class,
4300 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4302 AVCodec ff_msmpeg4v2_encoder = {
4303 .name = "msmpeg4v2",
4304 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4305 .type = AVMEDIA_TYPE_VIDEO,
4306 .id = AV_CODEC_ID_MSMPEG4V2,
4307 .priv_data_size = sizeof(MpegEncContext),
4308 .init = ff_mpv_encode_init,
4309 .encode2 = ff_mpv_encode_picture,
4310 .close = ff_mpv_encode_end,
4311 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4312 .priv_class = &msmpeg4v2_class,
4315 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4317 AVCodec ff_msmpeg4v3_encoder = {
4319 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4320 .type = AVMEDIA_TYPE_VIDEO,
4321 .id = AV_CODEC_ID_MSMPEG4V3,
4322 .priv_data_size = sizeof(MpegEncContext),
4323 .init = ff_mpv_encode_init,
4324 .encode2 = ff_mpv_encode_picture,
4325 .close = ff_mpv_encode_end,
4326 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4327 .priv_class = &msmpeg4v3_class,
4330 FF_MPV_GENERIC_CLASS(wmv1)
4332 AVCodec ff_wmv1_encoder = {
4334 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4335 .type = AVMEDIA_TYPE_VIDEO,
4336 .id = AV_CODEC_ID_WMV1,
4337 .priv_data_size = sizeof(MpegEncContext),
4338 .init = ff_mpv_encode_init,
4339 .encode2 = ff_mpv_encode_picture,
4340 .close = ff_mpv_encode_end,
4341 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4342 .priv_class = &wmv1_class,