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