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