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