mpegvideo_enc: force encoding delay of at least 1 frame when low_delay=0
[libav.git] / libavcodec / mpegvideo_enc.c
CommitLineData
3ada94ba
BF
1/*
2 * The simplest mpeg encoder (well, it was the simplest!)
406792e7 3 * Copyright (c) 2000,2001 Fabrice Bellard
3ada94ba
BF
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
7b94177e
DB
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7 *
2912e87a 8 * This file is part of Libav.
3ada94ba 9 *
2912e87a 10 * Libav is free software; you can redistribute it and/or
3ada94ba
BF
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.
14 *
2912e87a 15 * Libav is distributed in the hope that it will be useful,
3ada94ba
BF
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.
19 *
20 * You should have received a copy of the GNU Lesser General Public
2912e87a 21 * License along with Libav; if not, write to the Free Software
3ada94ba 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
3ada94ba
BF
23 */
24
25/**
ba87f080 26 * @file
3ada94ba
BF
27 * The simplest mpeg encoder (well, it was the simplest!).
28 */
29
94ca624f 30#include "libavutil/intmath.h"
0ebcdf5c 31#include "libavutil/mathematics.h"
9bb2d1a3 32#include "libavutil/opt.h"
3ada94ba
BF
33#include "avcodec.h"
34#include "dsputil.h"
35#include "mpegvideo.h"
36#include "mpegvideo_common.h"
c46eeae2 37#include "h263.h"
3ada94ba
BF
38#include "mjpegenc.h"
39#include "msmpeg4.h"
40#include "faandct.h"
6a9c8594 41#include "thread.h"
8b22017f 42#include "aandcttab.h"
eb523769 43#include "flv.h"
ca334dd1 44#include "mpeg4video.h"
7ffd8332 45#include "internal.h"
3ada94ba
BF
46#include <limits.h>
47
48//#undef NDEBUG
49//#include <assert.h>
50
51static int encode_picture(MpegEncContext *s, int picture_number);
52static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
53static int sse_mb(MpegEncContext *s);
1d4da6a4
DEP
54static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
55static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
3ada94ba
BF
56
57/* enable all paranoid tests for rounding, overflows, etc... */
58//#define PARANOID
59
60//#define DEBUG
61
bd96be6e
AD
62static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
63static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
3ada94ba 64
bd96be6e
AD
65void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
66 uint16_t (*qmat16)[2][64],
67 const uint16_t *quant_matrix,
68 int bias, int qmin, int qmax, int intra)
3ada94ba
BF
69{
70 int qscale;
bd96be6e 71 int shift = 0;
3ada94ba 72
bd96be6e 73 for (qscale = qmin; qscale <= qmax; qscale++) {
3ada94ba 74 int i;
0a72533e
MR
75 if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
76 dsp->fdct == ff_jpeg_fdct_islow_10
3ada94ba
BF
77#ifdef FAAN_POSTSCALE
78 || dsp->fdct == ff_faandct
79#endif
80 ) {
bd96be6e
AD
81 for (i = 0; i < 64; i++) {
82 const int j = dsp->idct_permutation[i];
83 /* 16 <= qscale * quant_matrix[i] <= 7905
84 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
85 * 19952 <= x <= 249205026
86 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
87 * 3444240 >= (1 << 36) / (x) >= 275 */
3ada94ba
BF
88
89 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
bd96be6e 90 (qscale * quant_matrix[j]));
3ada94ba 91 }
3e2efacd 92 } else if (dsp->fdct == ff_fdct_ifast
3ada94ba
BF
93#ifndef FAAN_POSTSCALE
94 || dsp->fdct == ff_faandct
95#endif
96 ) {
bd96be6e
AD
97 for (i = 0; i < 64; i++) {
98 const int j = dsp->idct_permutation[i];
99 /* 16 <= qscale * quant_matrix[i] <= 7905
100 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101 * 19952 <= x <= 249205026
102 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103 * 3444240 >= (1 << 36) / (x) >= 275 */
3ada94ba
BF
104
105 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
bd96be6e
AD
106 (ff_aanscales[i] * qscale *
107 quant_matrix[j]));
3ada94ba
BF
108 }
109 } else {
bd96be6e
AD
110 for (i = 0; i < 64; i++) {
111 const int j = dsp->idct_permutation[i];
3ada94ba 112 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
bd96be6e
AD
113 * Assume x = qscale * quant_matrix[i]
114 * So 16 <= x <= 7905
115 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
116 * so 32768 >= (1 << 19) / (x) >= 67 */
117 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
118 (qscale * quant_matrix[j]));
119 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
120 // (qscale * quant_matrix[i]);
121 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
122 (qscale * quant_matrix[j]);
123
124 if (qmat16[qscale][0][i] == 0 ||
125 qmat16[qscale][0][i] == 128 * 256)
126 qmat16[qscale][0][i] = 128 * 256 - 1;
127 qmat16[qscale][1][i] =
128 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
129 qmat16[qscale][0][i]);
3ada94ba
BF
130 }
131 }
132
bd96be6e
AD
133 for (i = intra; i < 64; i++) {
134 int64_t max = 8191;
3e2efacd 135 if (dsp->fdct == ff_fdct_ifast
3ada94ba 136#ifndef FAAN_POSTSCALE
bd96be6e 137 || dsp->fdct == ff_faandct
3ada94ba 138#endif
bd96be6e
AD
139 ) {
140 max = (8191LL * ff_aanscales[i]) >> 14;
3ada94ba 141 }
bd96be6e 142 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
3ada94ba
BF
143 shift++;
144 }
145 }
146 }
bd96be6e
AD
147 if (shift) {
148 av_log(NULL, AV_LOG_INFO,
149 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
150 QMAT_SHIFT - shift);
3ada94ba
BF
151 }
152}
153
bd96be6e
AD
154static inline void update_qscale(MpegEncContext *s)
155{
156 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
157 (FF_LAMBDA_SHIFT + 7);
158 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
3ada94ba 159
bd96be6e
AD
160 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
161 FF_LAMBDA_SHIFT;
3ada94ba
BF
162}
163
bd96be6e
AD
164void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165{
3ada94ba
BF
166 int i;
167
bd96be6e 168 if (matrix) {
3ada94ba 169 put_bits(pb, 1, 1);
bd96be6e
AD
170 for (i = 0; i < 64; i++) {
171 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
3ada94ba 172 }
bd96be6e 173 } else
3ada94ba
BF
174 put_bits(pb, 1, 0);
175}
176
9015b095
MN
177/**
178 * init s->current_picture.qscale_table from s->lambda_table
179 */
bd96be6e
AD
180void ff_init_qscale_tab(MpegEncContext *s)
181{
657ccb5a 182 int8_t * const qscale_table = s->current_picture.f.qscale_table;
9015b095
MN
183 int i;
184
bd96be6e
AD
185 for (i = 0; i < s->mb_num; i++) {
186 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
187 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
188 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
189 s->avctx->qmax);
9015b095
MN
190 }
191}
192
bd96be6e
AD
193static void copy_picture_attributes(MpegEncContext *s,
194 AVFrame *dst,
195 AVFrame *src)
196{
3ada94ba
BF
197 int i;
198
199 dst->pict_type = src->pict_type;
200 dst->quality = src->quality;
201 dst->coded_picture_number = src->coded_picture_number;
202 dst->display_picture_number = src->display_picture_number;
bd96be6e 203 //dst->reference = src->reference;
3ada94ba
BF
204 dst->pts = src->pts;
205 dst->interlaced_frame = src->interlaced_frame;
206 dst->top_field_first = src->top_field_first;
207
bd96be6e
AD
208 if (s->avctx->me_threshold) {
209 if (!src->motion_val[0])
3ada94ba 210 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
bd96be6e 211 if (!src->mb_type)
3ada94ba 212 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
bd96be6e 213 if (!src->ref_index[0])
3ada94ba 214 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
bd96be6e
AD
215 if (src->motion_subsample_log2 != dst->motion_subsample_log2)
216 av_log(s->avctx, AV_LOG_ERROR,
217 "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
218 src->motion_subsample_log2, dst->motion_subsample_log2);
219
220 memcpy(dst->mb_type, src->mb_type,
221 s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
222
223 for (i = 0; i < 2; i++) {
224 int stride = ((16 * s->mb_width ) >>
225 src->motion_subsample_log2) + 1;
226 int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
227
228 if (src->motion_val[i] &&
229 src->motion_val[i] != dst->motion_val[i]) {
230 memcpy(dst->motion_val[i], src->motion_val[i],
231 2 * stride * height * sizeof(int16_t));
3ada94ba 232 }
bd96be6e
AD
233 if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
234 memcpy(dst->ref_index[i], src->ref_index[i],
235 s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
3ada94ba
BF
236 }
237 }
238 }
239}
240
bd96be6e
AD
241static void update_duplicate_context_after_me(MpegEncContext *dst,
242 MpegEncContext *src)
243{
3ada94ba
BF
244#define COPY(a) dst->a= src->a
245 COPY(pict_type);
246 COPY(current_picture);
247 COPY(f_code);
248 COPY(b_code);
249 COPY(qscale);
250 COPY(lambda);
251 COPY(lambda2);
252 COPY(picture_in_gop_number);
253 COPY(gop_picture_number);
bd96be6e
AD
254 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
255 COPY(progressive_frame); // FIXME don't set in encode_header
256 COPY(partitioned_frame); // FIXME don't set in encode_header
3ada94ba
BF
257#undef COPY
258}
259
260/**
58c42af7 261 * Set the given MpegEncContext to defaults for encoding.
3ada94ba
BF
262 * the changed fields will not depend upon the prior state of the MpegEncContext.
263 */
bd96be6e
AD
264static void MPV_encode_defaults(MpegEncContext *s)
265{
3ada94ba 266 int i;
efd29844 267 ff_MPV_common_defaults(s);
3ada94ba 268
bd96be6e
AD
269 for (i = -16; i < 16; i++) {
270 default_fcode_tab[i + MAX_MV] = 1;
3ada94ba 271 }
bd96be6e
AD
272 s->me.mv_penalty = default_mv_penalty;
273 s->fcode_tab = default_fcode_tab;
3ada94ba
BF
274}
275
276/* init video encoder */
efd29844 277av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
3ada94ba
BF
278{
279 MpegEncContext *s = avctx->priv_data;
280 int i;
281 int chroma_h_shift, chroma_v_shift;
282
283 MPV_encode_defaults(s);
284
285 switch (avctx->codec_id) {
286 case CODEC_ID_MPEG2VIDEO:
bd96be6e
AD
287 if (avctx->pix_fmt != PIX_FMT_YUV420P &&
288 avctx->pix_fmt != PIX_FMT_YUV422P) {
289 av_log(avctx, AV_LOG_ERROR,
290 "only YUV420 and YUV422 are supported\n");
3ada94ba
BF
291 return -1;
292 }
293 break;
294 case CODEC_ID_LJPEG:
bd96be6e
AD
295 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
296 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
297 avctx->pix_fmt != PIX_FMT_YUVJ444P &&
298 avctx->pix_fmt != PIX_FMT_BGRA &&
299 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
300 avctx->pix_fmt != PIX_FMT_YUV422P &&
301 avctx->pix_fmt != PIX_FMT_YUV444P) ||
302 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
e27bf2c7
MN
303 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
304 return -1;
305 }
306 break;
3ada94ba 307 case CODEC_ID_MJPEG:
bd96be6e
AD
308 if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
309 avctx->pix_fmt != PIX_FMT_YUVJ422P &&
310 ((avctx->pix_fmt != PIX_FMT_YUV420P &&
311 avctx->pix_fmt != PIX_FMT_YUV422P) ||
312 avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
3ada94ba
BF
313 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
314 return -1;
315 }
316 break;
317 default:
bd96be6e 318 if (avctx->pix_fmt != PIX_FMT_YUV420P) {
3ada94ba
BF
319 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
320 return -1;
321 }
322 }
323
324 switch (avctx->pix_fmt) {
325 case PIX_FMT_YUVJ422P:
326 case PIX_FMT_YUV422P:
327 s->chroma_format = CHROMA_422;
328 break;
329 case PIX_FMT_YUVJ420P:
330 case PIX_FMT_YUV420P:
331 default:
332 s->chroma_format = CHROMA_420;
333 break;
334 }
335
336 s->bit_rate = avctx->bit_rate;
bd96be6e
AD
337 s->width = avctx->width;
338 s->height = avctx->height;
339 if (avctx->gop_size > 600 &&
340 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
341 av_log(avctx, AV_LOG_ERROR,
342 "Warning keyframe interval too large! reducing it ...\n");
343 avctx->gop_size = 600;
344 }
345 s->gop_size = avctx->gop_size;
346 s->avctx = avctx;
347 s->flags = avctx->flags;
348 s->flags2 = avctx->flags2;
349 s->max_b_frames = avctx->max_b_frames;
350 s->codec_id = avctx->codec->id;
351 s->luma_elim_threshold = avctx->luma_elim_threshold;
352 s->chroma_elim_threshold = avctx->chroma_elim_threshold;
353 s->strict_std_compliance = avctx->strict_std_compliance;
bd96be6e
AD
354 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
355 s->mpeg_quant = avctx->mpeg_quant;
356 s->rtp_mode = !!avctx->rtp_payload_size;
357 s->intra_dc_precision = avctx->intra_dc_precision;
3ada94ba
BF
358 s->user_specified_pts = AV_NOPTS_VALUE;
359
360 if (s->gop_size <= 1) {
361 s->intra_only = 1;
bd96be6e 362 s->gop_size = 12;
3ada94ba
BF
363 } else {
364 s->intra_only = 0;
365 }
366
367 s->me_method = avctx->me_method;
368
369 /* Fixed QSCALE */
370 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
371
bd96be6e
AD
372 s->adaptive_quant = (s->avctx->lumi_masking ||
373 s->avctx->dark_masking ||
374 s->avctx->temporal_cplx_masking ||
375 s->avctx->spatial_cplx_masking ||
376 s->avctx->p_masking ||
377 s->avctx->border_masking ||
378 (s->flags & CODEC_FLAG_QP_RD)) &&
379 !s->fixed_qscale;
3ada94ba 380
bd96be6e 381 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
3ada94ba 382
bd96be6e
AD
383 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
384 av_log(avctx, AV_LOG_ERROR,
385 "a vbv buffer size is needed, "
386 "for encoding with a maximum bitrate\n");
3ada94ba
BF
387 return -1;
388 }
389
bd96be6e
AD
390 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
391 av_log(avctx, AV_LOG_INFO,
392 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
3ada94ba
BF
393 }
394
bd96be6e 395 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
3ada94ba
BF
396 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
397 return -1;
398 }
399
bd96be6e 400 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
3ada94ba
BF
401 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
402 return -1;
403 }
404
bd96be6e
AD
405 if (avctx->rc_max_rate &&
406 avctx->rc_max_rate == avctx->bit_rate &&
407 avctx->rc_max_rate != avctx->rc_min_rate) {
408 av_log(avctx, AV_LOG_INFO,
409 "impossible bitrate constraints, this will fail\n");
3dd2a1c5
MN
410 }
411
bd96be6e
AD
412 if (avctx->rc_buffer_size &&
413 avctx->bit_rate * (int64_t)avctx->time_base.num >
414 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
3ada94ba
BF
415 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
416 return -1;
417 }
418
bd96be6e
AD
419 if (!s->fixed_qscale &&
420 avctx->bit_rate * av_q2d(avctx->time_base) >
421 avctx->bit_rate_tolerance) {
422 av_log(avctx, AV_LOG_ERROR,
423 "bitrate tolerance too small for bitrate\n");
3ada94ba
BF
424 return -1;
425 }
426
bd96be6e
AD
427 if (s->avctx->rc_max_rate &&
428 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
429 (s->codec_id == CODEC_ID_MPEG1VIDEO ||
430 s->codec_id == CODEC_ID_MPEG2VIDEO) &&
431 90000LL * (avctx->rc_buffer_size - 1) >
432 s->avctx->rc_max_rate * 0xFFFFLL) {
433 av_log(avctx, AV_LOG_INFO,
434 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
435 "specified vbv buffer is too large for the given bitrate!\n");
3ada94ba
BF
436 }
437
bd96be6e
AD
438 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 &&
439 s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P &&
440 s->codec_id != CODEC_ID_FLV1) {
3ada94ba
BF
441 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
442 return -1;
443 }
444
bd96be6e
AD
445 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
446 av_log(avctx, AV_LOG_ERROR,
447 "OBMC is only supported with simple mb decision\n");
3ada94ba
BF
448 return -1;
449 }
450
bd96be6e 451 if (s->quarter_sample && s->codec_id != CODEC_ID_MPEG4) {
3ada94ba
BF
452 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
453 return -1;
454 }
455
bd96be6e
AD
456 if (s->max_b_frames &&
457 s->codec_id != CODEC_ID_MPEG4 &&
458 s->codec_id != CODEC_ID_MPEG1VIDEO &&
459 s->codec_id != CODEC_ID_MPEG2VIDEO) {
3ada94ba
BF
460 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
461 return -1;
462 }
463
bd96be6e
AD
464 if ((s->codec_id == CODEC_ID_MPEG4 ||
465 s->codec_id == CODEC_ID_H263 ||
954a0b48 466 s->codec_id == CODEC_ID_H263P) &&
bd96be6e
AD
467 (avctx->sample_aspect_ratio.num > 255 ||
468 avctx->sample_aspect_ratio.den > 255)) {
469 av_log(avctx, AV_LOG_ERROR,
470 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
954a0b48
MN
471 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
472 return -1;
473 }
474
9ce2a91b 475 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
bd96be6e 476 s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO) {
3ada94ba
BF
477 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
478 return -1;
479 }
480
bd96be6e
AD
481 // FIXME mpeg2 uses that too
482 if (s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4) {
483 av_log(avctx, AV_LOG_ERROR,
484 "mpeg2 style quantization not supported by codec\n");
3ada94ba
BF
485 return -1;
486 }
487
bd96be6e 488 if ((s->flags & CODEC_FLAG_CBP_RD) && !avctx->trellis) {
3ada94ba
BF
489 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
490 return -1;
491 }
492
bd96be6e
AD
493 if ((s->flags & CODEC_FLAG_QP_RD) &&
494 s->avctx->mb_decision != FF_MB_DECISION_RD) {
3ada94ba
BF
495 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
496 return -1;
497 }
498
bd96be6e
AD
499 if (s->avctx->scenechange_threshold < 1000000000 &&
500 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
501 av_log(avctx, AV_LOG_ERROR,
502 "closed gop with scene change detection are not supported yet, "
503 "set threshold to 1000000000\n");
3ada94ba
BF
504 return -1;
505 }
506
bd96be6e
AD
507 if (s->flags & CODEC_FLAG_LOW_DELAY) {
508 if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
509 av_log(avctx, AV_LOG_ERROR,
510 "low delay forcing is only available for mpeg2\n");
3ada94ba
BF
511 return -1;
512 }
bd96be6e
AD
513 if (s->max_b_frames != 0) {
514 av_log(avctx, AV_LOG_ERROR,
515 "b frames cannot be used with low delay\n");
3ada94ba
BF
516 return -1;
517 }
518 }
519
bd96be6e 520 if (s->q_scale_type == 1) {
bd96be6e
AD
521 if (avctx->qmax > 12) {
522 av_log(avctx, AV_LOG_ERROR,
523 "non linear quant only supports qmax <= 12 currently\n");
3ada94ba
BF
524 return -1;
525 }
526 }
527
bd96be6e
AD
528 if (s->avctx->thread_count > 1 &&
529 s->codec_id != CODEC_ID_MPEG4 &&
530 s->codec_id != CODEC_ID_MPEG1VIDEO &&
531 s->codec_id != CODEC_ID_MPEG2VIDEO &&
9ce2a91b 532 (s->codec_id != CODEC_ID_H263P)) {
bd96be6e
AD
533 av_log(avctx, AV_LOG_ERROR,
534 "multi threaded encoding not supported by codec\n");
3ada94ba
BF
535 return -1;
536 }
537
bd96be6e
AD
538 if (s->avctx->thread_count < 1) {
539 av_log(avctx, AV_LOG_ERROR,
540 "automatic thread number detection not supported by codec,"
541 "patch welcome\n");
b52b0913
MN
542 return -1;
543 }
544
bd96be6e
AD
545 if (s->avctx->thread_count > 1)
546 s->rtp_mode = 1;
3ada94ba 547
bd96be6e 548 if (!avctx->time_base.den || !avctx->time_base.num) {
3ada94ba
BF
549 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
550 return -1;
551 }
552
bd96be6e
AD
553 i = (INT_MAX / 2 + 128) >> 8;
554 if (avctx->me_threshold >= i) {
555 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
556 i - 1);
3ada94ba
BF
557 return -1;
558 }
bd96be6e
AD
559 if (avctx->mb_threshold >= i) {
560 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
561 i - 1);
3ada94ba
BF
562 return -1;
563 }
564
bd96be6e
AD
565 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
566 av_log(avctx, AV_LOG_INFO,
567 "notice: b_frame_strategy only affects the first pass\n");
3ada94ba
BF
568 avctx->b_frame_strategy = 0;
569 }
570
bd96be6e
AD
571 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
572 if (i > 1) {
3ada94ba
BF
573 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
574 avctx->time_base.den /= i;
575 avctx->time_base.num /= i;
bd96be6e 576 //return -1;
3ada94ba
BF
577 }
578
bd96be6e
AD
579 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG1VIDEO ||
580 s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG) {
581 // (a + x * 3 / 8) / x
582 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
583 s->inter_quant_bias = 0;
584 } else {
585 s->intra_quant_bias = 0;
586 // (a - x / 4) / x
587 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
3ada94ba
BF
588 }
589
bd96be6e
AD
590 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
591 s->intra_quant_bias = avctx->intra_quant_bias;
592 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
593 s->inter_quant_bias = avctx->inter_quant_bias;
594
595 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
596 &chroma_v_shift);
597
598 if (avctx->codec_id == CODEC_ID_MPEG4 &&
599 s->avctx->time_base.den > (1 << 16) - 1) {
600 av_log(avctx, AV_LOG_ERROR,
601 "timebase %d/%d not supported by MPEG 4 standard, "
602 "the maximum admitted value for the timebase denominator "
603 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
604 (1 << 16) - 1);
3ada94ba
BF
605 return -1;
606 }
607 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
608
bd96be6e 609 switch (avctx->codec->id) {
3ada94ba
BF
610 case CODEC_ID_MPEG1VIDEO:
611 s->out_format = FMT_MPEG1;
bd96be6e
AD
612 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
613 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
3ada94ba
BF
614 break;
615 case CODEC_ID_MPEG2VIDEO:
616 s->out_format = FMT_MPEG1;
bd96be6e
AD
617 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
618 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
619 s->rtp_mode = 1;
3ada94ba
BF
620 break;
621 case CODEC_ID_LJPEG:
622 case CODEC_ID_MJPEG:
623 s->out_format = FMT_MJPEG;
624 s->intra_only = 1; /* force intra only for jpeg */
bd96be6e
AD
625 if (avctx->codec->id == CODEC_ID_LJPEG &&
626 avctx->pix_fmt == PIX_FMT_BGRA) {
e0b176ad
MN
627 s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
628 s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
629 s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
bd96be6e 630 } else {
a1a63143 631 s->mjpeg_vsample[0] = 2;
bd96be6e
AD
632 s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
633 s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
a1a63143 634 s->mjpeg_hsample[0] = 2;
bd96be6e
AD
635 s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
636 s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
e0b176ad 637 }
bd96be6e
AD
638 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
639 ff_mjpeg_encode_init(s) < 0)
3ada94ba 640 return -1;
bd96be6e
AD
641 avctx->delay = 0;
642 s->low_delay = 1;
3ada94ba
BF
643 break;
644 case CODEC_ID_H261:
bd96be6e
AD
645 if (!CONFIG_H261_ENCODER)
646 return -1;
3ada94ba 647 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
bd96be6e
AD
648 av_log(avctx, AV_LOG_ERROR,
649 "The specified picture size of %dx%d is not valid for the "
650 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
651 s->width, s->height);
3ada94ba
BF
652 return -1;
653 }
654 s->out_format = FMT_H261;
bd96be6e
AD
655 avctx->delay = 0;
656 s->low_delay = 1;
3ada94ba
BF
657 break;
658 case CODEC_ID_H263:
bd96be6e
AD
659 if (!CONFIG_H263_ENCODER)
660 return -1;
ddce8953 661 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
bd96be6e
AD
662 s->width, s->height) == 8) {
663 av_log(avctx, AV_LOG_INFO,
664 "The specified picture size of %dx%d is not valid for "
665 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
666 "352x288, 704x576, and 1408x1152."
667 "Try H.263+.\n", s->width, s->height);
3ada94ba
BF
668 return -1;
669 }
670 s->out_format = FMT_H263;
bd96be6e
AD
671 avctx->delay = 0;
672 s->low_delay = 1;
3ada94ba
BF
673 break;
674 case CODEC_ID_H263P:
675 s->out_format = FMT_H263;
bd96be6e 676 s->h263_plus = 1;
3ada94ba 677 /* Fx */
bd96be6e
AD
678 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
679 s->modified_quant = s->h263_aic;
680 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
681 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
3ada94ba
BF
682
683 /* /Fx */
684 /* These are just to be sure */
bd96be6e
AD
685 avctx->delay = 0;
686 s->low_delay = 1;
3ada94ba
BF
687 break;
688 case CODEC_ID_FLV1:
bd96be6e
AD
689 s->out_format = FMT_H263;
690 s->h263_flv = 2; /* format = 1; 11-bit codes */
3ada94ba 691 s->unrestricted_mv = 1;
bd96be6e
AD
692 s->rtp_mode = 0; /* don't allow GOB */
693 avctx->delay = 0;
694 s->low_delay = 1;
3ada94ba
BF
695 break;
696 case CODEC_ID_RV10:
697 s->out_format = FMT_H263;
bd96be6e
AD
698 avctx->delay = 0;
699 s->low_delay = 1;
3ada94ba
BF
700 break;
701 case CODEC_ID_RV20:
bd96be6e
AD
702 s->out_format = FMT_H263;
703 avctx->delay = 0;
704 s->low_delay = 1;
705 s->modified_quant = 1;
706 s->h263_aic = 1;
707 s->h263_plus = 1;
708 s->loop_filter = 1;
709 s->unrestricted_mv = 0;
3ada94ba
BF
710 break;
711 case CODEC_ID_MPEG4:
bd96be6e
AD
712 s->out_format = FMT_H263;
713 s->h263_pred = 1;
3ada94ba 714 s->unrestricted_mv = 1;
bd96be6e
AD
715 s->low_delay = s->max_b_frames ? 0 : 1;
716 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
3ada94ba 717 break;
3ada94ba 718 case CODEC_ID_MSMPEG4V2:
bd96be6e
AD
719 s->out_format = FMT_H263;
720 s->h263_pred = 1;
3ada94ba 721 s->unrestricted_mv = 1;
bd96be6e
AD
722 s->msmpeg4_version = 2;
723 avctx->delay = 0;
724 s->low_delay = 1;
3ada94ba
BF
725 break;
726 case CODEC_ID_MSMPEG4V3:
bd96be6e
AD
727 s->out_format = FMT_H263;
728 s->h263_pred = 1;
729 s->unrestricted_mv = 1;
730 s->msmpeg4_version = 3;
731 s->flipflop_rounding = 1;
732 avctx->delay = 0;
733 s->low_delay = 1;
3ada94ba
BF
734 break;
735 case CODEC_ID_WMV1:
bd96be6e
AD
736 s->out_format = FMT_H263;
737 s->h263_pred = 1;
738 s->unrestricted_mv = 1;
739 s->msmpeg4_version = 4;
740 s->flipflop_rounding = 1;
741 avctx->delay = 0;
742 s->low_delay = 1;
3ada94ba
BF
743 break;
744 case CODEC_ID_WMV2:
bd96be6e
AD
745 s->out_format = FMT_H263;
746 s->h263_pred = 1;
747 s->unrestricted_mv = 1;
748 s->msmpeg4_version = 5;
749 s->flipflop_rounding = 1;
750 avctx->delay = 0;
751 s->low_delay = 1;
3ada94ba
BF
752 break;
753 default:
754 return -1;
755 }
756
bd96be6e 757 avctx->has_b_frames = !s->low_delay;
3ada94ba
BF
758
759 s->encoding = 1;
760
bd96be6e
AD
761 s->progressive_frame =
762 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
0c71cc65
AK
763 CODEC_FLAG_INTERLACED_ME) ||
764 s->alternate_scan);
01bc48f4 765
3ada94ba 766 /* init */
efd29844 767 if (ff_MPV_common_init(s) < 0)
3ada94ba
BF
768 return -1;
769
bd96be6e 770 if (!s->dct_quantize)
99560a4c 771 s->dct_quantize = ff_dct_quantize_c;
bd96be6e
AD
772 if (!s->denoise_dct)
773 s->denoise_dct = denoise_dct_c;
53727262 774 s->fast_dct_quantize = s->dct_quantize;
bd96be6e
AD
775 if (avctx->trellis)
776 s->dct_quantize = dct_quantize_trellis_c;
53727262 777
bd96be6e
AD
778 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
779 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
01bc48f4 780
bd96be6e 781 s->quant_precision = 5;
3ada94ba
BF
782
783 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
784 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
785
49fb20cb 786 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
3ada94ba 787 ff_h261_encode_init(s);
f34121f3 788 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
ddce8953 789 ff_h263_encode_init(s);
49fb20cb 790 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3ada94ba 791 ff_msmpeg4_encode_init(s);
49fb20cb 792 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
a6bc5731 793 && s->out_format == FMT_MPEG1)
3ada94ba
BF
794 ff_mpeg1_encode_init(s);
795
796 /* init q matrix */
bd96be6e
AD
797 for (i = 0; i < 64; i++) {
798 int j = s->dsp.idct_permutation[i];
799 if (CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4 &&
800 s->mpeg_quant) {
3ada94ba
BF
801 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
802 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
bd96be6e 803 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
3ada94ba
BF
804 s->intra_matrix[j] =
805 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
bd96be6e
AD
806 } else {
807 /* mpeg1/2 */
3ada94ba
BF
808 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
809 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
810 }
bd96be6e 811 if (s->avctx->intra_matrix)
3ada94ba 812 s->intra_matrix[j] = s->avctx->intra_matrix[i];
bd96be6e 813 if (s->avctx->inter_matrix)
3ada94ba
BF
814 s->inter_matrix[j] = s->avctx->inter_matrix[i];
815 }
816
817 /* precompute matrix */
818 /* for mjpeg, we do include qscale in the matrix */
819 if (s->out_format != FMT_MJPEG) {
69cea75f 820 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
bd96be6e
AD
821 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
822 31, 1);
69cea75f 823 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
bd96be6e
AD
824 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
825 31, 0);
3ada94ba
BF
826 }
827
bd96be6e 828 if (ff_rate_control_init(s) < 0)
3ada94ba
BF
829 return -1;
830
831 return 0;
832}
833
efd29844 834av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
3ada94ba
BF
835{
836 MpegEncContext *s = avctx->priv_data;
837
838 ff_rate_control_uninit(s);
839
efd29844 840 ff_MPV_common_end(s);
bd96be6e
AD
841 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
842 s->out_format == FMT_MJPEG)
3ada94ba
BF
843 ff_mjpeg_encode_close(s);
844
845 av_freep(&avctx->extradata);
846
847 return 0;
848}
849
bd96be6e
AD
850static int get_sae(uint8_t *src, int ref, int stride)
851{
3ada94ba 852 int x,y;
bd96be6e 853 int acc = 0;
3ada94ba 854
bd96be6e
AD
855 for (y = 0; y < 16; y++) {
856 for (x = 0; x < 16; x++) {
857 acc += FFABS(src[x + y * stride] - ref);
3ada94ba
BF
858 }
859 }
860
861 return acc;
862}
863
bd96be6e
AD
864static int get_intra_count(MpegEncContext *s, uint8_t *src,
865 uint8_t *ref, int stride)
866{
3ada94ba 867 int x, y, w, h;
bd96be6e 868 int acc = 0;
3ada94ba 869
bd96be6e
AD
870 w = s->width & ~15;
871 h = s->height & ~15;
3ada94ba 872
bd96be6e
AD
873 for (y = 0; y < h; y += 16) {
874 for (x = 0; x < w; x += 16) {
875 int offset = x + y * stride;
876 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
877 16);
878 int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
879 int sae = get_sae(src + offset, mean, stride);
3ada94ba 880
bd96be6e 881 acc += sae + 500 < sad;
3ada94ba
BF
882 }
883 }
884 return acc;
885}
886
887
bd96be6e
AD
888static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
889{
890 AVFrame *pic = NULL;
3ada94ba
BF
891 int64_t pts;
892 int i;
54553842
AK
893 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
894 (s->low_delay ? 0 : 1);
bd96be6e
AD
895 int direct = 1;
896
897 if (pic_arg) {
898 pts = pic_arg->pts;
899 pic_arg->display_picture_number = s->input_picture_number++;
900
901 if (pts != AV_NOPTS_VALUE) {
902 if (s->user_specified_pts != AV_NOPTS_VALUE) {
903 int64_t time = pts;
904 int64_t last = s->user_specified_pts;
905
906 if (time <= last) {
907 av_log(s->avctx, AV_LOG_ERROR,
908 "Error, Invalid timestamp=%"PRId64", "
909 "last=%"PRId64"\n", pts, s->user_specified_pts);
3ada94ba
BF
910 return -1;
911 }
912 }
bd96be6e
AD
913 s->user_specified_pts = pts;
914 } else {
915 if (s->user_specified_pts != AV_NOPTS_VALUE) {
916 s->user_specified_pts =
917 pts = s->user_specified_pts + 1;
918 av_log(s->avctx, AV_LOG_INFO,
919 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
920 pts);
921 } else {
922 pts = pic_arg->display_picture_number;
3ada94ba
BF
923 }
924 }
925 }
926
bd96be6e
AD
927 if (pic_arg) {
928 if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
929 direct = 0;
930 if (pic_arg->linesize[0] != s->linesize)
931 direct = 0;
932 if (pic_arg->linesize[1] != s->uvlinesize)
933 direct = 0;
934 if (pic_arg->linesize[2] != s->uvlinesize)
935 direct = 0;
936
937 //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
938 // pic_arg->linesize[1], s->linesize, s->uvlinesize);
939
940 if (direct) {
941 i = ff_find_unused_picture(s, 1);
4f820131
AU
942 if (i < 0)
943 return i;
3ada94ba 944
bd96be6e
AD
945 pic = (AVFrame *) &s->picture[i];
946 pic->reference = 3;
3ada94ba 947
bd96be6e
AD
948 for (i = 0; i < 4; i++) {
949 pic->data[i] = pic_arg->data[i];
950 pic->linesize[i] = pic_arg->linesize[i];
3ada94ba 951 }
bd96be6e 952 if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
be548816
PP
953 return -1;
954 }
bd96be6e
AD
955 } else {
956 i = ff_find_unused_picture(s, 0);
4f820131
AU
957 if (i < 0)
958 return i;
3ada94ba 959
bd96be6e
AD
960 pic = (AVFrame *) &s->picture[i];
961 pic->reference = 3;
3ada94ba 962
bd96be6e 963 if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
be548816
PP
964 return -1;
965 }
3ada94ba 966
bd96be6e
AD
967 if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
968 pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
969 pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
970 // empty
971 } else {
3ada94ba 972 int h_chroma_shift, v_chroma_shift;
bd96be6e
AD
973 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
974 &v_chroma_shift);
975
976 for (i = 0; i < 3; i++) {
977 int src_stride = pic_arg->linesize[i];
978 int dst_stride = i ? s->uvlinesize : s->linesize;
979 int h_shift = i ? h_chroma_shift : 0;
980 int v_shift = i ? v_chroma_shift : 0;
981 int w = s->width >> h_shift;
982 int h = s->height >> v_shift;
983 uint8_t *src = pic_arg->data[i];
984 uint8_t *dst = pic->data[i];
985
986 if (!s->avctx->rc_buffer_size)
987 dst += INPLACE_OFFSET;
988
989 if (src_stride == dst_stride)
990 memcpy(dst, src, src_stride * h);
991 else {
992 while (h--) {
3ada94ba
BF
993 memcpy(dst, src, w);
994 dst += dst_stride;
995 src += src_stride;
996 }
997 }
998 }
999 }
1000 }
1001 copy_picture_attributes(s, pic, pic_arg);
bd96be6e 1002 pic->pts = pts; // we set this here to avoid modifiying pic_arg
3ada94ba
BF
1003 }
1004
1005 /* shift buffer entries */
bd96be6e
AD
1006 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1007 s->input_picture[i - 1] = s->input_picture[i];
3ada94ba 1008
bd96be6e 1009 s->input_picture[encoding_delay] = (Picture*) pic;
3ada94ba
BF
1010
1011 return 0;
1012}
1013
bd96be6e
AD
1014static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1015{
3ada94ba 1016 int x, y, plane;
bd96be6e
AD
1017 int score = 0;
1018 int64_t score64 = 0;
3ada94ba 1019
bd96be6e 1020 for (plane = 0; plane < 3; plane++) {
657ccb5a 1021 const int stride = p->f.linesize[plane];
bd96be6e
AD
1022 const int bw = plane ? 1 : 2;
1023 for (y = 0; y < s->mb_height * bw; y++) {
1024 for (x = 0; x < s->mb_width * bw; x++) {
1025 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1026 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1027 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1028 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1029
1030 switch (s->avctx->frame_skip_exp) {
1031 case 0: score = FFMAX(score, v); break;
1032 case 1: score += FFABS(v); break;
1033 case 2: score += v * v; break;
1034 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1035 case 4: score64 += v * v * (int64_t)(v * v); break;
3ada94ba
BF
1036 }
1037 }
1038 }
1039 }
1040
bd96be6e
AD
1041 if (score)
1042 score64 = score;
3ada94ba 1043
bd96be6e 1044 if (score64 < s->avctx->frame_skip_threshold)
3ada94ba 1045 return 1;
bd96be6e 1046 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
3ada94ba
BF
1047 return 1;
1048 return 0;
1049}
1050
bd96be6e
AD
1051static int estimate_best_b_count(MpegEncContext *s)
1052{
9342ecf0 1053 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
71a861cf 1054 AVCodecContext *c = avcodec_alloc_context3(NULL);
bd96be6e
AD
1055 AVFrame input[FF_MAX_B_FRAMES + 2];
1056 const int scale = s->avctx->brd_scale;
3ada94ba 1057 int i, j, out_size, p_lambda, b_lambda, lambda2;
bd96be6e
AD
1058 int outbuf_size = s->width * s->height; // FIXME
1059 uint8_t *outbuf = av_malloc(outbuf_size);
1060 int64_t best_rd = INT64_MAX;
1061 int best_b_count = -1;
1062
1063 assert(scale >= 0 && scale <= 3);
1064
1065 //emms_c();
1066 //s->next_picture_ptr->quality;
1067 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1068 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1069 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1070 if (!b_lambda) // FIXME we should do this somewhere else
1071 b_lambda = p_lambda;
1072 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1073 FF_LAMBDA_SHIFT;
1074
1075 c->width = s->width >> scale;
1076 c->height = s->height >> scale;
1077 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1078 CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1079 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1080 c->mb_decision = s->avctx->mb_decision;
1081 c->me_cmp = s->avctx->me_cmp;
1082 c->mb_cmp = s->avctx->mb_cmp;
1083 c->me_sub_cmp = s->avctx->me_sub_cmp;
1084 c->pix_fmt = PIX_FMT_YUV420P;
1085 c->time_base = s->avctx->time_base;
1086 c->max_b_frames = s->max_b_frames;
3ada94ba 1087
0b950fe2 1088 if (avcodec_open2(c, codec, NULL) < 0)
3ada94ba
BF
1089 return -1;
1090
9342ecf0
AD
1091 for (i = 0; i < s->max_b_frames + 2; i++) {
1092 int ysize = c->width * c->height;
1093 int csize = (c->width / 2) * (c->height / 2);
1094 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1095 s->next_picture_ptr;
3ada94ba
BF
1096
1097 avcodec_get_frame_defaults(&input[i]);
9342ecf0
AD
1098 input[i].data[0] = av_malloc(ysize + 2 * csize);
1099 input[i].data[1] = input[i].data[0] + ysize;
1100 input[i].data[2] = input[i].data[1] + csize;
1101 input[i].linesize[0] = c->width;
1102 input[i].linesize[1] =
1103 input[i].linesize[2] = c->width / 2;
3ada94ba 1104
9342ecf0
AD
1105 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1106 pre_input = *pre_input_ptr;
3ada94ba 1107
657ccb5a
DB
1108 if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1109 pre_input.f.data[0] += INPLACE_OFFSET;
1110 pre_input.f.data[1] += INPLACE_OFFSET;
1111 pre_input.f.data[2] += INPLACE_OFFSET;
3ada94ba
BF
1112 }
1113
9342ecf0
AD
1114 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1115 pre_input.f.data[0], pre_input.f.linesize[0],
1116 c->width, c->height);
1117 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1118 pre_input.f.data[1], pre_input.f.linesize[1],
1119 c->width >> 1, c->height >> 1);
1120 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1121 pre_input.f.data[2], pre_input.f.linesize[2],
1122 c->width >> 1, c->height >> 1);
3ada94ba
BF
1123 }
1124 }
1125
9342ecf0
AD
1126 for (j = 0; j < s->max_b_frames + 1; j++) {
1127 int64_t rd = 0;
3ada94ba 1128
9342ecf0 1129 if (!s->input_picture[j])
3ada94ba
BF
1130 break;
1131
9342ecf0 1132 c->error[0] = c->error[1] = c->error[2] = 0;
3ada94ba 1133
9342ecf0
AD
1134 input[0].pict_type = AV_PICTURE_TYPE_I;
1135 input[0].quality = 1 * FF_QP2LAMBDA;
1136 out_size = avcodec_encode_video(c, outbuf,
1137 outbuf_size, &input[0]);
1138 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
3ada94ba 1139
9342ecf0
AD
1140 for (i = 0; i < s->max_b_frames + 1; i++) {
1141 int is_p = i % (j + 1) == j || i == s->max_b_frames;
3ada94ba 1142
9342ecf0
AD
1143 input[i + 1].pict_type = is_p ?
1144 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1145 input[i + 1].quality = is_p ? p_lambda : b_lambda;
1146 out_size = avcodec_encode_video(c, outbuf, outbuf_size,
1147 &input[i + 1]);
3ada94ba
BF
1148 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1149 }
1150
1151 /* get the delayed frames */
9342ecf0 1152 while (out_size) {
3ada94ba
BF
1153 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
1154 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1155 }
1156
1157 rd += c->error[0] + c->error[1] + c->error[2];
1158
9342ecf0
AD
1159 if (rd < best_rd) {
1160 best_rd = rd;
1161 best_b_count = j;
3ada94ba
BF
1162 }
1163 }
1164
1165 av_freep(&outbuf);
1166 avcodec_close(c);
1167 av_freep(&c);
1168
9342ecf0 1169 for (i = 0; i < s->max_b_frames + 2; i++) {
3ada94ba
BF
1170 av_freep(&input[i].data[0]);
1171 }
1172
1173 return best_b_count;
1174}
1175
9342ecf0
AD
1176static int select_input_picture(MpegEncContext *s)
1177{
3ada94ba
BF
1178 int i;
1179
9342ecf0
AD
1180 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1181 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1182 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
3ada94ba
BF
1183
1184 /* set next picture type & ordering */
9342ecf0
AD
1185 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1186 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1187 s->next_picture_ptr == NULL || s->intra_only) {
1188 s->reordered_input_picture[0] = s->input_picture[0];
657ccb5a 1189 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
9342ecf0
AD
1190 s->reordered_input_picture[0]->f.coded_picture_number =
1191 s->coded_picture_number++;
1192 } else {
3ada94ba
BF
1193 int b_frames;
1194
9342ecf0
AD
1195 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1196 if (s->picture_in_gop_number < s->gop_size &&
1197 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1198 // FIXME check that te gop check above is +-1 correct
1199 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1200 // s->input_picture[0]->f.data[0],
1201 // s->input_picture[0]->pts);
3ada94ba 1202
657ccb5a 1203 if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
9342ecf0 1204 for (i = 0; i < 4; i++)
657ccb5a
DB
1205 s->input_picture[0]->f.data[i] = NULL;
1206 s->input_picture[0]->f.type = 0;
9342ecf0
AD
1207 } else {
1208 assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1209 s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
3ada94ba 1210
9342ecf0
AD
1211 s->avctx->release_buffer(s->avctx,
1212 (AVFrame *) s->input_picture[0]);
3ada94ba
BF
1213 }
1214
1215 emms_c();
1216 ff_vbv_update(s, 0);
1217
1218 goto no_output_pic;
1219 }
1220 }
1221
9342ecf0
AD
1222 if (s->flags & CODEC_FLAG_PASS2) {
1223 for (i = 0; i < s->max_b_frames + 1; i++) {
657ccb5a 1224 int pict_num = s->input_picture[0]->f.display_picture_number + i;
3ada94ba 1225
9342ecf0 1226 if (pict_num >= s->rc_context.num_entries)
3ada94ba 1227 break;
9342ecf0
AD
1228 if (!s->input_picture[i]) {
1229 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
3ada94ba
BF
1230 break;
1231 }
1232
657ccb5a 1233 s->input_picture[i]->f.pict_type =
3ada94ba
BF
1234 s->rc_context.entry[pict_num].new_pict_type;
1235 }
1236 }
1237
9342ecf0
AD
1238 if (s->avctx->b_frame_strategy == 0) {
1239 b_frames = s->max_b_frames;
1240 while (b_frames && !s->input_picture[b_frames])
1241 b_frames--;
1242 } else if (s->avctx->b_frame_strategy == 1) {
1243 for (i = 1; i < s->max_b_frames + 1; i++) {
1244 if (s->input_picture[i] &&
1245 s->input_picture[i]->b_frame_score == 0) {
1246 s->input_picture[i]->b_frame_score =
1247 get_intra_count(s,
1248 s->input_picture[i ]->f.data[0],
1249 s->input_picture[i - 1]->f.data[0],
1250 s->linesize) + 1;
3ada94ba
BF
1251 }
1252 }
9342ecf0
AD
1253 for (i = 0; i < s->max_b_frames + 1; i++) {
1254 if (s->input_picture[i] == NULL ||
1255 s->input_picture[i]->b_frame_score - 1 >
1256 s->mb_num / s->avctx->b_sensitivity)
1257 break;
3ada94ba
BF
1258 }
1259
9342ecf0 1260 b_frames = FFMAX(0, i - 1);
3ada94ba
BF
1261
1262 /* reset scores */
9342ecf0
AD
1263 for (i = 0; i < b_frames + 1; i++) {
1264 s->input_picture[i]->b_frame_score = 0;
3ada94ba 1265 }
9342ecf0
AD
1266 } else if (s->avctx->b_frame_strategy == 2) {
1267 b_frames = estimate_best_b_count(s);
1268 } else {
3ada94ba 1269 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
9342ecf0 1270 b_frames = 0;
3ada94ba
BF
1271 }
1272
1273 emms_c();
9342ecf0
AD
1274 //static int b_count = 0;
1275 //b_count += b_frames;
1276 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
3ada94ba 1277
9342ecf0 1278 for (i = b_frames - 1; i >= 0; i--) {
657ccb5a 1279 int type = s->input_picture[i]->f.pict_type;
9342ecf0
AD
1280 if (type && type != AV_PICTURE_TYPE_B)
1281 b_frames = i;
3ada94ba 1282 }
9342ecf0
AD
1283 if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1284 b_frames == s->max_b_frames) {
1285 av_log(s->avctx, AV_LOG_ERROR,
1286 "warning, too many b frames in a row\n");
3ada94ba
BF
1287 }
1288
9342ecf0
AD
1289 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1290 if ((s->flags2 & CODEC_FLAG2_STRICT_GOP) &&
1291 s->gop_size > s->picture_in_gop_number) {
1292 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1293 } else {
1294 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1295 b_frames = 0;
1296 s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1297 }
3ada94ba
BF
1298 }
1299
9342ecf0
AD
1300 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1301 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
3ada94ba
BF
1302 b_frames--;
1303
9342ecf0 1304 s->reordered_input_picture[0] = s->input_picture[b_frames];
657ccb5a
DB
1305 if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1306 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
9342ecf0
AD
1307 s->reordered_input_picture[0]->f.coded_picture_number =
1308 s->coded_picture_number++;
1309 for (i = 0; i < b_frames; i++) {
657ccb5a 1310 s->reordered_input_picture[i + 1] = s->input_picture[i];
9342ecf0
AD
1311 s->reordered_input_picture[i + 1]->f.pict_type =
1312 AV_PICTURE_TYPE_B;
1313 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1314 s->coded_picture_number++;
3ada94ba
BF
1315 }
1316 }
1317 }
1318no_output_pic:
9342ecf0
AD
1319 if (s->reordered_input_picture[0]) {
1320 s->reordered_input_picture[0]->f.reference =
1321 s->reordered_input_picture[0]->f.pict_type !=
1322 AV_PICTURE_TYPE_B ? 3 : 0;
3ada94ba 1323
8d2fc163 1324 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
3ada94ba 1325
9342ecf0
AD
1326 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1327 s->avctx->rc_buffer_size) {
1328 // input is a shared pix, so we can't modifiy it -> alloc a new
1329 // one & ensure that the shared one is reuseable
3ada94ba 1330
1ce1578e 1331 Picture *pic;
9342ecf0 1332 int i = ff_find_unused_picture(s, 0);
4f820131
AU
1333 if (i < 0)
1334 return i;
1ce1578e 1335 pic = &s->picture[i];
3ada94ba 1336
657ccb5a 1337 pic->f.reference = s->reordered_input_picture[0]->f.reference;
9342ecf0 1338 if (ff_alloc_picture(s, pic, 0) < 0) {
be548816
PP
1339 return -1;
1340 }
3ada94ba
BF
1341
1342 /* mark us unused / free shared pic */
657ccb5a 1343 if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
9342ecf0
AD
1344 s->avctx->release_buffer(s->avctx,
1345 (AVFrame *) s->reordered_input_picture[0]);
1346 for (i = 0; i < 4; i++)
657ccb5a
DB
1347 s->reordered_input_picture[0]->f.data[i] = NULL;
1348 s->reordered_input_picture[0]->f.type = 0;
3ada94ba 1349
9342ecf0
AD
1350 copy_picture_attributes(s, (AVFrame *) pic,
1351 (AVFrame *) s->reordered_input_picture[0]);
3ada94ba 1352
9342ecf0
AD
1353 s->current_picture_ptr = pic;
1354 } else {
3ada94ba
BF
1355 // input is not a shared pix -> reuse buffer for current_pix
1356
9342ecf0
AD
1357 assert(s->reordered_input_picture[0]->f.type ==
1358 FF_BUFFER_TYPE_USER ||
1359 s->reordered_input_picture[0]->f.type ==
1360 FF_BUFFER_TYPE_INTERNAL);
3ada94ba 1361
9342ecf0
AD
1362 s->current_picture_ptr = s->reordered_input_picture[0];
1363 for (i = 0; i < 4; i++) {
657ccb5a 1364 s->new_picture.f.data[i] += INPLACE_OFFSET;
3ada94ba
BF
1365 }
1366 }
8d2fc163 1367 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
3ada94ba 1368
657ccb5a 1369 s->picture_number = s->new_picture.f.display_picture_number;
9342ecf0
AD
1370 //printf("dpn:%d\n", s->picture_number);
1371 } else {
1372 memset(&s->new_picture, 0, sizeof(Picture));
3ada94ba 1373 }
be548816 1374 return 0;
3ada94ba
BF
1375}
1376
efd29844
MS
1377int ff_MPV_encode_picture(AVCodecContext *avctx,
1378 unsigned char *buf, int buf_size, void *data)
3ada94ba
BF
1379{
1380 MpegEncContext *s = avctx->priv_data;
9342ecf0 1381 AVFrame *pic_arg = data;
881a5e04
JG
1382 int i, stuffing_count;
1383 int context_count = s->slice_context_count;
3ada94ba 1384
9342ecf0
AD
1385 for (i = 0; i < context_count; i++) {
1386 int start_y = s->thread_context[i]->start_mb_y;
1387 int end_y = s->thread_context[i]-> end_mb_y;
1388 int h = s->mb_height;
1389 uint8_t *start = buf + (size_t)(((int64_t) buf_size) * start_y / h);
1390 uint8_t *end = buf + (size_t)(((int64_t) buf_size) * end_y / h);
3ada94ba
BF
1391
1392 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1393 }
1394
1395 s->picture_in_gop_number++;
1396
9342ecf0 1397 if (load_input_picture(s, pic_arg) < 0)
3ada94ba
BF
1398 return -1;
1399
9342ecf0 1400 if (select_input_picture(s) < 0) {
be548816
PP
1401 return -1;
1402 }
3ada94ba
BF
1403
1404 /* output? */
657ccb5a
DB
1405 if (s->new_picture.f.data[0]) {
1406 s->pict_type = s->new_picture.f.pict_type;
9342ecf0
AD
1407 //emms_c();
1408 //printf("qs:%f %f %d\n", s->new_picture.quality,
1409 // s->current_picture.quality, s->qscale);
efd29844 1410 ff_MPV_frame_start(s, avctx);
3ada94ba
BF
1411vbv_retry:
1412 if (encode_picture(s, s->picture_number) < 0)
1413 return -1;
1414
3ada94ba
BF
1415 avctx->header_bits = s->header_bits;
1416 avctx->mv_bits = s->mv_bits;
1417 avctx->misc_bits = s->misc_bits;
1418 avctx->i_tex_bits = s->i_tex_bits;
1419 avctx->p_tex_bits = s->p_tex_bits;
1420 avctx->i_count = s->i_count;
9342ecf0
AD
1421 // FIXME f/b_count in avctx
1422 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
3ada94ba
BF
1423 avctx->skip_count = s->skip_count;
1424
efd29844 1425 ff_MPV_frame_end(s);
3ada94ba 1426
49fb20cb 1427 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
3ada94ba
BF
1428 ff_mjpeg_encode_picture_trailer(s);
1429
9342ecf0
AD
1430 if (avctx->rc_buffer_size) {
1431 RateControlContext *rcc = &s->rc_context;
1432 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
3ada94ba 1433
9342ecf0
AD
1434 if (put_bits_count(&s->pb) > max_size &&
1435 s->lambda < s->avctx->lmax) {
1436 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1437 (s->qscale + 1) / s->qscale);
1438 if (s->adaptive_quant) {
3ada94ba 1439 int i;
9342ecf0
AD
1440 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1441 s->lambda_table[i] =
1442 FFMAX(s->lambda_table[i] + 1,
1443 s->lambda_table[i] * (s->qscale + 1) /
1444 s->qscale);
3ada94ba 1445 }
9342ecf0
AD
1446 s->mb_skipped = 0; // done in MPV_frame_start()
1447 // done in encode_picture() so we must undo it
1448 if (s->pict_type == AV_PICTURE_TYPE_P) {
1449 if (s->flipflop_rounding ||
1450 s->codec_id == CODEC_ID_H263P ||
1451 s->codec_id == CODEC_ID_MPEG4)
3ada94ba
BF
1452 s->no_rounding ^= 1;
1453 }
9342ecf0
AD
1454 if (s->pict_type != AV_PICTURE_TYPE_B) {
1455 s->time_base = s->last_time_base;
1456 s->last_non_b_time = s->time - s->pp_time;
3ada94ba 1457 }
9342ecf0
AD
1458 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1459 for (i = 0; i < context_count; i++) {
1460 PutBitContext *pb = &s->thread_context[i]->pb;
3ada94ba
BF
1461 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1462 }
1463 goto vbv_retry;
1464 }
1465
1466 assert(s->avctx->rc_max_rate);
1467 }
1468
9342ecf0 1469 if (s->flags & CODEC_FLAG_PASS1)
3ada94ba
BF
1470 ff_write_pass1_stats(s);
1471
9342ecf0
AD
1472 for (i = 0; i < 4; i++) {
1473 s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1474 avctx->error[i] += s->current_picture_ptr->f.error[i];
3ada94ba
BF
1475 }
1476
9342ecf0
AD
1477 if (s->flags & CODEC_FLAG_PASS1)
1478 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1479 avctx->i_tex_bits + avctx->p_tex_bits ==
1480 put_bits_count(&s->pb));
3ada94ba
BF
1481 flush_put_bits(&s->pb);
1482 s->frame_bits = put_bits_count(&s->pb);
1483
9342ecf0
AD
1484 stuffing_count = ff_vbv_update(s, s->frame_bits);
1485 if (stuffing_count) {
1486 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1487 stuffing_count + 50) {
3ada94ba
BF
1488 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1489 return -1;
1490 }
1491
9342ecf0 1492 switch (s->codec_id) {
3ada94ba
BF
1493 case CODEC_ID_MPEG1VIDEO:
1494 case CODEC_ID_MPEG2VIDEO:
9342ecf0 1495 while (stuffing_count--) {
3ada94ba
BF
1496 put_bits(&s->pb, 8, 0);
1497 }
1498 break;
1499 case CODEC_ID_MPEG4:
1500 put_bits(&s->pb, 16, 0);
1501 put_bits(&s->pb, 16, 0x1C3);
1502 stuffing_count -= 4;
9342ecf0 1503 while (stuffing_count--) {
3ada94ba
BF
1504 put_bits(&s->pb, 8, 0xFF);
1505 }
1506 break;
1507 default:
1508 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1509 }
1510 flush_put_bits(&s->pb);
1511 s->frame_bits = put_bits_count(&s->pb);
1512 }
1513
1514 /* update mpeg1/2 vbv_delay for CBR */
9342ecf0
AD
1515 if (s->avctx->rc_max_rate &&
1516 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1517 s->out_format == FMT_MPEG1 &&
1518 90000LL * (avctx->rc_buffer_size - 1) <=
1519 s->avctx->rc_max_rate * 0xFFFFLL) {
4601e76a 1520 int vbv_delay, min_delay;
9342ecf0
AD
1521 double inbits = s->avctx->rc_max_rate *
1522 av_q2d(s->avctx->time_base);
1523 int minbits = s->frame_bits - 8 *
1524 (s->vbv_delay_ptr - s->pb.buf - 1);
1525 double bits = s->rc_context.buffer_index + minbits - inbits;
4601e76a 1526
9342ecf0
AD
1527 if (bits < 0)
1528 av_log(s->avctx, AV_LOG_ERROR,
1529 "Internal error, negative bits\n");
3ada94ba 1530
9342ecf0 1531 assert(s->repeat_first_field == 0);
3ada94ba 1532
9342ecf0
AD
1533 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1534 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1535 s->avctx->rc_max_rate;
4601e76a 1536
9342ecf0 1537 vbv_delay = FFMAX(vbv_delay, min_delay);
4601e76a 1538
3ada94ba
BF
1539 assert(vbv_delay < 0xFFFF);
1540
1541 s->vbv_delay_ptr[0] &= 0xF8;
9342ecf0
AD
1542 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1543 s->vbv_delay_ptr[1] = vbv_delay >> 5;
3ada94ba 1544 s->vbv_delay_ptr[2] &= 0x07;
9342ecf0
AD
1545 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1546 avctx->vbv_delay = vbv_delay * 300;
3ada94ba 1547 }
9342ecf0 1548 s->total_bits += s->frame_bits;
3ada94ba 1549 avctx->frame_bits = s->frame_bits;
9342ecf0 1550 } else {
fb53b4a0 1551 assert((put_bits_ptr(&s->pb) == s->pb.buf));
9342ecf0 1552 s->frame_bits = 0;
3ada94ba 1553 }
9342ecf0 1554 assert((s->frame_bits & 7) == 0);
3ada94ba 1555
9342ecf0 1556 return s->frame_bits / 8;
3ada94ba
BF
1557}
1558
9342ecf0
AD
1559static inline void dct_single_coeff_elimination(MpegEncContext *s,
1560 int n, int threshold)
3ada94ba 1561{
9342ecf0
AD
1562 static const char tab[64] = {
1563 3, 2, 2, 1, 1, 1, 1, 1,
1564 1, 1, 1, 1, 1, 1, 1, 1,
1565 1, 1, 1, 1, 1, 1, 1, 1,
1566 0, 0, 0, 0, 0, 0, 0, 0,
1567 0, 0, 0, 0, 0, 0, 0, 0,
1568 0, 0, 0, 0, 0, 0, 0, 0,
1569 0, 0, 0, 0, 0, 0, 0, 0,
1570 0, 0, 0, 0, 0, 0, 0, 0
1571 };
1572 int score = 0;
1573 int run = 0;
3ada94ba 1574 int i;
9342ecf0
AD
1575 DCTELEM *block = s->block[n];
1576 const int last_index = s->block_last_index[n];
3ada94ba
BF
1577 int skip_dc;
1578
9342ecf0
AD
1579 if (threshold < 0) {
1580 skip_dc = 0;
1581 threshold = -threshold;
1582 } else
1583 skip_dc = 1;
3ada94ba 1584
bd107136 1585 /* Are all we could set to zero already zero? */
9342ecf0
AD
1586 if (last_index <= skip_dc - 1)
1587 return;
3ada94ba 1588
9342ecf0 1589 for (i = 0; i <= last_index; i++) {
3ada94ba
BF
1590 const int j = s->intra_scantable.permutated[i];
1591 const int level = FFABS(block[j]);
9342ecf0
AD
1592 if (level == 1) {
1593 if (skip_dc && i == 0)
1594 continue;
1595 score += tab[run];
1596 run = 0;
1597 } else if (level > 1) {
3ada94ba 1598 return;
9342ecf0 1599 } else {
3ada94ba
BF
1600 run++;
1601 }
1602 }
9342ecf0
AD
1603 if (score >= threshold)
1604 return;
1605 for (i = skip_dc; i <= last_index; i++) {
3ada94ba 1606 const int j = s->intra_scantable.permutated[i];
9342ecf0 1607 block[j] = 0;
3ada94ba 1608 }
9342ecf0
AD
1609 if (block[0])
1610 s->block_last_index[n] = 0;
1611 else
1612 s->block_last_index[n] = -1;
3ada94ba
BF
1613}
1614
9342ecf0
AD
1615static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1616 int last_index)
3ada94ba
BF
1617{
1618 int i;
9342ecf0
AD
1619 const int maxlevel = s->max_qcoeff;
1620 const int minlevel = s->min_qcoeff;
1621 int overflow = 0;
3ada94ba 1622
9342ecf0
AD
1623 if (s->mb_intra) {
1624 i = 1; // skip clipping of intra dc
1625 } else
1626 i = 0;
3ada94ba 1627
9342ecf0
AD
1628 for (; i <= last_index; i++) {
1629 const int j = s->intra_scantable.permutated[i];
3ada94ba
BF
1630 int level = block[j];
1631
9342ecf0
AD
1632 if (level > maxlevel) {
1633 level = maxlevel;
3ada94ba 1634 overflow++;
9342ecf0
AD
1635 } else if (level < minlevel) {
1636 level = minlevel;
3ada94ba
BF
1637 overflow++;
1638 }
1639
9342ecf0 1640 block[j] = level;
3ada94ba
BF
1641 }
1642
9342ecf0
AD
1643 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1644 av_log(s->avctx, AV_LOG_INFO,
1645 "warning, clipping %d dct coefficients to %d..%d\n",
1646 overflow, minlevel, maxlevel);
3ada94ba
BF
1647}
1648
9342ecf0
AD
1649static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1650{
3ada94ba 1651 int x, y;
9342ecf0
AD
1652 // FIXME optimize
1653 for (y = 0; y < 8; y++) {
1654 for (x = 0; x < 8; x++) {
3ada94ba 1655 int x2, y2;
9342ecf0
AD
1656 int sum = 0;
1657 int sqr = 0;
1658 int count = 0;
3ada94ba 1659
9342ecf0
AD
1660 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1661 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1662 int v = ptr[x2 + y2 * stride];
3ada94ba 1663 sum += v;
9342ecf0 1664 sqr += v * v;
3ada94ba
BF
1665 count++;
1666 }
1667 }
9342ecf0 1668 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
3ada94ba
BF
1669 }
1670 }
1671}
1672
9342ecf0
AD
1673static av_always_inline void encode_mb_internal(MpegEncContext *s,
1674 int motion_x, int motion_y,
1675 int mb_block_height,
1676 int mb_block_count)
3ada94ba
BF
1677{
1678 int16_t weight[8][64];
1679 DCTELEM orig[8][64];
9342ecf0
AD
1680 const int mb_x = s->mb_x;
1681 const int mb_y = s->mb_y;
3ada94ba
BF
1682 int i;
1683 int skip_dct[8];
9342ecf0 1684 int dct_offset = s->linesize * 8; // default for progressive frames
3ada94ba
BF
1685 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1686 int wrap_y, wrap_c;
1687
9342ecf0
AD
1688 for (i = 0; i < mb_block_count; i++)
1689 skip_dct[i] = s->skipdct;
3ada94ba 1690
9342ecf0
AD
1691 if (s->adaptive_quant) {
1692 const int last_qp = s->qscale;
1693 const int mb_xy = mb_x + mb_y * s->mb_stride;
3ada94ba 1694
9342ecf0 1695 s->lambda = s->lambda_table[mb_xy];
3ada94ba
BF
1696 update_qscale(s);
1697
9342ecf0 1698 if (!(s->flags & CODEC_FLAG_QP_RD)) {
657ccb5a 1699 s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
9342ecf0 1700 s->dquant = s->qscale - last_qp;
3ada94ba 1701
9342ecf0
AD
1702 if (s->out_format == FMT_H263) {
1703 s->dquant = av_clip(s->dquant, -2, 2);
3ada94ba 1704
9342ecf0
AD
1705 if (s->codec_id == CODEC_ID_MPEG4) {
1706 if (!s->mb_intra) {
1707 if (s->pict_type == AV_PICTURE_TYPE_B) {
1708 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1709 s->dquant = 0;
3ada94ba 1710 }
9342ecf0
AD
1711 if (s->mv_type == MV_TYPE_8X8)
1712 s->dquant = 0;
3ada94ba
BF
1713 }
1714 }
1715 }
1716 }
1717 ff_set_qscale(s, last_qp + s->dquant);
9342ecf0 1718 } else if (s->flags & CODEC_FLAG_QP_RD)
3ada94ba
BF
1719 ff_set_qscale(s, s->qscale + s->dquant);
1720
1721 wrap_y = s->linesize;
1722 wrap_c = s->uvlinesize;
9342ecf0
AD
1723 ptr_y = s->new_picture.f.data[0] +
1724 (mb_y * 16 * wrap_y) + mb_x * 16;
1725 ptr_cb = s->new_picture.f.data[1] +
1726 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1727 ptr_cr = s->new_picture.f.data[2] +
1728 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1729
1730 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1731 uint8_t *ebuf = s->edge_emu_buffer + 32;
1732 s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1733 mb_y * 16, s->width, s->height);
1734 ptr_y = ebuf;
1735 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1736 mb_block_height, mb_x * 8, mb_y * 8,
1737 s->width >> 1, s->height >> 1);
1738 ptr_cb = ebuf + 18 * wrap_y;
1739 s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1740 mb_block_height, mb_x * 8, mb_y * 8,
1741 s->width >> 1, s->height >> 1);
1742 ptr_cr = ebuf + 18 * wrap_y + 8;
3ada94ba
BF
1743 }
1744
1745 if (s->mb_intra) {
9342ecf0 1746 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1747 int progressive_score, interlaced_score;
1748
9342ecf0
AD
1749 s->interlaced_dct = 0;
1750 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1751 NULL, wrap_y, 8) +
1752 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1753 NULL, wrap_y, 8) - 400;
1754
1755 if (progressive_score > 0) {
1756 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1757 NULL, wrap_y * 2, 8) +
1758 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1759 NULL, wrap_y * 2, 8);
1760 if (progressive_score > interlaced_score) {
1761 s->interlaced_dct = 1;
1762
1763 dct_offset = wrap_y;
1764 wrap_y <<= 1;
3ada94ba 1765 if (s->chroma_format == CHROMA_422)
9342ecf0 1766 wrap_c <<= 1;
3ada94ba
BF
1767 }
1768 }
1769 }
1770
9342ecf0
AD
1771 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1772 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1773 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1774 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
3ada94ba 1775
9342ecf0
AD
1776 if (s->flags & CODEC_FLAG_GRAY) {
1777 skip_dct[4] = 1;
1778 skip_dct[5] = 1;
1779 } else {
3ada94ba
BF
1780 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1781 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
9342ecf0
AD
1782 if (!s->chroma_y_shift) { /* 422 */
1783 s->dsp.get_pixels(s->block[6],
1784 ptr_cb + (dct_offset >> 1), wrap_c);
1785 s->dsp.get_pixels(s->block[7],
1786 ptr_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
1787 }
1788 }
9342ecf0 1789 } else {
3ada94ba
BF
1790 op_pixels_func (*op_pix)[4];
1791 qpel_mc_func (*op_qpix)[16];
1792 uint8_t *dest_y, *dest_cb, *dest_cr;
1793
1794 dest_y = s->dest[0];
1795 dest_cb = s->dest[1];
1796 dest_cr = s->dest[2];
1797
9342ecf0
AD
1798 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1799 op_pix = s->dsp.put_pixels_tab;
1800 op_qpix = s->dsp.put_qpel_pixels_tab;
1801 } else {
1802 op_pix = s->dsp.put_no_rnd_pixels_tab;
1803 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
3ada94ba
BF
1804 }
1805
1806 if (s->mv_dir & MV_DIR_FORWARD) {
9342ecf0
AD
1807 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data,
1808 op_pix, op_qpix);
1809 op_pix = s->dsp.avg_pixels_tab;
1810 op_qpix = s->dsp.avg_qpel_pixels_tab;
3ada94ba
BF
1811 }
1812 if (s->mv_dir & MV_DIR_BACKWARD) {
9342ecf0
AD
1813 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data,
1814 op_pix, op_qpix);
3ada94ba
BF
1815 }
1816
9342ecf0 1817 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1818 int progressive_score, interlaced_score;
1819
9342ecf0
AD
1820 s->interlaced_dct = 0;
1821 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1822 ptr_y, wrap_y,
1823 8) +
1824 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1825 ptr_y + wrap_y * 8, wrap_y,
1826 8) - 400;
1827
1828 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1829 progressive_score -= 400;
1830
1831 if (progressive_score > 0) {
1832 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1833 ptr_y,
1834 wrap_y * 2, 8) +
1835 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1836 ptr_y + wrap_y,
1837 wrap_y * 2, 8);
1838
1839 if (progressive_score > interlaced_score) {
1840 s->interlaced_dct = 1;
1841
1842 dct_offset = wrap_y;
1843 wrap_y <<= 1;
3ada94ba 1844 if (s->chroma_format == CHROMA_422)
9342ecf0 1845 wrap_c <<= 1;
3ada94ba
BF
1846 }
1847 }
1848 }
1849
9342ecf0
AD
1850 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1851 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1852 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1853 dest_y + dct_offset, wrap_y);
1854 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1855 dest_y + dct_offset + 8, wrap_y);
3ada94ba 1856
9342ecf0
AD
1857 if (s->flags & CODEC_FLAG_GRAY) {
1858 skip_dct[4] = 1;
1859 skip_dct[5] = 1;
1860 } else {
3ada94ba
BF
1861 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1862 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
9342ecf0
AD
1863 if (!s->chroma_y_shift) { /* 422 */
1864 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1865 dest_cb + (dct_offset >> 1), wrap_c);
1866 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1867 dest_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
1868 }
1869 }
1870 /* pre quantization */
9342ecf0
AD
1871 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1872 2 * s->qscale * s->qscale) {
1873 // FIXME optimize
1874 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1875 wrap_y, 8) < 20 * s->qscale)
1876 skip_dct[0] = 1;
1877 if (s->dsp.sad[1](NULL, ptr_y + 8,
1878 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1879 skip_dct[1] = 1;
1880 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1881 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1882 skip_dct[2] = 1;
1883 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1884 dest_y + dct_offset + 8,
1885 wrap_y, 8) < 20 * s->qscale)
1886 skip_dct[3] = 1;
1887 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1888 wrap_c, 8) < 20 * s->qscale)
1889 skip_dct[4] = 1;
1890 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1891 wrap_c, 8) < 20 * s->qscale)
1892 skip_dct[5] = 1;
1893 if (!s->chroma_y_shift) { /* 422 */
1894 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1895 dest_cb + (dct_offset >> 1),
1896 wrap_c, 8) < 20 * s->qscale)
1897 skip_dct[6] = 1;
1898 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1899 dest_cr + (dct_offset >> 1),
1900 wrap_c, 8) < 20 * s->qscale)
1901 skip_dct[7] = 1;
3ada94ba
BF
1902 }
1903 }
1904 }
1905
9342ecf0
AD
1906 if (s->avctx->quantizer_noise_shaping) {
1907 if (!skip_dct[0])
1908 get_visual_weight(weight[0], ptr_y , wrap_y);
1909 if (!skip_dct[1])
1910 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
1911 if (!skip_dct[2])
1912 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
1913 if (!skip_dct[3])
1914 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
1915 if (!skip_dct[4])
1916 get_visual_weight(weight[4], ptr_cb , wrap_c);
1917 if (!skip_dct[5])
1918 get_visual_weight(weight[5], ptr_cr , wrap_c);
1919 if (!s->chroma_y_shift) { /* 422 */
1920 if (!skip_dct[6])
1921 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
1922 wrap_c);
1923 if (!skip_dct[7])
1924 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
1925 wrap_c);
3ada94ba 1926 }
9342ecf0 1927 memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
3ada94ba
BF
1928 }
1929
1930 /* DCT & quantize */
9342ecf0 1931 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
3ada94ba 1932 {
9342ecf0
AD
1933 for (i = 0; i < mb_block_count; i++) {
1934 if (!skip_dct[i]) {
3ada94ba
BF
1935 int overflow;
1936 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
9342ecf0
AD
1937 // FIXME we could decide to change to quantizer instead of
1938 // clipping
1939 // JS: I don't think that would be a good idea it could lower
1940 // quality instead of improve it. Just INTRADC clipping
1941 // deserves changes in quantizer
1942 if (overflow)
1943 clip_coeffs(s, s->block[i], s->block_last_index[i]);
1944 } else
1945 s->block_last_index[i] = -1;
3ada94ba 1946 }
9342ecf0
AD
1947 if (s->avctx->quantizer_noise_shaping) {
1948 for (i = 0; i < mb_block_count; i++) {
1949 if (!skip_dct[i]) {
1950 s->block_last_index[i] =
1951 dct_quantize_refine(s, s->block[i], weight[i],
1952 orig[i], i, s->qscale);
3ada94ba
BF
1953 }
1954 }
1955 }
1956
9342ecf0
AD
1957 if (s->luma_elim_threshold && !s->mb_intra)
1958 for (i = 0; i < 4; i++)
3ada94ba 1959 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
9342ecf0
AD
1960 if (s->chroma_elim_threshold && !s->mb_intra)
1961 for (i = 4; i < mb_block_count; i++)
3ada94ba
BF
1962 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
1963
9342ecf0
AD
1964 if (s->flags & CODEC_FLAG_CBP_RD) {
1965 for (i = 0; i < mb_block_count; i++) {
1966 if (s->block_last_index[i] == -1)
1967 s->coded_score[i] = INT_MAX / 256;
3ada94ba
BF
1968 }
1969 }
1970 }
1971
9342ecf0
AD
1972 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
1973 s->block_last_index[4] =
1974 s->block_last_index[5] = 0;
1975 s->block[4][0] =
1976 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
3ada94ba
BF
1977 }
1978
9342ecf0 1979 // non c quantize code returns incorrect block_last_index FIXME
99560a4c 1980 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
9342ecf0 1981 for (i = 0; i < mb_block_count; i++) {
3ada94ba 1982 int j;
9342ecf0
AD
1983 if (s->block_last_index[i] > 0) {
1984 for (j = 63; j > 0; j--) {
1985 if (s->block[i][s->intra_scantable.permutated[j]])
1986 break;
3ada94ba 1987 }
9342ecf0 1988 s->block_last_index[i] = j;
3ada94ba
BF
1989 }
1990 }
1991 }
1992
1993 /* huffman encode */
1994 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
1995 case CODEC_ID_MPEG1VIDEO:
1996 case CODEC_ID_MPEG2VIDEO:
49fb20cb 1997 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
d6c8dcb8 1998 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
56be950a 1999 break;
3ada94ba 2000 case CODEC_ID_MPEG4:
49fb20cb 2001 if (CONFIG_MPEG4_ENCODER)
6f13a371 2002 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
674eeb5f 2003 break;
3ada94ba
BF
2004 case CODEC_ID_MSMPEG4V2:
2005 case CODEC_ID_MSMPEG4V3:
2006 case CODEC_ID_WMV1:
49fb20cb 2007 if (CONFIG_MSMPEG4_ENCODER)
04d38225 2008 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
3ada94ba
BF
2009 break;
2010 case CODEC_ID_WMV2:
49fb20cb 2011 if (CONFIG_WMV2_ENCODER)
3ada94ba
BF
2012 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2013 break;
2014 case CODEC_ID_H261:
49fb20cb 2015 if (CONFIG_H261_ENCODER)
3ada94ba
BF
2016 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2017 break;
2018 case CODEC_ID_H263:
2019 case CODEC_ID_H263P:
2020 case CODEC_ID_FLV1:
2021 case CODEC_ID_RV10:
2022 case CODEC_ID_RV20:
0bd48530 2023 if (CONFIG_H263_ENCODER)
ddce8953 2024 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
674eeb5f 2025 break;
3ada94ba 2026 case CODEC_ID_MJPEG:
49fb20cb 2027 if (CONFIG_MJPEG_ENCODER)
3ada94ba
BF
2028 ff_mjpeg_encode_mb(s, s->block);
2029 break;
2030 default:
2031 assert(0);
2032 }
2033}
2034
2035static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2036{
2037 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2038 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2039}
2040
3ada94ba
BF
2041static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2042 int i;
2043
be73d76b 2044 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
3ada94ba
BF
2045
2046 /* mpeg1 */
2047 d->mb_skip_run= s->mb_skip_run;
2048 for(i=0; i<3; i++)
9342ecf0 2049 d->last_dc[i] = s->last_dc[i];
3ada94ba
BF
2050
2051 /* statistics */
2052 d->mv_bits= s->mv_bits;
2053 d->i_tex_bits= s->i_tex_bits;
2054 d->p_tex_bits= s->p_tex_bits;
2055 d->i_count= s->i_count;
2056 d->f_count= s->f_count;
2057 d->b_count= s->b_count;
2058 d->skip_count= s->skip_count;
2059 d->misc_bits= s->misc_bits;
2060 d->last_bits= 0;
2061
2062 d->mb_skipped= 0;
2063 d->qscale= s->qscale;
2064 d->dquant= s->dquant;
9f175aa0
MN
2065
2066 d->esc3_level_length= s->esc3_level_length;
3ada94ba
BF
2067}
2068
2069static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2070 int i;
2071
2072 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
be73d76b 2073 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
3ada94ba
BF
2074
2075 /* mpeg1 */
2076 d->mb_skip_run= s->mb_skip_run;
2077 for(i=0; i<3; i++)
9342ecf0 2078 d->last_dc[i] = s->last_dc[i];
3ada94ba
BF
2079
2080 /* statistics */
2081 d->mv_bits= s->mv_bits;
2082 d->i_tex_bits= s->i_tex_bits;
2083 d->p_tex_bits= s->p_tex_bits;
2084 d->i_count= s->i_count;
2085 d->f_count= s->f_count;
2086 d->b_count= s->b_count;
2087 d->skip_count= s->skip_count;
2088 d->misc_bits= s->misc_bits;
2089
2090 d->mb_intra= s->mb_intra;
2091 d->mb_skipped= s->mb_skipped;
2092 d->mv_type= s->mv_type;
2093 d->mv_dir= s->mv_dir;
2094 d->pb= s->pb;
2095 if(s->data_partitioning){
2096 d->pb2= s->pb2;
2097 d->tex_pb= s->tex_pb;
2098 }
2099 d->block= s->block;
2100 for(i=0; i<8; i++)
2101 d->block_last_index[i]= s->block_last_index[i];
2102 d->interlaced_dct= s->interlaced_dct;
2103 d->qscale= s->qscale;
9f175aa0
MN
2104
2105 d->esc3_level_length= s->esc3_level_length;
3ada94ba
BF
2106}
2107
2108static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2109 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2110 int *dmin, int *next_block, int motion_x, int motion_y)
2111{
2112 int score;
2113 uint8_t *dest_backup[3];
2114
2115 copy_context_before_encode(s, backup, type);
2116
2117 s->block= s->blocks[*next_block];
2118 s->pb= pb[*next_block];
2119 if(s->data_partitioning){
2120 s->pb2 = pb2 [*next_block];
2121 s->tex_pb= tex_pb[*next_block];
2122 }
2123
2124 if(*next_block){
2125 memcpy(dest_backup, s->dest, sizeof(s->dest));
2126 s->dest[0] = s->rd_scratchpad;
2127 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2128 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2129 assert(s->linesize >= 32); //FIXME
2130 }
2131
2132 encode_mb(s, motion_x, motion_y);
2133
2134 score= put_bits_count(&s->pb);
2135 if(s->data_partitioning){
2136 score+= put_bits_count(&s->pb2);
2137 score+= put_bits_count(&s->tex_pb);
2138 }
2139
2140 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
efd29844 2141 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2142
2143 score *= s->lambda2;
2144 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2145 }
2146
2147 if(*next_block){
2148 memcpy(s->dest, dest_backup, sizeof(s->dest));
2149 }
2150
2151 if(score<*dmin){
2152 *dmin= score;
2153 *next_block^=1;
2154
2155 copy_context_after_encode(best, s, type);
2156 }
2157}
2158
2159static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2160 uint32_t *sq = ff_squareTbl + 256;
2161 int acc=0;
2162 int x,y;
2163
2164 if(w==16 && h==16)
2165 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2166 else if(w==8 && h==8)
2167 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2168
2169 for(y=0; y<h; y++){
2170 for(x=0; x<w; x++){
2171 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2172 }
2173 }
2174
2175 assert(acc>=0);
2176
2177 return acc;
2178}
2179
2180static int sse_mb(MpegEncContext *s){
2181 int w= 16;
2182 int h= 16;
2183
2184 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2185 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2186
2187 if(w==16 && h==16)
2188 if(s->avctx->mb_cmp == FF_CMP_NSSE){
657ccb5a
DB
2189 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)
2190 +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)
2191 +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);
3ada94ba 2192 }else{
657ccb5a
DB
2193 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)
2194 +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)
2195 +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);
3ada94ba
BF
2196 }
2197 else
657ccb5a
DB
2198 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)
2199 +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)
2200 +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);
3ada94ba
BF
2201}
2202
2203static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3a84713a 2204 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2205
2206
2207 s->me.pre_pass=1;
2208 s->me.dia_size= s->avctx->pre_dia_size;
2209 s->first_slice_line=1;
2210 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2211 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2212 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2213 }
2214 s->first_slice_line=0;
2215 }
2216
2217 s->me.pre_pass=0;
2218
2219 return 0;
2220}
2221
2222static int estimate_motion_thread(AVCodecContext *c, void *arg){
3a84713a 2223 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2224
2225 ff_check_alignment();
2226
2227 s->me.dia_size= s->avctx->dia_size;
2228 s->first_slice_line=1;
2229 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2230 s->mb_x=0; //for block init below
2231 ff_init_block_index(s);
2232 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2233 s->block_index[0]+=2;
2234 s->block_index[1]+=2;
2235 s->block_index[2]+=2;
2236 s->block_index[3]+=2;
2237
2238 /* compute motion vector & mb_type and store in context */
975a1447 2239 if(s->pict_type==AV_PICTURE_TYPE_B)
3ada94ba
BF
2240 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2241 else
2242 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2243 }
2244 s->first_slice_line=0;
2245 }
2246 return 0;
2247}
2248
2249static int mb_var_thread(AVCodecContext *c, void *arg){
3a84713a 2250 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2251 int mb_x, mb_y;
2252
2253 ff_check_alignment();
2254
2255 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2256 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2257 int xx = mb_x * 16;
2258 int yy = mb_y * 16;
657ccb5a 2259 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
3ada94ba
BF
2260 int varc;
2261 int sum = s->dsp.pix_sum(pix, s->linesize);
2262
05795f35 2263 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
3ada94ba
BF
2264
2265 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2266 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2267 s->me.mb_var_sum_temp += varc;
2268 }
2269 }
2270 return 0;
2271}
2272
2273static void write_slice_end(MpegEncContext *s){
49fb20cb 2274 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
3ada94ba
BF
2275 if(s->partitioned_frame){
2276 ff_mpeg4_merge_partitions(s);
2277 }
2278
2279 ff_mpeg4_stuffing(&s->pb);
49fb20cb 2280 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
3ada94ba
BF
2281 ff_mjpeg_encode_stuffing(&s->pb);
2282 }
2283
9f51c682 2284 avpriv_align_put_bits(&s->pb);
3ada94ba
BF
2285 flush_put_bits(&s->pb);
2286
2287 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2288 s->misc_bits+= get_bits_diff(s);
2289}
2290
2291static int encode_thread(AVCodecContext *c, void *arg){
3a84713a 2292 MpegEncContext *s= *(void**)arg;
3ada94ba 2293 int mb_x, mb_y, pdif = 0;
ec7e2582 2294 int chr_h= 16>>s->chroma_y_shift;
3ada94ba
BF
2295 int i, j;
2296 MpegEncContext best_s, backup_s;
2297 uint8_t bit_buf[2][MAX_MB_BYTES];
2298 uint8_t bit_buf2[2][MAX_MB_BYTES];
2299 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2300 PutBitContext pb[2], pb2[2], tex_pb[2];
2301//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2302
2303 ff_check_alignment();
2304
2305 for(i=0; i<2; i++){
2306 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2307 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2308 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2309 }
2310
2311 s->last_bits= put_bits_count(&s->pb);
2312 s->mv_bits=0;
2313 s->misc_bits=0;
2314 s->i_tex_bits=0;
2315 s->p_tex_bits=0;
2316 s->i_count=0;
2317 s->f_count=0;
2318 s->b_count=0;
2319 s->skip_count=0;
2320
2321 for(i=0; i<3; i++){
2322 /* init last dc values */
2323 /* note: quant matrix value (8) is implied here */
2324 s->last_dc[i] = 128 << s->intra_dc_precision;
2325
657ccb5a 2326 s->current_picture.f.error[i] = 0;
3ada94ba
BF
2327 }
2328 s->mb_skip_run = 0;
2329 memset(s->last_mv, 0, sizeof(s->last_mv));
2330
2331 s->last_mv_dir = 0;
2332
2333 switch(s->codec_id){
2334 case CODEC_ID_H263:
2335 case CODEC_ID_H263P:
2336 case CODEC_ID_FLV1:
0bd48530 2337 if (CONFIG_H263_ENCODER)
674eeb5f 2338 s->gob_index = ff_h263_get_gob_height(s);
3ada94ba
BF
2339 break;
2340 case CODEC_ID_MPEG4:
49fb20cb 2341 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3ada94ba
BF
2342 ff_mpeg4_init_partitions(s);
2343 break;
2344 }
2345
2346 s->resync_mb_x=0;
2347 s->resync_mb_y=0;
2348 s->first_slice_line = 1;
2349 s->ptr_lastgob = s->pb.buf;
2350 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2351// printf("row %d at %X\n", s->mb_y, (int)s);
2352 s->mb_x=0;
2353 s->mb_y= mb_y;
2354
2355 ff_set_qscale(s, s->qscale);
2356 ff_init_block_index(s);
2357
2358 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2359 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2360 int mb_type= s->mb_type[xy];
2361// int d;
2362 int dmin= INT_MAX;
2363 int dir;
2364
2365 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2366 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2367 return -1;
2368 }
2369 if(s->data_partitioning){
2370 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2371 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2372 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2373 return -1;
2374 }
2375 }
2376
2377 s->mb_x = mb_x;
2378 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2379 ff_update_block_index(s);
2380
49fb20cb 2381 if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){
3ada94ba
BF
2382 ff_h261_reorder_mb_index(s);
2383 xy= s->mb_y*s->mb_stride + s->mb_x;
2384 mb_type= s->mb_type[xy];
2385 }
2386
2387 /* write gob / video packet header */
2388 if(s->rtp_mode){
2389 int current_packet_size, is_gob_start;
2390
2391 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2392
2393 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2394
2395 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2396
2397 switch(s->codec_id){
2398 case CODEC_ID_H263:
2399 case CODEC_ID_H263P:
2400 if(!s->h263_slice_structured)
2401 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2402 break;
2403 case CODEC_ID_MPEG2VIDEO:
2404 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2405 case CODEC_ID_MPEG1VIDEO:
2406 if(s->mb_skip_run) is_gob_start=0;
2407 break;
2408 }
2409
2410 if(is_gob_start){
2411 if(s->start_mb_y != mb_y || mb_x!=0){
2412 write_slice_end(s);
2413
49fb20cb 2414 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
3ada94ba
BF
2415 ff_mpeg4_init_partitions(s);
2416 }
2417 }
2418
2419 assert((put_bits_count(&s->pb)&7) == 0);
fb53b4a0 2420 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3ada94ba
BF
2421
2422 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2423 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2424 int d= 100 / s->avctx->error_rate;
2425 if(r % d == 0){
2426 current_packet_size=0;
3ada94ba 2427 s->pb.buf_ptr= s->ptr_lastgob;
fb53b4a0 2428 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3ada94ba
BF
2429 }
2430 }
2431
2432 if (s->avctx->rtp_callback){
2433 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2434 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2435 }
2436
2437 switch(s->codec_id){
2438 case CODEC_ID_MPEG4:
49fb20cb 2439 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2440 ff_mpeg4_encode_video_packet_header(s);
2441 ff_mpeg4_clean_buffers(s);
eb75a698 2442 }
3ada94ba
BF
2443 break;
2444 case CODEC_ID_MPEG1VIDEO:
2445 case CODEC_ID_MPEG2VIDEO:
49fb20cb 2446 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
56be950a
AJ
2447 ff_mpeg1_encode_slice_header(s);
2448 ff_mpeg1_clean_buffers(s);
a6bc5731 2449 }
3ada94ba
BF
2450 break;
2451 case CODEC_ID_H263:
2452 case CODEC_ID_H263P:
965424da 2453 if (CONFIG_H263_ENCODER)
ddce8953 2454 ff_h263_encode_gob_header(s, mb_y);
3ada94ba
BF
2455 break;
2456 }
2457
2458 if(s->flags&CODEC_FLAG_PASS1){
2459 int bits= put_bits_count(&s->pb);
2460 s->misc_bits+= bits - s->last_bits;
2461 s->last_bits= bits;
2462 }
2463
2464 s->ptr_lastgob += current_packet_size;
2465 s->first_slice_line=1;
2466 s->resync_mb_x=mb_x;
2467 s->resync_mb_y=mb_y;
2468 }
2469 }
2470
2471 if( (s->resync_mb_x == s->mb_x)
2472 && s->resync_mb_y+1 == s->mb_y){
2473 s->first_slice_line=0;
2474 }
2475
2476 s->mb_skipped=0;
2477 s->dquant=0; //only for QP_RD
2478
2479 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
2480 int next_block=0;
2481 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2482
2483 copy_context_before_encode(&backup_s, s, -1);
2484 backup_s.pb= s->pb;
2485 best_s.data_partitioning= s->data_partitioning;
2486 best_s.partitioned_frame= s->partitioned_frame;
2487 if(s->data_partitioning){
2488 backup_s.pb2= s->pb2;
2489 backup_s.tex_pb= s->tex_pb;
2490 }
2491
2492 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2493 s->mv_dir = MV_DIR_FORWARD;
2494 s->mv_type = MV_TYPE_16X16;
2495 s->mb_intra= 0;
2496 s->mv[0][0][0] = s->p_mv_table[xy][0];
2497 s->mv[0][0][1] = s->p_mv_table[xy][1];
2498 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2499 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2500 }
2501 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2502 s->mv_dir = MV_DIR_FORWARD;
2503 s->mv_type = MV_TYPE_FIELD;
2504 s->mb_intra= 0;
2505 for(i=0; i<2; i++){
2506 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2507 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2508 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2509 }
2510 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2511 &dmin, &next_block, 0, 0);
2512 }
2513 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2514 s->mv_dir = MV_DIR_FORWARD;
2515 s->mv_type = MV_TYPE_16X16;
2516 s->mb_intra= 0;
2517 s->mv[0][0][0] = 0;
2518 s->mv[0][0][1] = 0;
2519 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2520 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2521 }
2522 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2523 s->mv_dir = MV_DIR_FORWARD;
2524 s->mv_type = MV_TYPE_8X8;
2525 s->mb_intra= 0;
2526 for(i=0; i<4; i++){
657ccb5a
DB
2527 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2528 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
3ada94ba
BF
2529 }
2530 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2531 &dmin, &next_block, 0, 0);
2532 }
2533 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2534 s->mv_dir = MV_DIR_FORWARD;
2535 s->mv_type = MV_TYPE_16X16;
2536 s->mb_intra= 0;
2537 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2538 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2539 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2540 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2541 }
2542 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2543 s->mv_dir = MV_DIR_BACKWARD;
2544 s->mv_type = MV_TYPE_16X16;
2545 s->mb_intra= 0;
2546 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2547 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2548 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2549 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2550 }
2551 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2552 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2553 s->mv_type = MV_TYPE_16X16;
2554 s->mb_intra= 0;
2555 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2556 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2557 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2558 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2559 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2560 &dmin, &next_block, 0, 0);
2561 }
2562 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2563 s->mv_dir = MV_DIR_FORWARD;
2564 s->mv_type = MV_TYPE_FIELD;
2565 s->mb_intra= 0;
2566 for(i=0; i<2; i++){
2567 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2568 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2569 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2570 }
2571 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2572 &dmin, &next_block, 0, 0);
2573 }
2574 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2575 s->mv_dir = MV_DIR_BACKWARD;
2576 s->mv_type = MV_TYPE_FIELD;
2577 s->mb_intra= 0;
2578 for(i=0; i<2; i++){
2579 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2580 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2581 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2582 }
2583 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2584 &dmin, &next_block, 0, 0);
2585 }
2586 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2587 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2588 s->mv_type = MV_TYPE_FIELD;
2589 s->mb_intra= 0;
2590 for(dir=0; dir<2; dir++){
2591 for(i=0; i<2; i++){
2592 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2593 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2594 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2595 }
2596 }
2597 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2598 &dmin, &next_block, 0, 0);
2599 }
2600 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2601 s->mv_dir = 0;
2602 s->mv_type = MV_TYPE_16X16;
2603 s->mb_intra= 1;
2604 s->mv[0][0][0] = 0;
2605 s->mv[0][0][1] = 0;
2606 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2607 &dmin, &next_block, 0, 0);
2608 if(s->h263_pred || s->h263_aic){
2609 if(best_s.mb_intra)
2610 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2611 else
2612 ff_clean_intra_table_entries(s); //old mode?
2613 }
2614 }
2615
2616 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
2617 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2618 const int last_qp= backup_s.qscale;
2619 int qpi, qp, dc[6];
2620 DCTELEM ac[6][16];
2621 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2622 static const int dquant_tab[4]={-1,1,-2,2};
2623
2624 assert(backup_s.dquant == 0);
2625
2626 //FIXME intra
2627 s->mv_dir= best_s.mv_dir;
2628 s->mv_type = MV_TYPE_16X16;
2629 s->mb_intra= best_s.mb_intra;
2630 s->mv[0][0][0] = best_s.mv[0][0][0];
2631 s->mv[0][0][1] = best_s.mv[0][0][1];
2632 s->mv[1][0][0] = best_s.mv[1][0][0];
2633 s->mv[1][0][1] = best_s.mv[1][0][1];
2634
975a1447 2635 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3ada94ba
BF
2636 for(; qpi<4; qpi++){
2637 int dquant= dquant_tab[qpi];
2638 qp= last_qp + dquant;
2639 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2640 continue;
2641 backup_s.dquant= dquant;
2642 if(s->mb_intra && s->dc_val[0]){
2643 for(i=0; i<6; i++){
2644 dc[i]= s->dc_val[0][ s->block_index[i] ];
2645 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2646 }
2647 }
2648
2649 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2650 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2651 if(best_s.qscale != qp){
2652 if(s->mb_intra && s->dc_val[0]){
2653 for(i=0; i<6; i++){
2654 s->dc_val[0][ s->block_index[i] ]= dc[i];
2655 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2656 }
2657 }
2658 }
2659 }
2660 }
2661 }
49fb20cb 2662 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3ada94ba
BF
2663 int mx= s->b_direct_mv_table[xy][0];
2664 int my= s->b_direct_mv_table[xy][1];
2665
2666 backup_s.dquant = 0;
2667 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2668 s->mb_intra= 0;
2669 ff_mpeg4_set_direct_mv(s, mx, my);
2670 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2671 &dmin, &next_block, mx, my);
2672 }
49fb20cb 2673 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3ada94ba
BF
2674 backup_s.dquant = 0;
2675 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2676 s->mb_intra= 0;
2677 ff_mpeg4_set_direct_mv(s, 0, 0);
2678 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2679 &dmin, &next_block, 0, 0);
2680 }
2681 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
2682 int coded=0;
2683 for(i=0; i<6; i++)
2684 coded |= s->block_last_index[i];
2685 if(coded){
2686 int mx,my;
2687 memcpy(s->mv, best_s.mv, sizeof(s->mv));
49fb20cb 2688 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3ada94ba
BF
2689 mx=my=0; //FIXME find the one we actually used
2690 ff_mpeg4_set_direct_mv(s, mx, my);
2691 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2692 mx= s->mv[1][0][0];
2693 my= s->mv[1][0][1];
2694 }else{
2695 mx= s->mv[0][0][0];
2696 my= s->mv[0][0][1];
2697 }
2698
2699 s->mv_dir= best_s.mv_dir;
2700 s->mv_type = best_s.mv_type;
2701 s->mb_intra= 0;
2702/* s->mv[0][0][0] = best_s.mv[0][0][0];
2703 s->mv[0][0][1] = best_s.mv[0][0][1];
2704 s->mv[1][0][0] = best_s.mv[1][0][0];
2705 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2706 backup_s.dquant= 0;
2707 s->skipdct=1;
2708 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2709 &dmin, &next_block, mx, my);
2710 s->skipdct=0;
2711 }
2712 }
2713
657ccb5a 2714 s->current_picture.f.qscale_table[xy] = best_s.qscale;
3ada94ba
BF
2715
2716 copy_context_after_encode(s, &best_s, -1);
2717
2718 pb_bits_count= put_bits_count(&s->pb);
2719 flush_put_bits(&s->pb);
9f51c682 2720 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3ada94ba
BF
2721 s->pb= backup_s.pb;
2722
2723 if(s->data_partitioning){
2724 pb2_bits_count= put_bits_count(&s->pb2);
2725 flush_put_bits(&s->pb2);
9f51c682 2726 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3ada94ba
BF
2727 s->pb2= backup_s.pb2;
2728
2729 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2730 flush_put_bits(&s->tex_pb);
9f51c682 2731 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3ada94ba
BF
2732 s->tex_pb= backup_s.tex_pb;
2733 }
2734 s->last_bits= put_bits_count(&s->pb);
2735
f34121f3 2736 if (CONFIG_H263_ENCODER &&
975a1447 2737 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3ada94ba
BF
2738 ff_h263_update_motion_val(s);
2739
2740 if(next_block==0){ //FIXME 16 vs linesize16
2741 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2742 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2743 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2744 }
2745
2746 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
efd29844 2747 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2748 } else {
2749 int motion_x = 0, motion_y = 0;
2750 s->mv_type=MV_TYPE_16X16;
2751 // only one MB-Type possible
2752
2753 switch(mb_type){
2754 case CANDIDATE_MB_TYPE_INTRA:
2755 s->mv_dir = 0;
2756 s->mb_intra= 1;
2757 motion_x= s->mv[0][0][0] = 0;
2758 motion_y= s->mv[0][0][1] = 0;
2759 break;
2760 case CANDIDATE_MB_TYPE_INTER:
2761 s->mv_dir = MV_DIR_FORWARD;
2762 s->mb_intra= 0;
2763 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2764 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2765 break;
2766 case CANDIDATE_MB_TYPE_INTER_I:
2767 s->mv_dir = MV_DIR_FORWARD;
2768 s->mv_type = MV_TYPE_FIELD;
2769 s->mb_intra= 0;
2770 for(i=0; i<2; i++){
2771 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2772 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2773 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2774 }
2775 break;
2776 case CANDIDATE_MB_TYPE_INTER4V:
2777 s->mv_dir = MV_DIR_FORWARD;
2778 s->mv_type = MV_TYPE_8X8;
2779 s->mb_intra= 0;
2780 for(i=0; i<4; i++){
657ccb5a
DB
2781 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2782 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
3ada94ba
BF
2783 }
2784 break;
2785 case CANDIDATE_MB_TYPE_DIRECT:
49fb20cb 2786 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2787 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2788 s->mb_intra= 0;
2789 motion_x=s->b_direct_mv_table[xy][0];
2790 motion_y=s->b_direct_mv_table[xy][1];
2791 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
eb75a698 2792 }
3ada94ba
BF
2793 break;
2794 case CANDIDATE_MB_TYPE_DIRECT0:
49fb20cb 2795 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2796 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2797 s->mb_intra= 0;
2798 ff_mpeg4_set_direct_mv(s, 0, 0);
eb75a698 2799 }
3ada94ba
BF
2800 break;
2801 case CANDIDATE_MB_TYPE_BIDIR:
2802 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2803 s->mb_intra= 0;
2804 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2805 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2806 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2807 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2808 break;
2809 case CANDIDATE_MB_TYPE_BACKWARD:
2810 s->mv_dir = MV_DIR_BACKWARD;
2811 s->mb_intra= 0;
2812 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2813 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2814 break;
2815 case CANDIDATE_MB_TYPE_FORWARD:
2816 s->mv_dir = MV_DIR_FORWARD;
2817 s->mb_intra= 0;
2818 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2819 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2820// printf(" %d %d ", motion_x, motion_y);
2821 break;
2822 case CANDIDATE_MB_TYPE_FORWARD_I:
2823 s->mv_dir = MV_DIR_FORWARD;
2824 s->mv_type = MV_TYPE_FIELD;
2825 s->mb_intra= 0;
2826 for(i=0; i<2; i++){
2827 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2828 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2829 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2830 }
2831 break;
2832 case CANDIDATE_MB_TYPE_BACKWARD_I:
2833 s->mv_dir = MV_DIR_BACKWARD;
2834 s->mv_type = MV_TYPE_FIELD;
2835 s->mb_intra= 0;
2836 for(i=0; i<2; i++){
2837 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2838 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2839 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2840 }
2841 break;
2842 case CANDIDATE_MB_TYPE_BIDIR_I:
2843 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2844 s->mv_type = MV_TYPE_FIELD;
2845 s->mb_intra= 0;
2846 for(dir=0; dir<2; dir++){
2847 for(i=0; i<2; i++){
2848 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2849 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2850 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2851 }
2852 }
2853 break;
2854 default:
2855 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
2856 }
2857
2858 encode_mb(s, motion_x, motion_y);
2859
2860 // RAL: Update last macroblock type
2861 s->last_mv_dir = s->mv_dir;
2862
f34121f3 2863 if (CONFIG_H263_ENCODER &&
975a1447 2864 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3ada94ba
BF
2865 ff_h263_update_motion_val(s);
2866
efd29844 2867 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2868 }
2869
2870 /* clean the MV table in IPS frames for direct mode in B frames */
2871 if(s->mb_intra /* && I,P,S_TYPE */){
2872 s->p_mv_table[xy][0]=0;
2873 s->p_mv_table[xy][1]=0;
2874 }
2875
2876 if(s->flags&CODEC_FLAG_PSNR){
2877 int w= 16;
2878 int h= 16;
2879
2880 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2881 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2882
657ccb5a
DB
2883 s->current_picture.f.error[0] += sse(
2884 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3ada94ba 2885 s->dest[0], w, h, s->linesize);
657ccb5a
DB
2886 s->current_picture.f.error[1] += sse(
2887 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
ec7e2582 2888 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
657ccb5a
DB
2889 s->current_picture.f.error[2] += sse(
2890 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
ec7e2582 2891 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3ada94ba
BF
2892 }
2893 if(s->loop_filter){
f34121f3 2894 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3ada94ba
BF
2895 ff_h263_loop_filter(s);
2896 }
2897//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
2898 }
2899 }
2900
2901 //not beautiful here but we must write it before flushing so it has to be here
975a1447 2902 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
04d38225 2903 ff_msmpeg4_encode_ext_header(s);
3ada94ba
BF
2904
2905 write_slice_end(s);
2906
2907 /* Send the last GOB if RTP */
2908 if (s->avctx->rtp_callback) {
2909 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
fb53b4a0 2910 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3ada94ba
BF
2911 /* Call the RTP callback to send the last GOB */
2912 emms_c();
2913 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
2914 }
2915
2916 return 0;
2917}
2918
2919#define MERGE(field) dst->field += src->field; src->field=0
2920static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
2921 MERGE(me.scene_change_score);
2922 MERGE(me.mc_mb_var_sum_temp);
2923 MERGE(me.mb_var_sum_temp);
2924}
2925
2926static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
2927 int i;
2928
2929 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
2930 MERGE(dct_count[1]);
2931 MERGE(mv_bits);
2932 MERGE(i_tex_bits);
2933 MERGE(p_tex_bits);
2934 MERGE(i_count);
2935 MERGE(f_count);
2936 MERGE(b_count);
2937 MERGE(skip_count);
2938 MERGE(misc_bits);
2939 MERGE(error_count);
2940 MERGE(padding_bug_score);
657ccb5a
DB
2941 MERGE(current_picture.f.error[0]);
2942 MERGE(current_picture.f.error[1]);
2943 MERGE(current_picture.f.error[2]);
3ada94ba
BF
2944
2945 if(dst->avctx->noise_reduction){
2946 for(i=0; i<64; i++){
2947 MERGE(dct_error_sum[0][i]);
2948 MERGE(dct_error_sum[1][i]);
2949 }
2950 }
2951
2952 assert(put_bits_count(&src->pb) % 8 ==0);
2953 assert(put_bits_count(&dst->pb) % 8 ==0);
9f51c682 2954 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3ada94ba
BF
2955 flush_put_bits(&dst->pb);
2956}
2957
2958static int estimate_qp(MpegEncContext *s, int dry_run){
2959 if (s->next_lambda){
657ccb5a
DB
2960 s->current_picture_ptr->f.quality =
2961 s->current_picture.f.quality = s->next_lambda;
3ada94ba
BF
2962 if(!dry_run) s->next_lambda= 0;
2963 } else if (!s->fixed_qscale) {
657ccb5a
DB
2964 s->current_picture_ptr->f.quality =
2965 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
2966 if (s->current_picture.f.quality < 0)
3ada94ba
BF
2967 return -1;
2968 }
2969
2970 if(s->adaptive_quant){
2971 switch(s->codec_id){
2972 case CODEC_ID_MPEG4:
49fb20cb 2973 if (CONFIG_MPEG4_ENCODER)
674eeb5f 2974 ff_clean_mpeg4_qscales(s);
3ada94ba
BF
2975 break;
2976 case CODEC_ID_H263:
2977 case CODEC_ID_H263P:
2978 case CODEC_ID_FLV1:
0bd48530 2979 if (CONFIG_H263_ENCODER)
674eeb5f 2980 ff_clean_h263_qscales(s);
3ada94ba 2981 break;
ccc4b918
MN
2982 default:
2983 ff_init_qscale_tab(s);
3ada94ba
BF
2984 }
2985
2986 s->lambda= s->lambda_table[0];
2987 //FIXME broken
2988 }else
657ccb5a 2989 s->lambda = s->current_picture.f.quality;
3ada94ba
BF
2990//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
2991 update_qscale(s);
2992 return 0;
2993}
2994
7da31a80
AJ
2995/* must be called before writing the header */
2996static void set_frame_distances(MpegEncContext * s){
95a06eb4 2997 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
657ccb5a 2998 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
7da31a80 2999
975a1447 3000 if(s->pict_type==AV_PICTURE_TYPE_B){
7da31a80
AJ
3001 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3002 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3003 }else{
3004 s->pp_time= s->time - s->last_non_b_time;
3005 s->last_non_b_time= s->time;
3006 assert(s->picture_number==0 || s->pp_time > 0);
3007 }
3008}
3009
3ada94ba
BF
3010static int encode_picture(MpegEncContext *s, int picture_number)
3011{
3012 int i;
3013 int bits;
881a5e04 3014 int context_count = s->slice_context_count;
3ada94ba
BF
3015
3016 s->picture_number = picture_number;
3017
3018 /* Reset the average MB variance */
3019 s->me.mb_var_sum_temp =
3020 s->me.mc_mb_var_sum_temp = 0;
3021
3022 /* we need to initialize some time vars before we can encode b-frames */
3023 // RAL: Condition added for MPEG1VIDEO
8c51620f 3024 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
7da31a80 3025 set_frame_distances(s);
49fb20cb 3026 if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
7da31a80 3027 ff_set_mpeg4_time(s);
3ada94ba
BF
3028
3029 s->me.scene_change_score=0;
3030
e6dba5df 3031// s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3ada94ba 3032
975a1447 3033 if(s->pict_type==AV_PICTURE_TYPE_I){
3ada94ba
BF
3034 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3035 else s->no_rounding=0;
975a1447 3036 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3ada94ba
BF
3037 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3038 s->no_rounding ^= 1;
3039 }
3040
3041 if(s->flags & CODEC_FLAG_PASS2){
3042 if (estimate_qp(s,1) < 0)
3043 return -1;
3044 ff_get_2pass_fcode(s);
3045 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
975a1447 3046 if(s->pict_type==AV_PICTURE_TYPE_B)
3ada94ba
BF
3047 s->lambda= s->last_lambda_for[s->pict_type];
3048 else
3049 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3050 update_qscale(s);
3051 }
3052
3053 s->mb_intra=0; //for the rate distortion & bit compare functions
6a9c8594 3054 for(i=1; i<context_count; i++){
3ada94ba
BF
3055 ff_update_duplicate_context(s->thread_context[i], s);
3056 }
3057
719f3702
MN
3058 if(ff_init_me(s)<0)
3059 return -1;
3ada94ba
BF
3060
3061 /* Estimate motion for every MB */
975a1447 3062 if(s->pict_type != AV_PICTURE_TYPE_I){
3ada94ba
BF
3063 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3064 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
975a1447
SS
3065 if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3066 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
6a9c8594 3067 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3ada94ba
BF
3068 }
3069 }
3070
6a9c8594 3071 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
975a1447 3072 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3ada94ba
BF
3073 /* I-Frame */
3074 for(i=0; i<s->mb_stride*s->mb_height; i++)
3075 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3076
3077 if(!s->fixed_qscale){
3078 /* finding spatial complexity for I-frame rate control */
6a9c8594 3079 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3ada94ba
BF
3080 }
3081 }
6a9c8594 3082 for(i=1; i<context_count; i++){
3ada94ba
BF
3083 merge_context_after_me(s, s->thread_context[i]);
3084 }
3085 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3086 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3087 emms_c();
3088
975a1447
SS
3089 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3090 s->pict_type= AV_PICTURE_TYPE_I;
3ada94ba
BF
3091 for(i=0; i<s->mb_stride*s->mb_height; i++)
3092 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3093//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3094 }
3095
3096 if(!s->umvplus){
975a1447 3097 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3ada94ba
BF
3098 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3099
3100 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3101 int a,b;
3102 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3103 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
159ef4b0 3104 s->f_code= FFMAX3(s->f_code, a, b);
3ada94ba
BF
3105 }
3106
3107 ff_fix_long_p_mvs(s);
3108 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3109 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3110 int j;
3111 for(i=0; i<2; i++){
3112 for(j=0; j<2; j++)
3113 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3114 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3115 }
3116 }
3117 }
3118
975a1447 3119 if(s->pict_type==AV_PICTURE_TYPE_B){
3ada94ba
BF
3120 int a, b;
3121
3122 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3123 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3124 s->f_code = FFMAX(a, b);
3125
3126 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3127 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3128 s->b_code = FFMAX(a, b);
3129
3130 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3131 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3132 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3133 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3134 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3135 int dir, j;
3136 for(dir=0; dir<2; dir++){
3137 for(i=0; i<2; i++){
3138 for(j=0; j<2; j++){
3139 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3140 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3141 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3142 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3143 }
3144 }
3145 }
3146 }
3147 }
3148 }
3149
3150 if (estimate_qp(s, 0) < 0)
3151 return -1;
3152
975a1447 3153 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3ada94ba
BF
3154 s->qscale= 3; //reduce clipping problems
3155
3156 if (s->out_format == FMT_MJPEG) {
3157 /* for mjpeg, we do include qscale in the matrix */
3ada94ba
BF
3158 for(i=1;i<64;i++){
3159 int j= s->dsp.idct_permutation[i];
3160
3161 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3162 }
6506c3d2 3163 s->y_dc_scale_table=
53f66cee
MN
3164 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3165 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
69cea75f 3166 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3ada94ba
BF
3167 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3168 s->qscale= 8;
3169 }
3170
3171 //FIXME var duplication
657ccb5a
DB
3172 s->current_picture_ptr->f.key_frame =
3173 s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3174 s->current_picture_ptr->f.pict_type =
3175 s->current_picture.f.pict_type = s->pict_type;
3ada94ba 3176
657ccb5a 3177 if (s->current_picture.f.key_frame)
3ada94ba
BF
3178 s->picture_in_gop_number=0;
3179
3180 s->last_bits= put_bits_count(&s->pb);
3181 switch(s->out_format) {
3182 case FMT_MJPEG:
49fb20cb 3183 if (CONFIG_MJPEG_ENCODER)
3ada94ba
BF
3184 ff_mjpeg_encode_picture_header(s);
3185 break;
3186 case FMT_H261:
49fb20cb 3187 if (CONFIG_H261_ENCODER)
3ada94ba
BF
3188 ff_h261_encode_picture_header(s, picture_number);
3189 break;
3190 case FMT_H263:
49fb20cb 3191 if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2)
3ada94ba 3192 ff_wmv2_encode_picture_header(s, picture_number);
8c51620f 3193 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
04d38225 3194 ff_msmpeg4_encode_picture_header(s, picture_number);
49fb20cb 3195 else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
6f13a371 3196 ff_mpeg4_encode_picture_header(s, picture_number);
49fb20cb 3197 else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
6c28d657 3198 ff_rv10_encode_picture_header(s, picture_number);
49fb20cb 3199 else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
6c28d657 3200 ff_rv20_encode_picture_header(s, picture_number);
49fb20cb 3201 else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
3ada94ba 3202 ff_flv_encode_picture_header(s, picture_number);
f34121f3 3203 else if (CONFIG_H263_ENCODER)
ddce8953 3204 ff_h263_encode_picture_header(s, picture_number);
3ada94ba
BF
3205 break;
3206 case FMT_MPEG1:
49fb20cb 3207 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
d6c8dcb8 3208 ff_mpeg1_encode_picture_header(s, picture_number);
3ada94ba
BF
3209 break;
3210 case FMT_H264:
3211 break;
3212 default:
3213 assert(0);
3214 }
3215 bits= put_bits_count(&s->pb);
3216 s->header_bits= bits - s->last_bits;
3217
6a9c8594 3218 for(i=1; i<context_count; i++){
3ada94ba
BF
3219 update_duplicate_context_after_me(s->thread_context[i], s);
3220 }
6a9c8594
AS
3221 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3222 for(i=1; i<context_count; i++){
3ada94ba
BF
3223 merge_context_after_encode(s, s->thread_context[i]);
3224 }
3225 emms_c();
3226 return 0;
3227}
3228
aa61e39e 3229static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
3ada94ba
BF
3230 const int intra= s->mb_intra;
3231 int i;
3232
3233 s->dct_count[intra]++;
3234
3235 for(i=0; i<64; i++){
3236 int level= block[i];
3237
3238 if(level){
3239 if(level>0){
3240 s->dct_error_sum[intra][i] += level;
3241 level -= s->dct_offset[intra][i];
3242 if(level<0) level=0;
3243 }else{
3244 s->dct_error_sum[intra][i] -= level;
3245 level += s->dct_offset[intra][i];
3246 if(level>0) level=0;
3247 }
3248 block[i]= level;
3249 }
3250 }
3251}
3252
aa61e39e
MR
3253static int dct_quantize_trellis_c(MpegEncContext *s,
3254 DCTELEM *block, int n,
3255 int qscale, int *overflow){