2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/internal.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/opt.h"
39 #include "mpegvideo.h"
47 #include "aandcttab.h"
49 #include "mpeg4video.h"
51 #include "bytestream.h"
55 static int encode_picture(MpegEncContext *s, int picture_number);
56 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
57 static int sse_mb(MpegEncContext *s);
58 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
59 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
61 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
62 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
64 const AVOption ff_mpv_generic_options[] = {
69 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
70 uint16_t (*qmat16)[2][64],
71 const uint16_t *quant_matrix,
72 int bias, int qmin, int qmax, int intra)
77 for (qscale = qmin; qscale <= qmax; qscale++) {
79 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
80 dsp->fdct == ff_jpeg_fdct_islow_10 ||
81 dsp->fdct == ff_faandct) {
82 for (i = 0; i < 64; i++) {
83 const int j = dsp->idct_permutation[i];
84 /* 16 <= qscale * quant_matrix[i] <= 7905
85 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
86 * 19952 <= x <= 249205026
87 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
88 * 3444240 >= (1 << 36) / (x) >= 275 */
90 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
91 (qscale * quant_matrix[j]));
93 } else if (dsp->fdct == ff_fdct_ifast) {
94 for (i = 0; i < 64; i++) {
95 const int j = dsp->idct_permutation[i];
96 /* 16 <= qscale * quant_matrix[i] <= 7905
97 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
98 * 19952 <= x <= 249205026
99 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
100 * 3444240 >= (1 << 36) / (x) >= 275 */
102 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
103 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
106 for (i = 0; i < 64; i++) {
107 const int j = dsp->idct_permutation[i];
108 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
109 * Assume x = qscale * quant_matrix[i]
111 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
112 * so 32768 >= (1 << 19) / (x) >= 67 */
113 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
114 (qscale * quant_matrix[j]));
115 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
116 // (qscale * quant_matrix[i]);
117 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
118 (qscale * quant_matrix[j]);
120 if (qmat16[qscale][0][i] == 0 ||
121 qmat16[qscale][0][i] == 128 * 256)
122 qmat16[qscale][0][i] = 128 * 256 - 1;
123 qmat16[qscale][1][i] =
124 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
125 qmat16[qscale][0][i]);
129 for (i = intra; i < 64; i++) {
131 if (dsp->fdct == ff_fdct_ifast) {
132 max = (8191LL * ff_aanscales[i]) >> 14;
134 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
140 av_log(NULL, AV_LOG_INFO,
141 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
146 static inline void update_qscale(MpegEncContext *s)
148 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
149 (FF_LAMBDA_SHIFT + 7);
150 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
152 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
156 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
162 for (i = 0; i < 64; i++) {
163 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
170 * init s->current_picture.qscale_table from s->lambda_table
172 void ff_init_qscale_tab(MpegEncContext *s)
174 int8_t * const qscale_table = s->current_picture.qscale_table;
177 for (i = 0; i < s->mb_num; i++) {
178 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
179 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
180 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
185 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst,
188 dst->pict_type = src->pict_type;
189 dst->quality = src->quality;
190 dst->coded_picture_number = src->coded_picture_number;
191 dst->display_picture_number = src->display_picture_number;
192 //dst->reference = src->reference;
194 dst->interlaced_frame = src->interlaced_frame;
195 dst->top_field_first = src->top_field_first;
198 static void update_duplicate_context_after_me(MpegEncContext *dst,
201 #define COPY(a) dst->a= src->a
203 COPY(current_picture);
209 COPY(picture_in_gop_number);
210 COPY(gop_picture_number);
211 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
212 COPY(progressive_frame); // FIXME don't set in encode_header
213 COPY(partitioned_frame); // FIXME don't set in encode_header
218 * Set the given MpegEncContext to defaults for encoding.
219 * the changed fields will not depend upon the prior state of the MpegEncContext.
221 static void MPV_encode_defaults(MpegEncContext *s)
224 ff_MPV_common_defaults(s);
226 for (i = -16; i < 16; i++) {
227 default_fcode_tab[i + MAX_MV] = 1;
229 s->me.mv_penalty = default_mv_penalty;
230 s->fcode_tab = default_fcode_tab;
233 av_cold int ff_dct_encode_init(MpegEncContext *s) {
235 ff_dct_encode_init_x86(s);
237 if (!s->dct_quantize)
238 s->dct_quantize = ff_dct_quantize_c;
240 s->denoise_dct = denoise_dct_c;
241 s->fast_dct_quantize = s->dct_quantize;
242 if (s->avctx->trellis)
243 s->dct_quantize = dct_quantize_trellis_c;
248 /* init video encoder */
249 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
251 MpegEncContext *s = avctx->priv_data;
253 int chroma_h_shift, chroma_v_shift;
255 MPV_encode_defaults(s);
257 switch (avctx->codec_id) {
258 case AV_CODEC_ID_MPEG2VIDEO:
259 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
260 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
261 av_log(avctx, AV_LOG_ERROR,
262 "only YUV420 and YUV422 are supported\n");
266 case AV_CODEC_ID_LJPEG:
267 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
268 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
269 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
270 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
271 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
272 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
273 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
274 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
275 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
276 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
277 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
281 case AV_CODEC_ID_MJPEG:
282 case AV_CODEC_ID_AMV:
283 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
284 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
285 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
286 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
287 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
288 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
289 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
290 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
295 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
296 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
301 switch (avctx->pix_fmt) {
302 case AV_PIX_FMT_YUVJ444P:
303 case AV_PIX_FMT_YUV444P:
304 s->chroma_format = CHROMA_444;
306 case AV_PIX_FMT_YUVJ422P:
307 case AV_PIX_FMT_YUV422P:
308 s->chroma_format = CHROMA_422;
310 case AV_PIX_FMT_YUVJ420P:
311 case AV_PIX_FMT_YUV420P:
313 s->chroma_format = CHROMA_420;
317 s->bit_rate = avctx->bit_rate;
318 s->width = avctx->width;
319 s->height = avctx->height;
320 if (avctx->gop_size > 600 &&
321 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
322 av_log(avctx, AV_LOG_WARNING,
323 "keyframe interval too large!, reducing it from %d to %d\n",
324 avctx->gop_size, 600);
325 avctx->gop_size = 600;
327 s->gop_size = avctx->gop_size;
329 s->flags = avctx->flags;
330 s->flags2 = avctx->flags2;
331 s->max_b_frames = avctx->max_b_frames;
332 s->codec_id = avctx->codec->id;
333 s->strict_std_compliance = avctx->strict_std_compliance;
334 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
335 s->mpeg_quant = avctx->mpeg_quant;
336 s->rtp_mode = !!avctx->rtp_payload_size;
337 s->intra_dc_precision = avctx->intra_dc_precision;
338 s->user_specified_pts = AV_NOPTS_VALUE;
340 if (s->gop_size <= 1) {
347 s->me_method = avctx->me_method;
350 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
352 s->adaptive_quant = (s->avctx->lumi_masking ||
353 s->avctx->dark_masking ||
354 s->avctx->temporal_cplx_masking ||
355 s->avctx->spatial_cplx_masking ||
356 s->avctx->p_masking ||
357 s->avctx->border_masking ||
358 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
361 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
363 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
364 switch(avctx->codec_id) {
365 case AV_CODEC_ID_MPEG1VIDEO:
366 case AV_CODEC_ID_MPEG2VIDEO:
367 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
369 case AV_CODEC_ID_MPEG4:
370 case AV_CODEC_ID_MSMPEG4V1:
371 case AV_CODEC_ID_MSMPEG4V2:
372 case AV_CODEC_ID_MSMPEG4V3:
373 if (avctx->rc_max_rate >= 15000000) {
374 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
375 } else if(avctx->rc_max_rate >= 2000000) {
376 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
377 } else if(avctx->rc_max_rate >= 384000) {
378 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
380 avctx->rc_buffer_size = 40;
381 avctx->rc_buffer_size *= 16384;
384 if (avctx->rc_buffer_size) {
385 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
389 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
390 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
391 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
395 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
396 av_log(avctx, AV_LOG_INFO,
397 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
400 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
401 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
405 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
406 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
410 if (avctx->rc_max_rate &&
411 avctx->rc_max_rate == avctx->bit_rate &&
412 avctx->rc_max_rate != avctx->rc_min_rate) {
413 av_log(avctx, AV_LOG_INFO,
414 "impossible bitrate constraints, this will fail\n");
417 if (avctx->rc_buffer_size &&
418 avctx->bit_rate * (int64_t)avctx->time_base.num >
419 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
420 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
424 if (!s->fixed_qscale &&
425 avctx->bit_rate * av_q2d(avctx->time_base) >
426 avctx->bit_rate_tolerance) {
427 av_log(avctx, AV_LOG_ERROR,
428 "bitrate tolerance too small for bitrate\n");
432 if (s->avctx->rc_max_rate &&
433 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
434 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
435 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
436 90000LL * (avctx->rc_buffer_size - 1) >
437 s->avctx->rc_max_rate * 0xFFFFLL) {
438 av_log(avctx, AV_LOG_INFO,
439 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
440 "specified vbv buffer is too large for the given bitrate!\n");
443 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
444 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
445 s->codec_id != AV_CODEC_ID_FLV1) {
446 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
450 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
451 av_log(avctx, AV_LOG_ERROR,
452 "OBMC is only supported with simple mb decision\n");
456 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
457 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
461 if (s->max_b_frames &&
462 s->codec_id != AV_CODEC_ID_MPEG4 &&
463 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
464 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
465 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
469 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
470 s->codec_id == AV_CODEC_ID_H263 ||
471 s->codec_id == AV_CODEC_ID_H263P) &&
472 (avctx->sample_aspect_ratio.num > 255 ||
473 avctx->sample_aspect_ratio.den > 255)) {
474 av_log(avctx, AV_LOG_WARNING,
475 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
476 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
477 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
478 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
481 if ((s->codec_id == AV_CODEC_ID_H263 ||
482 s->codec_id == AV_CODEC_ID_H263P) &&
483 (avctx->width > 2048 ||
484 avctx->height > 1152 )) {
485 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
488 if ((s->codec_id == AV_CODEC_ID_H263 ||
489 s->codec_id == AV_CODEC_ID_H263P) &&
490 ((avctx->width &3) ||
491 (avctx->height&3) )) {
492 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
496 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
497 (avctx->width > 4095 ||
498 avctx->height > 4095 )) {
499 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
503 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
504 (avctx->width > 16383 ||
505 avctx->height > 16383 )) {
506 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
510 if (s->codec_id == AV_CODEC_ID_RV10 &&
512 avctx->height&15 )) {
513 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
514 return AVERROR(EINVAL);
517 if (s->codec_id == AV_CODEC_ID_RV20 &&
520 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
521 return AVERROR(EINVAL);
524 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
525 s->codec_id == AV_CODEC_ID_WMV2) &&
527 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
531 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
532 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
533 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
537 // FIXME mpeg2 uses that too
538 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
539 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
540 av_log(avctx, AV_LOG_ERROR,
541 "mpeg2 style quantization not supported by codec\n");
545 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
546 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
550 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
551 s->avctx->mb_decision != FF_MB_DECISION_RD) {
552 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
556 if (s->avctx->scenechange_threshold < 1000000000 &&
557 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
558 av_log(avctx, AV_LOG_ERROR,
559 "closed gop with scene change detection are not supported yet, "
560 "set threshold to 1000000000\n");
564 if (s->flags & CODEC_FLAG_LOW_DELAY) {
565 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
566 av_log(avctx, AV_LOG_ERROR,
567 "low delay forcing is only available for mpeg2\n");
570 if (s->max_b_frames != 0) {
571 av_log(avctx, AV_LOG_ERROR,
572 "b frames cannot be used with low delay\n");
577 if (s->q_scale_type == 1) {
578 if (avctx->qmax > 12) {
579 av_log(avctx, AV_LOG_ERROR,
580 "non linear quant only supports qmax <= 12 currently\n");
585 if (s->avctx->thread_count > 1 &&
586 s->codec_id != AV_CODEC_ID_MPEG4 &&
587 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
588 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
589 s->codec_id != AV_CODEC_ID_MJPEG &&
590 (s->codec_id != AV_CODEC_ID_H263P)) {
591 av_log(avctx, AV_LOG_ERROR,
592 "multi threaded encoding not supported by codec\n");
596 if (s->avctx->thread_count < 1) {
597 av_log(avctx, AV_LOG_ERROR,
598 "automatic thread number detection not supported by codec, "
603 if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
606 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
607 s->h263_slice_structured = 1;
609 if (!avctx->time_base.den || !avctx->time_base.num) {
610 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
614 i = (INT_MAX / 2 + 128) >> 8;
615 if (avctx->mb_threshold >= i) {
616 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
621 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
622 av_log(avctx, AV_LOG_INFO,
623 "notice: b_frame_strategy only affects the first pass\n");
624 avctx->b_frame_strategy = 0;
627 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
629 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
630 avctx->time_base.den /= i;
631 avctx->time_base.num /= i;
635 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
636 // (a + x * 3 / 8) / x
637 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
638 s->inter_quant_bias = 0;
640 s->intra_quant_bias = 0;
642 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
645 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
646 s->intra_quant_bias = avctx->intra_quant_bias;
647 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
648 s->inter_quant_bias = avctx->inter_quant_bias;
650 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
652 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
654 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
655 s->avctx->time_base.den > (1 << 16) - 1) {
656 av_log(avctx, AV_LOG_ERROR,
657 "timebase %d/%d not supported by MPEG 4 standard, "
658 "the maximum admitted value for the timebase denominator "
659 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
663 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
665 switch (avctx->codec->id) {
666 case AV_CODEC_ID_MPEG1VIDEO:
667 s->out_format = FMT_MPEG1;
668 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
669 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
671 case AV_CODEC_ID_MPEG2VIDEO:
672 s->out_format = FMT_MPEG1;
673 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
674 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
677 case AV_CODEC_ID_LJPEG:
678 case AV_CODEC_ID_MJPEG:
679 case AV_CODEC_ID_AMV:
680 s->out_format = FMT_MJPEG;
681 s->intra_only = 1; /* force intra only for jpeg */
682 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
683 (avctx->pix_fmt == AV_PIX_FMT_BGR0
684 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
685 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
686 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
687 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
688 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
689 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
690 s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
691 s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
693 s->mjpeg_vsample[0] = 2;
694 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
695 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
696 s->mjpeg_hsample[0] = 2;
697 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
698 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
700 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
701 ff_mjpeg_encode_init(s) < 0)
706 case AV_CODEC_ID_H261:
707 if (!CONFIG_H261_ENCODER)
709 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
710 av_log(avctx, AV_LOG_ERROR,
711 "The specified picture size of %dx%d is not valid for the "
712 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
713 s->width, s->height);
716 s->out_format = FMT_H261;
720 case AV_CODEC_ID_H263:
721 if (!CONFIG_H263_ENCODER)
723 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
724 s->width, s->height) == 8) {
725 av_log(avctx, AV_LOG_ERROR,
726 "The specified picture size of %dx%d is not valid for "
727 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
728 "352x288, 704x576, and 1408x1152. "
729 "Try H.263+.\n", s->width, s->height);
732 s->out_format = FMT_H263;
736 case AV_CODEC_ID_H263P:
737 s->out_format = FMT_H263;
740 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
741 s->modified_quant = s->h263_aic;
742 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
743 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
746 /* These are just to be sure */
750 case AV_CODEC_ID_FLV1:
751 s->out_format = FMT_H263;
752 s->h263_flv = 2; /* format = 1; 11-bit codes */
753 s->unrestricted_mv = 1;
754 s->rtp_mode = 0; /* don't allow GOB */
758 case AV_CODEC_ID_RV10:
759 s->out_format = FMT_H263;
763 case AV_CODEC_ID_RV20:
764 s->out_format = FMT_H263;
767 s->modified_quant = 1;
771 s->unrestricted_mv = 0;
773 case AV_CODEC_ID_MPEG4:
774 s->out_format = FMT_H263;
776 s->unrestricted_mv = 1;
777 s->low_delay = s->max_b_frames ? 0 : 1;
778 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
780 case AV_CODEC_ID_MSMPEG4V2:
781 s->out_format = FMT_H263;
783 s->unrestricted_mv = 1;
784 s->msmpeg4_version = 2;
788 case AV_CODEC_ID_MSMPEG4V3:
789 s->out_format = FMT_H263;
791 s->unrestricted_mv = 1;
792 s->msmpeg4_version = 3;
793 s->flipflop_rounding = 1;
797 case AV_CODEC_ID_WMV1:
798 s->out_format = FMT_H263;
800 s->unrestricted_mv = 1;
801 s->msmpeg4_version = 4;
802 s->flipflop_rounding = 1;
806 case AV_CODEC_ID_WMV2:
807 s->out_format = FMT_H263;
809 s->unrestricted_mv = 1;
810 s->msmpeg4_version = 5;
811 s->flipflop_rounding = 1;
819 avctx->has_b_frames = !s->low_delay;
823 s->progressive_frame =
824 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
825 CODEC_FLAG_INTERLACED_ME) ||
829 if (ff_MPV_common_init(s) < 0)
832 ff_dct_encode_init(s);
834 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
835 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
837 s->quant_precision = 5;
839 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
840 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
842 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
843 ff_h261_encode_init(s);
844 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
845 ff_h263_encode_init(s);
846 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
847 ff_msmpeg4_encode_init(s);
848 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
849 && s->out_format == FMT_MPEG1)
850 ff_mpeg1_encode_init(s);
853 for (i = 0; i < 64; i++) {
854 int j = s->dsp.idct_permutation[i];
855 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
857 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
858 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
859 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
861 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
864 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
865 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
867 if (s->avctx->intra_matrix)
868 s->intra_matrix[j] = s->avctx->intra_matrix[i];
869 if (s->avctx->inter_matrix)
870 s->inter_matrix[j] = s->avctx->inter_matrix[i];
873 /* precompute matrix */
874 /* for mjpeg, we do include qscale in the matrix */
875 if (s->out_format != FMT_MJPEG) {
876 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
877 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
879 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
880 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
884 if (ff_rate_control_init(s) < 0)
890 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
892 MpegEncContext *s = avctx->priv_data;
894 ff_rate_control_uninit(s);
896 ff_MPV_common_end(s);
897 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
898 s->out_format == FMT_MJPEG)
899 ff_mjpeg_encode_close(s);
901 av_freep(&avctx->extradata);
906 static int get_sae(uint8_t *src, int ref, int stride)
911 for (y = 0; y < 16; y++) {
912 for (x = 0; x < 16; x++) {
913 acc += FFABS(src[x + y * stride] - ref);
920 static int get_intra_count(MpegEncContext *s, uint8_t *src,
921 uint8_t *ref, int stride)
929 for (y = 0; y < h; y += 16) {
930 for (x = 0; x < w; x += 16) {
931 int offset = x + y * stride;
932 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
934 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
935 int sae = get_sae(src + offset, mean, stride);
937 acc += sae + 500 < sad;
944 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
948 int i, display_picture_number = 0, ret;
949 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
950 (s->low_delay ? 0 : 1);
955 display_picture_number = s->input_picture_number++;
957 if (pts != AV_NOPTS_VALUE) {
958 if (s->user_specified_pts != AV_NOPTS_VALUE) {
960 int64_t last = s->user_specified_pts;
963 av_log(s->avctx, AV_LOG_ERROR,
964 "Error, Invalid timestamp=%"PRId64", "
965 "last=%"PRId64"\n", pts, s->user_specified_pts);
969 if (!s->low_delay && display_picture_number == 1)
970 s->dts_delta = time - last;
972 s->user_specified_pts = pts;
974 if (s->user_specified_pts != AV_NOPTS_VALUE) {
975 s->user_specified_pts =
976 pts = s->user_specified_pts + 1;
977 av_log(s->avctx, AV_LOG_INFO,
978 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
981 pts = display_picture_number;
987 if (!pic_arg->buf[0])
989 if (pic_arg->linesize[0] != s->linesize)
991 if (pic_arg->linesize[1] != s->uvlinesize)
993 if (pic_arg->linesize[2] != s->uvlinesize)
996 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
997 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1000 i = ff_find_unused_picture(s, 1);
1004 pic = &s->picture[i];
1007 if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
1009 if (ff_alloc_picture(s, pic, 1) < 0) {
1013 i = ff_find_unused_picture(s, 0);
1017 pic = &s->picture[i];
1020 if (ff_alloc_picture(s, pic, 0) < 0) {
1024 if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1025 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1026 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1029 int h_chroma_shift, v_chroma_shift;
1030 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1034 for (i = 0; i < 3; i++) {
1035 int src_stride = pic_arg->linesize[i];
1036 int dst_stride = i ? s->uvlinesize : s->linesize;
1037 int h_shift = i ? h_chroma_shift : 0;
1038 int v_shift = i ? v_chroma_shift : 0;
1039 int w = s->width >> h_shift;
1040 int h = s->height >> v_shift;
1041 uint8_t *src = pic_arg->data[i];
1042 uint8_t *dst = pic->f.data[i];
1044 if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1045 h = ((s->height + 15)/16*16) >> v_shift;
1048 if (!s->avctx->rc_buffer_size)
1049 dst += INPLACE_OFFSET;
1051 if (src_stride == dst_stride)
1052 memcpy(dst, src, src_stride * h);
1055 uint8_t *dst2 = dst;
1057 memcpy(dst2, src, w);
1062 if ((s->width & 15) || (s->height & 15)) {
1063 s->dsp.draw_edges(dst, dst_stride,
1072 copy_picture_attributes(s, &pic->f, pic_arg);
1073 pic->f.display_picture_number = display_picture_number;
1074 pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
1077 /* shift buffer entries */
1078 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1079 s->input_picture[i - 1] = s->input_picture[i];
1081 s->input_picture[encoding_delay] = (Picture*) pic;
1086 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1090 int64_t score64 = 0;
1092 for (plane = 0; plane < 3; plane++) {
1093 const int stride = p->f.linesize[plane];
1094 const int bw = plane ? 1 : 2;
1095 for (y = 0; y < s->mb_height * bw; y++) {
1096 for (x = 0; x < s->mb_width * bw; x++) {
1097 int off = p->shared ? 0 : 16;
1098 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1099 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1100 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1102 switch (s->avctx->frame_skip_exp) {
1103 case 0: score = FFMAX(score, v); break;
1104 case 1: score += FFABS(v); break;
1105 case 2: score += v * v; break;
1106 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1107 case 4: score64 += v * v * (int64_t)(v * v); break;
1116 if (score64 < s->avctx->frame_skip_threshold)
1118 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1123 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1125 AVPacket pkt = { 0 };
1126 int ret, got_output;
1128 av_init_packet(&pkt);
1129 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1134 av_free_packet(&pkt);
1138 static int estimate_best_b_count(MpegEncContext *s)
1140 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1141 AVCodecContext *c = avcodec_alloc_context3(NULL);
1142 AVFrame input[FF_MAX_B_FRAMES + 2];
1143 const int scale = s->avctx->brd_scale;
1144 int i, j, out_size, p_lambda, b_lambda, lambda2;
1145 int64_t best_rd = INT64_MAX;
1146 int best_b_count = -1;
1148 av_assert0(scale >= 0 && scale <= 3);
1151 //s->next_picture_ptr->quality;
1152 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1153 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1154 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1155 if (!b_lambda) // FIXME we should do this somewhere else
1156 b_lambda = p_lambda;
1157 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1160 c->width = s->width >> scale;
1161 c->height = s->height >> scale;
1162 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1163 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1164 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1165 c->mb_decision = s->avctx->mb_decision;
1166 c->me_cmp = s->avctx->me_cmp;
1167 c->mb_cmp = s->avctx->mb_cmp;
1168 c->me_sub_cmp = s->avctx->me_sub_cmp;
1169 c->pix_fmt = AV_PIX_FMT_YUV420P;
1170 c->time_base = s->avctx->time_base;
1171 c->max_b_frames = s->max_b_frames;
1173 if (avcodec_open2(c, codec, NULL) < 0)
1176 for (i = 0; i < s->max_b_frames + 2; i++) {
1177 int ysize = c->width * c->height;
1178 int csize = (c->width / 2) * (c->height / 2);
1179 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1180 s->next_picture_ptr;
1182 avcodec_get_frame_defaults(&input[i]);
1183 input[i].data[0] = av_malloc(ysize + 2 * csize);
1184 input[i].data[1] = input[i].data[0] + ysize;
1185 input[i].data[2] = input[i].data[1] + csize;
1186 input[i].linesize[0] = c->width;
1187 input[i].linesize[1] =
1188 input[i].linesize[2] = c->width / 2;
1190 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1191 pre_input = *pre_input_ptr;
1193 if (!pre_input.shared && i) {
1194 pre_input.f.data[0] += INPLACE_OFFSET;
1195 pre_input.f.data[1] += INPLACE_OFFSET;
1196 pre_input.f.data[2] += INPLACE_OFFSET;
1199 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1200 pre_input.f.data[0], pre_input.f.linesize[0],
1201 c->width, c->height);
1202 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1203 pre_input.f.data[1], pre_input.f.linesize[1],
1204 c->width >> 1, c->height >> 1);
1205 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1206 pre_input.f.data[2], pre_input.f.linesize[2],
1207 c->width >> 1, c->height >> 1);
1211 for (j = 0; j < s->max_b_frames + 1; j++) {
1214 if (!s->input_picture[j])
1217 c->error[0] = c->error[1] = c->error[2] = 0;
1219 input[0].pict_type = AV_PICTURE_TYPE_I;
1220 input[0].quality = 1 * FF_QP2LAMBDA;
1222 out_size = encode_frame(c, &input[0]);
1224 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1226 for (i = 0; i < s->max_b_frames + 1; i++) {
1227 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1229 input[i + 1].pict_type = is_p ?
1230 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1231 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1233 out_size = encode_frame(c, &input[i + 1]);
1235 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1238 /* get the delayed frames */
1240 out_size = encode_frame(c, NULL);
1241 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1244 rd += c->error[0] + c->error[1] + c->error[2];
1255 for (i = 0; i < s->max_b_frames + 2; i++) {
1256 av_freep(&input[i].data[0]);
1259 return best_b_count;
1262 static int select_input_picture(MpegEncContext *s)
1266 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1267 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1268 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1270 /* set next picture type & ordering */
1271 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1272 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1273 s->next_picture_ptr == NULL || s->intra_only) {
1274 s->reordered_input_picture[0] = s->input_picture[0];
1275 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1276 s->reordered_input_picture[0]->f.coded_picture_number =
1277 s->coded_picture_number++;
1281 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1282 if (s->picture_in_gop_number < s->gop_size &&
1283 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1284 // FIXME check that te gop check above is +-1 correct
1285 av_frame_unref(&s->input_picture[0]->f);
1288 ff_vbv_update(s, 0);
1294 if (s->flags & CODEC_FLAG_PASS2) {
1295 for (i = 0; i < s->max_b_frames + 1; i++) {
1296 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1298 if (pict_num >= s->rc_context.num_entries)
1300 if (!s->input_picture[i]) {
1301 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1305 s->input_picture[i]->f.pict_type =
1306 s->rc_context.entry[pict_num].new_pict_type;
1310 if (s->avctx->b_frame_strategy == 0) {
1311 b_frames = s->max_b_frames;
1312 while (b_frames && !s->input_picture[b_frames])
1314 } else if (s->avctx->b_frame_strategy == 1) {
1315 for (i = 1; i < s->max_b_frames + 1; i++) {
1316 if (s->input_picture[i] &&
1317 s->input_picture[i]->b_frame_score == 0) {
1318 s->input_picture[i]->b_frame_score =
1320 s->input_picture[i ]->f.data[0],
1321 s->input_picture[i - 1]->f.data[0],
1325 for (i = 0; i < s->max_b_frames + 1; i++) {
1326 if (s->input_picture[i] == NULL ||
1327 s->input_picture[i]->b_frame_score - 1 >
1328 s->mb_num / s->avctx->b_sensitivity)
1332 b_frames = FFMAX(0, i - 1);
1335 for (i = 0; i < b_frames + 1; i++) {
1336 s->input_picture[i]->b_frame_score = 0;
1338 } else if (s->avctx->b_frame_strategy == 2) {
1339 b_frames = estimate_best_b_count(s);
1341 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1347 for (i = b_frames - 1; i >= 0; i--) {
1348 int type = s->input_picture[i]->f.pict_type;
1349 if (type && type != AV_PICTURE_TYPE_B)
1352 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1353 b_frames == s->max_b_frames) {
1354 av_log(s->avctx, AV_LOG_ERROR,
1355 "warning, too many b frames in a row\n");
1358 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1359 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1360 s->gop_size > s->picture_in_gop_number) {
1361 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1363 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1365 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1369 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1370 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1373 s->reordered_input_picture[0] = s->input_picture[b_frames];
1374 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1375 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1376 s->reordered_input_picture[0]->f.coded_picture_number =
1377 s->coded_picture_number++;
1378 for (i = 0; i < b_frames; i++) {
1379 s->reordered_input_picture[i + 1] = s->input_picture[i];
1380 s->reordered_input_picture[i + 1]->f.pict_type =
1382 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1383 s->coded_picture_number++;
1388 if (s->reordered_input_picture[0]) {
1389 s->reordered_input_picture[0]->reference =
1390 s->reordered_input_picture[0]->f.pict_type !=
1391 AV_PICTURE_TYPE_B ? 3 : 0;
1393 ff_mpeg_unref_picture(s, &s->new_picture);
1394 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1397 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1398 // input is a shared pix, so we can't modifiy it -> alloc a new
1399 // one & ensure that the shared one is reuseable
1402 int i = ff_find_unused_picture(s, 0);
1405 pic = &s->picture[i];
1407 pic->reference = s->reordered_input_picture[0]->reference;
1408 if (ff_alloc_picture(s, pic, 0) < 0) {
1412 copy_picture_attributes(s, &pic->f,
1413 &s->reordered_input_picture[0]->f);
1415 /* mark us unused / free shared pic */
1416 av_frame_unref(&s->reordered_input_picture[0]->f);
1417 s->reordered_input_picture[0]->shared = 0;
1419 s->current_picture_ptr = pic;
1421 // input is not a shared pix -> reuse buffer for current_pix
1422 s->current_picture_ptr = s->reordered_input_picture[0];
1423 for (i = 0; i < 4; i++) {
1424 s->new_picture.f.data[i] += INPLACE_OFFSET;
1427 ff_mpeg_unref_picture(s, &s->current_picture);
1428 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1429 s->current_picture_ptr)) < 0)
1432 s->picture_number = s->new_picture.f.display_picture_number;
1434 ff_mpeg_unref_picture(s, &s->new_picture);
1439 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1440 AVFrame *pic_arg, int *got_packet)
1442 MpegEncContext *s = avctx->priv_data;
1443 int i, stuffing_count, ret;
1444 int context_count = s->slice_context_count;
1446 s->picture_in_gop_number++;
1448 if (load_input_picture(s, pic_arg) < 0)
1451 if (select_input_picture(s) < 0) {
1456 if (s->new_picture.f.data[0]) {
1457 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1460 s->mb_info_ptr = av_packet_new_side_data(pkt,
1461 AV_PKT_DATA_H263_MB_INFO,
1462 s->mb_width*s->mb_height*12);
1463 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1466 for (i = 0; i < context_count; i++) {
1467 int start_y = s->thread_context[i]->start_mb_y;
1468 int end_y = s->thread_context[i]-> end_mb_y;
1469 int h = s->mb_height;
1470 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1471 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1473 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1476 s->pict_type = s->new_picture.f.pict_type;
1478 if (ff_MPV_frame_start(s, avctx) < 0)
1481 if (encode_picture(s, s->picture_number) < 0)
1484 avctx->header_bits = s->header_bits;
1485 avctx->mv_bits = s->mv_bits;
1486 avctx->misc_bits = s->misc_bits;
1487 avctx->i_tex_bits = s->i_tex_bits;
1488 avctx->p_tex_bits = s->p_tex_bits;
1489 avctx->i_count = s->i_count;
1490 // FIXME f/b_count in avctx
1491 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1492 avctx->skip_count = s->skip_count;
1494 ff_MPV_frame_end(s);
1496 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1497 ff_mjpeg_encode_picture_trailer(s);
1499 if (avctx->rc_buffer_size) {
1500 RateControlContext *rcc = &s->rc_context;
1501 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1503 if (put_bits_count(&s->pb) > max_size &&
1504 s->lambda < s->avctx->lmax) {
1505 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1506 (s->qscale + 1) / s->qscale);
1507 if (s->adaptive_quant) {
1509 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1510 s->lambda_table[i] =
1511 FFMAX(s->lambda_table[i] + 1,
1512 s->lambda_table[i] * (s->qscale + 1) /
1515 s->mb_skipped = 0; // done in MPV_frame_start()
1516 // done in encode_picture() so we must undo it
1517 if (s->pict_type == AV_PICTURE_TYPE_P) {
1518 if (s->flipflop_rounding ||
1519 s->codec_id == AV_CODEC_ID_H263P ||
1520 s->codec_id == AV_CODEC_ID_MPEG4)
1521 s->no_rounding ^= 1;
1523 if (s->pict_type != AV_PICTURE_TYPE_B) {
1524 s->time_base = s->last_time_base;
1525 s->last_non_b_time = s->time - s->pp_time;
1527 for (i = 0; i < context_count; i++) {
1528 PutBitContext *pb = &s->thread_context[i]->pb;
1529 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1534 assert(s->avctx->rc_max_rate);
1537 if (s->flags & CODEC_FLAG_PASS1)
1538 ff_write_pass1_stats(s);
1540 for (i = 0; i < 4; i++) {
1541 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1542 avctx->error[i] += s->current_picture_ptr->f.error[i];
1545 if (s->flags & CODEC_FLAG_PASS1)
1546 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1547 avctx->i_tex_bits + avctx->p_tex_bits ==
1548 put_bits_count(&s->pb));
1549 flush_put_bits(&s->pb);
1550 s->frame_bits = put_bits_count(&s->pb);
1552 stuffing_count = ff_vbv_update(s, s->frame_bits);
1553 s->stuffing_bits = 8*stuffing_count;
1554 if (stuffing_count) {
1555 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1556 stuffing_count + 50) {
1557 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1561 switch (s->codec_id) {
1562 case AV_CODEC_ID_MPEG1VIDEO:
1563 case AV_CODEC_ID_MPEG2VIDEO:
1564 while (stuffing_count--) {
1565 put_bits(&s->pb, 8, 0);
1568 case AV_CODEC_ID_MPEG4:
1569 put_bits(&s->pb, 16, 0);
1570 put_bits(&s->pb, 16, 0x1C3);
1571 stuffing_count -= 4;
1572 while (stuffing_count--) {
1573 put_bits(&s->pb, 8, 0xFF);
1577 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1579 flush_put_bits(&s->pb);
1580 s->frame_bits = put_bits_count(&s->pb);
1583 /* update mpeg1/2 vbv_delay for CBR */
1584 if (s->avctx->rc_max_rate &&
1585 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1586 s->out_format == FMT_MPEG1 &&
1587 90000LL * (avctx->rc_buffer_size - 1) <=
1588 s->avctx->rc_max_rate * 0xFFFFLL) {
1589 int vbv_delay, min_delay;
1590 double inbits = s->avctx->rc_max_rate *
1591 av_q2d(s->avctx->time_base);
1592 int minbits = s->frame_bits - 8 *
1593 (s->vbv_delay_ptr - s->pb.buf - 1);
1594 double bits = s->rc_context.buffer_index + minbits - inbits;
1597 av_log(s->avctx, AV_LOG_ERROR,
1598 "Internal error, negative bits\n");
1600 assert(s->repeat_first_field == 0);
1602 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1603 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1604 s->avctx->rc_max_rate;
1606 vbv_delay = FFMAX(vbv_delay, min_delay);
1608 av_assert0(vbv_delay < 0xFFFF);
1610 s->vbv_delay_ptr[0] &= 0xF8;
1611 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1612 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1613 s->vbv_delay_ptr[2] &= 0x07;
1614 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1615 avctx->vbv_delay = vbv_delay * 300;
1617 s->total_bits += s->frame_bits;
1618 avctx->frame_bits = s->frame_bits;
1620 pkt->pts = s->current_picture.f.pts;
1621 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1622 if (!s->current_picture.f.coded_picture_number)
1623 pkt->dts = pkt->pts - s->dts_delta;
1625 pkt->dts = s->reordered_pts;
1626 s->reordered_pts = pkt->pts;
1628 pkt->dts = pkt->pts;
1629 if (s->current_picture.f.key_frame)
1630 pkt->flags |= AV_PKT_FLAG_KEY;
1632 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1637 /* release non-reference frames */
1638 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1639 if (!s->picture[i].reference)
1640 ff_mpeg_unref_picture(s, &s->picture[i]);
1643 assert((s->frame_bits & 7) == 0);
1645 pkt->size = s->frame_bits / 8;
1646 *got_packet = !!pkt->size;
1650 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1651 int n, int threshold)
1653 static const char tab[64] = {
1654 3, 2, 2, 1, 1, 1, 1, 1,
1655 1, 1, 1, 1, 1, 1, 1, 1,
1656 1, 1, 1, 1, 1, 1, 1, 1,
1657 0, 0, 0, 0, 0, 0, 0, 0,
1658 0, 0, 0, 0, 0, 0, 0, 0,
1659 0, 0, 0, 0, 0, 0, 0, 0,
1660 0, 0, 0, 0, 0, 0, 0, 0,
1661 0, 0, 0, 0, 0, 0, 0, 0
1666 int16_t *block = s->block[n];
1667 const int last_index = s->block_last_index[n];
1670 if (threshold < 0) {
1672 threshold = -threshold;
1676 /* Are all we could set to zero already zero? */
1677 if (last_index <= skip_dc - 1)
1680 for (i = 0; i <= last_index; i++) {
1681 const int j = s->intra_scantable.permutated[i];
1682 const int level = FFABS(block[j]);
1684 if (skip_dc && i == 0)
1688 } else if (level > 1) {
1694 if (score >= threshold)
1696 for (i = skip_dc; i <= last_index; i++) {
1697 const int j = s->intra_scantable.permutated[i];
1701 s->block_last_index[n] = 0;
1703 s->block_last_index[n] = -1;
1706 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1710 const int maxlevel = s->max_qcoeff;
1711 const int minlevel = s->min_qcoeff;
1715 i = 1; // skip clipping of intra dc
1719 for (; i <= last_index; i++) {
1720 const int j = s->intra_scantable.permutated[i];
1721 int level = block[j];
1723 if (level > maxlevel) {
1726 } else if (level < minlevel) {
1734 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1735 av_log(s->avctx, AV_LOG_INFO,
1736 "warning, clipping %d dct coefficients to %d..%d\n",
1737 overflow, minlevel, maxlevel);
1740 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1744 for (y = 0; y < 8; y++) {
1745 for (x = 0; x < 8; x++) {
1751 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1752 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1753 int v = ptr[x2 + y2 * stride];
1759 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1764 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1765 int motion_x, int motion_y,
1766 int mb_block_height,
1770 int16_t weight[12][64];
1771 int16_t orig[12][64];
1772 const int mb_x = s->mb_x;
1773 const int mb_y = s->mb_y;
1776 int dct_offset = s->linesize * 8; // default for progressive frames
1777 int uv_dct_offset = s->uvlinesize * 8;
1778 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1781 for (i = 0; i < mb_block_count; i++)
1782 skip_dct[i] = s->skipdct;
1784 if (s->adaptive_quant) {
1785 const int last_qp = s->qscale;
1786 const int mb_xy = mb_x + mb_y * s->mb_stride;
1788 s->lambda = s->lambda_table[mb_xy];
1791 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1792 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1793 s->dquant = s->qscale - last_qp;
1795 if (s->out_format == FMT_H263) {
1796 s->dquant = av_clip(s->dquant, -2, 2);
1798 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1800 if (s->pict_type == AV_PICTURE_TYPE_B) {
1801 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1804 if (s->mv_type == MV_TYPE_8X8)
1810 ff_set_qscale(s, last_qp + s->dquant);
1811 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1812 ff_set_qscale(s, s->qscale + s->dquant);
1814 wrap_y = s->linesize;
1815 wrap_c = s->uvlinesize;
1816 ptr_y = s->new_picture.f.data[0] +
1817 (mb_y * 16 * wrap_y) + mb_x * 16;
1818 ptr_cb = s->new_picture.f.data[1] +
1819 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1820 ptr_cr = s->new_picture.f.data[2] +
1821 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1823 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1824 uint8_t *ebuf = s->edge_emu_buffer + 32;
1825 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1826 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1827 s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1828 mb_y * 16, s->width, s->height);
1830 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, mb_block_width,
1831 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1833 ptr_cb = ebuf + 18 * wrap_y;
1834 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr, wrap_c, mb_block_width,
1835 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1837 ptr_cr = ebuf + 18 * wrap_y + 16;
1841 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1842 int progressive_score, interlaced_score;
1844 s->interlaced_dct = 0;
1845 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1847 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1848 NULL, wrap_y, 8) - 400;
1850 if (progressive_score > 0) {
1851 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1852 NULL, wrap_y * 2, 8) +
1853 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1854 NULL, wrap_y * 2, 8);
1855 if (progressive_score > interlaced_score) {
1856 s->interlaced_dct = 1;
1858 dct_offset = wrap_y;
1859 uv_dct_offset = wrap_c;
1861 if (s->chroma_format == CHROMA_422 ||
1862 s->chroma_format == CHROMA_444)
1868 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1869 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1870 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1871 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1873 if (s->flags & CODEC_FLAG_GRAY) {
1877 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1878 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1879 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1880 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1881 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1882 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1883 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1884 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1885 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1886 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1887 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1888 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1892 op_pixels_func (*op_pix)[4];
1893 qpel_mc_func (*op_qpix)[16];
1894 uint8_t *dest_y, *dest_cb, *dest_cr;
1896 dest_y = s->dest[0];
1897 dest_cb = s->dest[1];
1898 dest_cr = s->dest[2];
1900 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1901 op_pix = s->hdsp.put_pixels_tab;
1902 op_qpix = s->dsp.put_qpel_pixels_tab;
1904 op_pix = s->hdsp.put_no_rnd_pixels_tab;
1905 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1908 if (s->mv_dir & MV_DIR_FORWARD) {
1909 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1910 s->last_picture.f.data,
1912 op_pix = s->hdsp.avg_pixels_tab;
1913 op_qpix = s->dsp.avg_qpel_pixels_tab;
1915 if (s->mv_dir & MV_DIR_BACKWARD) {
1916 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1917 s->next_picture.f.data,
1921 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1922 int progressive_score, interlaced_score;
1924 s->interlaced_dct = 0;
1925 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1928 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1929 ptr_y + wrap_y * 8, wrap_y,
1932 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1933 progressive_score -= 400;
1935 if (progressive_score > 0) {
1936 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1939 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1943 if (progressive_score > interlaced_score) {
1944 s->interlaced_dct = 1;
1946 dct_offset = wrap_y;
1947 uv_dct_offset = wrap_c;
1949 if (s->chroma_format == CHROMA_422)
1955 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1956 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1957 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1958 dest_y + dct_offset, wrap_y);
1959 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1960 dest_y + dct_offset + 8, wrap_y);
1962 if (s->flags & CODEC_FLAG_GRAY) {
1966 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1967 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1968 if (!s->chroma_y_shift) { /* 422 */
1969 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
1970 dest_cb + uv_dct_offset, wrap_c);
1971 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
1972 dest_cr + uv_dct_offset, wrap_c);
1975 /* pre quantization */
1976 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1977 2 * s->qscale * s->qscale) {
1979 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1980 wrap_y, 8) < 20 * s->qscale)
1982 if (s->dsp.sad[1](NULL, ptr_y + 8,
1983 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1985 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1986 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1988 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1989 dest_y + dct_offset + 8,
1990 wrap_y, 8) < 20 * s->qscale)
1992 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1993 wrap_c, 8) < 20 * s->qscale)
1995 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1996 wrap_c, 8) < 20 * s->qscale)
1998 if (!s->chroma_y_shift) { /* 422 */
1999 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
2000 dest_cb + uv_dct_offset,
2001 wrap_c, 8) < 20 * s->qscale)
2003 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
2004 dest_cr + uv_dct_offset,
2005 wrap_c, 8) < 20 * s->qscale)
2011 if (s->quantizer_noise_shaping) {
2013 get_visual_weight(weight[0], ptr_y , wrap_y);
2015 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2017 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2019 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2021 get_visual_weight(weight[4], ptr_cb , wrap_c);
2023 get_visual_weight(weight[5], ptr_cr , wrap_c);
2024 if (!s->chroma_y_shift) { /* 422 */
2026 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2029 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2032 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2035 /* DCT & quantize */
2036 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2038 for (i = 0; i < mb_block_count; i++) {
2041 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2042 // FIXME we could decide to change to quantizer instead of
2044 // JS: I don't think that would be a good idea it could lower
2045 // quality instead of improve it. Just INTRADC clipping
2046 // deserves changes in quantizer
2048 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2050 s->block_last_index[i] = -1;
2052 if (s->quantizer_noise_shaping) {
2053 for (i = 0; i < mb_block_count; i++) {
2055 s->block_last_index[i] =
2056 dct_quantize_refine(s, s->block[i], weight[i],
2057 orig[i], i, s->qscale);
2062 if (s->luma_elim_threshold && !s->mb_intra)
2063 for (i = 0; i < 4; i++)
2064 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2065 if (s->chroma_elim_threshold && !s->mb_intra)
2066 for (i = 4; i < mb_block_count; i++)
2067 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2069 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2070 for (i = 0; i < mb_block_count; i++) {
2071 if (s->block_last_index[i] == -1)
2072 s->coded_score[i] = INT_MAX / 256;
2077 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2078 s->block_last_index[4] =
2079 s->block_last_index[5] = 0;
2081 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2082 if (!s->chroma_y_shift) { /* 422 / 444 */
2083 for (i=6; i<12; i++) {
2084 s->block_last_index[i] = 0;
2085 s->block[i][0] = s->block[4][0];
2090 // non c quantize code returns incorrect block_last_index FIXME
2091 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2092 for (i = 0; i < mb_block_count; i++) {
2094 if (s->block_last_index[i] > 0) {
2095 for (j = 63; j > 0; j--) {
2096 if (s->block[i][s->intra_scantable.permutated[j]])
2099 s->block_last_index[i] = j;
2104 /* huffman encode */
2105 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2106 case AV_CODEC_ID_MPEG1VIDEO:
2107 case AV_CODEC_ID_MPEG2VIDEO:
2108 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2109 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2111 case AV_CODEC_ID_MPEG4:
2112 if (CONFIG_MPEG4_ENCODER)
2113 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2115 case AV_CODEC_ID_MSMPEG4V2:
2116 case AV_CODEC_ID_MSMPEG4V3:
2117 case AV_CODEC_ID_WMV1:
2118 if (CONFIG_MSMPEG4_ENCODER)
2119 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2121 case AV_CODEC_ID_WMV2:
2122 if (CONFIG_WMV2_ENCODER)
2123 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2125 case AV_CODEC_ID_H261:
2126 if (CONFIG_H261_ENCODER)
2127 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2129 case AV_CODEC_ID_H263:
2130 case AV_CODEC_ID_H263P:
2131 case AV_CODEC_ID_FLV1:
2132 case AV_CODEC_ID_RV10:
2133 case AV_CODEC_ID_RV20:
2134 if (CONFIG_H263_ENCODER)
2135 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2137 case AV_CODEC_ID_MJPEG:
2138 case AV_CODEC_ID_AMV:
2139 if (CONFIG_MJPEG_ENCODER)
2140 ff_mjpeg_encode_mb(s, s->block);
2147 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2149 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2150 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2151 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2154 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2157 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2160 d->mb_skip_run= s->mb_skip_run;
2162 d->last_dc[i] = s->last_dc[i];
2165 d->mv_bits= s->mv_bits;
2166 d->i_tex_bits= s->i_tex_bits;
2167 d->p_tex_bits= s->p_tex_bits;
2168 d->i_count= s->i_count;
2169 d->f_count= s->f_count;
2170 d->b_count= s->b_count;
2171 d->skip_count= s->skip_count;
2172 d->misc_bits= s->misc_bits;
2176 d->qscale= s->qscale;
2177 d->dquant= s->dquant;
2179 d->esc3_level_length= s->esc3_level_length;
2182 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2185 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2186 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2189 d->mb_skip_run= s->mb_skip_run;
2191 d->last_dc[i] = s->last_dc[i];
2194 d->mv_bits= s->mv_bits;
2195 d->i_tex_bits= s->i_tex_bits;
2196 d->p_tex_bits= s->p_tex_bits;
2197 d->i_count= s->i_count;
2198 d->f_count= s->f_count;
2199 d->b_count= s->b_count;
2200 d->skip_count= s->skip_count;
2201 d->misc_bits= s->misc_bits;
2203 d->mb_intra= s->mb_intra;
2204 d->mb_skipped= s->mb_skipped;
2205 d->mv_type= s->mv_type;
2206 d->mv_dir= s->mv_dir;
2208 if(s->data_partitioning){
2210 d->tex_pb= s->tex_pb;
2214 d->block_last_index[i]= s->block_last_index[i];
2215 d->interlaced_dct= s->interlaced_dct;
2216 d->qscale= s->qscale;
2218 d->esc3_level_length= s->esc3_level_length;
2221 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2222 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2223 int *dmin, int *next_block, int motion_x, int motion_y)
2226 uint8_t *dest_backup[3];
2228 copy_context_before_encode(s, backup, type);
2230 s->block= s->blocks[*next_block];
2231 s->pb= pb[*next_block];
2232 if(s->data_partitioning){
2233 s->pb2 = pb2 [*next_block];
2234 s->tex_pb= tex_pb[*next_block];
2238 memcpy(dest_backup, s->dest, sizeof(s->dest));
2239 s->dest[0] = s->rd_scratchpad;
2240 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2241 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2242 assert(s->linesize >= 32); //FIXME
2245 encode_mb(s, motion_x, motion_y);
2247 score= put_bits_count(&s->pb);
2248 if(s->data_partitioning){
2249 score+= put_bits_count(&s->pb2);
2250 score+= put_bits_count(&s->tex_pb);
2253 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2254 ff_MPV_decode_mb(s, s->block);
2256 score *= s->lambda2;
2257 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2261 memcpy(s->dest, dest_backup, sizeof(s->dest));
2268 copy_context_after_encode(best, s, type);
2272 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2273 uint32_t *sq = ff_squareTbl + 256;
2278 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2279 else if(w==8 && h==8)
2280 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2284 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2293 static int sse_mb(MpegEncContext *s){
2297 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2298 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2301 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2302 return s->dsp.nsse[0](s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
2303 +s->dsp.nsse[1](s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
2304 +s->dsp.nsse[1](s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2306 return s->dsp.sse[0](NULL, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
2307 +s->dsp.sse[1](NULL, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
2308 +s->dsp.sse[1](NULL, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
2311 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)
2312 +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)
2313 +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);
2316 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2317 MpegEncContext *s= *(void**)arg;
2321 s->me.dia_size= s->avctx->pre_dia_size;
2322 s->first_slice_line=1;
2323 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2324 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2325 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2327 s->first_slice_line=0;
2335 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2336 MpegEncContext *s= *(void**)arg;
2338 ff_check_alignment();
2340 s->me.dia_size= s->avctx->dia_size;
2341 s->first_slice_line=1;
2342 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2343 s->mb_x=0; //for block init below
2344 ff_init_block_index(s);
2345 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2346 s->block_index[0]+=2;
2347 s->block_index[1]+=2;
2348 s->block_index[2]+=2;
2349 s->block_index[3]+=2;
2351 /* compute motion vector & mb_type and store in context */
2352 if(s->pict_type==AV_PICTURE_TYPE_B)
2353 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2355 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2357 s->first_slice_line=0;
2362 static int mb_var_thread(AVCodecContext *c, void *arg){
2363 MpegEncContext *s= *(void**)arg;
2366 ff_check_alignment();
2368 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2369 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2372 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2374 int sum = s->dsp.pix_sum(pix, s->linesize);
2376 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2378 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2379 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2380 s->me.mb_var_sum_temp += varc;
2386 static void write_slice_end(MpegEncContext *s){
2387 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2388 if(s->partitioned_frame){
2389 ff_mpeg4_merge_partitions(s);
2392 ff_mpeg4_stuffing(&s->pb);
2393 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2394 ff_mjpeg_encode_stuffing(s);
2397 avpriv_align_put_bits(&s->pb);
2398 flush_put_bits(&s->pb);
2400 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2401 s->misc_bits+= get_bits_diff(s);
2404 static void write_mb_info(MpegEncContext *s)
2406 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2407 int offset = put_bits_count(&s->pb);
2408 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2409 int gobn = s->mb_y / s->gob_index;
2411 if (CONFIG_H263_ENCODER)
2412 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2413 bytestream_put_le32(&ptr, offset);
2414 bytestream_put_byte(&ptr, s->qscale);
2415 bytestream_put_byte(&ptr, gobn);
2416 bytestream_put_le16(&ptr, mba);
2417 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2418 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2419 /* 4MV not implemented */
2420 bytestream_put_byte(&ptr, 0); /* hmv2 */
2421 bytestream_put_byte(&ptr, 0); /* vmv2 */
2424 static void update_mb_info(MpegEncContext *s, int startcode)
2428 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2429 s->mb_info_size += 12;
2430 s->prev_mb_info = s->last_mb_info;
2433 s->prev_mb_info = put_bits_count(&s->pb)/8;
2434 /* This might have incremented mb_info_size above, and we return without
2435 * actually writing any info into that slot yet. But in that case,
2436 * this will be called again at the start of the after writing the
2437 * start code, actually writing the mb info. */
2441 s->last_mb_info = put_bits_count(&s->pb)/8;
2442 if (!s->mb_info_size)
2443 s->mb_info_size += 12;
2447 static int encode_thread(AVCodecContext *c, void *arg){
2448 MpegEncContext *s= *(void**)arg;
2449 int mb_x, mb_y, pdif = 0;
2450 int chr_h= 16>>s->chroma_y_shift;
2452 MpegEncContext best_s, backup_s;
2453 uint8_t bit_buf[2][MAX_MB_BYTES];
2454 uint8_t bit_buf2[2][MAX_MB_BYTES];
2455 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2456 PutBitContext pb[2], pb2[2], tex_pb[2];
2458 ff_check_alignment();
2461 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2462 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2463 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2466 s->last_bits= put_bits_count(&s->pb);
2477 /* init last dc values */
2478 /* note: quant matrix value (8) is implied here */
2479 s->last_dc[i] = 128 << s->intra_dc_precision;
2481 s->current_picture.f.error[i] = 0;
2483 if(s->codec_id==AV_CODEC_ID_AMV){
2484 s->last_dc[0] = 128*8/13;
2485 s->last_dc[1] = 128*8/14;
2486 s->last_dc[2] = 128*8/14;
2489 memset(s->last_mv, 0, sizeof(s->last_mv));
2493 switch(s->codec_id){
2494 case AV_CODEC_ID_H263:
2495 case AV_CODEC_ID_H263P:
2496 case AV_CODEC_ID_FLV1:
2497 if (CONFIG_H263_ENCODER)
2498 s->gob_index = ff_h263_get_gob_height(s);
2500 case AV_CODEC_ID_MPEG4:
2501 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2502 ff_mpeg4_init_partitions(s);
2508 s->first_slice_line = 1;
2509 s->ptr_lastgob = s->pb.buf;
2510 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2514 ff_set_qscale(s, s->qscale);
2515 ff_init_block_index(s);
2517 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2518 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2519 int mb_type= s->mb_type[xy];
2524 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2525 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2528 if(s->data_partitioning){
2529 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2530 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2531 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2537 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2538 ff_update_block_index(s);
2540 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2541 ff_h261_reorder_mb_index(s);
2542 xy= s->mb_y*s->mb_stride + s->mb_x;
2543 mb_type= s->mb_type[xy];
2546 /* write gob / video packet header */
2548 int current_packet_size, is_gob_start;
2550 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2552 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2554 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2556 switch(s->codec_id){
2557 case AV_CODEC_ID_H263:
2558 case AV_CODEC_ID_H263P:
2559 if(!s->h263_slice_structured)
2560 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2562 case AV_CODEC_ID_MPEG2VIDEO:
2563 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2564 case AV_CODEC_ID_MPEG1VIDEO:
2565 if(s->mb_skip_run) is_gob_start=0;
2567 case AV_CODEC_ID_MJPEG:
2568 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2573 if(s->start_mb_y != mb_y || mb_x!=0){
2575 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2576 ff_mpeg4_init_partitions(s);
2580 av_assert2((put_bits_count(&s->pb)&7) == 0);
2581 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2583 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2584 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2585 int d= 100 / s->avctx->error_rate;
2587 current_packet_size=0;
2588 s->pb.buf_ptr= s->ptr_lastgob;
2589 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2593 if (s->avctx->rtp_callback){
2594 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2595 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2597 update_mb_info(s, 1);
2599 switch(s->codec_id){
2600 case AV_CODEC_ID_MPEG4:
2601 if (CONFIG_MPEG4_ENCODER) {
2602 ff_mpeg4_encode_video_packet_header(s);
2603 ff_mpeg4_clean_buffers(s);
2606 case AV_CODEC_ID_MPEG1VIDEO:
2607 case AV_CODEC_ID_MPEG2VIDEO:
2608 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2609 ff_mpeg1_encode_slice_header(s);
2610 ff_mpeg1_clean_buffers(s);
2613 case AV_CODEC_ID_H263:
2614 case AV_CODEC_ID_H263P:
2615 if (CONFIG_H263_ENCODER)
2616 ff_h263_encode_gob_header(s, mb_y);
2620 if(s->flags&CODEC_FLAG_PASS1){
2621 int bits= put_bits_count(&s->pb);
2622 s->misc_bits+= bits - s->last_bits;
2626 s->ptr_lastgob += current_packet_size;
2627 s->first_slice_line=1;
2628 s->resync_mb_x=mb_x;
2629 s->resync_mb_y=mb_y;
2633 if( (s->resync_mb_x == s->mb_x)
2634 && s->resync_mb_y+1 == s->mb_y){
2635 s->first_slice_line=0;
2639 s->dquant=0; //only for QP_RD
2641 update_mb_info(s, 0);
2643 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
2645 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2647 copy_context_before_encode(&backup_s, s, -1);
2649 best_s.data_partitioning= s->data_partitioning;
2650 best_s.partitioned_frame= s->partitioned_frame;
2651 if(s->data_partitioning){
2652 backup_s.pb2= s->pb2;
2653 backup_s.tex_pb= s->tex_pb;
2656 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2657 s->mv_dir = MV_DIR_FORWARD;
2658 s->mv_type = MV_TYPE_16X16;
2660 s->mv[0][0][0] = s->p_mv_table[xy][0];
2661 s->mv[0][0][1] = s->p_mv_table[xy][1];
2662 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2663 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2665 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2666 s->mv_dir = MV_DIR_FORWARD;
2667 s->mv_type = MV_TYPE_FIELD;
2670 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2671 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2672 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2674 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2675 &dmin, &next_block, 0, 0);
2677 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2678 s->mv_dir = MV_DIR_FORWARD;
2679 s->mv_type = MV_TYPE_16X16;
2683 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2684 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2686 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2687 s->mv_dir = MV_DIR_FORWARD;
2688 s->mv_type = MV_TYPE_8X8;
2691 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2692 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2694 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2695 &dmin, &next_block, 0, 0);
2697 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2698 s->mv_dir = MV_DIR_FORWARD;
2699 s->mv_type = MV_TYPE_16X16;
2701 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2702 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2703 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2704 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2706 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2707 s->mv_dir = MV_DIR_BACKWARD;
2708 s->mv_type = MV_TYPE_16X16;
2710 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2711 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2712 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2713 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2715 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2716 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2717 s->mv_type = MV_TYPE_16X16;
2719 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2720 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2721 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2722 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2723 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2724 &dmin, &next_block, 0, 0);
2726 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2727 s->mv_dir = MV_DIR_FORWARD;
2728 s->mv_type = MV_TYPE_FIELD;
2731 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2732 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2733 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2735 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2736 &dmin, &next_block, 0, 0);
2738 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2739 s->mv_dir = MV_DIR_BACKWARD;
2740 s->mv_type = MV_TYPE_FIELD;
2743 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2744 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2745 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2747 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2748 &dmin, &next_block, 0, 0);
2750 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2751 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2752 s->mv_type = MV_TYPE_FIELD;
2754 for(dir=0; dir<2; dir++){
2756 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2757 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2758 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2761 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2762 &dmin, &next_block, 0, 0);
2764 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2766 s->mv_type = MV_TYPE_16X16;
2770 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2771 &dmin, &next_block, 0, 0);
2772 if(s->h263_pred || s->h263_aic){
2774 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2776 ff_clean_intra_table_entries(s); //old mode?
2780 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2781 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2782 const int last_qp= backup_s.qscale;
2785 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2786 static const int dquant_tab[4]={-1,1,-2,2};
2787 int storecoefs = s->mb_intra && s->dc_val[0];
2789 av_assert2(backup_s.dquant == 0);
2792 s->mv_dir= best_s.mv_dir;
2793 s->mv_type = MV_TYPE_16X16;
2794 s->mb_intra= best_s.mb_intra;
2795 s->mv[0][0][0] = best_s.mv[0][0][0];
2796 s->mv[0][0][1] = best_s.mv[0][0][1];
2797 s->mv[1][0][0] = best_s.mv[1][0][0];
2798 s->mv[1][0][1] = best_s.mv[1][0][1];
2800 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2801 for(; qpi<4; qpi++){
2802 int dquant= dquant_tab[qpi];
2803 qp= last_qp + dquant;
2804 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2806 backup_s.dquant= dquant;
2809 dc[i]= s->dc_val[0][ s->block_index[i] ];
2810 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2814 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2815 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2816 if(best_s.qscale != qp){
2819 s->dc_val[0][ s->block_index[i] ]= dc[i];
2820 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2827 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2828 int mx= s->b_direct_mv_table[xy][0];
2829 int my= s->b_direct_mv_table[xy][1];
2831 backup_s.dquant = 0;
2832 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2834 ff_mpeg4_set_direct_mv(s, mx, my);
2835 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2836 &dmin, &next_block, mx, my);
2838 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2839 backup_s.dquant = 0;
2840 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2842 ff_mpeg4_set_direct_mv(s, 0, 0);
2843 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2844 &dmin, &next_block, 0, 0);
2846 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2849 coded |= s->block_last_index[i];
2852 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2853 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2854 mx=my=0; //FIXME find the one we actually used
2855 ff_mpeg4_set_direct_mv(s, mx, my);
2856 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2864 s->mv_dir= best_s.mv_dir;
2865 s->mv_type = best_s.mv_type;
2867 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2868 s->mv[0][0][1] = best_s.mv[0][0][1];
2869 s->mv[1][0][0] = best_s.mv[1][0][0];
2870 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2873 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2874 &dmin, &next_block, mx, my);
2879 s->current_picture.qscale_table[xy] = best_s.qscale;
2881 copy_context_after_encode(s, &best_s, -1);
2883 pb_bits_count= put_bits_count(&s->pb);
2884 flush_put_bits(&s->pb);
2885 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2888 if(s->data_partitioning){
2889 pb2_bits_count= put_bits_count(&s->pb2);
2890 flush_put_bits(&s->pb2);
2891 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2892 s->pb2= backup_s.pb2;
2894 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2895 flush_put_bits(&s->tex_pb);
2896 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2897 s->tex_pb= backup_s.tex_pb;
2899 s->last_bits= put_bits_count(&s->pb);
2901 if (CONFIG_H263_ENCODER &&
2902 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2903 ff_h263_update_motion_val(s);
2905 if(next_block==0){ //FIXME 16 vs linesize16
2906 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2907 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2908 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2911 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2912 ff_MPV_decode_mb(s, s->block);
2914 int motion_x = 0, motion_y = 0;
2915 s->mv_type=MV_TYPE_16X16;
2916 // only one MB-Type possible
2919 case CANDIDATE_MB_TYPE_INTRA:
2922 motion_x= s->mv[0][0][0] = 0;
2923 motion_y= s->mv[0][0][1] = 0;
2925 case CANDIDATE_MB_TYPE_INTER:
2926 s->mv_dir = MV_DIR_FORWARD;
2928 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2929 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2931 case CANDIDATE_MB_TYPE_INTER_I:
2932 s->mv_dir = MV_DIR_FORWARD;
2933 s->mv_type = MV_TYPE_FIELD;
2936 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2937 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2938 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2941 case CANDIDATE_MB_TYPE_INTER4V:
2942 s->mv_dir = MV_DIR_FORWARD;
2943 s->mv_type = MV_TYPE_8X8;
2946 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2947 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2950 case CANDIDATE_MB_TYPE_DIRECT:
2951 if (CONFIG_MPEG4_ENCODER) {
2952 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2954 motion_x=s->b_direct_mv_table[xy][0];
2955 motion_y=s->b_direct_mv_table[xy][1];
2956 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2959 case CANDIDATE_MB_TYPE_DIRECT0:
2960 if (CONFIG_MPEG4_ENCODER) {
2961 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2963 ff_mpeg4_set_direct_mv(s, 0, 0);
2966 case CANDIDATE_MB_TYPE_BIDIR:
2967 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2969 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2970 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2971 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2972 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2974 case CANDIDATE_MB_TYPE_BACKWARD:
2975 s->mv_dir = MV_DIR_BACKWARD;
2977 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2978 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2980 case CANDIDATE_MB_TYPE_FORWARD:
2981 s->mv_dir = MV_DIR_FORWARD;
2983 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2984 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2986 case CANDIDATE_MB_TYPE_FORWARD_I:
2987 s->mv_dir = MV_DIR_FORWARD;
2988 s->mv_type = MV_TYPE_FIELD;
2991 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2992 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2993 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2996 case CANDIDATE_MB_TYPE_BACKWARD_I:
2997 s->mv_dir = MV_DIR_BACKWARD;
2998 s->mv_type = MV_TYPE_FIELD;
3001 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3002 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3003 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3006 case CANDIDATE_MB_TYPE_BIDIR_I:
3007 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3008 s->mv_type = MV_TYPE_FIELD;
3010 for(dir=0; dir<2; dir++){
3012 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3013 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3014 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3019 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3022 encode_mb(s, motion_x, motion_y);
3024 // RAL: Update last macroblock type
3025 s->last_mv_dir = s->mv_dir;
3027 if (CONFIG_H263_ENCODER &&
3028 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3029 ff_h263_update_motion_val(s);
3031 ff_MPV_decode_mb(s, s->block);
3034 /* clean the MV table in IPS frames for direct mode in B frames */
3035 if(s->mb_intra /* && I,P,S_TYPE */){
3036 s->p_mv_table[xy][0]=0;
3037 s->p_mv_table[xy][1]=0;
3040 if(s->flags&CODEC_FLAG_PSNR){
3044 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3045 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3047 s->current_picture.f.error[0] += sse(
3048 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3049 s->dest[0], w, h, s->linesize);
3050 s->current_picture.f.error[1] += sse(
3051 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3052 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3053 s->current_picture.f.error[2] += sse(
3054 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3055 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3058 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3059 ff_h263_loop_filter(s);
3061 av_dlog(s->avctx, "MB %d %d bits\n",
3062 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3066 //not beautiful here but we must write it before flushing so it has to be here
3067 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3068 ff_msmpeg4_encode_ext_header(s);
3072 /* Send the last GOB if RTP */
3073 if (s->avctx->rtp_callback) {
3074 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3075 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3076 /* Call the RTP callback to send the last GOB */
3078 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3084 #define MERGE(field) dst->field += src->field; src->field=0
3085 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3086 MERGE(me.scene_change_score);
3087 MERGE(me.mc_mb_var_sum_temp);
3088 MERGE(me.mb_var_sum_temp);
3091 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3094 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3095 MERGE(dct_count[1]);
3104 MERGE(er.error_count);
3105 MERGE(padding_bug_score);
3106 MERGE(current_picture.f.error[0]);
3107 MERGE(current_picture.f.error[1]);
3108 MERGE(current_picture.f.error[2]);
3110 if(dst->avctx->noise_reduction){
3111 for(i=0; i<64; i++){
3112 MERGE(dct_error_sum[0][i]);
3113 MERGE(dct_error_sum[1][i]);
3117 assert(put_bits_count(&src->pb) % 8 ==0);
3118 assert(put_bits_count(&dst->pb) % 8 ==0);
3119 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3120 flush_put_bits(&dst->pb);
3123 static int estimate_qp(MpegEncContext *s, int dry_run){
3124 if (s->next_lambda){
3125 s->current_picture_ptr->f.quality =
3126 s->current_picture.f.quality = s->next_lambda;
3127 if(!dry_run) s->next_lambda= 0;
3128 } else if (!s->fixed_qscale) {
3129 s->current_picture_ptr->f.quality =
3130 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3131 if (s->current_picture.f.quality < 0)
3135 if(s->adaptive_quant){
3136 switch(s->codec_id){
3137 case AV_CODEC_ID_MPEG4:
3138 if (CONFIG_MPEG4_ENCODER)
3139 ff_clean_mpeg4_qscales(s);
3141 case AV_CODEC_ID_H263:
3142 case AV_CODEC_ID_H263P:
3143 case AV_CODEC_ID_FLV1:
3144 if (CONFIG_H263_ENCODER)
3145 ff_clean_h263_qscales(s);
3148 ff_init_qscale_tab(s);
3151 s->lambda= s->lambda_table[0];
3154 s->lambda = s->current_picture.f.quality;
3159 /* must be called before writing the header */
3160 static void set_frame_distances(MpegEncContext * s){
3161 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3162 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3164 if(s->pict_type==AV_PICTURE_TYPE_B){
3165 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3166 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3168 s->pp_time= s->time - s->last_non_b_time;
3169 s->last_non_b_time= s->time;
3170 assert(s->picture_number==0 || s->pp_time > 0);
3174 static int encode_picture(MpegEncContext *s, int picture_number)
3178 int context_count = s->slice_context_count;
3180 s->picture_number = picture_number;
3182 /* Reset the average MB variance */
3183 s->me.mb_var_sum_temp =
3184 s->me.mc_mb_var_sum_temp = 0;
3186 /* we need to initialize some time vars before we can encode b-frames */
3187 // RAL: Condition added for MPEG1VIDEO
3188 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3189 set_frame_distances(s);
3190 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3191 ff_set_mpeg4_time(s);
3193 s->me.scene_change_score=0;
3195 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3197 if(s->pict_type==AV_PICTURE_TYPE_I){
3198 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3199 else s->no_rounding=0;
3200 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3201 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3202 s->no_rounding ^= 1;
3205 if(s->flags & CODEC_FLAG_PASS2){
3206 if (estimate_qp(s,1) < 0)
3208 ff_get_2pass_fcode(s);
3209 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3210 if(s->pict_type==AV_PICTURE_TYPE_B)
3211 s->lambda= s->last_lambda_for[s->pict_type];
3213 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3217 if(s->codec_id != AV_CODEC_ID_AMV){
3218 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3219 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3220 s->q_chroma_intra_matrix = s->q_intra_matrix;
3221 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3224 s->mb_intra=0; //for the rate distortion & bit compare functions
3225 for(i=1; i<context_count; i++){
3226 ret = ff_update_duplicate_context(s->thread_context[i], s);
3234 /* Estimate motion for every MB */
3235 if(s->pict_type != AV_PICTURE_TYPE_I){
3236 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3237 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3238 if (s->pict_type != AV_PICTURE_TYPE_B) {
3239 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3240 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3244 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3245 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3247 for(i=0; i<s->mb_stride*s->mb_height; i++)
3248 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3250 if(!s->fixed_qscale){
3251 /* finding spatial complexity for I-frame rate control */
3252 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3255 for(i=1; i<context_count; i++){
3256 merge_context_after_me(s, s->thread_context[i]);
3258 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3259 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3262 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3263 s->pict_type= AV_PICTURE_TYPE_I;
3264 for(i=0; i<s->mb_stride*s->mb_height; i++)
3265 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3266 if(s->msmpeg4_version >= 3)
3268 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3269 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3273 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3274 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3276 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3278 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3279 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3280 s->f_code= FFMAX3(s->f_code, a, b);
3283 ff_fix_long_p_mvs(s);
3284 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3285 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3289 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3290 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3295 if(s->pict_type==AV_PICTURE_TYPE_B){
3298 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3299 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3300 s->f_code = FFMAX(a, b);
3302 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3303 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3304 s->b_code = FFMAX(a, b);
3306 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3307 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3308 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3309 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3310 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3312 for(dir=0; dir<2; dir++){
3315 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3316 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3317 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3318 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3326 if (estimate_qp(s, 0) < 0)
3329 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3330 s->qscale= 3; //reduce clipping problems
3332 if (s->out_format == FMT_MJPEG) {
3333 /* for mjpeg, we do include qscale in the matrix */
3335 int j= s->dsp.idct_permutation[i];
3337 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3339 s->y_dc_scale_table=
3340 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3341 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3342 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3343 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3346 if(s->codec_id == AV_CODEC_ID_AMV){
3347 static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
3348 static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
3350 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3352 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3353 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3355 s->y_dc_scale_table= y;
3356 s->c_dc_scale_table= c;
3357 s->intra_matrix[0] = 13;
3358 s->chroma_intra_matrix[0] = 14;
3359 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3360 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3361 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3362 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3366 //FIXME var duplication
3367 s->current_picture_ptr->f.key_frame =
3368 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3369 s->current_picture_ptr->f.pict_type =
3370 s->current_picture.f.pict_type = s->pict_type;
3372 if (s->current_picture.f.key_frame)
3373 s->picture_in_gop_number=0;
3375 s->mb_x = s->mb_y = 0;
3376 s->last_bits= put_bits_count(&s->pb);
3377 switch(s->out_format) {
3379 if (CONFIG_MJPEG_ENCODER)
3380 ff_mjpeg_encode_picture_header(s);
3383 if (CONFIG_H261_ENCODER)
3384 ff_h261_encode_picture_header(s, picture_number);
3387 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3388 ff_wmv2_encode_picture_header(s, picture_number);
3389 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3390 ff_msmpeg4_encode_picture_header(s, picture_number);
3391 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3392 ff_mpeg4_encode_picture_header(s, picture_number);
3393 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3394 ff_rv10_encode_picture_header(s, picture_number);
3395 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3396 ff_rv20_encode_picture_header(s, picture_number);
3397 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3398 ff_flv_encode_picture_header(s, picture_number);
3399 else if (CONFIG_H263_ENCODER)
3400 ff_h263_encode_picture_header(s, picture_number);
3403 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3404 ff_mpeg1_encode_picture_header(s, picture_number);
3409 bits= put_bits_count(&s->pb);
3410 s->header_bits= bits - s->last_bits;
3412 for(i=1; i<context_count; i++){
3413 update_duplicate_context_after_me(s->thread_context[i], s);
3415 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3416 for(i=1; i<context_count; i++){
3417 merge_context_after_encode(s, s->thread_context[i]);
3423 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3424 const int intra= s->mb_intra;
3427 s->dct_count[intra]++;
3429 for(i=0; i<64; i++){
3430 int level= block[i];
3434 s->dct_error_sum[intra][i] += level;
3435 level -= s->dct_offset[intra][i];
3436 if(level<0) level=0;
3438 s->dct_error_sum[intra][i] -= level;
3439 level += s->dct_offset[intra][i];
3440 if(level>0) level=0;
3447 static int dct_quantize_trellis_c(MpegEncContext *s,
3448 int16_t *block, int n,
3449 int qscale, int *overflow){
3451 const uint8_t *scantable= s->intra_scantable.scantable;
3452 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3454 unsigned int threshold1, threshold2;
3466 int coeff_count[64];
3467 int qmul, qadd, start_i, last_non_zero, i, dc;
3468 const int esc_length= s->ac_esc_length;
3470 uint8_t * last_length;
3471 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3473 s->dsp.fdct (block);
3475 if(s->dct_error_sum)
3476 s->denoise_dct(s, block);
3478 qadd= ((qscale-1)|1)*8;
3489 /* For AIC we skip quant/dequant of INTRADC */
3494 /* note: block[0] is assumed to be positive */
3495 block[0] = (block[0] + (q >> 1)) / q;
3498 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3499 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3500 bias= 1<<(QMAT_SHIFT-1);
3501 length = s->intra_ac_vlc_length;
3502 last_length= s->intra_ac_vlc_last_length;
3506 qmat = s->q_inter_matrix[qscale];
3507 length = s->inter_ac_vlc_length;
3508 last_length= s->inter_ac_vlc_last_length;
3512 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3513 threshold2= (threshold1<<1);
3515 for(i=63; i>=start_i; i--) {
3516 const int j = scantable[i];
3517 int level = block[j] * qmat[j];
3519 if(((unsigned)(level+threshold1))>threshold2){
3525 for(i=start_i; i<=last_non_zero; i++) {
3526 const int j = scantable[i];
3527 int level = block[j] * qmat[j];
3529 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3530 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3531 if(((unsigned)(level+threshold1))>threshold2){
3533 level= (bias + level)>>QMAT_SHIFT;
3535 coeff[1][i]= level-1;
3536 // coeff[2][k]= level-2;
3538 level= (bias - level)>>QMAT_SHIFT;
3539 coeff[0][i]= -level;
3540 coeff[1][i]= -level+1;
3541 // coeff[2][k]= -level+2;
3543 coeff_count[i]= FFMIN(level, 2);
3544 av_assert2(coeff_count[i]);
3547 coeff[0][i]= (level>>31)|1;
3552 *overflow= s->max_qcoeff < max; //overflow might have happened
3554 if(last_non_zero < start_i){
3555 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3556 return last_non_zero;
3559 score_tab[start_i]= 0;
3560 survivor[0]= start_i;
3563 for(i=start_i; i<=last_non_zero; i++){
3564 int level_index, j, zero_distortion;
3565 int dct_coeff= FFABS(block[ scantable[i] ]);
3566 int best_score=256*256*256*120;
3568 if (s->dsp.fdct == ff_fdct_ifast)
3569 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3570 zero_distortion= dct_coeff*dct_coeff;
3572 for(level_index=0; level_index < coeff_count[i]; level_index++){
3574 int level= coeff[level_index][i];
3575 const int alevel= FFABS(level);
3580 if(s->out_format == FMT_H263){
3581 unquant_coeff= alevel*qmul + qadd;
3583 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3585 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3586 unquant_coeff = (unquant_coeff - 1) | 1;
3588 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3589 unquant_coeff = (unquant_coeff - 1) | 1;
3594 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3596 if((level&(~127)) == 0){
3597 for(j=survivor_count-1; j>=0; j--){
3598 int run= i - survivor[j];
3599 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3600 score += score_tab[i-run];
3602 if(score < best_score){
3605 level_tab[i+1]= level-64;
3609 if(s->out_format == FMT_H263){
3610 for(j=survivor_count-1; j>=0; j--){
3611 int run= i - survivor[j];
3612 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3613 score += score_tab[i-run];
3614 if(score < last_score){
3617 last_level= level-64;
3623 distortion += esc_length*lambda;
3624 for(j=survivor_count-1; j>=0; j--){
3625 int run= i - survivor[j];
3626 int score= distortion + score_tab[i-run];
3628 if(score < best_score){
3631 level_tab[i+1]= level-64;
3635 if(s->out_format == FMT_H263){
3636 for(j=survivor_count-1; j>=0; j--){
3637 int run= i - survivor[j];
3638 int score= distortion + score_tab[i-run];
3639 if(score < last_score){
3642 last_level= level-64;
3650 score_tab[i+1]= best_score;
3652 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3653 if(last_non_zero <= 27){
3654 for(; survivor_count; survivor_count--){
3655 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3659 for(; survivor_count; survivor_count--){
3660 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3665 survivor[ survivor_count++ ]= i+1;
3668 if(s->out_format != FMT_H263){
3669 last_score= 256*256*256*120;
3670 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3671 int score= score_tab[i];
3672 if(i) score += lambda*2; //FIXME exacter?
3674 if(score < last_score){
3677 last_level= level_tab[i];
3678 last_run= run_tab[i];
3683 s->coded_score[n] = last_score;
3685 dc= FFABS(block[0]);
3686 last_non_zero= last_i - 1;
3687 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3689 if(last_non_zero < start_i)
3690 return last_non_zero;
3692 if(last_non_zero == 0 && start_i == 0){
3694 int best_score= dc * dc;
3696 for(i=0; i<coeff_count[0]; i++){
3697 int level= coeff[i][0];
3698 int alevel= FFABS(level);
3699 int unquant_coeff, score, distortion;
3701 if(s->out_format == FMT_H263){
3702 unquant_coeff= (alevel*qmul + qadd)>>3;
3704 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3705 unquant_coeff = (unquant_coeff - 1) | 1;
3707 unquant_coeff = (unquant_coeff + 4) >> 3;
3708 unquant_coeff<<= 3 + 3;
3710 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3712 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3713 else score= distortion + esc_length*lambda;
3715 if(score < best_score){
3717 best_level= level - 64;
3720 block[0]= best_level;
3721 s->coded_score[n] = best_score - dc*dc;
3722 if(best_level == 0) return -1;
3723 else return last_non_zero;
3727 av_assert2(last_level);
3729 block[ perm_scantable[last_non_zero] ]= last_level;
3732 for(; i>start_i; i -= run_tab[i] + 1){
3733 block[ perm_scantable[i-1] ]= level_tab[i];
3736 return last_non_zero;
3739 //#define REFINE_STATS 1
3740 static int16_t basis[64][64];
3742 static void build_basis(uint8_t *perm){
3749 double s= 0.25*(1<<BASIS_SHIFT);
3751 int perm_index= perm[index];
3752 if(i==0) s*= sqrt(0.5);
3753 if(j==0) s*= sqrt(0.5);
3754 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)));
3761 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3762 int16_t *block, int16_t *weight, int16_t *orig,
3765 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3766 const uint8_t *scantable= s->intra_scantable.scantable;
3767 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3768 // unsigned int threshold1, threshold2;
3773 int qmul, qadd, start_i, last_non_zero, i, dc;
3775 uint8_t * last_length;
3777 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3780 static int after_last=0;
3781 static int to_zero=0;
3782 static int from_zero=0;
3785 static int messed_sign=0;
3788 if(basis[0][0] == 0)
3789 build_basis(s->dsp.idct_permutation);
3800 /* For AIC we skip quant/dequant of INTRADC */
3804 q <<= RECON_SHIFT-3;
3805 /* note: block[0] is assumed to be positive */
3807 // block[0] = (block[0] + (q >> 1)) / q;
3809 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3810 // bias= 1<<(QMAT_SHIFT-1);
3811 length = s->intra_ac_vlc_length;
3812 last_length= s->intra_ac_vlc_last_length;
3816 length = s->inter_ac_vlc_length;
3817 last_length= s->inter_ac_vlc_last_length;
3819 last_non_zero = s->block_last_index[n];
3824 dc += (1<<(RECON_SHIFT-1));
3825 for(i=0; i<64; i++){
3826 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3829 STOP_TIMER("memset rem[]")}
3832 for(i=0; i<64; i++){
3837 w= FFABS(weight[i]) + qns*one;
3838 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3841 // w=weight[i] = (63*qns + (w/2)) / w;
3844 av_assert2(w<(1<<6));
3847 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3853 for(i=start_i; i<=last_non_zero; i++){
3854 int j= perm_scantable[i];
3855 const int level= block[j];
3859 if(level<0) coeff= qmul*level - qadd;
3860 else coeff= qmul*level + qadd;
3861 run_tab[rle_index++]=run;
3864 s->dsp.add_8x8basis(rem, basis[j], coeff);
3870 if(last_non_zero>0){
3871 STOP_TIMER("init rem[]")
3878 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3881 int run2, best_unquant_change=0, analyze_gradient;
3885 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3887 if(analyze_gradient){
3891 for(i=0; i<64; i++){
3894 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3897 STOP_TIMER("rem*w*w")}
3907 const int level= block[0];
3908 int change, old_coeff;
3910 av_assert2(s->mb_intra);
3914 for(change=-1; change<=1; change+=2){
3915 int new_level= level + change;
3916 int score, new_coeff;
3918 new_coeff= q*new_level;
3919 if(new_coeff >= 2048 || new_coeff < 0)
3922 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3923 if(score<best_score){
3926 best_change= change;
3927 best_unquant_change= new_coeff - old_coeff;
3934 run2= run_tab[rle_index++];
3938 for(i=start_i; i<64; i++){
3939 int j= perm_scantable[i];
3940 const int level= block[j];
3941 int change, old_coeff;
3943 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3947 if(level<0) old_coeff= qmul*level - qadd;
3948 else old_coeff= qmul*level + qadd;
3949 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3953 av_assert2(run2>=0 || i >= last_non_zero );
3956 for(change=-1; change<=1; change+=2){
3957 int new_level= level + change;
3958 int score, new_coeff, unquant_change;
3961 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3965 if(new_level<0) new_coeff= qmul*new_level - qadd;
3966 else new_coeff= qmul*new_level + qadd;
3967 if(new_coeff >= 2048 || new_coeff <= -2048)
3969 //FIXME check for overflow
3972 if(level < 63 && level > -63){
3973 if(i < last_non_zero)
3974 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3975 - length[UNI_AC_ENC_INDEX(run, level+64)];
3977 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3978 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3981 av_assert2(FFABS(new_level)==1);
3983 if(analyze_gradient){
3984 int g= d1[ scantable[i] ];
3985 if(g && (g^new_level) >= 0)
3989 if(i < last_non_zero){
3990 int next_i= i + run2 + 1;
3991 int next_level= block[ perm_scantable[next_i] ] + 64;
3993 if(next_level&(~127))
3996 if(next_i < last_non_zero)
3997 score += length[UNI_AC_ENC_INDEX(run, 65)]
3998 + length[UNI_AC_ENC_INDEX(run2, next_level)]
3999 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4001 score += length[UNI_AC_ENC_INDEX(run, 65)]
4002 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4003 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4005 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4007 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4008 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4014 av_assert2(FFABS(level)==1);
4016 if(i < last_non_zero){
4017 int next_i= i + run2 + 1;
4018 int next_level= block[ perm_scantable[next_i] ] + 64;
4020 if(next_level&(~127))
4023 if(next_i < last_non_zero)
4024 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4025 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4026 - length[UNI_AC_ENC_INDEX(run, 65)];
4028 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4029 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4030 - length[UNI_AC_ENC_INDEX(run, 65)];
4032 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4034 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4035 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4042 unquant_change= new_coeff - old_coeff;
4043 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4045 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4046 if(score<best_score){
4049 best_change= change;
4050 best_unquant_change= unquant_change;
4054 prev_level= level + 64;
4055 if(prev_level&(~127))
4064 STOP_TIMER("iterative step")}
4068 int j= perm_scantable[ best_coeff ];
4070 block[j] += best_change;
4072 if(best_coeff > last_non_zero){
4073 last_non_zero= best_coeff;
4074 av_assert2(block[j]);
4081 if(block[j] - best_change){
4082 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4094 for(; last_non_zero>=start_i; last_non_zero--){
4095 if(block[perm_scantable[last_non_zero]])
4101 if(256*256*256*64 % count == 0){
4102 av_log(s->avctx, AV_LOG_DEBUG, "after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4107 for(i=start_i; i<=last_non_zero; i++){
4108 int j= perm_scantable[i];
4109 const int level= block[j];
4112 run_tab[rle_index++]=run;
4119 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4125 if(last_non_zero>0){
4126 STOP_TIMER("iterative search")
4131 return last_non_zero;
4134 int ff_dct_quantize_c(MpegEncContext *s,
4135 int16_t *block, int n,
4136 int qscale, int *overflow)
4138 int i, j, level, last_non_zero, q, start_i;
4140 const uint8_t *scantable= s->intra_scantable.scantable;
4143 unsigned int threshold1, threshold2;
4145 s->dsp.fdct (block);
4147 if(s->dct_error_sum)
4148 s->denoise_dct(s, block);
4158 /* For AIC we skip quant/dequant of INTRADC */
4161 /* note: block[0] is assumed to be positive */
4162 block[0] = (block[0] + (q >> 1)) / q;
4165 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4166 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4170 qmat = s->q_inter_matrix[qscale];
4171 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4173 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4174 threshold2= (threshold1<<1);
4175 for(i=63;i>=start_i;i--) {
4177 level = block[j] * qmat[j];
4179 if(((unsigned)(level+threshold1))>threshold2){
4186 for(i=start_i; i<=last_non_zero; i++) {
4188 level = block[j] * qmat[j];
4190 // if( bias+level >= (1<<QMAT_SHIFT)
4191 // || bias-level >= (1<<QMAT_SHIFT)){
4192 if(((unsigned)(level+threshold1))>threshold2){
4194 level= (bias + level)>>QMAT_SHIFT;
4197 level= (bias - level)>>QMAT_SHIFT;
4205 *overflow= s->max_qcoeff < max; //overflow might have happened
4207 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4208 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4209 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4211 return last_non_zero;
4214 #define OFFSET(x) offsetof(MpegEncContext, x)
4215 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4216 static const AVOption h263_options[] = {
4217 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4218 { "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},
4219 { "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 },
4224 static const AVClass h263_class = {
4225 .class_name = "H.263 encoder",
4226 .item_name = av_default_item_name,
4227 .option = h263_options,
4228 .version = LIBAVUTIL_VERSION_INT,
4231 AVCodec ff_h263_encoder = {
4233 .type = AVMEDIA_TYPE_VIDEO,
4234 .id = AV_CODEC_ID_H263,
4235 .priv_data_size = sizeof(MpegEncContext),
4236 .init = ff_MPV_encode_init,
4237 .encode2 = ff_MPV_encode_picture,
4238 .close = ff_MPV_encode_end,
4239 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4240 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4241 .priv_class = &h263_class,
4244 static const AVOption h263p_options[] = {
4245 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4246 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4247 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4248 { "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},
4252 static const AVClass h263p_class = {
4253 .class_name = "H.263p encoder",
4254 .item_name = av_default_item_name,
4255 .option = h263p_options,
4256 .version = LIBAVUTIL_VERSION_INT,
4259 AVCodec ff_h263p_encoder = {
4261 .type = AVMEDIA_TYPE_VIDEO,
4262 .id = AV_CODEC_ID_H263P,
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 .capabilities = CODEC_CAP_SLICE_THREADS,
4268 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4269 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4270 .priv_class = &h263p_class,
4273 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4275 AVCodec ff_msmpeg4v2_encoder = {
4276 .name = "msmpeg4v2",
4277 .type = AVMEDIA_TYPE_VIDEO,
4278 .id = AV_CODEC_ID_MSMPEG4V2,
4279 .priv_data_size = sizeof(MpegEncContext),
4280 .init = ff_MPV_encode_init,
4281 .encode2 = ff_MPV_encode_picture,
4282 .close = ff_MPV_encode_end,
4283 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4284 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4285 .priv_class = &msmpeg4v2_class,
4288 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4290 AVCodec ff_msmpeg4v3_encoder = {
4292 .type = AVMEDIA_TYPE_VIDEO,
4293 .id = AV_CODEC_ID_MSMPEG4V3,
4294 .priv_data_size = sizeof(MpegEncContext),
4295 .init = ff_MPV_encode_init,
4296 .encode2 = ff_MPV_encode_picture,
4297 .close = ff_MPV_encode_end,
4298 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4299 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4300 .priv_class = &msmpeg4v3_class,
4303 FF_MPV_GENERIC_CLASS(wmv1)
4305 AVCodec ff_wmv1_encoder = {
4307 .type = AVMEDIA_TYPE_VIDEO,
4308 .id = AV_CODEC_ID_WMV1,
4309 .priv_data_size = sizeof(MpegEncContext),
4310 .init = ff_MPV_encode_init,
4311 .encode2 = ff_MPV_encode_picture,
4312 .close = ff_MPV_encode_end,
4313 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4314 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4315 .priv_class = &wmv1_class,