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