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/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/opt.h"
36 #include "mpegvideo.h"
43 #include "aandcttab.h"
45 #include "mpeg4video.h"
47 #include "bytestream.h"
54 static int encode_picture(MpegEncContext *s, int picture_number);
55 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
56 static int sse_mb(MpegEncContext *s);
57 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
58 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
62 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
63 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
65 const AVOption ff_mpv_generic_options[] = {
70 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
71 uint16_t (*qmat16)[2][64],
72 const uint16_t *quant_matrix,
73 int bias, int qmin, int qmax, int intra)
78 for (qscale = qmin; qscale <= qmax; qscale++) {
80 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
81 dsp->fdct == ff_jpeg_fdct_islow_10 ||
82 dsp->fdct == ff_faandct) {
83 for (i = 0; i < 64; i++) {
84 const int j = dsp->idct_permutation[i];
85 /* 16 <= qscale * quant_matrix[i] <= 7905
86 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
87 * 19952 <= x <= 249205026
88 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
89 * 3444240 >= (1 << 36) / (x) >= 275 */
91 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
92 (qscale * quant_matrix[j]));
94 } else if (dsp->fdct == ff_fdct_ifast) {
95 for (i = 0; i < 64; i++) {
96 const int j = dsp->idct_permutation[i];
97 /* 16 <= qscale * quant_matrix[i] <= 7905
98 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
99 * 19952 <= x <= 249205026
100 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
101 * 3444240 >= (1 << 36) / (x) >= 275 */
103 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
104 (ff_aanscales[i] * (int64_t)qscale * quant_matrix[j]));
107 for (i = 0; i < 64; i++) {
108 const int j = dsp->idct_permutation[i];
109 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
110 * Assume x = qscale * quant_matrix[i]
112 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
113 * so 32768 >= (1 << 19) / (x) >= 67 */
114 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
115 (qscale * quant_matrix[j]));
116 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
117 // (qscale * quant_matrix[i]);
118 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
119 (qscale * quant_matrix[j]);
121 if (qmat16[qscale][0][i] == 0 ||
122 qmat16[qscale][0][i] == 128 * 256)
123 qmat16[qscale][0][i] = 128 * 256 - 1;
124 qmat16[qscale][1][i] =
125 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
126 qmat16[qscale][0][i]);
130 for (i = intra; i < 64; i++) {
132 if (dsp->fdct == ff_fdct_ifast) {
133 max = (8191LL * ff_aanscales[i]) >> 14;
135 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
141 av_log(NULL, AV_LOG_INFO,
142 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
147 static inline void update_qscale(MpegEncContext *s)
149 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
150 (FF_LAMBDA_SHIFT + 7);
151 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
153 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
157 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
163 for (i = 0; i < 64; i++) {
164 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
171 * init s->current_picture.qscale_table from s->lambda_table
173 void ff_init_qscale_tab(MpegEncContext *s)
175 int8_t * const qscale_table = s->current_picture.f.qscale_table;
178 for (i = 0; i < s->mb_num; i++) {
179 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
180 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
181 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
186 static void copy_picture_attributes(MpegEncContext *s,
192 dst->pict_type = src->pict_type;
193 dst->quality = src->quality;
194 dst->coded_picture_number = src->coded_picture_number;
195 dst->display_picture_number = src->display_picture_number;
196 //dst->reference = src->reference;
198 dst->interlaced_frame = src->interlaced_frame;
199 dst->top_field_first = src->top_field_first;
201 if (s->avctx->me_threshold) {
202 if (!src->motion_val[0])
203 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
205 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
206 if (!src->ref_index[0])
207 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
208 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
209 av_log(s->avctx, AV_LOG_ERROR,
210 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
211 src->motion_subsample_log2, dst->motion_subsample_log2);
213 memcpy(dst->mb_type, src->mb_type,
214 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
216 for (i = 0; i < 2; i++) {
217 int stride = ((16 * s->mb_width ) >>
218 src->motion_subsample_log2) + 1;
219 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
221 if (src->motion_val[i] &&
222 src->motion_val[i] != dst->motion_val[i]) {
223 memcpy(dst->motion_val[i], src->motion_val[i],
224 2 * stride * height * sizeof(int16_t));
226 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
227 memcpy(dst->ref_index[i], src->ref_index[i],
228 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
234 static void update_duplicate_context_after_me(MpegEncContext *dst,
237 #define COPY(a) dst->a= src->a
239 COPY(current_picture);
245 COPY(picture_in_gop_number);
246 COPY(gop_picture_number);
247 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
248 COPY(progressive_frame); // FIXME don't set in encode_header
249 COPY(partitioned_frame); // FIXME don't set in encode_header
254 * Set the given MpegEncContext to defaults for encoding.
255 * the changed fields will not depend upon the prior state of the MpegEncContext.
257 static void MPV_encode_defaults(MpegEncContext *s)
260 ff_MPV_common_defaults(s);
262 for (i = -16; i < 16; i++) {
263 default_fcode_tab[i + MAX_MV] = 1;
265 s->me.mv_penalty = default_mv_penalty;
266 s->fcode_tab = default_fcode_tab;
269 av_cold int ff_dct_encode_init(MpegEncContext *s) {
271 ff_dct_encode_init_x86(s);
273 if (!s->dct_quantize)
274 s->dct_quantize = ff_dct_quantize_c;
276 s->denoise_dct = denoise_dct_c;
277 s->fast_dct_quantize = s->dct_quantize;
278 if (s->avctx->trellis)
279 s->dct_quantize = dct_quantize_trellis_c;
284 /* init video encoder */
285 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
287 MpegEncContext *s = avctx->priv_data;
289 int chroma_h_shift, chroma_v_shift;
291 MPV_encode_defaults(s);
293 switch (avctx->codec_id) {
294 case AV_CODEC_ID_MPEG2VIDEO:
295 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
296 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
297 av_log(avctx, AV_LOG_ERROR,
298 "only YUV420 and YUV422 are supported\n");
302 case AV_CODEC_ID_LJPEG:
303 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
304 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
305 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
306 avctx->pix_fmt != AV_PIX_FMT_BGR0 &&
307 avctx->pix_fmt != AV_PIX_FMT_BGRA &&
308 avctx->pix_fmt != AV_PIX_FMT_BGR24 &&
309 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
310 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
311 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
312 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
313 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
317 case AV_CODEC_ID_MJPEG:
318 case AV_CODEC_ID_AMV:
319 if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
320 avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
321 avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
322 ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
323 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
324 avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
325 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
326 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
331 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
332 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
337 switch (avctx->pix_fmt) {
338 case AV_PIX_FMT_YUVJ444P:
339 case AV_PIX_FMT_YUV444P:
340 s->chroma_format = CHROMA_444;
342 case AV_PIX_FMT_YUVJ422P:
343 case AV_PIX_FMT_YUV422P:
344 s->chroma_format = CHROMA_422;
346 case AV_PIX_FMT_YUVJ420P:
347 case AV_PIX_FMT_YUV420P:
349 s->chroma_format = CHROMA_420;
353 s->bit_rate = avctx->bit_rate;
354 s->width = avctx->width;
355 s->height = avctx->height;
356 if (avctx->gop_size > 600 &&
357 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
358 av_log(avctx, AV_LOG_WARNING,
359 "keyframe interval too large!, reducing it from %d to %d\n",
360 avctx->gop_size, 600);
361 avctx->gop_size = 600;
363 s->gop_size = avctx->gop_size;
365 s->flags = avctx->flags;
366 s->flags2 = avctx->flags2;
367 s->max_b_frames = avctx->max_b_frames;
368 s->codec_id = avctx->codec->id;
369 #if FF_API_MPV_GLOBAL_OPTS
370 if (avctx->luma_elim_threshold)
371 s->luma_elim_threshold = avctx->luma_elim_threshold;
372 if (avctx->chroma_elim_threshold)
373 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
375 s->strict_std_compliance = avctx->strict_std_compliance;
376 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
377 s->mpeg_quant = avctx->mpeg_quant;
378 s->rtp_mode = !!avctx->rtp_payload_size;
379 s->intra_dc_precision = avctx->intra_dc_precision;
380 s->user_specified_pts = AV_NOPTS_VALUE;
382 if (s->gop_size <= 1) {
389 s->me_method = avctx->me_method;
392 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
394 #if FF_API_MPV_GLOBAL_OPTS
395 if (s->flags & CODEC_FLAG_QP_RD)
396 s->mpv_flags |= FF_MPV_FLAG_QP_RD;
399 s->adaptive_quant = (s->avctx->lumi_masking ||
400 s->avctx->dark_masking ||
401 s->avctx->temporal_cplx_masking ||
402 s->avctx->spatial_cplx_masking ||
403 s->avctx->p_masking ||
404 s->avctx->border_masking ||
405 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
408 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
410 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
411 switch(avctx->codec_id) {
412 case AV_CODEC_ID_MPEG1VIDEO:
413 case AV_CODEC_ID_MPEG2VIDEO:
414 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
416 case AV_CODEC_ID_MPEG4:
417 case AV_CODEC_ID_MSMPEG4V1:
418 case AV_CODEC_ID_MSMPEG4V2:
419 case AV_CODEC_ID_MSMPEG4V3:
420 if (avctx->rc_max_rate >= 15000000) {
421 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
422 } else if(avctx->rc_max_rate >= 2000000) {
423 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000L) * (320- 80) / (15000000 - 2000000);
424 } else if(avctx->rc_max_rate >= 384000) {
425 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000L) * ( 80- 40) / ( 2000000 - 384000);
427 avctx->rc_buffer_size = 40;
428 avctx->rc_buffer_size *= 16384;
431 if (avctx->rc_buffer_size) {
432 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
436 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
437 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
438 if (avctx->rc_max_rate && !avctx->rc_buffer_size)
442 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
443 av_log(avctx, AV_LOG_INFO,
444 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
447 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
448 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
452 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
453 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
457 if (avctx->rc_max_rate &&
458 avctx->rc_max_rate == avctx->bit_rate &&
459 avctx->rc_max_rate != avctx->rc_min_rate) {
460 av_log(avctx, AV_LOG_INFO,
461 "impossible bitrate constraints, this will fail\n");
464 if (avctx->rc_buffer_size &&
465 avctx->bit_rate * (int64_t)avctx->time_base.num >
466 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
467 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
471 if (!s->fixed_qscale &&
472 avctx->bit_rate * av_q2d(avctx->time_base) >
473 avctx->bit_rate_tolerance) {
474 av_log(avctx, AV_LOG_ERROR,
475 "bitrate tolerance too small for bitrate\n");
479 if (s->avctx->rc_max_rate &&
480 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
481 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
482 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
483 90000LL * (avctx->rc_buffer_size - 1) >
484 s->avctx->rc_max_rate * 0xFFFFLL) {
485 av_log(avctx, AV_LOG_INFO,
486 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
487 "specified vbv buffer is too large for the given bitrate!\n");
490 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
491 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
492 s->codec_id != AV_CODEC_ID_FLV1) {
493 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
497 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
498 av_log(avctx, AV_LOG_ERROR,
499 "OBMC is only supported with simple mb decision\n");
503 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
504 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
508 if (s->max_b_frames &&
509 s->codec_id != AV_CODEC_ID_MPEG4 &&
510 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
511 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
512 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
516 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
517 s->codec_id == AV_CODEC_ID_H263 ||
518 s->codec_id == AV_CODEC_ID_H263P) &&
519 (avctx->sample_aspect_ratio.num > 255 ||
520 avctx->sample_aspect_ratio.den > 255)) {
521 av_log(avctx, AV_LOG_WARNING,
522 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
523 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
524 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
525 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
528 if ((s->codec_id == AV_CODEC_ID_H263 ||
529 s->codec_id == AV_CODEC_ID_H263P) &&
530 (avctx->width > 2048 ||
531 avctx->height > 1152 )) {
532 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
535 if ((s->codec_id == AV_CODEC_ID_H263 ||
536 s->codec_id == AV_CODEC_ID_H263P) &&
537 ((avctx->width &3) ||
538 (avctx->height&3) )) {
539 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
543 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
544 (avctx->width > 4095 ||
545 avctx->height > 4095 )) {
546 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
550 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
551 (avctx->width > 16383 ||
552 avctx->height > 16383 )) {
553 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
557 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
558 s->codec_id == AV_CODEC_ID_WMV2) &&
560 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
564 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
565 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
566 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
570 // FIXME mpeg2 uses that too
571 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
572 av_log(avctx, AV_LOG_ERROR,
573 "mpeg2 style quantization not supported by codec\n");
577 #if FF_API_MPV_GLOBAL_OPTS
578 if (s->flags & CODEC_FLAG_CBP_RD)
579 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
582 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
583 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
587 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
588 s->avctx->mb_decision != FF_MB_DECISION_RD) {
589 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
593 if (s->avctx->scenechange_threshold < 1000000000 &&
594 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
595 av_log(avctx, AV_LOG_ERROR,
596 "closed gop with scene change detection are not supported yet, "
597 "set threshold to 1000000000\n");
601 if (s->flags & CODEC_FLAG_LOW_DELAY) {
602 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
603 av_log(avctx, AV_LOG_ERROR,
604 "low delay forcing is only available for mpeg2\n");
607 if (s->max_b_frames != 0) {
608 av_log(avctx, AV_LOG_ERROR,
609 "b frames cannot be used with low delay\n");
614 if (s->q_scale_type == 1) {
615 if (avctx->qmax > 12) {
616 av_log(avctx, AV_LOG_ERROR,
617 "non linear quant only supports qmax <= 12 currently\n");
622 if (s->avctx->thread_count > 1 &&
623 s->codec_id != AV_CODEC_ID_MPEG4 &&
624 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
625 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
626 s->codec_id != AV_CODEC_ID_MJPEG &&
627 (s->codec_id != AV_CODEC_ID_H263P)) {
628 av_log(avctx, AV_LOG_ERROR,
629 "multi threaded encoding not supported by codec\n");
633 if (s->avctx->thread_count < 1) {
634 av_log(avctx, AV_LOG_ERROR,
635 "automatic thread number detection not supported by codec, "
640 if (s->avctx->thread_count > 1)
643 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
644 s->h263_slice_structured = 1;
646 if (!avctx->time_base.den || !avctx->time_base.num) {
647 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
651 i = (INT_MAX / 2 + 128) >> 8;
652 if (avctx->me_threshold >= i) {
653 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
657 if (avctx->mb_threshold >= i) {
658 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
663 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
664 av_log(avctx, AV_LOG_INFO,
665 "notice: b_frame_strategy only affects the first pass\n");
666 avctx->b_frame_strategy = 0;
669 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
671 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
672 avctx->time_base.den /= i;
673 avctx->time_base.num /= i;
677 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) {
678 // (a + x * 3 / 8) / x
679 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
680 s->inter_quant_bias = 0;
682 s->intra_quant_bias = 0;
684 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
687 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
688 s->intra_quant_bias = avctx->intra_quant_bias;
689 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
690 s->inter_quant_bias = avctx->inter_quant_bias;
692 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
694 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
696 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
697 s->avctx->time_base.den > (1 << 16) - 1) {
698 av_log(avctx, AV_LOG_ERROR,
699 "timebase %d/%d not supported by MPEG 4 standard, "
700 "the maximum admitted value for the timebase denominator "
701 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
705 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
707 #if FF_API_MPV_GLOBAL_OPTS
708 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
709 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
710 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
711 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
712 if (avctx->quantizer_noise_shaping)
713 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
716 switch (avctx->codec->id) {
717 case AV_CODEC_ID_MPEG1VIDEO:
718 s->out_format = FMT_MPEG1;
719 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
720 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
722 case AV_CODEC_ID_MPEG2VIDEO:
723 s->out_format = FMT_MPEG1;
724 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
725 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
728 case AV_CODEC_ID_LJPEG:
729 case AV_CODEC_ID_MJPEG:
730 case AV_CODEC_ID_AMV:
731 s->out_format = FMT_MJPEG;
732 s->intra_only = 1; /* force intra only for jpeg */
733 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
734 (avctx->pix_fmt == AV_PIX_FMT_BGR0
735 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
736 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
737 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
738 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
739 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
741 s->mjpeg_vsample[0] = 2;
742 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
743 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
744 s->mjpeg_hsample[0] = 2;
745 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
746 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
748 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
749 ff_mjpeg_encode_init(s) < 0)
754 case AV_CODEC_ID_H261:
755 if (!CONFIG_H261_ENCODER)
757 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
758 av_log(avctx, AV_LOG_ERROR,
759 "The specified picture size of %dx%d is not valid for the "
760 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
761 s->width, s->height);
764 s->out_format = FMT_H261;
768 case AV_CODEC_ID_H263:
769 if (!CONFIG_H263_ENCODER)
771 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
772 s->width, s->height) == 8) {
773 av_log(avctx, AV_LOG_ERROR,
774 "The specified picture size of %dx%d is not valid for "
775 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
776 "352x288, 704x576, and 1408x1152. "
777 "Try H.263+.\n", s->width, s->height);
780 s->out_format = FMT_H263;
784 case AV_CODEC_ID_H263P:
785 s->out_format = FMT_H263;
788 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
789 s->modified_quant = s->h263_aic;
790 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
791 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
794 /* These are just to be sure */
798 case AV_CODEC_ID_FLV1:
799 s->out_format = FMT_H263;
800 s->h263_flv = 2; /* format = 1; 11-bit codes */
801 s->unrestricted_mv = 1;
802 s->rtp_mode = 0; /* don't allow GOB */
806 case AV_CODEC_ID_RV10:
807 s->out_format = FMT_H263;
811 case AV_CODEC_ID_RV20:
812 s->out_format = FMT_H263;
815 s->modified_quant = 1;
819 s->unrestricted_mv = 0;
821 case AV_CODEC_ID_MPEG4:
822 s->out_format = FMT_H263;
824 s->unrestricted_mv = 1;
825 s->low_delay = s->max_b_frames ? 0 : 1;
826 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
828 case AV_CODEC_ID_MSMPEG4V2:
829 s->out_format = FMT_H263;
831 s->unrestricted_mv = 1;
832 s->msmpeg4_version = 2;
836 case AV_CODEC_ID_MSMPEG4V3:
837 s->out_format = FMT_H263;
839 s->unrestricted_mv = 1;
840 s->msmpeg4_version = 3;
841 s->flipflop_rounding = 1;
845 case AV_CODEC_ID_WMV1:
846 s->out_format = FMT_H263;
848 s->unrestricted_mv = 1;
849 s->msmpeg4_version = 4;
850 s->flipflop_rounding = 1;
854 case AV_CODEC_ID_WMV2:
855 s->out_format = FMT_H263;
857 s->unrestricted_mv = 1;
858 s->msmpeg4_version = 5;
859 s->flipflop_rounding = 1;
867 avctx->has_b_frames = !s->low_delay;
871 s->progressive_frame =
872 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
873 CODEC_FLAG_INTERLACED_ME) ||
877 if (ff_MPV_common_init(s) < 0)
880 ff_dct_encode_init(s);
882 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
883 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
885 s->quant_precision = 5;
887 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
888 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
890 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
891 ff_h261_encode_init(s);
892 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
893 ff_h263_encode_init(s);
894 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
895 ff_msmpeg4_encode_init(s);
896 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
897 && s->out_format == FMT_MPEG1)
898 ff_mpeg1_encode_init(s);
901 for (i = 0; i < 64; i++) {
902 int j = s->dsp.idct_permutation[i];
903 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
905 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
906 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
907 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
909 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
912 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
913 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
915 if (s->avctx->intra_matrix)
916 s->intra_matrix[j] = s->avctx->intra_matrix[i];
917 if (s->avctx->inter_matrix)
918 s->inter_matrix[j] = s->avctx->inter_matrix[i];
921 /* precompute matrix */
922 /* for mjpeg, we do include qscale in the matrix */
923 if (s->out_format != FMT_MJPEG) {
924 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
925 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
927 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
928 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
932 if (ff_rate_control_init(s) < 0)
938 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
940 MpegEncContext *s = avctx->priv_data;
942 ff_rate_control_uninit(s);
944 ff_MPV_common_end(s);
945 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
946 s->out_format == FMT_MJPEG)
947 ff_mjpeg_encode_close(s);
949 av_freep(&avctx->extradata);
954 static int get_sae(uint8_t *src, int ref, int stride)
959 for (y = 0; y < 16; y++) {
960 for (x = 0; x < 16; x++) {
961 acc += FFABS(src[x + y * stride] - ref);
968 static int get_intra_count(MpegEncContext *s, uint8_t *src,
969 uint8_t *ref, int stride)
977 for (y = 0; y < h; y += 16) {
978 for (x = 0; x < w; x += 16) {
979 int offset = x + y * stride;
980 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
982 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
983 int sae = get_sae(src + offset, mean, stride);
985 acc += sae + 500 < sad;
992 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
997 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
998 (s->low_delay ? 0 : 1);
1003 pic_arg->display_picture_number = s->input_picture_number++;
1005 if (pts != AV_NOPTS_VALUE) {
1006 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1008 int64_t last = s->user_specified_pts;
1011 av_log(s->avctx, AV_LOG_ERROR,
1012 "Error, Invalid timestamp=%"PRId64", "
1013 "last=%"PRId64"\n", pts, s->user_specified_pts);
1017 if (!s->low_delay && pic_arg->display_picture_number == 1)
1018 s->dts_delta = time - last;
1020 s->user_specified_pts = pts;
1022 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1023 s->user_specified_pts =
1024 pts = s->user_specified_pts + 1;
1025 av_log(s->avctx, AV_LOG_INFO,
1026 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1029 pts = pic_arg->display_picture_number;
1035 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
1037 if (pic_arg->linesize[0] != s->linesize)
1039 if (pic_arg->linesize[1] != s->uvlinesize)
1041 if (pic_arg->linesize[2] != s->uvlinesize)
1044 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
1045 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1048 i = ff_find_unused_picture(s, 1);
1052 pic = &s->picture[i].f;
1055 for (i = 0; i < 4; i++) {
1056 pic->data[i] = pic_arg->data[i];
1057 pic->linesize[i] = pic_arg->linesize[i];
1059 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1063 i = ff_find_unused_picture(s, 0);
1067 pic = &s->picture[i].f;
1070 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1074 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1075 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1076 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1079 int h_chroma_shift, v_chroma_shift;
1080 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1082 for (i = 0; i < 3; i++) {
1083 int src_stride = pic_arg->linesize[i];
1084 int dst_stride = i ? s->uvlinesize : s->linesize;
1085 int h_shift = i ? h_chroma_shift : 0;
1086 int v_shift = i ? v_chroma_shift : 0;
1087 int w = s->width >> h_shift;
1088 int h = s->height >> v_shift;
1089 uint8_t *src = pic_arg->data[i];
1090 uint8_t *dst = pic->data[i];
1092 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1093 h= ((s->height+15)/16*16)>>v_shift;
1096 if (!s->avctx->rc_buffer_size)
1097 dst += INPLACE_OFFSET;
1099 if (src_stride == dst_stride)
1100 memcpy(dst, src, src_stride * h);
1103 memcpy(dst, src, w);
1111 copy_picture_attributes(s, pic, pic_arg);
1112 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1115 /* shift buffer entries */
1116 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1117 s->input_picture[i - 1] = s->input_picture[i];
1119 s->input_picture[encoding_delay] = (Picture*) pic;
1124 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1128 int64_t score64 = 0;
1130 for (plane = 0; plane < 3; plane++) {
1131 const int stride = p->f.linesize[plane];
1132 const int bw = plane ? 1 : 2;
1133 for (y = 0; y < s->mb_height * bw; y++) {
1134 for (x = 0; x < s->mb_width * bw; x++) {
1135 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1136 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1137 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1138 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1140 switch (s->avctx->frame_skip_exp) {
1141 case 0: score = FFMAX(score, v); break;
1142 case 1: score += FFABS(v); break;
1143 case 2: score += v * v; break;
1144 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1145 case 4: score64 += v * v * (int64_t)(v * v); break;
1154 if (score64 < s->avctx->frame_skip_threshold)
1156 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1161 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1163 AVPacket pkt = { 0 };
1164 int ret, got_output;
1166 av_init_packet(&pkt);
1167 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1172 av_free_packet(&pkt);
1176 static int estimate_best_b_count(MpegEncContext *s)
1178 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1179 AVCodecContext *c = avcodec_alloc_context3(NULL);
1180 AVFrame input[FF_MAX_B_FRAMES + 2];
1181 const int scale = s->avctx->brd_scale;
1182 int i, j, out_size, p_lambda, b_lambda, lambda2;
1183 int64_t best_rd = INT64_MAX;
1184 int best_b_count = -1;
1186 av_assert0(scale >= 0 && scale <= 3);
1189 //s->next_picture_ptr->quality;
1190 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1191 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1192 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1193 if (!b_lambda) // FIXME we should do this somewhere else
1194 b_lambda = p_lambda;
1195 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1198 c->width = s->width >> scale;
1199 c->height = s->height >> scale;
1200 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1201 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1202 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1203 c->mb_decision = s->avctx->mb_decision;
1204 c->me_cmp = s->avctx->me_cmp;
1205 c->mb_cmp = s->avctx->mb_cmp;
1206 c->me_sub_cmp = s->avctx->me_sub_cmp;
1207 c->pix_fmt = AV_PIX_FMT_YUV420P;
1208 c->time_base = s->avctx->time_base;
1209 c->max_b_frames = s->max_b_frames;
1211 if (avcodec_open2(c, codec, NULL) < 0)
1214 for (i = 0; i < s->max_b_frames + 2; i++) {
1215 int ysize = c->width * c->height;
1216 int csize = (c->width / 2) * (c->height / 2);
1217 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1218 s->next_picture_ptr;
1220 avcodec_get_frame_defaults(&input[i]);
1221 input[i].data[0] = av_malloc(ysize + 2 * csize);
1222 input[i].data[1] = input[i].data[0] + ysize;
1223 input[i].data[2] = input[i].data[1] + csize;
1224 input[i].linesize[0] = c->width;
1225 input[i].linesize[1] =
1226 input[i].linesize[2] = c->width / 2;
1228 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1229 pre_input = *pre_input_ptr;
1231 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1232 pre_input.f.data[0] += INPLACE_OFFSET;
1233 pre_input.f.data[1] += INPLACE_OFFSET;
1234 pre_input.f.data[2] += INPLACE_OFFSET;
1237 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1238 pre_input.f.data[0], pre_input.f.linesize[0],
1239 c->width, c->height);
1240 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1241 pre_input.f.data[1], pre_input.f.linesize[1],
1242 c->width >> 1, c->height >> 1);
1243 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1244 pre_input.f.data[2], pre_input.f.linesize[2],
1245 c->width >> 1, c->height >> 1);
1249 for (j = 0; j < s->max_b_frames + 1; j++) {
1252 if (!s->input_picture[j])
1255 c->error[0] = c->error[1] = c->error[2] = 0;
1257 input[0].pict_type = AV_PICTURE_TYPE_I;
1258 input[0].quality = 1 * FF_QP2LAMBDA;
1260 out_size = encode_frame(c, &input[0]);
1262 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1264 for (i = 0; i < s->max_b_frames + 1; i++) {
1265 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1267 input[i + 1].pict_type = is_p ?
1268 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1269 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1271 out_size = encode_frame(c, &input[i + 1]);
1273 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1276 /* get the delayed frames */
1278 out_size = encode_frame(c, NULL);
1279 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1282 rd += c->error[0] + c->error[1] + c->error[2];
1293 for (i = 0; i < s->max_b_frames + 2; i++) {
1294 av_freep(&input[i].data[0]);
1297 return best_b_count;
1300 static int select_input_picture(MpegEncContext *s)
1304 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1305 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1306 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1308 /* set next picture type & ordering */
1309 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1310 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1311 s->next_picture_ptr == NULL || s->intra_only) {
1312 s->reordered_input_picture[0] = s->input_picture[0];
1313 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1314 s->reordered_input_picture[0]->f.coded_picture_number =
1315 s->coded_picture_number++;
1319 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1320 if (s->picture_in_gop_number < s->gop_size &&
1321 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1322 // FIXME check that te gop check above is +-1 correct
1323 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1324 for (i = 0; i < 4; i++)
1325 s->input_picture[0]->f.data[i] = NULL;
1326 s->input_picture[0]->f.type = 0;
1328 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1329 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1331 s->avctx->release_buffer(s->avctx,
1332 &s->input_picture[0]->f);
1336 ff_vbv_update(s, 0);
1342 if (s->flags & CODEC_FLAG_PASS2) {
1343 for (i = 0; i < s->max_b_frames + 1; i++) {
1344 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1346 if (pict_num >= s->rc_context.num_entries)
1348 if (!s->input_picture[i]) {
1349 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1353 s->input_picture[i]->f.pict_type =
1354 s->rc_context.entry[pict_num].new_pict_type;
1358 if (s->avctx->b_frame_strategy == 0) {
1359 b_frames = s->max_b_frames;
1360 while (b_frames && !s->input_picture[b_frames])
1362 } else if (s->avctx->b_frame_strategy == 1) {
1363 for (i = 1; i < s->max_b_frames + 1; i++) {
1364 if (s->input_picture[i] &&
1365 s->input_picture[i]->b_frame_score == 0) {
1366 s->input_picture[i]->b_frame_score =
1368 s->input_picture[i ]->f.data[0],
1369 s->input_picture[i - 1]->f.data[0],
1373 for (i = 0; i < s->max_b_frames + 1; i++) {
1374 if (s->input_picture[i] == NULL ||
1375 s->input_picture[i]->b_frame_score - 1 >
1376 s->mb_num / s->avctx->b_sensitivity)
1380 b_frames = FFMAX(0, i - 1);
1383 for (i = 0; i < b_frames + 1; i++) {
1384 s->input_picture[i]->b_frame_score = 0;
1386 } else if (s->avctx->b_frame_strategy == 2) {
1387 b_frames = estimate_best_b_count(s);
1389 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1395 for (i = b_frames - 1; i >= 0; i--) {
1396 int type = s->input_picture[i]->f.pict_type;
1397 if (type && type != AV_PICTURE_TYPE_B)
1400 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1401 b_frames == s->max_b_frames) {
1402 av_log(s->avctx, AV_LOG_ERROR,
1403 "warning, too many b frames in a row\n");
1406 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1407 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1408 s->gop_size > s->picture_in_gop_number) {
1409 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1411 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1413 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1417 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1418 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1421 s->reordered_input_picture[0] = s->input_picture[b_frames];
1422 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1423 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1424 s->reordered_input_picture[0]->f.coded_picture_number =
1425 s->coded_picture_number++;
1426 for (i = 0; i < b_frames; i++) {
1427 s->reordered_input_picture[i + 1] = s->input_picture[i];
1428 s->reordered_input_picture[i + 1]->f.pict_type =
1430 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1431 s->coded_picture_number++;
1436 if (s->reordered_input_picture[0]) {
1437 s->reordered_input_picture[0]->f.reference =
1438 s->reordered_input_picture[0]->f.pict_type !=
1439 AV_PICTURE_TYPE_B ? 3 : 0;
1441 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1443 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1444 s->avctx->rc_buffer_size) {
1445 // input is a shared pix, so we can't modifiy it -> alloc a new
1446 // one & ensure that the shared one is reuseable
1449 int i = ff_find_unused_picture(s, 0);
1452 pic = &s->picture[i];
1454 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1455 if (ff_alloc_picture(s, pic, 0) < 0) {
1459 /* mark us unused / free shared pic */
1460 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1461 s->avctx->release_buffer(s->avctx,
1462 &s->reordered_input_picture[0]->f);
1463 for (i = 0; i < 4; i++)
1464 s->reordered_input_picture[0]->f.data[i] = NULL;
1465 s->reordered_input_picture[0]->f.type = 0;
1467 copy_picture_attributes(s, &pic->f,
1468 &s->reordered_input_picture[0]->f);
1470 s->current_picture_ptr = pic;
1472 // input is not a shared pix -> reuse buffer for current_pix
1474 assert(s->reordered_input_picture[0]->f.type ==
1475 FF_BUFFER_TYPE_USER ||
1476 s->reordered_input_picture[0]->f.type ==
1477 FF_BUFFER_TYPE_INTERNAL);
1479 s->current_picture_ptr = s->reordered_input_picture[0];
1480 for (i = 0; i < 4; i++) {
1481 s->new_picture.f.data[i] += INPLACE_OFFSET;
1484 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1486 s->picture_number = s->new_picture.f.display_picture_number;
1488 memset(&s->new_picture, 0, sizeof(Picture));
1493 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1494 AVFrame *pic_arg, int *got_packet)
1496 MpegEncContext *s = avctx->priv_data;
1497 int i, stuffing_count, ret;
1498 int context_count = s->slice_context_count;
1500 s->picture_in_gop_number++;
1502 if (load_input_picture(s, pic_arg) < 0)
1505 if (select_input_picture(s) < 0) {
1510 if (s->new_picture.f.data[0]) {
1511 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1514 s->mb_info_ptr = av_packet_new_side_data(pkt,
1515 AV_PKT_DATA_H263_MB_INFO,
1516 s->mb_width*s->mb_height*12);
1517 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1520 for (i = 0; i < context_count; i++) {
1521 int start_y = s->thread_context[i]->start_mb_y;
1522 int end_y = s->thread_context[i]-> end_mb_y;
1523 int h = s->mb_height;
1524 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1525 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1527 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1530 s->pict_type = s->new_picture.f.pict_type;
1532 if (ff_MPV_frame_start(s, avctx) < 0)
1535 if (encode_picture(s, s->picture_number) < 0)
1538 avctx->header_bits = s->header_bits;
1539 avctx->mv_bits = s->mv_bits;
1540 avctx->misc_bits = s->misc_bits;
1541 avctx->i_tex_bits = s->i_tex_bits;
1542 avctx->p_tex_bits = s->p_tex_bits;
1543 avctx->i_count = s->i_count;
1544 // FIXME f/b_count in avctx
1545 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1546 avctx->skip_count = s->skip_count;
1548 ff_MPV_frame_end(s);
1550 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1551 ff_mjpeg_encode_picture_trailer(s);
1553 if (avctx->rc_buffer_size) {
1554 RateControlContext *rcc = &s->rc_context;
1555 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1557 if (put_bits_count(&s->pb) > max_size &&
1558 s->lambda < s->avctx->lmax) {
1559 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1560 (s->qscale + 1) / s->qscale);
1561 if (s->adaptive_quant) {
1563 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1564 s->lambda_table[i] =
1565 FFMAX(s->lambda_table[i] + 1,
1566 s->lambda_table[i] * (s->qscale + 1) /
1569 s->mb_skipped = 0; // done in MPV_frame_start()
1570 // done in encode_picture() so we must undo it
1571 if (s->pict_type == AV_PICTURE_TYPE_P) {
1572 if (s->flipflop_rounding ||
1573 s->codec_id == AV_CODEC_ID_H263P ||
1574 s->codec_id == AV_CODEC_ID_MPEG4)
1575 s->no_rounding ^= 1;
1577 if (s->pict_type != AV_PICTURE_TYPE_B) {
1578 s->time_base = s->last_time_base;
1579 s->last_non_b_time = s->time - s->pp_time;
1581 for (i = 0; i < context_count; i++) {
1582 PutBitContext *pb = &s->thread_context[i]->pb;
1583 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1588 assert(s->avctx->rc_max_rate);
1591 if (s->flags & CODEC_FLAG_PASS1)
1592 ff_write_pass1_stats(s);
1594 for (i = 0; i < 4; i++) {
1595 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1596 avctx->error[i] += s->current_picture_ptr->f.error[i];
1599 if (s->flags & CODEC_FLAG_PASS1)
1600 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1601 avctx->i_tex_bits + avctx->p_tex_bits ==
1602 put_bits_count(&s->pb));
1603 flush_put_bits(&s->pb);
1604 s->frame_bits = put_bits_count(&s->pb);
1606 stuffing_count = ff_vbv_update(s, s->frame_bits);
1607 s->stuffing_bits = 8*stuffing_count;
1608 if (stuffing_count) {
1609 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1610 stuffing_count + 50) {
1611 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1615 switch (s->codec_id) {
1616 case AV_CODEC_ID_MPEG1VIDEO:
1617 case AV_CODEC_ID_MPEG2VIDEO:
1618 while (stuffing_count--) {
1619 put_bits(&s->pb, 8, 0);
1622 case AV_CODEC_ID_MPEG4:
1623 put_bits(&s->pb, 16, 0);
1624 put_bits(&s->pb, 16, 0x1C3);
1625 stuffing_count -= 4;
1626 while (stuffing_count--) {
1627 put_bits(&s->pb, 8, 0xFF);
1631 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1633 flush_put_bits(&s->pb);
1634 s->frame_bits = put_bits_count(&s->pb);
1637 /* update mpeg1/2 vbv_delay for CBR */
1638 if (s->avctx->rc_max_rate &&
1639 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1640 s->out_format == FMT_MPEG1 &&
1641 90000LL * (avctx->rc_buffer_size - 1) <=
1642 s->avctx->rc_max_rate * 0xFFFFLL) {
1643 int vbv_delay, min_delay;
1644 double inbits = s->avctx->rc_max_rate *
1645 av_q2d(s->avctx->time_base);
1646 int minbits = s->frame_bits - 8 *
1647 (s->vbv_delay_ptr - s->pb.buf - 1);
1648 double bits = s->rc_context.buffer_index + minbits - inbits;
1651 av_log(s->avctx, AV_LOG_ERROR,
1652 "Internal error, negative bits\n");
1654 assert(s->repeat_first_field == 0);
1656 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1657 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1658 s->avctx->rc_max_rate;
1660 vbv_delay = FFMAX(vbv_delay, min_delay);
1662 av_assert0(vbv_delay < 0xFFFF);
1664 s->vbv_delay_ptr[0] &= 0xF8;
1665 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1666 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1667 s->vbv_delay_ptr[2] &= 0x07;
1668 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1669 avctx->vbv_delay = vbv_delay * 300;
1671 s->total_bits += s->frame_bits;
1672 avctx->frame_bits = s->frame_bits;
1674 pkt->pts = s->current_picture.f.pts;
1675 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1676 if (!s->current_picture.f.coded_picture_number)
1677 pkt->dts = pkt->pts - s->dts_delta;
1679 pkt->dts = s->reordered_pts;
1680 s->reordered_pts = pkt->pts;
1682 pkt->dts = pkt->pts;
1683 if (s->current_picture.f.key_frame)
1684 pkt->flags |= AV_PKT_FLAG_KEY;
1686 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1690 assert((s->frame_bits & 7) == 0);
1692 pkt->size = s->frame_bits / 8;
1693 *got_packet = !!pkt->size;
1697 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1698 int n, int threshold)
1700 static const char tab[64] = {
1701 3, 2, 2, 1, 1, 1, 1, 1,
1702 1, 1, 1, 1, 1, 1, 1, 1,
1703 1, 1, 1, 1, 1, 1, 1, 1,
1704 0, 0, 0, 0, 0, 0, 0, 0,
1705 0, 0, 0, 0, 0, 0, 0, 0,
1706 0, 0, 0, 0, 0, 0, 0, 0,
1707 0, 0, 0, 0, 0, 0, 0, 0,
1708 0, 0, 0, 0, 0, 0, 0, 0
1713 DCTELEM *block = s->block[n];
1714 const int last_index = s->block_last_index[n];
1717 if (threshold < 0) {
1719 threshold = -threshold;
1723 /* Are all we could set to zero already zero? */
1724 if (last_index <= skip_dc - 1)
1727 for (i = 0; i <= last_index; i++) {
1728 const int j = s->intra_scantable.permutated[i];
1729 const int level = FFABS(block[j]);
1731 if (skip_dc && i == 0)
1735 } else if (level > 1) {
1741 if (score >= threshold)
1743 for (i = skip_dc; i <= last_index; i++) {
1744 const int j = s->intra_scantable.permutated[i];
1748 s->block_last_index[n] = 0;
1750 s->block_last_index[n] = -1;
1753 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1757 const int maxlevel = s->max_qcoeff;
1758 const int minlevel = s->min_qcoeff;
1762 i = 1; // skip clipping of intra dc
1766 for (; i <= last_index; i++) {
1767 const int j = s->intra_scantable.permutated[i];
1768 int level = block[j];
1770 if (level > maxlevel) {
1773 } else if (level < minlevel) {
1781 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1782 av_log(s->avctx, AV_LOG_INFO,
1783 "warning, clipping %d dct coefficients to %d..%d\n",
1784 overflow, minlevel, maxlevel);
1787 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1791 for (y = 0; y < 8; y++) {
1792 for (x = 0; x < 8; x++) {
1798 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1799 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1800 int v = ptr[x2 + y2 * stride];
1806 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1811 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1812 int motion_x, int motion_y,
1813 int mb_block_height,
1817 int16_t weight[12][64];
1818 DCTELEM orig[12][64];
1819 const int mb_x = s->mb_x;
1820 const int mb_y = s->mb_y;
1823 int dct_offset = s->linesize * 8; // default for progressive frames
1824 int uv_dct_offset = s->uvlinesize * 8;
1825 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1828 for (i = 0; i < mb_block_count; i++)
1829 skip_dct[i] = s->skipdct;
1831 if (s->adaptive_quant) {
1832 const int last_qp = s->qscale;
1833 const int mb_xy = mb_x + mb_y * s->mb_stride;
1835 s->lambda = s->lambda_table[mb_xy];
1838 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1839 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1840 s->dquant = s->qscale - last_qp;
1842 if (s->out_format == FMT_H263) {
1843 s->dquant = av_clip(s->dquant, -2, 2);
1845 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1847 if (s->pict_type == AV_PICTURE_TYPE_B) {
1848 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1851 if (s->mv_type == MV_TYPE_8X8)
1857 ff_set_qscale(s, last_qp + s->dquant);
1858 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1859 ff_set_qscale(s, s->qscale + s->dquant);
1861 wrap_y = s->linesize;
1862 wrap_c = s->uvlinesize;
1863 ptr_y = s->new_picture.f.data[0] +
1864 (mb_y * 16 * wrap_y) + mb_x * 16;
1865 ptr_cb = s->new_picture.f.data[1] +
1866 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1867 ptr_cr = s->new_picture.f.data[2] +
1868 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1870 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1871 uint8_t *ebuf = s->edge_emu_buffer + 32;
1872 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1873 mb_y * 16, s->width, s->height);
1875 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, mb_block_width,
1876 mb_block_height, mb_x * 8, mb_y * 8,
1877 (s->width+1) >> 1, (s->height+1) >> 1);
1878 ptr_cb = ebuf + 18 * wrap_y;
1879 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, mb_block_width,
1880 mb_block_height, mb_x * 8, mb_y * 8,
1881 (s->width+1) >> 1, (s->height+1) >> 1);
1882 ptr_cr = ebuf + 18 * wrap_y + 8;
1886 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1887 int progressive_score, interlaced_score;
1889 s->interlaced_dct = 0;
1890 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1892 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1893 NULL, wrap_y, 8) - 400;
1895 if (progressive_score > 0) {
1896 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1897 NULL, wrap_y * 2, 8) +
1898 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1899 NULL, wrap_y * 2, 8);
1900 if (progressive_score > interlaced_score) {
1901 s->interlaced_dct = 1;
1903 dct_offset = wrap_y;
1904 uv_dct_offset = wrap_c;
1906 if (s->chroma_format == CHROMA_422 ||
1907 s->chroma_format == CHROMA_444)
1913 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1914 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1915 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1916 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1918 if (s->flags & CODEC_FLAG_GRAY) {
1922 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1923 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1924 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1925 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1926 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1927 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1928 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1929 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1930 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1931 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1932 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1933 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1937 op_pixels_func (*op_pix)[4];
1938 qpel_mc_func (*op_qpix)[16];
1939 uint8_t *dest_y, *dest_cb, *dest_cr;
1941 dest_y = s->dest[0];
1942 dest_cb = s->dest[1];
1943 dest_cr = s->dest[2];
1945 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1946 op_pix = s->dsp.put_pixels_tab;
1947 op_qpix = s->dsp.put_qpel_pixels_tab;
1949 op_pix = s->dsp.put_no_rnd_pixels_tab;
1950 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1953 if (s->mv_dir & MV_DIR_FORWARD) {
1954 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1955 s->last_picture.f.data,
1957 op_pix = s->dsp.avg_pixels_tab;
1958 op_qpix = s->dsp.avg_qpel_pixels_tab;
1960 if (s->mv_dir & MV_DIR_BACKWARD) {
1961 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1962 s->next_picture.f.data,
1966 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1967 int progressive_score, interlaced_score;
1969 s->interlaced_dct = 0;
1970 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1973 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1974 ptr_y + wrap_y * 8, wrap_y,
1977 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1978 progressive_score -= 400;
1980 if (progressive_score > 0) {
1981 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1984 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1988 if (progressive_score > interlaced_score) {
1989 s->interlaced_dct = 1;
1991 dct_offset = wrap_y;
1992 uv_dct_offset = wrap_c;
1994 if (s->chroma_format == CHROMA_422)
2000 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2001 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2002 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2003 dest_y + dct_offset, wrap_y);
2004 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2005 dest_y + dct_offset + 8, wrap_y);
2007 if (s->flags & CODEC_FLAG_GRAY) {
2011 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2012 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2013 if (!s->chroma_y_shift) { /* 422 */
2014 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2015 dest_cb + uv_dct_offset, wrap_c);
2016 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2017 dest_cr + uv_dct_offset, wrap_c);
2020 /* pre quantization */
2021 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2022 2 * s->qscale * s->qscale) {
2024 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
2025 wrap_y, 8) < 20 * s->qscale)
2027 if (s->dsp.sad[1](NULL, ptr_y + 8,
2028 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2030 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
2031 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
2033 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
2034 dest_y + dct_offset + 8,
2035 wrap_y, 8) < 20 * s->qscale)
2037 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2038 wrap_c, 8) < 20 * s->qscale)
2040 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2041 wrap_c, 8) < 20 * s->qscale)
2043 if (!s->chroma_y_shift) { /* 422 */
2044 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
2045 dest_cb + uv_dct_offset,
2046 wrap_c, 8) < 20 * s->qscale)
2048 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
2049 dest_cr + uv_dct_offset,
2050 wrap_c, 8) < 20 * s->qscale)
2056 if (s->quantizer_noise_shaping) {
2058 get_visual_weight(weight[0], ptr_y , wrap_y);
2060 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2062 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2064 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2066 get_visual_weight(weight[4], ptr_cb , wrap_c);
2068 get_visual_weight(weight[5], ptr_cr , wrap_c);
2069 if (!s->chroma_y_shift) { /* 422 */
2071 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2074 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2077 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2080 /* DCT & quantize */
2081 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2083 for (i = 0; i < mb_block_count; i++) {
2086 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2087 // FIXME we could decide to change to quantizer instead of
2089 // JS: I don't think that would be a good idea it could lower
2090 // quality instead of improve it. Just INTRADC clipping
2091 // deserves changes in quantizer
2093 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2095 s->block_last_index[i] = -1;
2097 if (s->quantizer_noise_shaping) {
2098 for (i = 0; i < mb_block_count; i++) {
2100 s->block_last_index[i] =
2101 dct_quantize_refine(s, s->block[i], weight[i],
2102 orig[i], i, s->qscale);
2107 if (s->luma_elim_threshold && !s->mb_intra)
2108 for (i = 0; i < 4; i++)
2109 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2110 if (s->chroma_elim_threshold && !s->mb_intra)
2111 for (i = 4; i < mb_block_count; i++)
2112 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2114 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2115 for (i = 0; i < mb_block_count; i++) {
2116 if (s->block_last_index[i] == -1)
2117 s->coded_score[i] = INT_MAX / 256;
2122 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2123 s->block_last_index[4] =
2124 s->block_last_index[5] = 0;
2126 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2129 // non c quantize code returns incorrect block_last_index FIXME
2130 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2131 for (i = 0; i < mb_block_count; i++) {
2133 if (s->block_last_index[i] > 0) {
2134 for (j = 63; j > 0; j--) {
2135 if (s->block[i][s->intra_scantable.permutated[j]])
2138 s->block_last_index[i] = j;
2143 /* huffman encode */
2144 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2145 case AV_CODEC_ID_MPEG1VIDEO:
2146 case AV_CODEC_ID_MPEG2VIDEO:
2147 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2148 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2150 case AV_CODEC_ID_MPEG4:
2151 if (CONFIG_MPEG4_ENCODER)
2152 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2154 case AV_CODEC_ID_MSMPEG4V2:
2155 case AV_CODEC_ID_MSMPEG4V3:
2156 case AV_CODEC_ID_WMV1:
2157 if (CONFIG_MSMPEG4_ENCODER)
2158 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2160 case AV_CODEC_ID_WMV2:
2161 if (CONFIG_WMV2_ENCODER)
2162 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2164 case AV_CODEC_ID_H261:
2165 if (CONFIG_H261_ENCODER)
2166 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2168 case AV_CODEC_ID_H263:
2169 case AV_CODEC_ID_H263P:
2170 case AV_CODEC_ID_FLV1:
2171 case AV_CODEC_ID_RV10:
2172 case AV_CODEC_ID_RV20:
2173 if (CONFIG_H263_ENCODER)
2174 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2176 case AV_CODEC_ID_MJPEG:
2177 case AV_CODEC_ID_AMV:
2178 if (CONFIG_MJPEG_ENCODER)
2179 ff_mjpeg_encode_mb(s, s->block);
2186 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2188 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2189 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2190 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2193 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2196 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2199 d->mb_skip_run= s->mb_skip_run;
2201 d->last_dc[i] = s->last_dc[i];
2204 d->mv_bits= s->mv_bits;
2205 d->i_tex_bits= s->i_tex_bits;
2206 d->p_tex_bits= s->p_tex_bits;
2207 d->i_count= s->i_count;
2208 d->f_count= s->f_count;
2209 d->b_count= s->b_count;
2210 d->skip_count= s->skip_count;
2211 d->misc_bits= s->misc_bits;
2215 d->qscale= s->qscale;
2216 d->dquant= s->dquant;
2218 d->esc3_level_length= s->esc3_level_length;
2221 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2224 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2225 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2228 d->mb_skip_run= s->mb_skip_run;
2230 d->last_dc[i] = s->last_dc[i];
2233 d->mv_bits= s->mv_bits;
2234 d->i_tex_bits= s->i_tex_bits;
2235 d->p_tex_bits= s->p_tex_bits;
2236 d->i_count= s->i_count;
2237 d->f_count= s->f_count;
2238 d->b_count= s->b_count;
2239 d->skip_count= s->skip_count;
2240 d->misc_bits= s->misc_bits;
2242 d->mb_intra= s->mb_intra;
2243 d->mb_skipped= s->mb_skipped;
2244 d->mv_type= s->mv_type;
2245 d->mv_dir= s->mv_dir;
2247 if(s->data_partitioning){
2249 d->tex_pb= s->tex_pb;
2253 d->block_last_index[i]= s->block_last_index[i];
2254 d->interlaced_dct= s->interlaced_dct;
2255 d->qscale= s->qscale;
2257 d->esc3_level_length= s->esc3_level_length;
2260 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2261 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2262 int *dmin, int *next_block, int motion_x, int motion_y)
2265 uint8_t *dest_backup[3];
2267 copy_context_before_encode(s, backup, type);
2269 s->block= s->blocks[*next_block];
2270 s->pb= pb[*next_block];
2271 if(s->data_partitioning){
2272 s->pb2 = pb2 [*next_block];
2273 s->tex_pb= tex_pb[*next_block];
2277 memcpy(dest_backup, s->dest, sizeof(s->dest));
2278 s->dest[0] = s->rd_scratchpad;
2279 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2280 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2281 assert(s->linesize >= 32); //FIXME
2284 encode_mb(s, motion_x, motion_y);
2286 score= put_bits_count(&s->pb);
2287 if(s->data_partitioning){
2288 score+= put_bits_count(&s->pb2);
2289 score+= put_bits_count(&s->tex_pb);
2292 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2293 ff_MPV_decode_mb(s, s->block);
2295 score *= s->lambda2;
2296 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2300 memcpy(s->dest, dest_backup, sizeof(s->dest));
2307 copy_context_after_encode(best, s, type);
2311 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2312 uint32_t *sq = ff_squareTbl + 256;
2317 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2318 else if(w==8 && h==8)
2319 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2323 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2332 static int sse_mb(MpegEncContext *s){
2336 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2337 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2340 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2341 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)
2342 +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)
2343 +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);
2345 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)
2346 +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)
2347 +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);
2350 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)
2351 +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)
2352 +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);
2355 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2356 MpegEncContext *s= *(void**)arg;
2360 s->me.dia_size= s->avctx->pre_dia_size;
2361 s->first_slice_line=1;
2362 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2363 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2364 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2366 s->first_slice_line=0;
2374 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2375 MpegEncContext *s= *(void**)arg;
2377 ff_check_alignment();
2379 s->me.dia_size= s->avctx->dia_size;
2380 s->first_slice_line=1;
2381 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2382 s->mb_x=0; //for block init below
2383 ff_init_block_index(s);
2384 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2385 s->block_index[0]+=2;
2386 s->block_index[1]+=2;
2387 s->block_index[2]+=2;
2388 s->block_index[3]+=2;
2390 /* compute motion vector & mb_type and store in context */
2391 if(s->pict_type==AV_PICTURE_TYPE_B)
2392 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2394 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2396 s->first_slice_line=0;
2401 static int mb_var_thread(AVCodecContext *c, void *arg){
2402 MpegEncContext *s= *(void**)arg;
2405 ff_check_alignment();
2407 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2408 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2411 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2413 int sum = s->dsp.pix_sum(pix, s->linesize);
2415 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2417 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2418 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2419 s->me.mb_var_sum_temp += varc;
2425 static void write_slice_end(MpegEncContext *s){
2426 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2427 if(s->partitioned_frame){
2428 ff_mpeg4_merge_partitions(s);
2431 ff_mpeg4_stuffing(&s->pb);
2432 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2433 ff_mjpeg_encode_stuffing(s);
2436 avpriv_align_put_bits(&s->pb);
2437 flush_put_bits(&s->pb);
2439 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2440 s->misc_bits+= get_bits_diff(s);
2443 static void write_mb_info(MpegEncContext *s)
2445 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2446 int offset = put_bits_count(&s->pb);
2447 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2448 int gobn = s->mb_y / s->gob_index;
2450 if (CONFIG_H263_ENCODER)
2451 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2452 bytestream_put_le32(&ptr, offset);
2453 bytestream_put_byte(&ptr, s->qscale);
2454 bytestream_put_byte(&ptr, gobn);
2455 bytestream_put_le16(&ptr, mba);
2456 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2457 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2458 /* 4MV not implemented */
2459 bytestream_put_byte(&ptr, 0); /* hmv2 */
2460 bytestream_put_byte(&ptr, 0); /* vmv2 */
2463 static void update_mb_info(MpegEncContext *s, int startcode)
2467 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2468 s->mb_info_size += 12;
2469 s->prev_mb_info = s->last_mb_info;
2472 s->prev_mb_info = put_bits_count(&s->pb)/8;
2473 /* This might have incremented mb_info_size above, and we return without
2474 * actually writing any info into that slot yet. But in that case,
2475 * this will be called again at the start of the after writing the
2476 * start code, actually writing the mb info. */
2480 s->last_mb_info = put_bits_count(&s->pb)/8;
2481 if (!s->mb_info_size)
2482 s->mb_info_size += 12;
2486 static int encode_thread(AVCodecContext *c, void *arg){
2487 MpegEncContext *s= *(void**)arg;
2488 int mb_x, mb_y, pdif = 0;
2489 int chr_h= 16>>s->chroma_y_shift;
2491 MpegEncContext best_s, backup_s;
2492 uint8_t bit_buf[2][MAX_MB_BYTES];
2493 uint8_t bit_buf2[2][MAX_MB_BYTES];
2494 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2495 PutBitContext pb[2], pb2[2], tex_pb[2];
2497 ff_check_alignment();
2500 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2501 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2502 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2505 s->last_bits= put_bits_count(&s->pb);
2516 /* init last dc values */
2517 /* note: quant matrix value (8) is implied here */
2518 s->last_dc[i] = 128 << s->intra_dc_precision;
2520 s->current_picture.f.error[i] = 0;
2522 if(s->codec_id==AV_CODEC_ID_AMV){
2523 s->last_dc[0] = 128*8/13;
2524 s->last_dc[1] = 128*8/14;
2525 s->last_dc[2] = 128*8/14;
2528 memset(s->last_mv, 0, sizeof(s->last_mv));
2532 switch(s->codec_id){
2533 case AV_CODEC_ID_H263:
2534 case AV_CODEC_ID_H263P:
2535 case AV_CODEC_ID_FLV1:
2536 if (CONFIG_H263_ENCODER)
2537 s->gob_index = ff_h263_get_gob_height(s);
2539 case AV_CODEC_ID_MPEG4:
2540 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2541 ff_mpeg4_init_partitions(s);
2547 s->first_slice_line = 1;
2548 s->ptr_lastgob = s->pb.buf;
2549 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2553 ff_set_qscale(s, s->qscale);
2554 ff_init_block_index(s);
2556 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2557 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2558 int mb_type= s->mb_type[xy];
2563 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2564 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2567 if(s->data_partitioning){
2568 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2569 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2570 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2576 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2577 ff_update_block_index(s);
2579 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2580 ff_h261_reorder_mb_index(s);
2581 xy= s->mb_y*s->mb_stride + s->mb_x;
2582 mb_type= s->mb_type[xy];
2585 /* write gob / video packet header */
2587 int current_packet_size, is_gob_start;
2589 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2591 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2593 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2595 switch(s->codec_id){
2596 case AV_CODEC_ID_H263:
2597 case AV_CODEC_ID_H263P:
2598 if(!s->h263_slice_structured)
2599 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2601 case AV_CODEC_ID_MPEG2VIDEO:
2602 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2603 case AV_CODEC_ID_MPEG1VIDEO:
2604 if(s->mb_skip_run) is_gob_start=0;
2606 case AV_CODEC_ID_MJPEG:
2607 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2612 if(s->start_mb_y != mb_y || mb_x!=0){
2614 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2615 ff_mpeg4_init_partitions(s);
2619 av_assert2((put_bits_count(&s->pb)&7) == 0);
2620 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2622 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2623 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2624 int d= 100 / s->avctx->error_rate;
2626 current_packet_size=0;
2627 s->pb.buf_ptr= s->ptr_lastgob;
2628 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2632 if (s->avctx->rtp_callback){
2633 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2634 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2636 update_mb_info(s, 1);
2638 switch(s->codec_id){
2639 case AV_CODEC_ID_MPEG4:
2640 if (CONFIG_MPEG4_ENCODER) {
2641 ff_mpeg4_encode_video_packet_header(s);
2642 ff_mpeg4_clean_buffers(s);
2645 case AV_CODEC_ID_MPEG1VIDEO:
2646 case AV_CODEC_ID_MPEG2VIDEO:
2647 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2648 ff_mpeg1_encode_slice_header(s);
2649 ff_mpeg1_clean_buffers(s);
2652 case AV_CODEC_ID_H263:
2653 case AV_CODEC_ID_H263P:
2654 if (CONFIG_H263_ENCODER)
2655 ff_h263_encode_gob_header(s, mb_y);
2659 if(s->flags&CODEC_FLAG_PASS1){
2660 int bits= put_bits_count(&s->pb);
2661 s->misc_bits+= bits - s->last_bits;
2665 s->ptr_lastgob += current_packet_size;
2666 s->first_slice_line=1;
2667 s->resync_mb_x=mb_x;
2668 s->resync_mb_y=mb_y;
2672 if( (s->resync_mb_x == s->mb_x)
2673 && s->resync_mb_y+1 == s->mb_y){
2674 s->first_slice_line=0;
2678 s->dquant=0; //only for QP_RD
2680 update_mb_info(s, 0);
2682 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
2684 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2686 copy_context_before_encode(&backup_s, s, -1);
2688 best_s.data_partitioning= s->data_partitioning;
2689 best_s.partitioned_frame= s->partitioned_frame;
2690 if(s->data_partitioning){
2691 backup_s.pb2= s->pb2;
2692 backup_s.tex_pb= s->tex_pb;
2695 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2696 s->mv_dir = MV_DIR_FORWARD;
2697 s->mv_type = MV_TYPE_16X16;
2699 s->mv[0][0][0] = s->p_mv_table[xy][0];
2700 s->mv[0][0][1] = s->p_mv_table[xy][1];
2701 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2702 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2704 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2705 s->mv_dir = MV_DIR_FORWARD;
2706 s->mv_type = MV_TYPE_FIELD;
2709 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2710 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2711 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2713 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2714 &dmin, &next_block, 0, 0);
2716 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2717 s->mv_dir = MV_DIR_FORWARD;
2718 s->mv_type = MV_TYPE_16X16;
2722 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2723 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2725 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2726 s->mv_dir = MV_DIR_FORWARD;
2727 s->mv_type = MV_TYPE_8X8;
2730 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2731 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2733 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2734 &dmin, &next_block, 0, 0);
2736 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2737 s->mv_dir = MV_DIR_FORWARD;
2738 s->mv_type = MV_TYPE_16X16;
2740 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2741 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2742 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2743 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2745 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2746 s->mv_dir = MV_DIR_BACKWARD;
2747 s->mv_type = MV_TYPE_16X16;
2749 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2750 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2751 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2752 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2754 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2755 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2756 s->mv_type = MV_TYPE_16X16;
2758 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2759 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2760 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2761 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2762 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2763 &dmin, &next_block, 0, 0);
2765 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2766 s->mv_dir = MV_DIR_FORWARD;
2767 s->mv_type = MV_TYPE_FIELD;
2770 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2771 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2772 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2774 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2775 &dmin, &next_block, 0, 0);
2777 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2778 s->mv_dir = MV_DIR_BACKWARD;
2779 s->mv_type = MV_TYPE_FIELD;
2782 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2783 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2784 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2786 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2787 &dmin, &next_block, 0, 0);
2789 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2790 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2791 s->mv_type = MV_TYPE_FIELD;
2793 for(dir=0; dir<2; dir++){
2795 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2796 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2797 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2800 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2801 &dmin, &next_block, 0, 0);
2803 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2805 s->mv_type = MV_TYPE_16X16;
2809 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2810 &dmin, &next_block, 0, 0);
2811 if(s->h263_pred || s->h263_aic){
2813 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2815 ff_clean_intra_table_entries(s); //old mode?
2819 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2820 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2821 const int last_qp= backup_s.qscale;
2824 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2825 static const int dquant_tab[4]={-1,1,-2,2};
2827 av_assert2(backup_s.dquant == 0);
2830 s->mv_dir= best_s.mv_dir;
2831 s->mv_type = MV_TYPE_16X16;
2832 s->mb_intra= best_s.mb_intra;
2833 s->mv[0][0][0] = best_s.mv[0][0][0];
2834 s->mv[0][0][1] = best_s.mv[0][0][1];
2835 s->mv[1][0][0] = best_s.mv[1][0][0];
2836 s->mv[1][0][1] = best_s.mv[1][0][1];
2838 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2839 for(; qpi<4; qpi++){
2840 int dquant= dquant_tab[qpi];
2841 qp= last_qp + dquant;
2842 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2844 backup_s.dquant= dquant;
2845 if(s->mb_intra && s->dc_val[0]){
2847 dc[i]= s->dc_val[0][ s->block_index[i] ];
2848 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2852 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2853 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2854 if(best_s.qscale != qp){
2855 if(s->mb_intra && s->dc_val[0]){
2857 s->dc_val[0][ s->block_index[i] ]= dc[i];
2858 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2865 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2866 int mx= s->b_direct_mv_table[xy][0];
2867 int my= s->b_direct_mv_table[xy][1];
2869 backup_s.dquant = 0;
2870 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2872 ff_mpeg4_set_direct_mv(s, mx, my);
2873 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2874 &dmin, &next_block, mx, my);
2876 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2877 backup_s.dquant = 0;
2878 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2880 ff_mpeg4_set_direct_mv(s, 0, 0);
2881 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2882 &dmin, &next_block, 0, 0);
2884 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2887 coded |= s->block_last_index[i];
2890 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2891 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2892 mx=my=0; //FIXME find the one we actually used
2893 ff_mpeg4_set_direct_mv(s, mx, my);
2894 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2902 s->mv_dir= best_s.mv_dir;
2903 s->mv_type = best_s.mv_type;
2905 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2906 s->mv[0][0][1] = best_s.mv[0][0][1];
2907 s->mv[1][0][0] = best_s.mv[1][0][0];
2908 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2911 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2912 &dmin, &next_block, mx, my);
2917 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2919 copy_context_after_encode(s, &best_s, -1);
2921 pb_bits_count= put_bits_count(&s->pb);
2922 flush_put_bits(&s->pb);
2923 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2926 if(s->data_partitioning){
2927 pb2_bits_count= put_bits_count(&s->pb2);
2928 flush_put_bits(&s->pb2);
2929 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2930 s->pb2= backup_s.pb2;
2932 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2933 flush_put_bits(&s->tex_pb);
2934 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2935 s->tex_pb= backup_s.tex_pb;
2937 s->last_bits= put_bits_count(&s->pb);
2939 if (CONFIG_H263_ENCODER &&
2940 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2941 ff_h263_update_motion_val(s);
2943 if(next_block==0){ //FIXME 16 vs linesize16
2944 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2945 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2946 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2949 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2950 ff_MPV_decode_mb(s, s->block);
2952 int motion_x = 0, motion_y = 0;
2953 s->mv_type=MV_TYPE_16X16;
2954 // only one MB-Type possible
2957 case CANDIDATE_MB_TYPE_INTRA:
2960 motion_x= s->mv[0][0][0] = 0;
2961 motion_y= s->mv[0][0][1] = 0;
2963 case CANDIDATE_MB_TYPE_INTER:
2964 s->mv_dir = MV_DIR_FORWARD;
2966 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2967 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2969 case CANDIDATE_MB_TYPE_INTER_I:
2970 s->mv_dir = MV_DIR_FORWARD;
2971 s->mv_type = MV_TYPE_FIELD;
2974 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2975 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2976 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2979 case CANDIDATE_MB_TYPE_INTER4V:
2980 s->mv_dir = MV_DIR_FORWARD;
2981 s->mv_type = MV_TYPE_8X8;
2984 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2985 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2988 case CANDIDATE_MB_TYPE_DIRECT:
2989 if (CONFIG_MPEG4_ENCODER) {
2990 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2992 motion_x=s->b_direct_mv_table[xy][0];
2993 motion_y=s->b_direct_mv_table[xy][1];
2994 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2997 case CANDIDATE_MB_TYPE_DIRECT0:
2998 if (CONFIG_MPEG4_ENCODER) {
2999 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3001 ff_mpeg4_set_direct_mv(s, 0, 0);
3004 case CANDIDATE_MB_TYPE_BIDIR:
3005 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3007 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3008 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3009 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3010 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3012 case CANDIDATE_MB_TYPE_BACKWARD:
3013 s->mv_dir = MV_DIR_BACKWARD;
3015 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3016 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3018 case CANDIDATE_MB_TYPE_FORWARD:
3019 s->mv_dir = MV_DIR_FORWARD;
3021 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3022 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3024 case CANDIDATE_MB_TYPE_FORWARD_I:
3025 s->mv_dir = MV_DIR_FORWARD;
3026 s->mv_type = MV_TYPE_FIELD;
3029 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3030 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3031 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3034 case CANDIDATE_MB_TYPE_BACKWARD_I:
3035 s->mv_dir = MV_DIR_BACKWARD;
3036 s->mv_type = MV_TYPE_FIELD;
3039 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3040 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3041 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3044 case CANDIDATE_MB_TYPE_BIDIR_I:
3045 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3046 s->mv_type = MV_TYPE_FIELD;
3048 for(dir=0; dir<2; dir++){
3050 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3051 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3052 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3057 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3060 encode_mb(s, motion_x, motion_y);
3062 // RAL: Update last macroblock type
3063 s->last_mv_dir = s->mv_dir;
3065 if (CONFIG_H263_ENCODER &&
3066 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3067 ff_h263_update_motion_val(s);
3069 ff_MPV_decode_mb(s, s->block);
3072 /* clean the MV table in IPS frames for direct mode in B frames */
3073 if(s->mb_intra /* && I,P,S_TYPE */){
3074 s->p_mv_table[xy][0]=0;
3075 s->p_mv_table[xy][1]=0;
3078 if(s->flags&CODEC_FLAG_PSNR){
3082 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3083 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3085 s->current_picture.f.error[0] += sse(
3086 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3087 s->dest[0], w, h, s->linesize);
3088 s->current_picture.f.error[1] += sse(
3089 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3090 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3091 s->current_picture.f.error[2] += sse(
3092 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3093 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3096 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3097 ff_h263_loop_filter(s);
3099 av_dlog(s->avctx, "MB %d %d bits\n",
3100 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3104 //not beautiful here but we must write it before flushing so it has to be here
3105 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3106 ff_msmpeg4_encode_ext_header(s);
3110 /* Send the last GOB if RTP */
3111 if (s->avctx->rtp_callback) {
3112 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3113 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3114 /* Call the RTP callback to send the last GOB */
3116 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3122 #define MERGE(field) dst->field += src->field; src->field=0
3123 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3124 MERGE(me.scene_change_score);
3125 MERGE(me.mc_mb_var_sum_temp);
3126 MERGE(me.mb_var_sum_temp);
3129 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3132 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3133 MERGE(dct_count[1]);
3143 MERGE(padding_bug_score);
3144 MERGE(current_picture.f.error[0]);
3145 MERGE(current_picture.f.error[1]);
3146 MERGE(current_picture.f.error[2]);
3148 if(dst->avctx->noise_reduction){
3149 for(i=0; i<64; i++){
3150 MERGE(dct_error_sum[0][i]);
3151 MERGE(dct_error_sum[1][i]);
3155 assert(put_bits_count(&src->pb) % 8 ==0);
3156 assert(put_bits_count(&dst->pb) % 8 ==0);
3157 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3158 flush_put_bits(&dst->pb);
3161 static int estimate_qp(MpegEncContext *s, int dry_run){
3162 if (s->next_lambda){
3163 s->current_picture_ptr->f.quality =
3164 s->current_picture.f.quality = s->next_lambda;
3165 if(!dry_run) s->next_lambda= 0;
3166 } else if (!s->fixed_qscale) {
3167 s->current_picture_ptr->f.quality =
3168 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3169 if (s->current_picture.f.quality < 0)
3173 if(s->adaptive_quant){
3174 switch(s->codec_id){
3175 case AV_CODEC_ID_MPEG4:
3176 if (CONFIG_MPEG4_ENCODER)
3177 ff_clean_mpeg4_qscales(s);
3179 case AV_CODEC_ID_H263:
3180 case AV_CODEC_ID_H263P:
3181 case AV_CODEC_ID_FLV1:
3182 if (CONFIG_H263_ENCODER)
3183 ff_clean_h263_qscales(s);
3186 ff_init_qscale_tab(s);
3189 s->lambda= s->lambda_table[0];
3192 s->lambda = s->current_picture.f.quality;
3197 /* must be called before writing the header */
3198 static void set_frame_distances(MpegEncContext * s){
3199 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3200 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3202 if(s->pict_type==AV_PICTURE_TYPE_B){
3203 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3204 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3206 s->pp_time= s->time - s->last_non_b_time;
3207 s->last_non_b_time= s->time;
3208 assert(s->picture_number==0 || s->pp_time > 0);
3212 static int encode_picture(MpegEncContext *s, int picture_number)
3216 int context_count = s->slice_context_count;
3218 s->picture_number = picture_number;
3220 /* Reset the average MB variance */
3221 s->me.mb_var_sum_temp =
3222 s->me.mc_mb_var_sum_temp = 0;
3224 /* we need to initialize some time vars before we can encode b-frames */
3225 // RAL: Condition added for MPEG1VIDEO
3226 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3227 set_frame_distances(s);
3228 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3229 ff_set_mpeg4_time(s);
3231 s->me.scene_change_score=0;
3233 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3235 if(s->pict_type==AV_PICTURE_TYPE_I){
3236 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3237 else s->no_rounding=0;
3238 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3239 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3240 s->no_rounding ^= 1;
3243 if(s->flags & CODEC_FLAG_PASS2){
3244 if (estimate_qp(s,1) < 0)
3246 ff_get_2pass_fcode(s);
3247 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3248 if(s->pict_type==AV_PICTURE_TYPE_B)
3249 s->lambda= s->last_lambda_for[s->pict_type];
3251 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3255 if(s->codec_id != AV_CODEC_ID_AMV){
3256 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3257 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3258 s->q_chroma_intra_matrix = s->q_intra_matrix;
3259 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3262 s->mb_intra=0; //for the rate distortion & bit compare functions
3263 for(i=1; i<context_count; i++){
3264 ff_update_duplicate_context(s->thread_context[i], s);
3270 /* Estimate motion for every MB */
3271 if(s->pict_type != AV_PICTURE_TYPE_I){
3272 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3273 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3274 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3275 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3276 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3280 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3281 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3283 for(i=0; i<s->mb_stride*s->mb_height; i++)
3284 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3286 if(!s->fixed_qscale){
3287 /* finding spatial complexity for I-frame rate control */
3288 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3291 for(i=1; i<context_count; i++){
3292 merge_context_after_me(s, s->thread_context[i]);
3294 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3295 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3298 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3299 s->pict_type= AV_PICTURE_TYPE_I;
3300 for(i=0; i<s->mb_stride*s->mb_height; i++)
3301 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3302 if(s->msmpeg4_version >= 3)
3304 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3305 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3309 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3310 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3312 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3314 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3315 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3316 s->f_code= FFMAX3(s->f_code, a, b);
3319 ff_fix_long_p_mvs(s);
3320 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3321 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3325 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3326 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3331 if(s->pict_type==AV_PICTURE_TYPE_B){
3334 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3335 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3336 s->f_code = FFMAX(a, b);
3338 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3339 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3340 s->b_code = FFMAX(a, b);
3342 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3343 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3344 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3345 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3346 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3348 for(dir=0; dir<2; dir++){
3351 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3352 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3353 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3354 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3362 if (estimate_qp(s, 0) < 0)
3365 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3366 s->qscale= 3; //reduce clipping problems
3368 if (s->out_format == FMT_MJPEG) {
3369 /* for mjpeg, we do include qscale in the matrix */
3371 int j= s->dsp.idct_permutation[i];
3373 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3375 s->y_dc_scale_table=
3376 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3377 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3378 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3379 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3382 if(s->codec_id == AV_CODEC_ID_AMV){
3383 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};
3384 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};
3386 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3388 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3389 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3391 s->y_dc_scale_table= y;
3392 s->c_dc_scale_table= c;
3393 s->intra_matrix[0] = 13;
3394 s->chroma_intra_matrix[0] = 14;
3395 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3396 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3397 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3398 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3402 //FIXME var duplication
3403 s->current_picture_ptr->f.key_frame =
3404 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3405 s->current_picture_ptr->f.pict_type =
3406 s->current_picture.f.pict_type = s->pict_type;
3408 if (s->current_picture.f.key_frame)
3409 s->picture_in_gop_number=0;
3411 s->mb_x = s->mb_y = 0;
3412 s->last_bits= put_bits_count(&s->pb);
3413 switch(s->out_format) {
3415 if (CONFIG_MJPEG_ENCODER)
3416 ff_mjpeg_encode_picture_header(s);
3419 if (CONFIG_H261_ENCODER)
3420 ff_h261_encode_picture_header(s, picture_number);
3423 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3424 ff_wmv2_encode_picture_header(s, picture_number);
3425 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3426 ff_msmpeg4_encode_picture_header(s, picture_number);
3427 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3428 ff_mpeg4_encode_picture_header(s, picture_number);
3429 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3430 ff_rv10_encode_picture_header(s, picture_number);
3431 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3432 ff_rv20_encode_picture_header(s, picture_number);
3433 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3434 ff_flv_encode_picture_header(s, picture_number);
3435 else if (CONFIG_H263_ENCODER)
3436 ff_h263_encode_picture_header(s, picture_number);
3439 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3440 ff_mpeg1_encode_picture_header(s, picture_number);
3447 bits= put_bits_count(&s->pb);
3448 s->header_bits= bits - s->last_bits;
3450 for(i=1; i<context_count; i++){
3451 update_duplicate_context_after_me(s->thread_context[i], s);
3453 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3454 for(i=1; i<context_count; i++){
3455 merge_context_after_encode(s, s->thread_context[i]);
3461 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3462 const int intra= s->mb_intra;
3465 s->dct_count[intra]++;
3467 for(i=0; i<64; i++){
3468 int level= block[i];
3472 s->dct_error_sum[intra][i] += level;
3473 level -= s->dct_offset[intra][i];
3474 if(level<0) level=0;
3476 s->dct_error_sum[intra][i] -= level;
3477 level += s->dct_offset[intra][i];
3478 if(level>0) level=0;
3485 static int dct_quantize_trellis_c(MpegEncContext *s,
3486 DCTELEM *block, int n,
3487 int qscale, int *overflow){
3489 const uint8_t *scantable= s->intra_scantable.scantable;
3490 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3492 unsigned int threshold1, threshold2;
3504 int coeff_count[64];
3505 int qmul, qadd, start_i, last_non_zero, i, dc;
3506 const int esc_length= s->ac_esc_length;
3508 uint8_t * last_length;
3509 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3511 s->dsp.fdct (block);
3513 if(s->dct_error_sum)
3514 s->denoise_dct(s, block);
3516 qadd= ((qscale-1)|1)*8;
3527 /* For AIC we skip quant/dequant of INTRADC */
3532 /* note: block[0] is assumed to be positive */
3533 block[0] = (block[0] + (q >> 1)) / q;
3536 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3537 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3538 bias= 1<<(QMAT_SHIFT-1);
3539 length = s->intra_ac_vlc_length;
3540 last_length= s->intra_ac_vlc_last_length;
3544 qmat = s->q_inter_matrix[qscale];
3545 length = s->inter_ac_vlc_length;
3546 last_length= s->inter_ac_vlc_last_length;
3550 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3551 threshold2= (threshold1<<1);
3553 for(i=63; i>=start_i; i--) {
3554 const int j = scantable[i];
3555 int level = block[j] * qmat[j];
3557 if(((unsigned)(level+threshold1))>threshold2){
3563 for(i=start_i; i<=last_non_zero; i++) {
3564 const int j = scantable[i];
3565 int level = block[j] * qmat[j];
3567 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3568 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3569 if(((unsigned)(level+threshold1))>threshold2){
3571 level= (bias + level)>>QMAT_SHIFT;
3573 coeff[1][i]= level-1;
3574 // coeff[2][k]= level-2;
3576 level= (bias - level)>>QMAT_SHIFT;
3577 coeff[0][i]= -level;
3578 coeff[1][i]= -level+1;
3579 // coeff[2][k]= -level+2;
3581 coeff_count[i]= FFMIN(level, 2);
3582 av_assert2(coeff_count[i]);
3585 coeff[0][i]= (level>>31)|1;
3590 *overflow= s->max_qcoeff < max; //overflow might have happened
3592 if(last_non_zero < start_i){
3593 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3594 return last_non_zero;
3597 score_tab[start_i]= 0;
3598 survivor[0]= start_i;
3601 for(i=start_i; i<=last_non_zero; i++){
3602 int level_index, j, zero_distortion;
3603 int dct_coeff= FFABS(block[ scantable[i] ]);
3604 int best_score=256*256*256*120;
3606 if (s->dsp.fdct == ff_fdct_ifast)
3607 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3608 zero_distortion= dct_coeff*dct_coeff;
3610 for(level_index=0; level_index < coeff_count[i]; level_index++){
3612 int level= coeff[level_index][i];
3613 const int alevel= FFABS(level);
3618 if(s->out_format == FMT_H263){
3619 unquant_coeff= alevel*qmul + qadd;
3621 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3623 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3624 unquant_coeff = (unquant_coeff - 1) | 1;
3626 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3627 unquant_coeff = (unquant_coeff - 1) | 1;
3632 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3634 if((level&(~127)) == 0){
3635 for(j=survivor_count-1; j>=0; j--){
3636 int run= i - survivor[j];
3637 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3638 score += score_tab[i-run];
3640 if(score < best_score){
3643 level_tab[i+1]= level-64;
3647 if(s->out_format == FMT_H263){
3648 for(j=survivor_count-1; j>=0; j--){
3649 int run= i - survivor[j];
3650 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3651 score += score_tab[i-run];
3652 if(score < last_score){
3655 last_level= level-64;
3661 distortion += esc_length*lambda;
3662 for(j=survivor_count-1; j>=0; j--){
3663 int run= i - survivor[j];
3664 int score= distortion + score_tab[i-run];
3666 if(score < best_score){
3669 level_tab[i+1]= level-64;
3673 if(s->out_format == FMT_H263){
3674 for(j=survivor_count-1; j>=0; j--){
3675 int run= i - survivor[j];
3676 int score= distortion + score_tab[i-run];
3677 if(score < last_score){
3680 last_level= level-64;
3688 score_tab[i+1]= best_score;
3690 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3691 if(last_non_zero <= 27){
3692 for(; survivor_count; survivor_count--){
3693 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3697 for(; survivor_count; survivor_count--){
3698 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3703 survivor[ survivor_count++ ]= i+1;
3706 if(s->out_format != FMT_H263){
3707 last_score= 256*256*256*120;
3708 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3709 int score= score_tab[i];
3710 if(i) score += lambda*2; //FIXME exacter?
3712 if(score < last_score){
3715 last_level= level_tab[i];
3716 last_run= run_tab[i];
3721 s->coded_score[n] = last_score;
3723 dc= FFABS(block[0]);
3724 last_non_zero= last_i - 1;
3725 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3727 if(last_non_zero < start_i)
3728 return last_non_zero;
3730 if(last_non_zero == 0 && start_i == 0){
3732 int best_score= dc * dc;
3734 for(i=0; i<coeff_count[0]; i++){
3735 int level= coeff[i][0];
3736 int alevel= FFABS(level);
3737 int unquant_coeff, score, distortion;
3739 if(s->out_format == FMT_H263){
3740 unquant_coeff= (alevel*qmul + qadd)>>3;
3742 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3743 unquant_coeff = (unquant_coeff - 1) | 1;
3745 unquant_coeff = (unquant_coeff + 4) >> 3;
3746 unquant_coeff<<= 3 + 3;
3748 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3750 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3751 else score= distortion + esc_length*lambda;
3753 if(score < best_score){
3755 best_level= level - 64;
3758 block[0]= best_level;
3759 s->coded_score[n] = best_score - dc*dc;
3760 if(best_level == 0) return -1;
3761 else return last_non_zero;
3765 av_assert2(last_level);
3767 block[ perm_scantable[last_non_zero] ]= last_level;
3770 for(; i>start_i; i -= run_tab[i] + 1){
3771 block[ perm_scantable[i-1] ]= level_tab[i];
3774 return last_non_zero;
3777 //#define REFINE_STATS 1
3778 static int16_t basis[64][64];
3780 static void build_basis(uint8_t *perm){
3787 double s= 0.25*(1<<BASIS_SHIFT);
3789 int perm_index= perm[index];
3790 if(i==0) s*= sqrt(0.5);
3791 if(j==0) s*= sqrt(0.5);
3792 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)));
3799 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3800 DCTELEM *block, int16_t *weight, DCTELEM *orig,
3803 LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3804 const uint8_t *scantable= s->intra_scantable.scantable;
3805 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3806 // unsigned int threshold1, threshold2;
3811 int qmul, qadd, start_i, last_non_zero, i, dc;
3813 uint8_t * last_length;
3815 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3818 static int after_last=0;
3819 static int to_zero=0;
3820 static int from_zero=0;
3823 static int messed_sign=0;
3826 if(basis[0][0] == 0)
3827 build_basis(s->dsp.idct_permutation);
3838 /* For AIC we skip quant/dequant of INTRADC */
3842 q <<= RECON_SHIFT-3;
3843 /* note: block[0] is assumed to be positive */
3845 // block[0] = (block[0] + (q >> 1)) / q;
3847 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3848 // bias= 1<<(QMAT_SHIFT-1);
3849 length = s->intra_ac_vlc_length;
3850 last_length= s->intra_ac_vlc_last_length;
3854 length = s->inter_ac_vlc_length;
3855 last_length= s->inter_ac_vlc_last_length;
3857 last_non_zero = s->block_last_index[n];
3862 dc += (1<<(RECON_SHIFT-1));
3863 for(i=0; i<64; i++){
3864 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3867 STOP_TIMER("memset rem[]")}
3870 for(i=0; i<64; i++){
3875 w= FFABS(weight[i]) + qns*one;
3876 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3879 // w=weight[i] = (63*qns + (w/2)) / w;
3882 av_assert2(w<(1<<6));
3885 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3891 for(i=start_i; i<=last_non_zero; i++){
3892 int j= perm_scantable[i];
3893 const int level= block[j];
3897 if(level<0) coeff= qmul*level - qadd;
3898 else coeff= qmul*level + qadd;
3899 run_tab[rle_index++]=run;
3902 s->dsp.add_8x8basis(rem, basis[j], coeff);
3908 if(last_non_zero>0){
3909 STOP_TIMER("init rem[]")
3916 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3919 int run2, best_unquant_change=0, analyze_gradient;
3923 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3925 if(analyze_gradient){
3929 for(i=0; i<64; i++){
3932 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3935 STOP_TIMER("rem*w*w")}
3945 const int level= block[0];
3946 int change, old_coeff;
3948 av_assert2(s->mb_intra);
3952 for(change=-1; change<=1; change+=2){
3953 int new_level= level + change;
3954 int score, new_coeff;
3956 new_coeff= q*new_level;
3957 if(new_coeff >= 2048 || new_coeff < 0)
3960 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3961 if(score<best_score){
3964 best_change= change;
3965 best_unquant_change= new_coeff - old_coeff;
3972 run2= run_tab[rle_index++];
3976 for(i=start_i; i<64; i++){
3977 int j= perm_scantable[i];
3978 const int level= block[j];
3979 int change, old_coeff;
3981 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3985 if(level<0) old_coeff= qmul*level - qadd;
3986 else old_coeff= qmul*level + qadd;
3987 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3991 av_assert2(run2>=0 || i >= last_non_zero );
3994 for(change=-1; change<=1; change+=2){
3995 int new_level= level + change;
3996 int score, new_coeff, unquant_change;
3999 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4003 if(new_level<0) new_coeff= qmul*new_level - qadd;
4004 else new_coeff= qmul*new_level + qadd;
4005 if(new_coeff >= 2048 || new_coeff <= -2048)
4007 //FIXME check for overflow
4010 if(level < 63 && level > -63){
4011 if(i < last_non_zero)
4012 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4013 - length[UNI_AC_ENC_INDEX(run, level+64)];
4015 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4016 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4019 av_assert2(FFABS(new_level)==1);
4021 if(analyze_gradient){
4022 int g= d1[ scantable[i] ];
4023 if(g && (g^new_level) >= 0)
4027 if(i < last_non_zero){
4028 int next_i= i + run2 + 1;
4029 int next_level= block[ perm_scantable[next_i] ] + 64;
4031 if(next_level&(~127))
4034 if(next_i < last_non_zero)
4035 score += length[UNI_AC_ENC_INDEX(run, 65)]
4036 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4037 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4039 score += length[UNI_AC_ENC_INDEX(run, 65)]
4040 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4041 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4043 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4045 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4046 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4052 av_assert2(FFABS(level)==1);
4054 if(i < last_non_zero){
4055 int next_i= i + run2 + 1;
4056 int next_level= block[ perm_scantable[next_i] ] + 64;
4058 if(next_level&(~127))
4061 if(next_i < last_non_zero)
4062 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4063 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4064 - length[UNI_AC_ENC_INDEX(run, 65)];
4066 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4067 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4068 - length[UNI_AC_ENC_INDEX(run, 65)];
4070 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4072 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4073 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4080 unquant_change= new_coeff - old_coeff;
4081 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4083 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4084 if(score<best_score){
4087 best_change= change;
4088 best_unquant_change= unquant_change;
4092 prev_level= level + 64;
4093 if(prev_level&(~127))
4102 STOP_TIMER("iterative step")}
4106 int j= perm_scantable[ best_coeff ];
4108 block[j] += best_change;
4110 if(best_coeff > last_non_zero){
4111 last_non_zero= best_coeff;
4112 av_assert2(block[j]);
4119 if(block[j] - best_change){
4120 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4132 for(; last_non_zero>=start_i; last_non_zero--){
4133 if(block[perm_scantable[last_non_zero]])
4139 if(256*256*256*64 % count == 0){
4140 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4145 for(i=start_i; i<=last_non_zero; i++){
4146 int j= perm_scantable[i];
4147 const int level= block[j];
4150 run_tab[rle_index++]=run;
4157 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4163 if(last_non_zero>0){
4164 STOP_TIMER("iterative search")
4169 return last_non_zero;
4172 int ff_dct_quantize_c(MpegEncContext *s,
4173 DCTELEM *block, int n,
4174 int qscale, int *overflow)
4176 int i, j, level, last_non_zero, q, start_i;
4178 const uint8_t *scantable= s->intra_scantable.scantable;
4181 unsigned int threshold1, threshold2;
4183 s->dsp.fdct (block);
4185 if(s->dct_error_sum)
4186 s->denoise_dct(s, block);
4196 /* For AIC we skip quant/dequant of INTRADC */
4199 /* note: block[0] is assumed to be positive */
4200 block[0] = (block[0] + (q >> 1)) / q;
4203 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4204 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4208 qmat = s->q_inter_matrix[qscale];
4209 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4211 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4212 threshold2= (threshold1<<1);
4213 for(i=63;i>=start_i;i--) {
4215 level = block[j] * qmat[j];
4217 if(((unsigned)(level+threshold1))>threshold2){
4224 for(i=start_i; i<=last_non_zero; i++) {
4226 level = block[j] * qmat[j];
4228 // if( bias+level >= (1<<QMAT_SHIFT)
4229 // || bias-level >= (1<<QMAT_SHIFT)){
4230 if(((unsigned)(level+threshold1))>threshold2){
4232 level= (bias + level)>>QMAT_SHIFT;
4235 level= (bias - level)>>QMAT_SHIFT;
4243 *overflow= s->max_qcoeff < max; //overflow might have happened
4245 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4246 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4247 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4249 return last_non_zero;
4252 #define OFFSET(x) offsetof(MpegEncContext, x)
4253 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4254 static const AVOption h263_options[] = {
4255 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4256 { "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},
4257 { "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 },
4262 static const AVClass h263_class = {
4263 .class_name = "H.263 encoder",
4264 .item_name = av_default_item_name,
4265 .option = h263_options,
4266 .version = LIBAVUTIL_VERSION_INT,
4269 AVCodec ff_h263_encoder = {
4271 .type = AVMEDIA_TYPE_VIDEO,
4272 .id = AV_CODEC_ID_H263,
4273 .priv_data_size = sizeof(MpegEncContext),
4274 .init = ff_MPV_encode_init,
4275 .encode2 = ff_MPV_encode_picture,
4276 .close = ff_MPV_encode_end,
4277 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4278 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4279 .priv_class = &h263_class,
4282 static const AVOption h263p_options[] = {
4283 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4284 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4285 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4286 { "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},
4290 static const AVClass h263p_class = {
4291 .class_name = "H.263p encoder",
4292 .item_name = av_default_item_name,
4293 .option = h263p_options,
4294 .version = LIBAVUTIL_VERSION_INT,
4297 AVCodec ff_h263p_encoder = {
4299 .type = AVMEDIA_TYPE_VIDEO,
4300 .id = AV_CODEC_ID_H263P,
4301 .priv_data_size = sizeof(MpegEncContext),
4302 .init = ff_MPV_encode_init,
4303 .encode2 = ff_MPV_encode_picture,
4304 .close = ff_MPV_encode_end,
4305 .capabilities = CODEC_CAP_SLICE_THREADS,
4306 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4307 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4308 .priv_class = &h263p_class,
4311 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4313 AVCodec ff_msmpeg4v2_encoder = {
4314 .name = "msmpeg4v2",
4315 .type = AVMEDIA_TYPE_VIDEO,
4316 .id = AV_CODEC_ID_MSMPEG4V2,
4317 .priv_data_size = sizeof(MpegEncContext),
4318 .init = ff_MPV_encode_init,
4319 .encode2 = ff_MPV_encode_picture,
4320 .close = ff_MPV_encode_end,
4321 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4322 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4323 .priv_class = &msmpeg4v2_class,
4326 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4328 AVCodec ff_msmpeg4v3_encoder = {
4330 .type = AVMEDIA_TYPE_VIDEO,
4331 .id = AV_CODEC_ID_MSMPEG4V3,
4332 .priv_data_size = sizeof(MpegEncContext),
4333 .init = ff_MPV_encode_init,
4334 .encode2 = ff_MPV_encode_picture,
4335 .close = ff_MPV_encode_end,
4336 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4337 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4338 .priv_class = &msmpeg4v3_class,
4341 FF_MPV_GENERIC_CLASS(wmv1)
4343 AVCodec ff_wmv1_encoder = {
4345 .type = AVMEDIA_TYPE_VIDEO,
4346 .id = AV_CODEC_ID_WMV1,
4347 .priv_data_size = sizeof(MpegEncContext),
4348 .init = ff_MPV_encode_init,
4349 .encode2 = ff_MPV_encode_picture,
4350 .close = ff_MPV_encode_end,
4351 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4352 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4353 .priv_class = &wmv1_class,