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