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, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
56 static int sse_mb(MpegEncContext *s);
57 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
58 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *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_RV10 &&
559 avctx->height&15 )) {
560 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
561 return AVERROR(EINVAL);
564 if (s->codec_id == AV_CODEC_ID_RV20 &&
567 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
568 return AVERROR(EINVAL);
571 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
572 s->codec_id == AV_CODEC_ID_WMV2) &&
574 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
578 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
579 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
580 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
584 // FIXME mpeg2 uses that too
585 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
586 av_log(avctx, AV_LOG_ERROR,
587 "mpeg2 style quantization not supported by codec\n");
591 #if FF_API_MPV_GLOBAL_OPTS
592 if (s->flags & CODEC_FLAG_CBP_RD)
593 s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
596 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
597 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
601 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
602 s->avctx->mb_decision != FF_MB_DECISION_RD) {
603 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
607 if (s->avctx->scenechange_threshold < 1000000000 &&
608 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
609 av_log(avctx, AV_LOG_ERROR,
610 "closed gop with scene change detection are not supported yet, "
611 "set threshold to 1000000000\n");
615 if (s->flags & CODEC_FLAG_LOW_DELAY) {
616 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
617 av_log(avctx, AV_LOG_ERROR,
618 "low delay forcing is only available for mpeg2\n");
621 if (s->max_b_frames != 0) {
622 av_log(avctx, AV_LOG_ERROR,
623 "b frames cannot be used with low delay\n");
628 if (s->q_scale_type == 1) {
629 if (avctx->qmax > 12) {
630 av_log(avctx, AV_LOG_ERROR,
631 "non linear quant only supports qmax <= 12 currently\n");
636 if (s->avctx->thread_count > 1 &&
637 s->codec_id != AV_CODEC_ID_MPEG4 &&
638 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
639 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
640 s->codec_id != AV_CODEC_ID_MJPEG &&
641 (s->codec_id != AV_CODEC_ID_H263P)) {
642 av_log(avctx, AV_LOG_ERROR,
643 "multi threaded encoding not supported by codec\n");
647 if (s->avctx->thread_count < 1) {
648 av_log(avctx, AV_LOG_ERROR,
649 "automatic thread number detection not supported by codec, "
654 if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
657 if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
658 s->h263_slice_structured = 1;
660 if (!avctx->time_base.den || !avctx->time_base.num) {
661 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
665 i = (INT_MAX / 2 + 128) >> 8;
666 if (avctx->me_threshold >= i) {
667 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
671 if (avctx->mb_threshold >= i) {
672 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
677 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
678 av_log(avctx, AV_LOG_INFO,
679 "notice: b_frame_strategy only affects the first pass\n");
680 avctx->b_frame_strategy = 0;
683 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
685 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
686 avctx->time_base.den /= i;
687 avctx->time_base.num /= i;
691 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) {
692 // (a + x * 3 / 8) / x
693 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
694 s->inter_quant_bias = 0;
696 s->intra_quant_bias = 0;
698 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
701 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
702 s->intra_quant_bias = avctx->intra_quant_bias;
703 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
704 s->inter_quant_bias = avctx->inter_quant_bias;
706 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
708 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
710 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
711 s->avctx->time_base.den > (1 << 16) - 1) {
712 av_log(avctx, AV_LOG_ERROR,
713 "timebase %d/%d not supported by MPEG 4 standard, "
714 "the maximum admitted value for the timebase denominator "
715 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
719 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
721 #if FF_API_MPV_GLOBAL_OPTS
722 if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
723 s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
724 if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
725 s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
726 if (avctx->quantizer_noise_shaping)
727 s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
730 switch (avctx->codec->id) {
731 case AV_CODEC_ID_MPEG1VIDEO:
732 s->out_format = FMT_MPEG1;
733 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
734 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
736 case AV_CODEC_ID_MPEG2VIDEO:
737 s->out_format = FMT_MPEG1;
738 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
739 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
742 case AV_CODEC_ID_LJPEG:
743 case AV_CODEC_ID_MJPEG:
744 case AV_CODEC_ID_AMV:
745 s->out_format = FMT_MJPEG;
746 s->intra_only = 1; /* force intra only for jpeg */
747 if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
748 (avctx->pix_fmt == AV_PIX_FMT_BGR0
749 || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
750 || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
751 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
752 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
753 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
754 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
755 s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
756 s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
758 s->mjpeg_vsample[0] = 2;
759 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
760 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
761 s->mjpeg_hsample[0] = 2;
762 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
763 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
765 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
766 ff_mjpeg_encode_init(s) < 0)
771 case AV_CODEC_ID_H261:
772 if (!CONFIG_H261_ENCODER)
774 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
775 av_log(avctx, AV_LOG_ERROR,
776 "The specified picture size of %dx%d is not valid for the "
777 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
778 s->width, s->height);
781 s->out_format = FMT_H261;
785 case AV_CODEC_ID_H263:
786 if (!CONFIG_H263_ENCODER)
788 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
789 s->width, s->height) == 8) {
790 av_log(avctx, AV_LOG_ERROR,
791 "The specified picture size of %dx%d is not valid for "
792 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
793 "352x288, 704x576, and 1408x1152. "
794 "Try H.263+.\n", s->width, s->height);
797 s->out_format = FMT_H263;
801 case AV_CODEC_ID_H263P:
802 s->out_format = FMT_H263;
805 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
806 s->modified_quant = s->h263_aic;
807 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
808 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
811 /* These are just to be sure */
815 case AV_CODEC_ID_FLV1:
816 s->out_format = FMT_H263;
817 s->h263_flv = 2; /* format = 1; 11-bit codes */
818 s->unrestricted_mv = 1;
819 s->rtp_mode = 0; /* don't allow GOB */
823 case AV_CODEC_ID_RV10:
824 s->out_format = FMT_H263;
828 case AV_CODEC_ID_RV20:
829 s->out_format = FMT_H263;
832 s->modified_quant = 1;
836 s->unrestricted_mv = 0;
838 case AV_CODEC_ID_MPEG4:
839 s->out_format = FMT_H263;
841 s->unrestricted_mv = 1;
842 s->low_delay = s->max_b_frames ? 0 : 1;
843 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
845 case AV_CODEC_ID_MSMPEG4V2:
846 s->out_format = FMT_H263;
848 s->unrestricted_mv = 1;
849 s->msmpeg4_version = 2;
853 case AV_CODEC_ID_MSMPEG4V3:
854 s->out_format = FMT_H263;
856 s->unrestricted_mv = 1;
857 s->msmpeg4_version = 3;
858 s->flipflop_rounding = 1;
862 case AV_CODEC_ID_WMV1:
863 s->out_format = FMT_H263;
865 s->unrestricted_mv = 1;
866 s->msmpeg4_version = 4;
867 s->flipflop_rounding = 1;
871 case AV_CODEC_ID_WMV2:
872 s->out_format = FMT_H263;
874 s->unrestricted_mv = 1;
875 s->msmpeg4_version = 5;
876 s->flipflop_rounding = 1;
884 avctx->has_b_frames = !s->low_delay;
888 s->progressive_frame =
889 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
890 CODEC_FLAG_INTERLACED_ME) ||
894 if (ff_MPV_common_init(s) < 0)
897 ff_dct_encode_init(s);
899 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
900 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
902 s->quant_precision = 5;
904 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
905 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
907 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
908 ff_h261_encode_init(s);
909 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
910 ff_h263_encode_init(s);
911 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
912 ff_msmpeg4_encode_init(s);
913 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
914 && s->out_format == FMT_MPEG1)
915 ff_mpeg1_encode_init(s);
918 for (i = 0; i < 64; i++) {
919 int j = s->dsp.idct_permutation[i];
920 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
922 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
923 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
924 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
926 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
929 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
930 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
932 if (s->avctx->intra_matrix)
933 s->intra_matrix[j] = s->avctx->intra_matrix[i];
934 if (s->avctx->inter_matrix)
935 s->inter_matrix[j] = s->avctx->inter_matrix[i];
938 /* precompute matrix */
939 /* for mjpeg, we do include qscale in the matrix */
940 if (s->out_format != FMT_MJPEG) {
941 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
942 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
944 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
945 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
949 if (ff_rate_control_init(s) < 0)
955 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
957 MpegEncContext *s = avctx->priv_data;
959 ff_rate_control_uninit(s);
961 ff_MPV_common_end(s);
962 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
963 s->out_format == FMT_MJPEG)
964 ff_mjpeg_encode_close(s);
966 av_freep(&avctx->extradata);
971 static int get_sae(uint8_t *src, int ref, int stride)
976 for (y = 0; y < 16; y++) {
977 for (x = 0; x < 16; x++) {
978 acc += FFABS(src[x + y * stride] - ref);
985 static int get_intra_count(MpegEncContext *s, uint8_t *src,
986 uint8_t *ref, int stride)
994 for (y = 0; y < h; y += 16) {
995 for (x = 0; x < w; x += 16) {
996 int offset = x + y * stride;
997 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
999 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
1000 int sae = get_sae(src + offset, mean, stride);
1002 acc += sae + 500 < sad;
1009 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
1011 AVFrame *pic = NULL;
1014 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
1015 (s->low_delay ? 0 : 1);
1020 pic_arg->display_picture_number = s->input_picture_number++;
1022 if (pts != AV_NOPTS_VALUE) {
1023 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1025 int64_t last = s->user_specified_pts;
1028 av_log(s->avctx, AV_LOG_ERROR,
1029 "Error, Invalid timestamp=%"PRId64", "
1030 "last=%"PRId64"\n", pts, s->user_specified_pts);
1034 if (!s->low_delay && pic_arg->display_picture_number == 1)
1035 s->dts_delta = time - last;
1037 s->user_specified_pts = pts;
1039 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1040 s->user_specified_pts =
1041 pts = s->user_specified_pts + 1;
1042 av_log(s->avctx, AV_LOG_INFO,
1043 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1046 pts = pic_arg->display_picture_number;
1052 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
1054 if (pic_arg->linesize[0] != s->linesize)
1056 if (pic_arg->linesize[1] != s->uvlinesize)
1058 if (pic_arg->linesize[2] != s->uvlinesize)
1061 av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
1062 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1065 i = ff_find_unused_picture(s, 1);
1069 pic = &s->picture[i].f;
1072 for (i = 0; i < 4; i++) {
1073 pic->data[i] = pic_arg->data[i];
1074 pic->linesize[i] = pic_arg->linesize[i];
1076 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1080 i = ff_find_unused_picture(s, 0);
1084 pic = &s->picture[i].f;
1087 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1091 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1092 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1093 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1096 int h_chroma_shift, v_chroma_shift;
1097 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1099 for (i = 0; i < 3; i++) {
1100 int src_stride = pic_arg->linesize[i];
1101 int dst_stride = i ? s->uvlinesize : s->linesize;
1102 int h_shift = i ? h_chroma_shift : 0;
1103 int v_shift = i ? v_chroma_shift : 0;
1104 int w = s->width >> h_shift;
1105 int h = s->height >> v_shift;
1106 uint8_t *src = pic_arg->data[i];
1107 uint8_t *dst = pic->data[i];
1109 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1110 h= ((s->height+15)/16*16)>>v_shift;
1113 if (!s->avctx->rc_buffer_size)
1114 dst += INPLACE_OFFSET;
1116 if (src_stride == dst_stride)
1117 memcpy(dst, src, src_stride * h);
1120 memcpy(dst, src, w);
1128 copy_picture_attributes(s, pic, pic_arg);
1129 pic->pts = pts; // we set this here to avoid modifiying pic_arg
1132 /* shift buffer entries */
1133 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1134 s->input_picture[i - 1] = s->input_picture[i];
1136 s->input_picture[encoding_delay] = (Picture*) pic;
1141 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1145 int64_t score64 = 0;
1147 for (plane = 0; plane < 3; plane++) {
1148 const int stride = p->f.linesize[plane];
1149 const int bw = plane ? 1 : 2;
1150 for (y = 0; y < s->mb_height * bw; y++) {
1151 for (x = 0; x < s->mb_width * bw; x++) {
1152 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1153 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1154 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1155 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1157 switch (s->avctx->frame_skip_exp) {
1158 case 0: score = FFMAX(score, v); break;
1159 case 1: score += FFABS(v); break;
1160 case 2: score += v * v; break;
1161 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1162 case 4: score64 += v * v * (int64_t)(v * v); break;
1171 if (score64 < s->avctx->frame_skip_threshold)
1173 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1178 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1180 AVPacket pkt = { 0 };
1181 int ret, got_output;
1183 av_init_packet(&pkt);
1184 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1189 av_free_packet(&pkt);
1193 static int estimate_best_b_count(MpegEncContext *s)
1195 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1196 AVCodecContext *c = avcodec_alloc_context3(NULL);
1197 AVFrame input[FF_MAX_B_FRAMES + 2];
1198 const int scale = s->avctx->brd_scale;
1199 int i, j, out_size, p_lambda, b_lambda, lambda2;
1200 int64_t best_rd = INT64_MAX;
1201 int best_b_count = -1;
1203 av_assert0(scale >= 0 && scale <= 3);
1206 //s->next_picture_ptr->quality;
1207 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1208 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1209 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1210 if (!b_lambda) // FIXME we should do this somewhere else
1211 b_lambda = p_lambda;
1212 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1215 c->width = s->width >> scale;
1216 c->height = s->height >> scale;
1217 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1218 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1219 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1220 c->mb_decision = s->avctx->mb_decision;
1221 c->me_cmp = s->avctx->me_cmp;
1222 c->mb_cmp = s->avctx->mb_cmp;
1223 c->me_sub_cmp = s->avctx->me_sub_cmp;
1224 c->pix_fmt = AV_PIX_FMT_YUV420P;
1225 c->time_base = s->avctx->time_base;
1226 c->max_b_frames = s->max_b_frames;
1228 if (avcodec_open2(c, codec, NULL) < 0)
1231 for (i = 0; i < s->max_b_frames + 2; i++) {
1232 int ysize = c->width * c->height;
1233 int csize = (c->width / 2) * (c->height / 2);
1234 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1235 s->next_picture_ptr;
1237 avcodec_get_frame_defaults(&input[i]);
1238 input[i].data[0] = av_malloc(ysize + 2 * csize);
1239 input[i].data[1] = input[i].data[0] + ysize;
1240 input[i].data[2] = input[i].data[1] + csize;
1241 input[i].linesize[0] = c->width;
1242 input[i].linesize[1] =
1243 input[i].linesize[2] = c->width / 2;
1245 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1246 pre_input = *pre_input_ptr;
1248 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1249 pre_input.f.data[0] += INPLACE_OFFSET;
1250 pre_input.f.data[1] += INPLACE_OFFSET;
1251 pre_input.f.data[2] += INPLACE_OFFSET;
1254 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1255 pre_input.f.data[0], pre_input.f.linesize[0],
1256 c->width, c->height);
1257 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1258 pre_input.f.data[1], pre_input.f.linesize[1],
1259 c->width >> 1, c->height >> 1);
1260 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1261 pre_input.f.data[2], pre_input.f.linesize[2],
1262 c->width >> 1, c->height >> 1);
1266 for (j = 0; j < s->max_b_frames + 1; j++) {
1269 if (!s->input_picture[j])
1272 c->error[0] = c->error[1] = c->error[2] = 0;
1274 input[0].pict_type = AV_PICTURE_TYPE_I;
1275 input[0].quality = 1 * FF_QP2LAMBDA;
1277 out_size = encode_frame(c, &input[0]);
1279 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1281 for (i = 0; i < s->max_b_frames + 1; i++) {
1282 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1284 input[i + 1].pict_type = is_p ?
1285 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1286 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1288 out_size = encode_frame(c, &input[i + 1]);
1290 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1293 /* get the delayed frames */
1295 out_size = encode_frame(c, NULL);
1296 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1299 rd += c->error[0] + c->error[1] + c->error[2];
1310 for (i = 0; i < s->max_b_frames + 2; i++) {
1311 av_freep(&input[i].data[0]);
1314 return best_b_count;
1317 static int select_input_picture(MpegEncContext *s)
1321 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1322 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1323 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1325 /* set next picture type & ordering */
1326 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1327 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1328 s->next_picture_ptr == NULL || s->intra_only) {
1329 s->reordered_input_picture[0] = s->input_picture[0];
1330 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1331 s->reordered_input_picture[0]->f.coded_picture_number =
1332 s->coded_picture_number++;
1336 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1337 if (s->picture_in_gop_number < s->gop_size &&
1338 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1339 // FIXME check that te gop check above is +-1 correct
1340 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1341 for (i = 0; i < 4; i++)
1342 s->input_picture[0]->f.data[i] = NULL;
1343 s->input_picture[0]->f.type = 0;
1345 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1346 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1348 s->avctx->release_buffer(s->avctx,
1349 &s->input_picture[0]->f);
1353 ff_vbv_update(s, 0);
1359 if (s->flags & CODEC_FLAG_PASS2) {
1360 for (i = 0; i < s->max_b_frames + 1; i++) {
1361 int pict_num = s->input_picture[0]->f.display_picture_number + i;
1363 if (pict_num >= s->rc_context.num_entries)
1365 if (!s->input_picture[i]) {
1366 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1370 s->input_picture[i]->f.pict_type =
1371 s->rc_context.entry[pict_num].new_pict_type;
1375 if (s->avctx->b_frame_strategy == 0) {
1376 b_frames = s->max_b_frames;
1377 while (b_frames && !s->input_picture[b_frames])
1379 } else if (s->avctx->b_frame_strategy == 1) {
1380 for (i = 1; i < s->max_b_frames + 1; i++) {
1381 if (s->input_picture[i] &&
1382 s->input_picture[i]->b_frame_score == 0) {
1383 s->input_picture[i]->b_frame_score =
1385 s->input_picture[i ]->f.data[0],
1386 s->input_picture[i - 1]->f.data[0],
1390 for (i = 0; i < s->max_b_frames + 1; i++) {
1391 if (s->input_picture[i] == NULL ||
1392 s->input_picture[i]->b_frame_score - 1 >
1393 s->mb_num / s->avctx->b_sensitivity)
1397 b_frames = FFMAX(0, i - 1);
1400 for (i = 0; i < b_frames + 1; i++) {
1401 s->input_picture[i]->b_frame_score = 0;
1403 } else if (s->avctx->b_frame_strategy == 2) {
1404 b_frames = estimate_best_b_count(s);
1406 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1412 for (i = b_frames - 1; i >= 0; i--) {
1413 int type = s->input_picture[i]->f.pict_type;
1414 if (type && type != AV_PICTURE_TYPE_B)
1417 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1418 b_frames == s->max_b_frames) {
1419 av_log(s->avctx, AV_LOG_ERROR,
1420 "warning, too many b frames in a row\n");
1423 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1424 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1425 s->gop_size > s->picture_in_gop_number) {
1426 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1428 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1430 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1434 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1435 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1438 s->reordered_input_picture[0] = s->input_picture[b_frames];
1439 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1440 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1441 s->reordered_input_picture[0]->f.coded_picture_number =
1442 s->coded_picture_number++;
1443 for (i = 0; i < b_frames; i++) {
1444 s->reordered_input_picture[i + 1] = s->input_picture[i];
1445 s->reordered_input_picture[i + 1]->f.pict_type =
1447 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1448 s->coded_picture_number++;
1453 if (s->reordered_input_picture[0]) {
1454 s->reordered_input_picture[0]->f.reference =
1455 s->reordered_input_picture[0]->f.pict_type !=
1456 AV_PICTURE_TYPE_B ? 3 : 0;
1458 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1460 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1461 s->avctx->rc_buffer_size) {
1462 // input is a shared pix, so we can't modifiy it -> alloc a new
1463 // one & ensure that the shared one is reuseable
1466 int i = ff_find_unused_picture(s, 0);
1469 pic = &s->picture[i];
1471 pic->f.reference = s->reordered_input_picture[0]->f.reference;
1472 if (ff_alloc_picture(s, pic, 0) < 0) {
1476 /* mark us unused / free shared pic */
1477 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1478 s->avctx->release_buffer(s->avctx,
1479 &s->reordered_input_picture[0]->f);
1480 for (i = 0; i < 4; i++)
1481 s->reordered_input_picture[0]->f.data[i] = NULL;
1482 s->reordered_input_picture[0]->f.type = 0;
1484 copy_picture_attributes(s, &pic->f,
1485 &s->reordered_input_picture[0]->f);
1487 s->current_picture_ptr = pic;
1489 // input is not a shared pix -> reuse buffer for current_pix
1491 assert(s->reordered_input_picture[0]->f.type ==
1492 FF_BUFFER_TYPE_USER ||
1493 s->reordered_input_picture[0]->f.type ==
1494 FF_BUFFER_TYPE_INTERNAL);
1496 s->current_picture_ptr = s->reordered_input_picture[0];
1497 for (i = 0; i < 4; i++) {
1498 s->new_picture.f.data[i] += INPLACE_OFFSET;
1501 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1503 s->picture_number = s->new_picture.f.display_picture_number;
1505 memset(&s->new_picture, 0, sizeof(Picture));
1510 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1511 AVFrame *pic_arg, int *got_packet)
1513 MpegEncContext *s = avctx->priv_data;
1514 int i, stuffing_count, ret;
1515 int context_count = s->slice_context_count;
1517 s->picture_in_gop_number++;
1519 if (load_input_picture(s, pic_arg) < 0)
1522 if (select_input_picture(s) < 0) {
1527 if (s->new_picture.f.data[0]) {
1528 if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1531 s->mb_info_ptr = av_packet_new_side_data(pkt,
1532 AV_PKT_DATA_H263_MB_INFO,
1533 s->mb_width*s->mb_height*12);
1534 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1537 for (i = 0; i < context_count; i++) {
1538 int start_y = s->thread_context[i]->start_mb_y;
1539 int end_y = s->thread_context[i]-> end_mb_y;
1540 int h = s->mb_height;
1541 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1542 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1544 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1547 s->pict_type = s->new_picture.f.pict_type;
1549 if (ff_MPV_frame_start(s, avctx) < 0)
1552 if (encode_picture(s, s->picture_number) < 0)
1555 avctx->header_bits = s->header_bits;
1556 avctx->mv_bits = s->mv_bits;
1557 avctx->misc_bits = s->misc_bits;
1558 avctx->i_tex_bits = s->i_tex_bits;
1559 avctx->p_tex_bits = s->p_tex_bits;
1560 avctx->i_count = s->i_count;
1561 // FIXME f/b_count in avctx
1562 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1563 avctx->skip_count = s->skip_count;
1565 ff_MPV_frame_end(s);
1567 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1568 ff_mjpeg_encode_picture_trailer(s);
1570 if (avctx->rc_buffer_size) {
1571 RateControlContext *rcc = &s->rc_context;
1572 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1574 if (put_bits_count(&s->pb) > max_size &&
1575 s->lambda < s->avctx->lmax) {
1576 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1577 (s->qscale + 1) / s->qscale);
1578 if (s->adaptive_quant) {
1580 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1581 s->lambda_table[i] =
1582 FFMAX(s->lambda_table[i] + 1,
1583 s->lambda_table[i] * (s->qscale + 1) /
1586 s->mb_skipped = 0; // done in MPV_frame_start()
1587 // done in encode_picture() so we must undo it
1588 if (s->pict_type == AV_PICTURE_TYPE_P) {
1589 if (s->flipflop_rounding ||
1590 s->codec_id == AV_CODEC_ID_H263P ||
1591 s->codec_id == AV_CODEC_ID_MPEG4)
1592 s->no_rounding ^= 1;
1594 if (s->pict_type != AV_PICTURE_TYPE_B) {
1595 s->time_base = s->last_time_base;
1596 s->last_non_b_time = s->time - s->pp_time;
1598 for (i = 0; i < context_count; i++) {
1599 PutBitContext *pb = &s->thread_context[i]->pb;
1600 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1605 assert(s->avctx->rc_max_rate);
1608 if (s->flags & CODEC_FLAG_PASS1)
1609 ff_write_pass1_stats(s);
1611 for (i = 0; i < 4; i++) {
1612 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1613 avctx->error[i] += s->current_picture_ptr->f.error[i];
1616 if (s->flags & CODEC_FLAG_PASS1)
1617 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1618 avctx->i_tex_bits + avctx->p_tex_bits ==
1619 put_bits_count(&s->pb));
1620 flush_put_bits(&s->pb);
1621 s->frame_bits = put_bits_count(&s->pb);
1623 stuffing_count = ff_vbv_update(s, s->frame_bits);
1624 s->stuffing_bits = 8*stuffing_count;
1625 if (stuffing_count) {
1626 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1627 stuffing_count + 50) {
1628 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1632 switch (s->codec_id) {
1633 case AV_CODEC_ID_MPEG1VIDEO:
1634 case AV_CODEC_ID_MPEG2VIDEO:
1635 while (stuffing_count--) {
1636 put_bits(&s->pb, 8, 0);
1639 case AV_CODEC_ID_MPEG4:
1640 put_bits(&s->pb, 16, 0);
1641 put_bits(&s->pb, 16, 0x1C3);
1642 stuffing_count -= 4;
1643 while (stuffing_count--) {
1644 put_bits(&s->pb, 8, 0xFF);
1648 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1650 flush_put_bits(&s->pb);
1651 s->frame_bits = put_bits_count(&s->pb);
1654 /* update mpeg1/2 vbv_delay for CBR */
1655 if (s->avctx->rc_max_rate &&
1656 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1657 s->out_format == FMT_MPEG1 &&
1658 90000LL * (avctx->rc_buffer_size - 1) <=
1659 s->avctx->rc_max_rate * 0xFFFFLL) {
1660 int vbv_delay, min_delay;
1661 double inbits = s->avctx->rc_max_rate *
1662 av_q2d(s->avctx->time_base);
1663 int minbits = s->frame_bits - 8 *
1664 (s->vbv_delay_ptr - s->pb.buf - 1);
1665 double bits = s->rc_context.buffer_index + minbits - inbits;
1668 av_log(s->avctx, AV_LOG_ERROR,
1669 "Internal error, negative bits\n");
1671 assert(s->repeat_first_field == 0);
1673 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1674 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1675 s->avctx->rc_max_rate;
1677 vbv_delay = FFMAX(vbv_delay, min_delay);
1679 av_assert0(vbv_delay < 0xFFFF);
1681 s->vbv_delay_ptr[0] &= 0xF8;
1682 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1683 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1684 s->vbv_delay_ptr[2] &= 0x07;
1685 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1686 avctx->vbv_delay = vbv_delay * 300;
1688 s->total_bits += s->frame_bits;
1689 avctx->frame_bits = s->frame_bits;
1691 pkt->pts = s->current_picture.f.pts;
1692 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1693 if (!s->current_picture.f.coded_picture_number)
1694 pkt->dts = pkt->pts - s->dts_delta;
1696 pkt->dts = s->reordered_pts;
1697 s->reordered_pts = pkt->pts;
1699 pkt->dts = pkt->pts;
1700 if (s->current_picture.f.key_frame)
1701 pkt->flags |= AV_PKT_FLAG_KEY;
1703 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1707 assert((s->frame_bits & 7) == 0);
1709 pkt->size = s->frame_bits / 8;
1710 *got_packet = !!pkt->size;
1714 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1715 int n, int threshold)
1717 static const char tab[64] = {
1718 3, 2, 2, 1, 1, 1, 1, 1,
1719 1, 1, 1, 1, 1, 1, 1, 1,
1720 1, 1, 1, 1, 1, 1, 1, 1,
1721 0, 0, 0, 0, 0, 0, 0, 0,
1722 0, 0, 0, 0, 0, 0, 0, 0,
1723 0, 0, 0, 0, 0, 0, 0, 0,
1724 0, 0, 0, 0, 0, 0, 0, 0,
1725 0, 0, 0, 0, 0, 0, 0, 0
1730 int16_t *block = s->block[n];
1731 const int last_index = s->block_last_index[n];
1734 if (threshold < 0) {
1736 threshold = -threshold;
1740 /* Are all we could set to zero already zero? */
1741 if (last_index <= skip_dc - 1)
1744 for (i = 0; i <= last_index; i++) {
1745 const int j = s->intra_scantable.permutated[i];
1746 const int level = FFABS(block[j]);
1748 if (skip_dc && i == 0)
1752 } else if (level > 1) {
1758 if (score >= threshold)
1760 for (i = skip_dc; i <= last_index; i++) {
1761 const int j = s->intra_scantable.permutated[i];
1765 s->block_last_index[n] = 0;
1767 s->block_last_index[n] = -1;
1770 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1774 const int maxlevel = s->max_qcoeff;
1775 const int minlevel = s->min_qcoeff;
1779 i = 1; // skip clipping of intra dc
1783 for (; i <= last_index; i++) {
1784 const int j = s->intra_scantable.permutated[i];
1785 int level = block[j];
1787 if (level > maxlevel) {
1790 } else if (level < minlevel) {
1798 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1799 av_log(s->avctx, AV_LOG_INFO,
1800 "warning, clipping %d dct coefficients to %d..%d\n",
1801 overflow, minlevel, maxlevel);
1804 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1808 for (y = 0; y < 8; y++) {
1809 for (x = 0; x < 8; x++) {
1815 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1816 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1817 int v = ptr[x2 + y2 * stride];
1823 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1828 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1829 int motion_x, int motion_y,
1830 int mb_block_height,
1834 int16_t weight[12][64];
1835 int16_t orig[12][64];
1836 const int mb_x = s->mb_x;
1837 const int mb_y = s->mb_y;
1840 int dct_offset = s->linesize * 8; // default for progressive frames
1841 int uv_dct_offset = s->uvlinesize * 8;
1842 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1845 for (i = 0; i < mb_block_count; i++)
1846 skip_dct[i] = s->skipdct;
1848 if (s->adaptive_quant) {
1849 const int last_qp = s->qscale;
1850 const int mb_xy = mb_x + mb_y * s->mb_stride;
1852 s->lambda = s->lambda_table[mb_xy];
1855 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1856 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1857 s->dquant = s->qscale - last_qp;
1859 if (s->out_format == FMT_H263) {
1860 s->dquant = av_clip(s->dquant, -2, 2);
1862 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1864 if (s->pict_type == AV_PICTURE_TYPE_B) {
1865 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1868 if (s->mv_type == MV_TYPE_8X8)
1874 ff_set_qscale(s, last_qp + s->dquant);
1875 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1876 ff_set_qscale(s, s->qscale + s->dquant);
1878 wrap_y = s->linesize;
1879 wrap_c = s->uvlinesize;
1880 ptr_y = s->new_picture.f.data[0] +
1881 (mb_y * 16 * wrap_y) + mb_x * 16;
1882 ptr_cb = s->new_picture.f.data[1] +
1883 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1884 ptr_cr = s->new_picture.f.data[2] +
1885 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1887 if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1888 uint8_t *ebuf = s->edge_emu_buffer + 32;
1889 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1890 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1891 s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1892 mb_y * 16, s->width, s->height);
1894 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, mb_block_width,
1895 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1897 ptr_cb = ebuf + 18 * wrap_y;
1898 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr, wrap_c, mb_block_width,
1899 mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1901 ptr_cr = ebuf + 18 * wrap_y + 16;
1905 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1906 int progressive_score, interlaced_score;
1908 s->interlaced_dct = 0;
1909 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1911 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1912 NULL, wrap_y, 8) - 400;
1914 if (progressive_score > 0) {
1915 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1916 NULL, wrap_y * 2, 8) +
1917 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1918 NULL, wrap_y * 2, 8);
1919 if (progressive_score > interlaced_score) {
1920 s->interlaced_dct = 1;
1922 dct_offset = wrap_y;
1923 uv_dct_offset = wrap_c;
1925 if (s->chroma_format == CHROMA_422 ||
1926 s->chroma_format == CHROMA_444)
1932 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1933 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1934 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1935 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1937 if (s->flags & CODEC_FLAG_GRAY) {
1941 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1942 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1943 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1944 s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1945 s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1946 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1947 s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1948 s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1949 s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1950 s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1951 s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1952 s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1956 op_pixels_func (*op_pix)[4];
1957 qpel_mc_func (*op_qpix)[16];
1958 uint8_t *dest_y, *dest_cb, *dest_cr;
1960 dest_y = s->dest[0];
1961 dest_cb = s->dest[1];
1962 dest_cr = s->dest[2];
1964 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1965 op_pix = s->dsp.put_pixels_tab;
1966 op_qpix = s->dsp.put_qpel_pixels_tab;
1968 op_pix = s->dsp.put_no_rnd_pixels_tab;
1969 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1972 if (s->mv_dir & MV_DIR_FORWARD) {
1973 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1974 s->last_picture.f.data,
1976 op_pix = s->dsp.avg_pixels_tab;
1977 op_qpix = s->dsp.avg_qpel_pixels_tab;
1979 if (s->mv_dir & MV_DIR_BACKWARD) {
1980 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1981 s->next_picture.f.data,
1985 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1986 int progressive_score, interlaced_score;
1988 s->interlaced_dct = 0;
1989 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1992 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1993 ptr_y + wrap_y * 8, wrap_y,
1996 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1997 progressive_score -= 400;
1999 if (progressive_score > 0) {
2000 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
2003 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
2007 if (progressive_score > interlaced_score) {
2008 s->interlaced_dct = 1;
2010 dct_offset = wrap_y;
2011 uv_dct_offset = wrap_c;
2013 if (s->chroma_format == CHROMA_422)
2019 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2020 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2021 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2022 dest_y + dct_offset, wrap_y);
2023 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2024 dest_y + dct_offset + 8, wrap_y);
2026 if (s->flags & CODEC_FLAG_GRAY) {
2030 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2031 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2032 if (!s->chroma_y_shift) { /* 422 */
2033 s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2034 dest_cb + uv_dct_offset, wrap_c);
2035 s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2036 dest_cr + uv_dct_offset, wrap_c);
2039 /* pre quantization */
2040 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2041 2 * s->qscale * s->qscale) {
2043 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
2044 wrap_y, 8) < 20 * s->qscale)
2046 if (s->dsp.sad[1](NULL, ptr_y + 8,
2047 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2049 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
2050 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
2052 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
2053 dest_y + dct_offset + 8,
2054 wrap_y, 8) < 20 * s->qscale)
2056 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2057 wrap_c, 8) < 20 * s->qscale)
2059 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2060 wrap_c, 8) < 20 * s->qscale)
2062 if (!s->chroma_y_shift) { /* 422 */
2063 if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
2064 dest_cb + uv_dct_offset,
2065 wrap_c, 8) < 20 * s->qscale)
2067 if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
2068 dest_cr + uv_dct_offset,
2069 wrap_c, 8) < 20 * s->qscale)
2075 if (s->quantizer_noise_shaping) {
2077 get_visual_weight(weight[0], ptr_y , wrap_y);
2079 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2081 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2083 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2085 get_visual_weight(weight[4], ptr_cb , wrap_c);
2087 get_visual_weight(weight[5], ptr_cr , wrap_c);
2088 if (!s->chroma_y_shift) { /* 422 */
2090 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2093 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2096 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2099 /* DCT & quantize */
2100 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2102 for (i = 0; i < mb_block_count; i++) {
2105 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2106 // FIXME we could decide to change to quantizer instead of
2108 // JS: I don't think that would be a good idea it could lower
2109 // quality instead of improve it. Just INTRADC clipping
2110 // deserves changes in quantizer
2112 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2114 s->block_last_index[i] = -1;
2116 if (s->quantizer_noise_shaping) {
2117 for (i = 0; i < mb_block_count; i++) {
2119 s->block_last_index[i] =
2120 dct_quantize_refine(s, s->block[i], weight[i],
2121 orig[i], i, s->qscale);
2126 if (s->luma_elim_threshold && !s->mb_intra)
2127 for (i = 0; i < 4; i++)
2128 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2129 if (s->chroma_elim_threshold && !s->mb_intra)
2130 for (i = 4; i < mb_block_count; i++)
2131 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2133 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2134 for (i = 0; i < mb_block_count; i++) {
2135 if (s->block_last_index[i] == -1)
2136 s->coded_score[i] = INT_MAX / 256;
2141 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2142 s->block_last_index[4] =
2143 s->block_last_index[5] = 0;
2145 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2148 // non c quantize code returns incorrect block_last_index FIXME
2149 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2150 for (i = 0; i < mb_block_count; i++) {
2152 if (s->block_last_index[i] > 0) {
2153 for (j = 63; j > 0; j--) {
2154 if (s->block[i][s->intra_scantable.permutated[j]])
2157 s->block_last_index[i] = j;
2162 /* huffman encode */
2163 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2164 case AV_CODEC_ID_MPEG1VIDEO:
2165 case AV_CODEC_ID_MPEG2VIDEO:
2166 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2167 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2169 case AV_CODEC_ID_MPEG4:
2170 if (CONFIG_MPEG4_ENCODER)
2171 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2173 case AV_CODEC_ID_MSMPEG4V2:
2174 case AV_CODEC_ID_MSMPEG4V3:
2175 case AV_CODEC_ID_WMV1:
2176 if (CONFIG_MSMPEG4_ENCODER)
2177 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2179 case AV_CODEC_ID_WMV2:
2180 if (CONFIG_WMV2_ENCODER)
2181 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2183 case AV_CODEC_ID_H261:
2184 if (CONFIG_H261_ENCODER)
2185 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2187 case AV_CODEC_ID_H263:
2188 case AV_CODEC_ID_H263P:
2189 case AV_CODEC_ID_FLV1:
2190 case AV_CODEC_ID_RV10:
2191 case AV_CODEC_ID_RV20:
2192 if (CONFIG_H263_ENCODER)
2193 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2195 case AV_CODEC_ID_MJPEG:
2196 case AV_CODEC_ID_AMV:
2197 if (CONFIG_MJPEG_ENCODER)
2198 ff_mjpeg_encode_mb(s, s->block);
2205 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2207 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2208 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2209 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2212 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2215 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2218 d->mb_skip_run= s->mb_skip_run;
2220 d->last_dc[i] = s->last_dc[i];
2223 d->mv_bits= s->mv_bits;
2224 d->i_tex_bits= s->i_tex_bits;
2225 d->p_tex_bits= s->p_tex_bits;
2226 d->i_count= s->i_count;
2227 d->f_count= s->f_count;
2228 d->b_count= s->b_count;
2229 d->skip_count= s->skip_count;
2230 d->misc_bits= s->misc_bits;
2234 d->qscale= s->qscale;
2235 d->dquant= s->dquant;
2237 d->esc3_level_length= s->esc3_level_length;
2240 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2243 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2244 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2247 d->mb_skip_run= s->mb_skip_run;
2249 d->last_dc[i] = s->last_dc[i];
2252 d->mv_bits= s->mv_bits;
2253 d->i_tex_bits= s->i_tex_bits;
2254 d->p_tex_bits= s->p_tex_bits;
2255 d->i_count= s->i_count;
2256 d->f_count= s->f_count;
2257 d->b_count= s->b_count;
2258 d->skip_count= s->skip_count;
2259 d->misc_bits= s->misc_bits;
2261 d->mb_intra= s->mb_intra;
2262 d->mb_skipped= s->mb_skipped;
2263 d->mv_type= s->mv_type;
2264 d->mv_dir= s->mv_dir;
2266 if(s->data_partitioning){
2268 d->tex_pb= s->tex_pb;
2272 d->block_last_index[i]= s->block_last_index[i];
2273 d->interlaced_dct= s->interlaced_dct;
2274 d->qscale= s->qscale;
2276 d->esc3_level_length= s->esc3_level_length;
2279 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2280 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2281 int *dmin, int *next_block, int motion_x, int motion_y)
2284 uint8_t *dest_backup[3];
2286 copy_context_before_encode(s, backup, type);
2288 s->block= s->blocks[*next_block];
2289 s->pb= pb[*next_block];
2290 if(s->data_partitioning){
2291 s->pb2 = pb2 [*next_block];
2292 s->tex_pb= tex_pb[*next_block];
2296 memcpy(dest_backup, s->dest, sizeof(s->dest));
2297 s->dest[0] = s->rd_scratchpad;
2298 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2299 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2300 assert(s->linesize >= 32); //FIXME
2303 encode_mb(s, motion_x, motion_y);
2305 score= put_bits_count(&s->pb);
2306 if(s->data_partitioning){
2307 score+= put_bits_count(&s->pb2);
2308 score+= put_bits_count(&s->tex_pb);
2311 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2312 ff_MPV_decode_mb(s, s->block);
2314 score *= s->lambda2;
2315 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2319 memcpy(s->dest, dest_backup, sizeof(s->dest));
2326 copy_context_after_encode(best, s, type);
2330 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2331 uint32_t *sq = ff_squareTbl + 256;
2336 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2337 else if(w==8 && h==8)
2338 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2342 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2351 static int sse_mb(MpegEncContext *s){
2355 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2356 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2359 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2360 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)
2361 +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)
2362 +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);
2364 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)
2365 +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)
2366 +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);
2369 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)
2370 +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)
2371 +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);
2374 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2375 MpegEncContext *s= *(void**)arg;
2379 s->me.dia_size= s->avctx->pre_dia_size;
2380 s->first_slice_line=1;
2381 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2382 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2383 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2385 s->first_slice_line=0;
2393 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2394 MpegEncContext *s= *(void**)arg;
2396 ff_check_alignment();
2398 s->me.dia_size= s->avctx->dia_size;
2399 s->first_slice_line=1;
2400 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2401 s->mb_x=0; //for block init below
2402 ff_init_block_index(s);
2403 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2404 s->block_index[0]+=2;
2405 s->block_index[1]+=2;
2406 s->block_index[2]+=2;
2407 s->block_index[3]+=2;
2409 /* compute motion vector & mb_type and store in context */
2410 if(s->pict_type==AV_PICTURE_TYPE_B)
2411 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2413 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2415 s->first_slice_line=0;
2420 static int mb_var_thread(AVCodecContext *c, void *arg){
2421 MpegEncContext *s= *(void**)arg;
2424 ff_check_alignment();
2426 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2427 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2430 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2432 int sum = s->dsp.pix_sum(pix, s->linesize);
2434 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2436 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2437 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2438 s->me.mb_var_sum_temp += varc;
2444 static void write_slice_end(MpegEncContext *s){
2445 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2446 if(s->partitioned_frame){
2447 ff_mpeg4_merge_partitions(s);
2450 ff_mpeg4_stuffing(&s->pb);
2451 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2452 ff_mjpeg_encode_stuffing(s);
2455 avpriv_align_put_bits(&s->pb);
2456 flush_put_bits(&s->pb);
2458 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2459 s->misc_bits+= get_bits_diff(s);
2462 static void write_mb_info(MpegEncContext *s)
2464 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2465 int offset = put_bits_count(&s->pb);
2466 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2467 int gobn = s->mb_y / s->gob_index;
2469 if (CONFIG_H263_ENCODER)
2470 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2471 bytestream_put_le32(&ptr, offset);
2472 bytestream_put_byte(&ptr, s->qscale);
2473 bytestream_put_byte(&ptr, gobn);
2474 bytestream_put_le16(&ptr, mba);
2475 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2476 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2477 /* 4MV not implemented */
2478 bytestream_put_byte(&ptr, 0); /* hmv2 */
2479 bytestream_put_byte(&ptr, 0); /* vmv2 */
2482 static void update_mb_info(MpegEncContext *s, int startcode)
2486 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2487 s->mb_info_size += 12;
2488 s->prev_mb_info = s->last_mb_info;
2491 s->prev_mb_info = put_bits_count(&s->pb)/8;
2492 /* This might have incremented mb_info_size above, and we return without
2493 * actually writing any info into that slot yet. But in that case,
2494 * this will be called again at the start of the after writing the
2495 * start code, actually writing the mb info. */
2499 s->last_mb_info = put_bits_count(&s->pb)/8;
2500 if (!s->mb_info_size)
2501 s->mb_info_size += 12;
2505 static int encode_thread(AVCodecContext *c, void *arg){
2506 MpegEncContext *s= *(void**)arg;
2507 int mb_x, mb_y, pdif = 0;
2508 int chr_h= 16>>s->chroma_y_shift;
2510 MpegEncContext best_s, backup_s;
2511 uint8_t bit_buf[2][MAX_MB_BYTES];
2512 uint8_t bit_buf2[2][MAX_MB_BYTES];
2513 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2514 PutBitContext pb[2], pb2[2], tex_pb[2];
2516 ff_check_alignment();
2519 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2520 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2521 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2524 s->last_bits= put_bits_count(&s->pb);
2535 /* init last dc values */
2536 /* note: quant matrix value (8) is implied here */
2537 s->last_dc[i] = 128 << s->intra_dc_precision;
2539 s->current_picture.f.error[i] = 0;
2541 if(s->codec_id==AV_CODEC_ID_AMV){
2542 s->last_dc[0] = 128*8/13;
2543 s->last_dc[1] = 128*8/14;
2544 s->last_dc[2] = 128*8/14;
2547 memset(s->last_mv, 0, sizeof(s->last_mv));
2551 switch(s->codec_id){
2552 case AV_CODEC_ID_H263:
2553 case AV_CODEC_ID_H263P:
2554 case AV_CODEC_ID_FLV1:
2555 if (CONFIG_H263_ENCODER)
2556 s->gob_index = ff_h263_get_gob_height(s);
2558 case AV_CODEC_ID_MPEG4:
2559 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2560 ff_mpeg4_init_partitions(s);
2566 s->first_slice_line = 1;
2567 s->ptr_lastgob = s->pb.buf;
2568 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2572 ff_set_qscale(s, s->qscale);
2573 ff_init_block_index(s);
2575 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2576 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2577 int mb_type= s->mb_type[xy];
2582 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2583 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2586 if(s->data_partitioning){
2587 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2588 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2589 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2595 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2596 ff_update_block_index(s);
2598 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2599 ff_h261_reorder_mb_index(s);
2600 xy= s->mb_y*s->mb_stride + s->mb_x;
2601 mb_type= s->mb_type[xy];
2604 /* write gob / video packet header */
2606 int current_packet_size, is_gob_start;
2608 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2610 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2612 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2614 switch(s->codec_id){
2615 case AV_CODEC_ID_H263:
2616 case AV_CODEC_ID_H263P:
2617 if(!s->h263_slice_structured)
2618 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2620 case AV_CODEC_ID_MPEG2VIDEO:
2621 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2622 case AV_CODEC_ID_MPEG1VIDEO:
2623 if(s->mb_skip_run) is_gob_start=0;
2625 case AV_CODEC_ID_MJPEG:
2626 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2631 if(s->start_mb_y != mb_y || mb_x!=0){
2633 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2634 ff_mpeg4_init_partitions(s);
2638 av_assert2((put_bits_count(&s->pb)&7) == 0);
2639 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2641 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2642 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2643 int d= 100 / s->avctx->error_rate;
2645 current_packet_size=0;
2646 s->pb.buf_ptr= s->ptr_lastgob;
2647 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2651 if (s->avctx->rtp_callback){
2652 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2653 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2655 update_mb_info(s, 1);
2657 switch(s->codec_id){
2658 case AV_CODEC_ID_MPEG4:
2659 if (CONFIG_MPEG4_ENCODER) {
2660 ff_mpeg4_encode_video_packet_header(s);
2661 ff_mpeg4_clean_buffers(s);
2664 case AV_CODEC_ID_MPEG1VIDEO:
2665 case AV_CODEC_ID_MPEG2VIDEO:
2666 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2667 ff_mpeg1_encode_slice_header(s);
2668 ff_mpeg1_clean_buffers(s);
2671 case AV_CODEC_ID_H263:
2672 case AV_CODEC_ID_H263P:
2673 if (CONFIG_H263_ENCODER)
2674 ff_h263_encode_gob_header(s, mb_y);
2678 if(s->flags&CODEC_FLAG_PASS1){
2679 int bits= put_bits_count(&s->pb);
2680 s->misc_bits+= bits - s->last_bits;
2684 s->ptr_lastgob += current_packet_size;
2685 s->first_slice_line=1;
2686 s->resync_mb_x=mb_x;
2687 s->resync_mb_y=mb_y;
2691 if( (s->resync_mb_x == s->mb_x)
2692 && s->resync_mb_y+1 == s->mb_y){
2693 s->first_slice_line=0;
2697 s->dquant=0; //only for QP_RD
2699 update_mb_info(s, 0);
2701 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
2703 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2705 copy_context_before_encode(&backup_s, s, -1);
2707 best_s.data_partitioning= s->data_partitioning;
2708 best_s.partitioned_frame= s->partitioned_frame;
2709 if(s->data_partitioning){
2710 backup_s.pb2= s->pb2;
2711 backup_s.tex_pb= s->tex_pb;
2714 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2715 s->mv_dir = MV_DIR_FORWARD;
2716 s->mv_type = MV_TYPE_16X16;
2718 s->mv[0][0][0] = s->p_mv_table[xy][0];
2719 s->mv[0][0][1] = s->p_mv_table[xy][1];
2720 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2721 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2723 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2724 s->mv_dir = MV_DIR_FORWARD;
2725 s->mv_type = MV_TYPE_FIELD;
2728 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2729 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2730 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2732 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2733 &dmin, &next_block, 0, 0);
2735 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2736 s->mv_dir = MV_DIR_FORWARD;
2737 s->mv_type = MV_TYPE_16X16;
2741 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2742 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2744 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2745 s->mv_dir = MV_DIR_FORWARD;
2746 s->mv_type = MV_TYPE_8X8;
2749 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2750 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2752 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2753 &dmin, &next_block, 0, 0);
2755 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2756 s->mv_dir = MV_DIR_FORWARD;
2757 s->mv_type = MV_TYPE_16X16;
2759 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2760 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2761 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2762 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2764 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2765 s->mv_dir = MV_DIR_BACKWARD;
2766 s->mv_type = MV_TYPE_16X16;
2768 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2769 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2770 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2771 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2773 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2774 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2775 s->mv_type = MV_TYPE_16X16;
2777 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2778 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2779 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2780 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2781 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2782 &dmin, &next_block, 0, 0);
2784 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2785 s->mv_dir = MV_DIR_FORWARD;
2786 s->mv_type = MV_TYPE_FIELD;
2789 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2790 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2791 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2793 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2794 &dmin, &next_block, 0, 0);
2796 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2797 s->mv_dir = MV_DIR_BACKWARD;
2798 s->mv_type = MV_TYPE_FIELD;
2801 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2802 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2803 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2805 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2806 &dmin, &next_block, 0, 0);
2808 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2809 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2810 s->mv_type = MV_TYPE_FIELD;
2812 for(dir=0; dir<2; dir++){
2814 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2815 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2816 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2819 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2820 &dmin, &next_block, 0, 0);
2822 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2824 s->mv_type = MV_TYPE_16X16;
2828 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2829 &dmin, &next_block, 0, 0);
2830 if(s->h263_pred || s->h263_aic){
2832 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2834 ff_clean_intra_table_entries(s); //old mode?
2838 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2839 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2840 const int last_qp= backup_s.qscale;
2843 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2844 static const int dquant_tab[4]={-1,1,-2,2};
2846 av_assert2(backup_s.dquant == 0);
2849 s->mv_dir= best_s.mv_dir;
2850 s->mv_type = MV_TYPE_16X16;
2851 s->mb_intra= best_s.mb_intra;
2852 s->mv[0][0][0] = best_s.mv[0][0][0];
2853 s->mv[0][0][1] = best_s.mv[0][0][1];
2854 s->mv[1][0][0] = best_s.mv[1][0][0];
2855 s->mv[1][0][1] = best_s.mv[1][0][1];
2857 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2858 for(; qpi<4; qpi++){
2859 int dquant= dquant_tab[qpi];
2860 qp= last_qp + dquant;
2861 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2863 backup_s.dquant= dquant;
2864 if(s->mb_intra && s->dc_val[0]){
2866 dc[i]= s->dc_val[0][ s->block_index[i] ];
2867 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2871 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2872 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2873 if(best_s.qscale != qp){
2874 if(s->mb_intra && s->dc_val[0]){
2876 s->dc_val[0][ s->block_index[i] ]= dc[i];
2877 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2884 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2885 int mx= s->b_direct_mv_table[xy][0];
2886 int my= s->b_direct_mv_table[xy][1];
2888 backup_s.dquant = 0;
2889 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2891 ff_mpeg4_set_direct_mv(s, mx, my);
2892 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2893 &dmin, &next_block, mx, my);
2895 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2896 backup_s.dquant = 0;
2897 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2899 ff_mpeg4_set_direct_mv(s, 0, 0);
2900 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2901 &dmin, &next_block, 0, 0);
2903 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2906 coded |= s->block_last_index[i];
2909 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2910 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2911 mx=my=0; //FIXME find the one we actually used
2912 ff_mpeg4_set_direct_mv(s, mx, my);
2913 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2921 s->mv_dir= best_s.mv_dir;
2922 s->mv_type = best_s.mv_type;
2924 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2925 s->mv[0][0][1] = best_s.mv[0][0][1];
2926 s->mv[1][0][0] = best_s.mv[1][0][0];
2927 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2930 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2931 &dmin, &next_block, mx, my);
2936 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2938 copy_context_after_encode(s, &best_s, -1);
2940 pb_bits_count= put_bits_count(&s->pb);
2941 flush_put_bits(&s->pb);
2942 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2945 if(s->data_partitioning){
2946 pb2_bits_count= put_bits_count(&s->pb2);
2947 flush_put_bits(&s->pb2);
2948 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2949 s->pb2= backup_s.pb2;
2951 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2952 flush_put_bits(&s->tex_pb);
2953 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2954 s->tex_pb= backup_s.tex_pb;
2956 s->last_bits= put_bits_count(&s->pb);
2958 if (CONFIG_H263_ENCODER &&
2959 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2960 ff_h263_update_motion_val(s);
2962 if(next_block==0){ //FIXME 16 vs linesize16
2963 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2964 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2965 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2968 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2969 ff_MPV_decode_mb(s, s->block);
2971 int motion_x = 0, motion_y = 0;
2972 s->mv_type=MV_TYPE_16X16;
2973 // only one MB-Type possible
2976 case CANDIDATE_MB_TYPE_INTRA:
2979 motion_x= s->mv[0][0][0] = 0;
2980 motion_y= s->mv[0][0][1] = 0;
2982 case CANDIDATE_MB_TYPE_INTER:
2983 s->mv_dir = MV_DIR_FORWARD;
2985 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2986 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2988 case CANDIDATE_MB_TYPE_INTER_I:
2989 s->mv_dir = MV_DIR_FORWARD;
2990 s->mv_type = MV_TYPE_FIELD;
2993 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2994 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2995 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2998 case CANDIDATE_MB_TYPE_INTER4V:
2999 s->mv_dir = MV_DIR_FORWARD;
3000 s->mv_type = MV_TYPE_8X8;
3003 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
3004 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
3007 case CANDIDATE_MB_TYPE_DIRECT:
3008 if (CONFIG_MPEG4_ENCODER) {
3009 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3011 motion_x=s->b_direct_mv_table[xy][0];
3012 motion_y=s->b_direct_mv_table[xy][1];
3013 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3016 case CANDIDATE_MB_TYPE_DIRECT0:
3017 if (CONFIG_MPEG4_ENCODER) {
3018 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3020 ff_mpeg4_set_direct_mv(s, 0, 0);
3023 case CANDIDATE_MB_TYPE_BIDIR:
3024 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3026 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3027 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3028 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3029 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3031 case CANDIDATE_MB_TYPE_BACKWARD:
3032 s->mv_dir = MV_DIR_BACKWARD;
3034 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3035 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3037 case CANDIDATE_MB_TYPE_FORWARD:
3038 s->mv_dir = MV_DIR_FORWARD;
3040 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3041 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3043 case CANDIDATE_MB_TYPE_FORWARD_I:
3044 s->mv_dir = MV_DIR_FORWARD;
3045 s->mv_type = MV_TYPE_FIELD;
3048 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3049 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3050 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3053 case CANDIDATE_MB_TYPE_BACKWARD_I:
3054 s->mv_dir = MV_DIR_BACKWARD;
3055 s->mv_type = MV_TYPE_FIELD;
3058 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3059 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3060 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3063 case CANDIDATE_MB_TYPE_BIDIR_I:
3064 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3065 s->mv_type = MV_TYPE_FIELD;
3067 for(dir=0; dir<2; dir++){
3069 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3070 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3071 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3076 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3079 encode_mb(s, motion_x, motion_y);
3081 // RAL: Update last macroblock type
3082 s->last_mv_dir = s->mv_dir;
3084 if (CONFIG_H263_ENCODER &&
3085 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3086 ff_h263_update_motion_val(s);
3088 ff_MPV_decode_mb(s, s->block);
3091 /* clean the MV table in IPS frames for direct mode in B frames */
3092 if(s->mb_intra /* && I,P,S_TYPE */){
3093 s->p_mv_table[xy][0]=0;
3094 s->p_mv_table[xy][1]=0;
3097 if(s->flags&CODEC_FLAG_PSNR){
3101 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3102 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3104 s->current_picture.f.error[0] += sse(
3105 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3106 s->dest[0], w, h, s->linesize);
3107 s->current_picture.f.error[1] += sse(
3108 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3109 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3110 s->current_picture.f.error[2] += sse(
3111 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3112 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3115 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3116 ff_h263_loop_filter(s);
3118 av_dlog(s->avctx, "MB %d %d bits\n",
3119 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3123 //not beautiful here but we must write it before flushing so it has to be here
3124 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3125 ff_msmpeg4_encode_ext_header(s);
3129 /* Send the last GOB if RTP */
3130 if (s->avctx->rtp_callback) {
3131 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3132 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3133 /* Call the RTP callback to send the last GOB */
3135 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3141 #define MERGE(field) dst->field += src->field; src->field=0
3142 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3143 MERGE(me.scene_change_score);
3144 MERGE(me.mc_mb_var_sum_temp);
3145 MERGE(me.mb_var_sum_temp);
3148 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3151 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3152 MERGE(dct_count[1]);
3162 MERGE(padding_bug_score);
3163 MERGE(current_picture.f.error[0]);
3164 MERGE(current_picture.f.error[1]);
3165 MERGE(current_picture.f.error[2]);
3167 if(dst->avctx->noise_reduction){
3168 for(i=0; i<64; i++){
3169 MERGE(dct_error_sum[0][i]);
3170 MERGE(dct_error_sum[1][i]);
3174 assert(put_bits_count(&src->pb) % 8 ==0);
3175 assert(put_bits_count(&dst->pb) % 8 ==0);
3176 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3177 flush_put_bits(&dst->pb);
3180 static int estimate_qp(MpegEncContext *s, int dry_run){
3181 if (s->next_lambda){
3182 s->current_picture_ptr->f.quality =
3183 s->current_picture.f.quality = s->next_lambda;
3184 if(!dry_run) s->next_lambda= 0;
3185 } else if (!s->fixed_qscale) {
3186 s->current_picture_ptr->f.quality =
3187 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3188 if (s->current_picture.f.quality < 0)
3192 if(s->adaptive_quant){
3193 switch(s->codec_id){
3194 case AV_CODEC_ID_MPEG4:
3195 if (CONFIG_MPEG4_ENCODER)
3196 ff_clean_mpeg4_qscales(s);
3198 case AV_CODEC_ID_H263:
3199 case AV_CODEC_ID_H263P:
3200 case AV_CODEC_ID_FLV1:
3201 if (CONFIG_H263_ENCODER)
3202 ff_clean_h263_qscales(s);
3205 ff_init_qscale_tab(s);
3208 s->lambda= s->lambda_table[0];
3211 s->lambda = s->current_picture.f.quality;
3216 /* must be called before writing the header */
3217 static void set_frame_distances(MpegEncContext * s){
3218 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3219 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3221 if(s->pict_type==AV_PICTURE_TYPE_B){
3222 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3223 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3225 s->pp_time= s->time - s->last_non_b_time;
3226 s->last_non_b_time= s->time;
3227 assert(s->picture_number==0 || s->pp_time > 0);
3231 static int encode_picture(MpegEncContext *s, int picture_number)
3235 int context_count = s->slice_context_count;
3237 s->picture_number = picture_number;
3239 /* Reset the average MB variance */
3240 s->me.mb_var_sum_temp =
3241 s->me.mc_mb_var_sum_temp = 0;
3243 /* we need to initialize some time vars before we can encode b-frames */
3244 // RAL: Condition added for MPEG1VIDEO
3245 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3246 set_frame_distances(s);
3247 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3248 ff_set_mpeg4_time(s);
3250 s->me.scene_change_score=0;
3252 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3254 if(s->pict_type==AV_PICTURE_TYPE_I){
3255 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3256 else s->no_rounding=0;
3257 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3258 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3259 s->no_rounding ^= 1;
3262 if(s->flags & CODEC_FLAG_PASS2){
3263 if (estimate_qp(s,1) < 0)
3265 ff_get_2pass_fcode(s);
3266 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3267 if(s->pict_type==AV_PICTURE_TYPE_B)
3268 s->lambda= s->last_lambda_for[s->pict_type];
3270 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3274 if(s->codec_id != AV_CODEC_ID_AMV){
3275 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3276 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3277 s->q_chroma_intra_matrix = s->q_intra_matrix;
3278 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3281 s->mb_intra=0; //for the rate distortion & bit compare functions
3282 for(i=1; i<context_count; i++){
3283 ret = ff_update_duplicate_context(s->thread_context[i], s);
3291 /* Estimate motion for every MB */
3292 if(s->pict_type != AV_PICTURE_TYPE_I){
3293 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3294 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3295 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3296 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3297 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3301 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3302 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3304 for(i=0; i<s->mb_stride*s->mb_height; i++)
3305 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3307 if(!s->fixed_qscale){
3308 /* finding spatial complexity for I-frame rate control */
3309 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3312 for(i=1; i<context_count; i++){
3313 merge_context_after_me(s, s->thread_context[i]);
3315 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3316 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3319 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3320 s->pict_type= AV_PICTURE_TYPE_I;
3321 for(i=0; i<s->mb_stride*s->mb_height; i++)
3322 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3323 if(s->msmpeg4_version >= 3)
3325 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3326 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3330 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3331 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3333 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3335 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3336 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3337 s->f_code= FFMAX3(s->f_code, a, b);
3340 ff_fix_long_p_mvs(s);
3341 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3342 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3346 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3347 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3352 if(s->pict_type==AV_PICTURE_TYPE_B){
3355 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3356 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3357 s->f_code = FFMAX(a, b);
3359 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3360 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3361 s->b_code = FFMAX(a, b);
3363 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3364 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3365 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3366 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3367 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3369 for(dir=0; dir<2; dir++){
3372 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3373 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3374 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3375 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3383 if (estimate_qp(s, 0) < 0)
3386 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3387 s->qscale= 3; //reduce clipping problems
3389 if (s->out_format == FMT_MJPEG) {
3390 /* for mjpeg, we do include qscale in the matrix */
3392 int j= s->dsp.idct_permutation[i];
3394 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3396 s->y_dc_scale_table=
3397 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3398 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3399 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3400 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3403 if(s->codec_id == AV_CODEC_ID_AMV){
3404 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};
3405 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};
3407 int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3409 s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3410 s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3412 s->y_dc_scale_table= y;
3413 s->c_dc_scale_table= c;
3414 s->intra_matrix[0] = 13;
3415 s->chroma_intra_matrix[0] = 14;
3416 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3417 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3418 ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3419 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3423 //FIXME var duplication
3424 s->current_picture_ptr->f.key_frame =
3425 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3426 s->current_picture_ptr->f.pict_type =
3427 s->current_picture.f.pict_type = s->pict_type;
3429 if (s->current_picture.f.key_frame)
3430 s->picture_in_gop_number=0;
3432 s->mb_x = s->mb_y = 0;
3433 s->last_bits= put_bits_count(&s->pb);
3434 switch(s->out_format) {
3436 if (CONFIG_MJPEG_ENCODER)
3437 ff_mjpeg_encode_picture_header(s);
3440 if (CONFIG_H261_ENCODER)
3441 ff_h261_encode_picture_header(s, picture_number);
3444 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3445 ff_wmv2_encode_picture_header(s, picture_number);
3446 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3447 ff_msmpeg4_encode_picture_header(s, picture_number);
3448 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3449 ff_mpeg4_encode_picture_header(s, picture_number);
3450 else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3451 ff_rv10_encode_picture_header(s, picture_number);
3452 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3453 ff_rv20_encode_picture_header(s, picture_number);
3454 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3455 ff_flv_encode_picture_header(s, picture_number);
3456 else if (CONFIG_H263_ENCODER)
3457 ff_h263_encode_picture_header(s, picture_number);
3460 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3461 ff_mpeg1_encode_picture_header(s, picture_number);
3468 bits= put_bits_count(&s->pb);
3469 s->header_bits= bits - s->last_bits;
3471 for(i=1; i<context_count; i++){
3472 update_duplicate_context_after_me(s->thread_context[i], s);
3474 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3475 for(i=1; i<context_count; i++){
3476 merge_context_after_encode(s, s->thread_context[i]);
3482 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3483 const int intra= s->mb_intra;
3486 s->dct_count[intra]++;
3488 for(i=0; i<64; i++){
3489 int level= block[i];
3493 s->dct_error_sum[intra][i] += level;
3494 level -= s->dct_offset[intra][i];
3495 if(level<0) level=0;
3497 s->dct_error_sum[intra][i] -= level;
3498 level += s->dct_offset[intra][i];
3499 if(level>0) level=0;
3506 static int dct_quantize_trellis_c(MpegEncContext *s,
3507 int16_t *block, int n,
3508 int qscale, int *overflow){
3510 const uint8_t *scantable= s->intra_scantable.scantable;
3511 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3513 unsigned int threshold1, threshold2;
3525 int coeff_count[64];
3526 int qmul, qadd, start_i, last_non_zero, i, dc;
3527 const int esc_length= s->ac_esc_length;
3529 uint8_t * last_length;
3530 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3532 s->dsp.fdct (block);
3534 if(s->dct_error_sum)
3535 s->denoise_dct(s, block);
3537 qadd= ((qscale-1)|1)*8;
3548 /* For AIC we skip quant/dequant of INTRADC */
3553 /* note: block[0] is assumed to be positive */
3554 block[0] = (block[0] + (q >> 1)) / q;
3557 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3558 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3559 bias= 1<<(QMAT_SHIFT-1);
3560 length = s->intra_ac_vlc_length;
3561 last_length= s->intra_ac_vlc_last_length;
3565 qmat = s->q_inter_matrix[qscale];
3566 length = s->inter_ac_vlc_length;
3567 last_length= s->inter_ac_vlc_last_length;
3571 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3572 threshold2= (threshold1<<1);
3574 for(i=63; i>=start_i; i--) {
3575 const int j = scantable[i];
3576 int level = block[j] * qmat[j];
3578 if(((unsigned)(level+threshold1))>threshold2){
3584 for(i=start_i; i<=last_non_zero; i++) {
3585 const int j = scantable[i];
3586 int level = block[j] * qmat[j];
3588 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3589 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3590 if(((unsigned)(level+threshold1))>threshold2){
3592 level= (bias + level)>>QMAT_SHIFT;
3594 coeff[1][i]= level-1;
3595 // coeff[2][k]= level-2;
3597 level= (bias - level)>>QMAT_SHIFT;
3598 coeff[0][i]= -level;
3599 coeff[1][i]= -level+1;
3600 // coeff[2][k]= -level+2;
3602 coeff_count[i]= FFMIN(level, 2);
3603 av_assert2(coeff_count[i]);
3606 coeff[0][i]= (level>>31)|1;
3611 *overflow= s->max_qcoeff < max; //overflow might have happened
3613 if(last_non_zero < start_i){
3614 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3615 return last_non_zero;
3618 score_tab[start_i]= 0;
3619 survivor[0]= start_i;
3622 for(i=start_i; i<=last_non_zero; i++){
3623 int level_index, j, zero_distortion;
3624 int dct_coeff= FFABS(block[ scantable[i] ]);
3625 int best_score=256*256*256*120;
3627 if (s->dsp.fdct == ff_fdct_ifast)
3628 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3629 zero_distortion= dct_coeff*dct_coeff;
3631 for(level_index=0; level_index < coeff_count[i]; level_index++){
3633 int level= coeff[level_index][i];
3634 const int alevel= FFABS(level);
3639 if(s->out_format == FMT_H263){
3640 unquant_coeff= alevel*qmul + qadd;
3642 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3644 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3645 unquant_coeff = (unquant_coeff - 1) | 1;
3647 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3648 unquant_coeff = (unquant_coeff - 1) | 1;
3653 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3655 if((level&(~127)) == 0){
3656 for(j=survivor_count-1; j>=0; j--){
3657 int run= i - survivor[j];
3658 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3659 score += score_tab[i-run];
3661 if(score < best_score){
3664 level_tab[i+1]= level-64;
3668 if(s->out_format == FMT_H263){
3669 for(j=survivor_count-1; j>=0; j--){
3670 int run= i - survivor[j];
3671 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3672 score += score_tab[i-run];
3673 if(score < last_score){
3676 last_level= level-64;
3682 distortion += esc_length*lambda;
3683 for(j=survivor_count-1; j>=0; j--){
3684 int run= i - survivor[j];
3685 int score= distortion + score_tab[i-run];
3687 if(score < best_score){
3690 level_tab[i+1]= level-64;
3694 if(s->out_format == FMT_H263){
3695 for(j=survivor_count-1; j>=0; j--){
3696 int run= i - survivor[j];
3697 int score= distortion + score_tab[i-run];
3698 if(score < last_score){
3701 last_level= level-64;
3709 score_tab[i+1]= best_score;
3711 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3712 if(last_non_zero <= 27){
3713 for(; survivor_count; survivor_count--){
3714 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3718 for(; survivor_count; survivor_count--){
3719 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3724 survivor[ survivor_count++ ]= i+1;
3727 if(s->out_format != FMT_H263){
3728 last_score= 256*256*256*120;
3729 for(i= survivor[0]; i<=last_non_zero + 1; i++){
3730 int score= score_tab[i];
3731 if(i) score += lambda*2; //FIXME exacter?
3733 if(score < last_score){
3736 last_level= level_tab[i];
3737 last_run= run_tab[i];
3742 s->coded_score[n] = last_score;
3744 dc= FFABS(block[0]);
3745 last_non_zero= last_i - 1;
3746 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3748 if(last_non_zero < start_i)
3749 return last_non_zero;
3751 if(last_non_zero == 0 && start_i == 0){
3753 int best_score= dc * dc;
3755 for(i=0; i<coeff_count[0]; i++){
3756 int level= coeff[i][0];
3757 int alevel= FFABS(level);
3758 int unquant_coeff, score, distortion;
3760 if(s->out_format == FMT_H263){
3761 unquant_coeff= (alevel*qmul + qadd)>>3;
3763 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3764 unquant_coeff = (unquant_coeff - 1) | 1;
3766 unquant_coeff = (unquant_coeff + 4) >> 3;
3767 unquant_coeff<<= 3 + 3;
3769 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3771 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3772 else score= distortion + esc_length*lambda;
3774 if(score < best_score){
3776 best_level= level - 64;
3779 block[0]= best_level;
3780 s->coded_score[n] = best_score - dc*dc;
3781 if(best_level == 0) return -1;
3782 else return last_non_zero;
3786 av_assert2(last_level);
3788 block[ perm_scantable[last_non_zero] ]= last_level;
3791 for(; i>start_i; i -= run_tab[i] + 1){
3792 block[ perm_scantable[i-1] ]= level_tab[i];
3795 return last_non_zero;
3798 //#define REFINE_STATS 1
3799 static int16_t basis[64][64];
3801 static void build_basis(uint8_t *perm){
3808 double s= 0.25*(1<<BASIS_SHIFT);
3810 int perm_index= perm[index];
3811 if(i==0) s*= sqrt(0.5);
3812 if(j==0) s*= sqrt(0.5);
3813 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)));
3820 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3821 int16_t *block, int16_t *weight, int16_t *orig,
3824 LOCAL_ALIGNED_16(int16_t, d1, [64]);
3825 const uint8_t *scantable= s->intra_scantable.scantable;
3826 const uint8_t *perm_scantable= s->intra_scantable.permutated;
3827 // unsigned int threshold1, threshold2;
3832 int qmul, qadd, start_i, last_non_zero, i, dc;
3834 uint8_t * last_length;
3836 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3839 static int after_last=0;
3840 static int to_zero=0;
3841 static int from_zero=0;
3844 static int messed_sign=0;
3847 if(basis[0][0] == 0)
3848 build_basis(s->dsp.idct_permutation);
3859 /* For AIC we skip quant/dequant of INTRADC */
3863 q <<= RECON_SHIFT-3;
3864 /* note: block[0] is assumed to be positive */
3866 // block[0] = (block[0] + (q >> 1)) / q;
3868 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3869 // bias= 1<<(QMAT_SHIFT-1);
3870 length = s->intra_ac_vlc_length;
3871 last_length= s->intra_ac_vlc_last_length;
3875 length = s->inter_ac_vlc_length;
3876 last_length= s->inter_ac_vlc_last_length;
3878 last_non_zero = s->block_last_index[n];
3883 dc += (1<<(RECON_SHIFT-1));
3884 for(i=0; i<64; i++){
3885 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3888 STOP_TIMER("memset rem[]")}
3891 for(i=0; i<64; i++){
3896 w= FFABS(weight[i]) + qns*one;
3897 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3900 // w=weight[i] = (63*qns + (w/2)) / w;
3903 av_assert2(w<(1<<6));
3906 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3912 for(i=start_i; i<=last_non_zero; i++){
3913 int j= perm_scantable[i];
3914 const int level= block[j];
3918 if(level<0) coeff= qmul*level - qadd;
3919 else coeff= qmul*level + qadd;
3920 run_tab[rle_index++]=run;
3923 s->dsp.add_8x8basis(rem, basis[j], coeff);
3929 if(last_non_zero>0){
3930 STOP_TIMER("init rem[]")
3937 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3940 int run2, best_unquant_change=0, analyze_gradient;
3944 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3946 if(analyze_gradient){
3950 for(i=0; i<64; i++){
3953 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3956 STOP_TIMER("rem*w*w")}
3966 const int level= block[0];
3967 int change, old_coeff;
3969 av_assert2(s->mb_intra);
3973 for(change=-1; change<=1; change+=2){
3974 int new_level= level + change;
3975 int score, new_coeff;
3977 new_coeff= q*new_level;
3978 if(new_coeff >= 2048 || new_coeff < 0)
3981 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3982 if(score<best_score){
3985 best_change= change;
3986 best_unquant_change= new_coeff - old_coeff;
3993 run2= run_tab[rle_index++];
3997 for(i=start_i; i<64; i++){
3998 int j= perm_scantable[i];
3999 const int level= block[j];
4000 int change, old_coeff;
4002 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4006 if(level<0) old_coeff= qmul*level - qadd;
4007 else old_coeff= qmul*level + qadd;
4008 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4012 av_assert2(run2>=0 || i >= last_non_zero );
4015 for(change=-1; change<=1; change+=2){
4016 int new_level= level + change;
4017 int score, new_coeff, unquant_change;
4020 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4024 if(new_level<0) new_coeff= qmul*new_level - qadd;
4025 else new_coeff= qmul*new_level + qadd;
4026 if(new_coeff >= 2048 || new_coeff <= -2048)
4028 //FIXME check for overflow
4031 if(level < 63 && level > -63){
4032 if(i < last_non_zero)
4033 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4034 - length[UNI_AC_ENC_INDEX(run, level+64)];
4036 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4037 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4040 av_assert2(FFABS(new_level)==1);
4042 if(analyze_gradient){
4043 int g= d1[ scantable[i] ];
4044 if(g && (g^new_level) >= 0)
4048 if(i < last_non_zero){
4049 int next_i= i + run2 + 1;
4050 int next_level= block[ perm_scantable[next_i] ] + 64;
4052 if(next_level&(~127))
4055 if(next_i < last_non_zero)
4056 score += length[UNI_AC_ENC_INDEX(run, 65)]
4057 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4058 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4060 score += length[UNI_AC_ENC_INDEX(run, 65)]
4061 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4062 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4064 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4066 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4067 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4073 av_assert2(FFABS(level)==1);
4075 if(i < last_non_zero){
4076 int next_i= i + run2 + 1;
4077 int next_level= block[ perm_scantable[next_i] ] + 64;
4079 if(next_level&(~127))
4082 if(next_i < last_non_zero)
4083 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4084 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4085 - length[UNI_AC_ENC_INDEX(run, 65)];
4087 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4088 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4089 - length[UNI_AC_ENC_INDEX(run, 65)];
4091 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4093 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4094 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4101 unquant_change= new_coeff - old_coeff;
4102 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4104 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4105 if(score<best_score){
4108 best_change= change;
4109 best_unquant_change= unquant_change;
4113 prev_level= level + 64;
4114 if(prev_level&(~127))
4123 STOP_TIMER("iterative step")}
4127 int j= perm_scantable[ best_coeff ];
4129 block[j] += best_change;
4131 if(best_coeff > last_non_zero){
4132 last_non_zero= best_coeff;
4133 av_assert2(block[j]);
4140 if(block[j] - best_change){
4141 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4153 for(; last_non_zero>=start_i; last_non_zero--){
4154 if(block[perm_scantable[last_non_zero]])
4160 if(256*256*256*64 % count == 0){
4161 av_log(s->avctx, AV_LOG_DEBUG, "after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4166 for(i=start_i; i<=last_non_zero; i++){
4167 int j= perm_scantable[i];
4168 const int level= block[j];
4171 run_tab[rle_index++]=run;
4178 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4184 if(last_non_zero>0){
4185 STOP_TIMER("iterative search")
4190 return last_non_zero;
4193 int ff_dct_quantize_c(MpegEncContext *s,
4194 int16_t *block, int n,
4195 int qscale, int *overflow)
4197 int i, j, level, last_non_zero, q, start_i;
4199 const uint8_t *scantable= s->intra_scantable.scantable;
4202 unsigned int threshold1, threshold2;
4204 s->dsp.fdct (block);
4206 if(s->dct_error_sum)
4207 s->denoise_dct(s, block);
4217 /* For AIC we skip quant/dequant of INTRADC */
4220 /* note: block[0] is assumed to be positive */
4221 block[0] = (block[0] + (q >> 1)) / q;
4224 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4225 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4229 qmat = s->q_inter_matrix[qscale];
4230 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4232 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4233 threshold2= (threshold1<<1);
4234 for(i=63;i>=start_i;i--) {
4236 level = block[j] * qmat[j];
4238 if(((unsigned)(level+threshold1))>threshold2){
4245 for(i=start_i; i<=last_non_zero; i++) {
4247 level = block[j] * qmat[j];
4249 // if( bias+level >= (1<<QMAT_SHIFT)
4250 // || bias-level >= (1<<QMAT_SHIFT)){
4251 if(((unsigned)(level+threshold1))>threshold2){
4253 level= (bias + level)>>QMAT_SHIFT;
4256 level= (bias - level)>>QMAT_SHIFT;
4264 *overflow= s->max_qcoeff < max; //overflow might have happened
4266 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4267 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4268 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4270 return last_non_zero;
4273 #define OFFSET(x) offsetof(MpegEncContext, x)
4274 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4275 static const AVOption h263_options[] = {
4276 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4277 { "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},
4278 { "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 },
4283 static const AVClass h263_class = {
4284 .class_name = "H.263 encoder",
4285 .item_name = av_default_item_name,
4286 .option = h263_options,
4287 .version = LIBAVUTIL_VERSION_INT,
4290 AVCodec ff_h263_encoder = {
4292 .type = AVMEDIA_TYPE_VIDEO,
4293 .id = AV_CODEC_ID_H263,
4294 .priv_data_size = sizeof(MpegEncContext),
4295 .init = ff_MPV_encode_init,
4296 .encode2 = ff_MPV_encode_picture,
4297 .close = ff_MPV_encode_end,
4298 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4299 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4300 .priv_class = &h263_class,
4303 static const AVOption h263p_options[] = {
4304 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4305 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4306 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4307 { "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},
4311 static const AVClass h263p_class = {
4312 .class_name = "H.263p encoder",
4313 .item_name = av_default_item_name,
4314 .option = h263p_options,
4315 .version = LIBAVUTIL_VERSION_INT,
4318 AVCodec ff_h263p_encoder = {
4320 .type = AVMEDIA_TYPE_VIDEO,
4321 .id = AV_CODEC_ID_H263P,
4322 .priv_data_size = sizeof(MpegEncContext),
4323 .init = ff_MPV_encode_init,
4324 .encode2 = ff_MPV_encode_picture,
4325 .close = ff_MPV_encode_end,
4326 .capabilities = CODEC_CAP_SLICE_THREADS,
4327 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4328 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4329 .priv_class = &h263p_class,
4332 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4334 AVCodec ff_msmpeg4v2_encoder = {
4335 .name = "msmpeg4v2",
4336 .type = AVMEDIA_TYPE_VIDEO,
4337 .id = AV_CODEC_ID_MSMPEG4V2,
4338 .priv_data_size = sizeof(MpegEncContext),
4339 .init = ff_MPV_encode_init,
4340 .encode2 = ff_MPV_encode_picture,
4341 .close = ff_MPV_encode_end,
4342 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4343 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4344 .priv_class = &msmpeg4v2_class,
4347 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4349 AVCodec ff_msmpeg4v3_encoder = {
4351 .type = AVMEDIA_TYPE_VIDEO,
4352 .id = AV_CODEC_ID_MSMPEG4V3,
4353 .priv_data_size = sizeof(MpegEncContext),
4354 .init = ff_MPV_encode_init,
4355 .encode2 = ff_MPV_encode_picture,
4356 .close = ff_MPV_encode_end,
4357 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4358 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4359 .priv_class = &msmpeg4v3_class,
4362 FF_MPV_GENERIC_CLASS(wmv1)
4364 AVCodec ff_wmv1_encoder = {
4366 .type = AVMEDIA_TYPE_VIDEO,
4367 .id = AV_CODEC_ID_WMV1,
4368 .priv_data_size = sizeof(MpegEncContext),
4369 .init = ff_MPV_encode_init,
4370 .encode2 = ff_MPV_encode_picture,
4371 .close = ff_MPV_encode_end,
4372 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4373 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4374 .priv_class = &wmv1_class,