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