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