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