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