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