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