configure: Assume runtime cpu detection on arm on --target-os=android as well
[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
3ada94ba 61static int encode_picture(MpegEncContext *s, int picture_number);
88bd7fdc 62static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
3ada94ba 63static int sse_mb(MpegEncContext *s);
88bd7fdc
DB
64static void denoise_dct_c(MpegEncContext *s, int16_t *block);
65static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
3ada94ba 66
bd96be6e
AD
67static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
68static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
3ada94ba 69
ed019b8e
AK
70const AVOption ff_mpv_generic_options[] = {
71 FF_MPV_COMMON_OPTS
72 { NULL },
73};
74
5dd8c08f 75void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
bd96be6e
AD
76 uint16_t (*qmat16)[2][64],
77 const uint16_t *quant_matrix,
78 int bias, int qmin, int qmax, int intra)
3ada94ba 79{
a9aee08d 80 FDCTDSPContext *fdsp = &s->fdsp;
3ada94ba 81 int qscale;
bd96be6e 82 int shift = 0;
3ada94ba 83
bd96be6e 84 for (qscale = qmin; qscale <= qmax; qscale++) {
3ada94ba 85 int i;
a9aee08d
DB
86 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
87 fdsp->fdct == ff_jpeg_fdct_islow_10 ||
88 fdsp->fdct == ff_faandct) {
bd96be6e 89 for (i = 0; i < 64; i++) {
e3fcb143 90 const int j = s->idsp.idct_permutation[i];
bd96be6e
AD
91 /* 16 <= qscale * quant_matrix[i] <= 7905
92 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
93 * 19952 <= x <= 249205026
94 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
95 * 3444240 >= (1 << 36) / (x) >= 275 */
3ada94ba
BF
96
97 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
bd96be6e 98 (qscale * quant_matrix[j]));
3ada94ba 99 }
a9aee08d 100 } else if (fdsp->fdct == ff_fdct_ifast) {
bd96be6e 101 for (i = 0; i < 64; i++) {
e3fcb143 102 const int j = s->idsp.idct_permutation[i];
bd96be6e
AD
103 /* 16 <= qscale * quant_matrix[i] <= 7905
104 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
105 * 19952 <= x <= 249205026
106 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
107 * 3444240 >= (1 << 36) / (x) >= 275 */
3ada94ba
BF
108
109 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
bd96be6e
AD
110 (ff_aanscales[i] * qscale *
111 quant_matrix[j]));
3ada94ba
BF
112 }
113 } else {
bd96be6e 114 for (i = 0; i < 64; i++) {
e3fcb143 115 const int j = s->idsp.idct_permutation[i];
3ada94ba 116 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
bd96be6e
AD
117 * Assume x = qscale * quant_matrix[i]
118 * So 16 <= x <= 7905
119 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
120 * so 32768 >= (1 << 19) / (x) >= 67 */
121 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
122 (qscale * quant_matrix[j]));
123 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
124 // (qscale * quant_matrix[i]);
125 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
126 (qscale * quant_matrix[j]);
127
128 if (qmat16[qscale][0][i] == 0 ||
129 qmat16[qscale][0][i] == 128 * 256)
130 qmat16[qscale][0][i] = 128 * 256 - 1;
131 qmat16[qscale][1][i] =
132 ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
133 qmat16[qscale][0][i]);
3ada94ba
BF
134 }
135 }
136
bd96be6e
AD
137 for (i = intra; i < 64; i++) {
138 int64_t max = 8191;
a9aee08d 139 if (fdsp->fdct == ff_fdct_ifast) {
bd96be6e 140 max = (8191LL * ff_aanscales[i]) >> 14;
3ada94ba 141 }
bd96be6e 142 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
3ada94ba
BF
143 shift++;
144 }
145 }
146 }
bd96be6e
AD
147 if (shift) {
148 av_log(NULL, AV_LOG_INFO,
149 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
150 QMAT_SHIFT - shift);
3ada94ba
BF
151 }
152}
153
bd96be6e
AD
154static inline void update_qscale(MpegEncContext *s)
155{
156 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
157 (FF_LAMBDA_SHIFT + 7);
158 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
3ada94ba 159
bd96be6e
AD
160 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
161 FF_LAMBDA_SHIFT;
3ada94ba
BF
162}
163
bd96be6e
AD
164void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165{
3ada94ba
BF
166 int i;
167
bd96be6e 168 if (matrix) {
3ada94ba 169 put_bits(pb, 1, 1);
bd96be6e
AD
170 for (i = 0; i < 64; i++) {
171 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
3ada94ba 172 }
bd96be6e 173 } else
3ada94ba
BF
174 put_bits(pb, 1, 0);
175}
176
9015b095
MN
177/**
178 * init s->current_picture.qscale_table from s->lambda_table
179 */
bd96be6e
AD
180void ff_init_qscale_tab(MpegEncContext *s)
181{
759001c5 182 int8_t * const qscale_table = s->current_picture.qscale_table;
9015b095
MN
183 int i;
184
bd96be6e
AD
185 for (i = 0; i < s->mb_num; i++) {
186 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
187 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
188 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
189 s->avctx->qmax);
9015b095
MN
190 }
191}
192
bd96be6e
AD
193static void update_duplicate_context_after_me(MpegEncContext *dst,
194 MpegEncContext *src)
195{
3ada94ba
BF
196#define COPY(a) dst->a= src->a
197 COPY(pict_type);
198 COPY(current_picture);
199 COPY(f_code);
200 COPY(b_code);
201 COPY(qscale);
202 COPY(lambda);
203 COPY(lambda2);
204 COPY(picture_in_gop_number);
205 COPY(gop_picture_number);
bd96be6e
AD
206 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
207 COPY(progressive_frame); // FIXME don't set in encode_header
208 COPY(partitioned_frame); // FIXME don't set in encode_header
3ada94ba
BF
209#undef COPY
210}
211
212/**
58c42af7 213 * Set the given MpegEncContext to defaults for encoding.
3ada94ba
BF
214 * the changed fields will not depend upon the prior state of the MpegEncContext.
215 */
bd96be6e
AD
216static void MPV_encode_defaults(MpegEncContext *s)
217{
3ada94ba 218 int i;
efd29844 219 ff_MPV_common_defaults(s);
3ada94ba 220
bd96be6e
AD
221 for (i = -16; i < 16; i++) {
222 default_fcode_tab[i + MAX_MV] = 1;
3ada94ba 223 }
bd96be6e
AD
224 s->me.mv_penalty = default_mv_penalty;
225 s->fcode_tab = default_fcode_tab;
bedf952b
AK
226
227 s->input_picture_number = 0;
228 s->picture_in_gop_number = 0;
3ada94ba
BF
229}
230
231/* init video encoder */
efd29844 232av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
3ada94ba
BF
233{
234 MpegEncContext *s = avctx->priv_data;
d7705be9 235 int i, ret, format_supported;
3ada94ba
BF
236
237 MPV_encode_defaults(s);
238
239 switch (avctx->codec_id) {
36ef5369 240 case AV_CODEC_ID_MPEG2VIDEO:
716d413c
AK
241 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
242 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
bd96be6e
AD
243 av_log(avctx, AV_LOG_ERROR,
244 "only YUV420 and YUV422 are supported\n");
3ada94ba
BF
245 return -1;
246 }
247 break;
36ef5369 248 case AV_CODEC_ID_MJPEG:
d7705be9
VG
249 format_supported = 0;
250 /* JPEG color space */
251 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
252 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
253 (avctx->color_range == AVCOL_RANGE_JPEG &&
254 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
255 avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
256 format_supported = 1;
257 /* MPEG color space */
258 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
259 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
260 avctx->pix_fmt == AV_PIX_FMT_YUV422P))
261 format_supported = 1;
262
263 if (!format_supported) {
3ada94ba
BF
264 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
265 return -1;
266 }
267 break;
268 default:
716d413c 269 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
3ada94ba
BF
270 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
271 return -1;
272 }
273 }
274
275 switch (avctx->pix_fmt) {
716d413c
AK
276 case AV_PIX_FMT_YUVJ422P:
277 case AV_PIX_FMT_YUV422P:
3ada94ba
BF
278 s->chroma_format = CHROMA_422;
279 break;
716d413c
AK
280 case AV_PIX_FMT_YUVJ420P:
281 case AV_PIX_FMT_YUV420P:
3ada94ba
BF
282 default:
283 s->chroma_format = CHROMA_420;
284 break;
285 }
286
287 s->bit_rate = avctx->bit_rate;
bd96be6e
AD
288 s->width = avctx->width;
289 s->height = avctx->height;
290 if (avctx->gop_size > 600 &&
291 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
292 av_log(avctx, AV_LOG_ERROR,
293 "Warning keyframe interval too large! reducing it ...\n");
294 avctx->gop_size = 600;
295 }
296 s->gop_size = avctx->gop_size;
297 s->avctx = avctx;
298 s->flags = avctx->flags;
299 s->flags2 = avctx->flags2;
aa241229
AK
300 if (avctx->max_b_frames > MAX_B_FRAMES) {
301 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
302 "is %d.\n", MAX_B_FRAMES);
303 }
bd96be6e
AD
304 s->max_b_frames = avctx->max_b_frames;
305 s->codec_id = avctx->codec->id;
bd96be6e 306 s->strict_std_compliance = avctx->strict_std_compliance;
bd96be6e
AD
307 s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
308 s->mpeg_quant = avctx->mpeg_quant;
309 s->rtp_mode = !!avctx->rtp_payload_size;
310 s->intra_dc_precision = avctx->intra_dc_precision;
3ada94ba
BF
311 s->user_specified_pts = AV_NOPTS_VALUE;
312
313 if (s->gop_size <= 1) {
314 s->intra_only = 1;
bd96be6e 315 s->gop_size = 12;
3ada94ba
BF
316 } else {
317 s->intra_only = 0;
318 }
319
320 s->me_method = avctx->me_method;
321
322 /* Fixed QSCALE */
323 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
324
bd96be6e
AD
325 s->adaptive_quant = (s->avctx->lumi_masking ||
326 s->avctx->dark_masking ||
327 s->avctx->temporal_cplx_masking ||
328 s->avctx->spatial_cplx_masking ||
329 s->avctx->p_masking ||
330 s->avctx->border_masking ||
ff71a383 331 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
bd96be6e 332 !s->fixed_qscale;
3ada94ba 333
bd96be6e 334 s->loop_filter = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
3ada94ba 335
bd96be6e
AD
336 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
337 av_log(avctx, AV_LOG_ERROR,
338 "a vbv buffer size is needed, "
339 "for encoding with a maximum bitrate\n");
3ada94ba
BF
340 return -1;
341 }
342
bd96be6e
AD
343 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
344 av_log(avctx, AV_LOG_INFO,
345 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
3ada94ba
BF
346 }
347
bd96be6e 348 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
3ada94ba
BF
349 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
350 return -1;
351 }
352
bd96be6e 353 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
3ada94ba
BF
354 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
355 return -1;
356 }
357
bd96be6e
AD
358 if (avctx->rc_max_rate &&
359 avctx->rc_max_rate == avctx->bit_rate &&
360 avctx->rc_max_rate != avctx->rc_min_rate) {
361 av_log(avctx, AV_LOG_INFO,
362 "impossible bitrate constraints, this will fail\n");
3dd2a1c5
MN
363 }
364
bd96be6e
AD
365 if (avctx->rc_buffer_size &&
366 avctx->bit_rate * (int64_t)avctx->time_base.num >
367 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
3ada94ba
BF
368 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
369 return -1;
370 }
371
bd96be6e
AD
372 if (!s->fixed_qscale &&
373 avctx->bit_rate * av_q2d(avctx->time_base) >
374 avctx->bit_rate_tolerance) {
375 av_log(avctx, AV_LOG_ERROR,
376 "bitrate tolerance too small for bitrate\n");
3ada94ba
BF
377 return -1;
378 }
379
bd96be6e
AD
380 if (s->avctx->rc_max_rate &&
381 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
36ef5369
AK
382 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
383 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
bd96be6e
AD
384 90000LL * (avctx->rc_buffer_size - 1) >
385 s->avctx->rc_max_rate * 0xFFFFLL) {
386 av_log(avctx, AV_LOG_INFO,
387 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
388 "specified vbv buffer is too large for the given bitrate!\n");
3ada94ba
BF
389 }
390
36ef5369
AK
391 if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
392 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
393 s->codec_id != AV_CODEC_ID_FLV1) {
3ada94ba
BF
394 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
395 return -1;
396 }
397
bd96be6e
AD
398 if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
399 av_log(avctx, AV_LOG_ERROR,
400 "OBMC is only supported with simple mb decision\n");
3ada94ba
BF
401 return -1;
402 }
403
36ef5369 404 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
3ada94ba
BF
405 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
406 return -1;
407 }
408
bd96be6e 409 if (s->max_b_frames &&
36ef5369
AK
410 s->codec_id != AV_CODEC_ID_MPEG4 &&
411 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
412 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
3ada94ba
BF
413 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
414 return -1;
415 }
416
36ef5369
AK
417 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
418 s->codec_id == AV_CODEC_ID_H263 ||
419 s->codec_id == AV_CODEC_ID_H263P) &&
bd96be6e
AD
420 (avctx->sample_aspect_ratio.num > 255 ||
421 avctx->sample_aspect_ratio.den > 255)) {
422 av_log(avctx, AV_LOG_ERROR,
423 "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
954a0b48
MN
424 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
425 return -1;
426 }
427
9ce2a91b 428 if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
36ef5369 429 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
3ada94ba
BF
430 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
431 return -1;
432 }
433
bd96be6e 434 // FIXME mpeg2 uses that too
36ef5369 435 if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
bd96be6e
AD
436 av_log(avctx, AV_LOG_ERROR,
437 "mpeg2 style quantization not supported by codec\n");
3ada94ba
BF
438 return -1;
439 }
440
af3d804f 441 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
3ada94ba
BF
442 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
443 return -1;
444 }
445
ff71a383 446 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
bd96be6e 447 s->avctx->mb_decision != FF_MB_DECISION_RD) {
3ada94ba
BF
448 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
449 return -1;
450 }
451
bd96be6e
AD
452 if (s->avctx->scenechange_threshold < 1000000000 &&
453 (s->flags & CODEC_FLAG_CLOSED_GOP)) {
454 av_log(avctx, AV_LOG_ERROR,
455 "closed gop with scene change detection are not supported yet, "
456 "set threshold to 1000000000\n");
3ada94ba
BF
457 return -1;
458 }
459
bd96be6e 460 if (s->flags & CODEC_FLAG_LOW_DELAY) {
36ef5369 461 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
bd96be6e
AD
462 av_log(avctx, AV_LOG_ERROR,
463 "low delay forcing is only available for mpeg2\n");
3ada94ba
BF
464 return -1;
465 }
bd96be6e
AD
466 if (s->max_b_frames != 0) {
467 av_log(avctx, AV_LOG_ERROR,
468 "b frames cannot be used with low delay\n");
3ada94ba
BF
469 return -1;
470 }
471 }
472
bd96be6e 473 if (s->q_scale_type == 1) {
bd96be6e
AD
474 if (avctx->qmax > 12) {
475 av_log(avctx, AV_LOG_ERROR,
476 "non linear quant only supports qmax <= 12 currently\n");
3ada94ba
BF
477 return -1;
478 }
479 }
480
bd96be6e 481 if (s->avctx->thread_count > 1 &&
36ef5369
AK
482 s->codec_id != AV_CODEC_ID_MPEG4 &&
483 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
484 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
485 (s->codec_id != AV_CODEC_ID_H263P)) {
bd96be6e
AD
486 av_log(avctx, AV_LOG_ERROR,
487 "multi threaded encoding not supported by codec\n");
3ada94ba
BF
488 return -1;
489 }
490
bd96be6e
AD
491 if (s->avctx->thread_count < 1) {
492 av_log(avctx, AV_LOG_ERROR,
493 "automatic thread number detection not supported by codec,"
494 "patch welcome\n");
b52b0913
MN
495 return -1;
496 }
497
bd96be6e
AD
498 if (s->avctx->thread_count > 1)
499 s->rtp_mode = 1;
3ada94ba 500
bd96be6e 501 if (!avctx->time_base.den || !avctx->time_base.num) {
3ada94ba
BF
502 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
503 return -1;
504 }
505
bd96be6e 506 i = (INT_MAX / 2 + 128) >> 8;
bd96be6e
AD
507 if (avctx->mb_threshold >= i) {
508 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
509 i - 1);
3ada94ba
BF
510 return -1;
511 }
512
bd96be6e
AD
513 if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
514 av_log(avctx, AV_LOG_INFO,
515 "notice: b_frame_strategy only affects the first pass\n");
3ada94ba
BF
516 avctx->b_frame_strategy = 0;
517 }
518
bd96be6e
AD
519 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
520 if (i > 1) {
3ada94ba
BF
521 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
522 avctx->time_base.den /= i;
523 avctx->time_base.num /= i;
bd96be6e 524 //return -1;
3ada94ba
BF
525 }
526
36ef5369
AK
527 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
528 s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
bd96be6e
AD
529 // (a + x * 3 / 8) / x
530 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
531 s->inter_quant_bias = 0;
532 } else {
533 s->intra_quant_bias = 0;
534 // (a - x / 4) / x
535 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
3ada94ba
BF
536 }
537
bd96be6e
AD
538 if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
539 s->intra_quant_bias = avctx->intra_quant_bias;
540 if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
541 s->inter_quant_bias = avctx->inter_quant_bias;
542
36ef5369 543 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
bd96be6e
AD
544 s->avctx->time_base.den > (1 << 16) - 1) {
545 av_log(avctx, AV_LOG_ERROR,
546 "timebase %d/%d not supported by MPEG 4 standard, "
547 "the maximum admitted value for the timebase denominator "
548 "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
549 (1 << 16) - 1);
3ada94ba
BF
550 return -1;
551 }
552 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
553
bd96be6e 554 switch (avctx->codec->id) {
36ef5369 555 case AV_CODEC_ID_MPEG1VIDEO:
3ada94ba 556 s->out_format = FMT_MPEG1;
bd96be6e
AD
557 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
558 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
3ada94ba 559 break;
36ef5369 560 case AV_CODEC_ID_MPEG2VIDEO:
3ada94ba 561 s->out_format = FMT_MPEG1;
bd96be6e
AD
562 s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
563 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
564 s->rtp_mode = 1;
3ada94ba 565 break;
36ef5369 566 case AV_CODEC_ID_MJPEG:
3ada94ba
BF
567 s->out_format = FMT_MJPEG;
568 s->intra_only = 1; /* force intra only for jpeg */
24abd806 569 if (!CONFIG_MJPEG_ENCODER ||
bd96be6e 570 ff_mjpeg_encode_init(s) < 0)
3ada94ba 571 return -1;
bd96be6e
AD
572 avctx->delay = 0;
573 s->low_delay = 1;
3ada94ba 574 break;
36ef5369 575 case AV_CODEC_ID_H261:
bd96be6e
AD
576 if (!CONFIG_H261_ENCODER)
577 return -1;
3ada94ba 578 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
bd96be6e
AD
579 av_log(avctx, AV_LOG_ERROR,
580 "The specified picture size of %dx%d is not valid for the "
581 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
582 s->width, s->height);
3ada94ba
BF
583 return -1;
584 }
585 s->out_format = FMT_H261;
bd96be6e
AD
586 avctx->delay = 0;
587 s->low_delay = 1;
3ada94ba 588 break;
36ef5369 589 case AV_CODEC_ID_H263:
bd96be6e
AD
590 if (!CONFIG_H263_ENCODER)
591 return -1;
ddce8953 592 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
bd96be6e
AD
593 s->width, s->height) == 8) {
594 av_log(avctx, AV_LOG_INFO,
595 "The specified picture size of %dx%d is not valid for "
596 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
597 "352x288, 704x576, and 1408x1152."
598 "Try H.263+.\n", s->width, s->height);
3ada94ba
BF
599 return -1;
600 }
601 s->out_format = FMT_H263;
bd96be6e
AD
602 avctx->delay = 0;
603 s->low_delay = 1;
3ada94ba 604 break;
36ef5369 605 case AV_CODEC_ID_H263P:
3ada94ba 606 s->out_format = FMT_H263;
bd96be6e 607 s->h263_plus = 1;
3ada94ba 608 /* Fx */
bd96be6e
AD
609 s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
610 s->modified_quant = s->h263_aic;
611 s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
612 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
3ada94ba
BF
613
614 /* /Fx */
615 /* These are just to be sure */
bd96be6e
AD
616 avctx->delay = 0;
617 s->low_delay = 1;
3ada94ba 618 break;
36ef5369 619 case AV_CODEC_ID_FLV1:
bd96be6e
AD
620 s->out_format = FMT_H263;
621 s->h263_flv = 2; /* format = 1; 11-bit codes */
3ada94ba 622 s->unrestricted_mv = 1;
bd96be6e
AD
623 s->rtp_mode = 0; /* don't allow GOB */
624 avctx->delay = 0;
625 s->low_delay = 1;
3ada94ba 626 break;
36ef5369 627 case AV_CODEC_ID_RV10:
3ada94ba 628 s->out_format = FMT_H263;
bd96be6e
AD
629 avctx->delay = 0;
630 s->low_delay = 1;
3ada94ba 631 break;
36ef5369 632 case AV_CODEC_ID_RV20:
bd96be6e
AD
633 s->out_format = FMT_H263;
634 avctx->delay = 0;
635 s->low_delay = 1;
636 s->modified_quant = 1;
637 s->h263_aic = 1;
638 s->h263_plus = 1;
639 s->loop_filter = 1;
640 s->unrestricted_mv = 0;
3ada94ba 641 break;
36ef5369 642 case AV_CODEC_ID_MPEG4:
bd96be6e
AD
643 s->out_format = FMT_H263;
644 s->h263_pred = 1;
3ada94ba 645 s->unrestricted_mv = 1;
bd96be6e
AD
646 s->low_delay = s->max_b_frames ? 0 : 1;
647 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
3ada94ba 648 break;
36ef5369 649 case AV_CODEC_ID_MSMPEG4V2:
bd96be6e
AD
650 s->out_format = FMT_H263;
651 s->h263_pred = 1;
3ada94ba 652 s->unrestricted_mv = 1;
bd96be6e
AD
653 s->msmpeg4_version = 2;
654 avctx->delay = 0;
655 s->low_delay = 1;
3ada94ba 656 break;
36ef5369 657 case AV_CODEC_ID_MSMPEG4V3:
bd96be6e
AD
658 s->out_format = FMT_H263;
659 s->h263_pred = 1;
660 s->unrestricted_mv = 1;
661 s->msmpeg4_version = 3;
662 s->flipflop_rounding = 1;
663 avctx->delay = 0;
664 s->low_delay = 1;
3ada94ba 665 break;
36ef5369 666 case AV_CODEC_ID_WMV1:
bd96be6e
AD
667 s->out_format = FMT_H263;
668 s->h263_pred = 1;
669 s->unrestricted_mv = 1;
670 s->msmpeg4_version = 4;
671 s->flipflop_rounding = 1;
672 avctx->delay = 0;
673 s->low_delay = 1;
3ada94ba 674 break;
36ef5369 675 case AV_CODEC_ID_WMV2:
bd96be6e
AD
676 s->out_format = FMT_H263;
677 s->h263_pred = 1;
678 s->unrestricted_mv = 1;
679 s->msmpeg4_version = 5;
680 s->flipflop_rounding = 1;
681 avctx->delay = 0;
682 s->low_delay = 1;
3ada94ba
BF
683 break;
684 default:
685 return -1;
686 }
687
bd96be6e 688 avctx->has_b_frames = !s->low_delay;
3ada94ba
BF
689
690 s->encoding = 1;
691
bd96be6e
AD
692 s->progressive_frame =
693 s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
0c71cc65
AK
694 CODEC_FLAG_INTERLACED_ME) ||
695 s->alternate_scan);
01bc48f4 696
3ada94ba 697 /* init */
efd29844 698 if (ff_MPV_common_init(s) < 0)
3ada94ba
BF
699 return -1;
700
d211547d
DB
701 if (ARCH_X86)
702 ff_MPV_encode_init_x86(s);
703
a9aee08d 704 ff_fdctdsp_init(&s->fdsp, avctx);
8d686ca5 705 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
f46bb608 706 ff_pixblockdsp_init(&s->pdsp, avctx);
368f5035
DB
707 ff_qpeldsp_init(&s->qdsp);
708
f6774f90 709 s->avctx->coded_frame = s->current_picture.f;
1f8eb690
AK
710
711 if (s->msmpeg4_version) {
712 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
713 2 * 2 * (MAX_LEVEL + 1) *
714 (MAX_RUN + 1) * 2 * sizeof(int), fail);
715 }
716 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
717
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
719 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
720 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
722 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
723 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
724 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
725 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
726
727 if (s->avctx->noise_reduction) {
728 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
729 2 * 64 * sizeof(uint16_t), fail);
730 }
731
cff480e4
MS
732 if (CONFIG_H263_ENCODER)
733 ff_h263dsp_init(&s->h263dsp);
bd96be6e 734 if (!s->dct_quantize)
99560a4c 735 s->dct_quantize = ff_dct_quantize_c;
bd96be6e
AD
736 if (!s->denoise_dct)
737 s->denoise_dct = denoise_dct_c;
53727262 738 s->fast_dct_quantize = s->dct_quantize;
bd96be6e
AD
739 if (avctx->trellis)
740 s->dct_quantize = dct_quantize_trellis_c;
53727262 741
bd96be6e
AD
742 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
743 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
01bc48f4 744
bd96be6e 745 s->quant_precision = 5;
3ada94ba
BF
746
747 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
748 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
749
49fb20cb 750 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
3ada94ba 751 ff_h261_encode_init(s);
f34121f3 752 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
ddce8953 753 ff_h263_encode_init(s);
49fb20cb 754 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3ada94ba 755 ff_msmpeg4_encode_init(s);
49fb20cb 756 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
a6bc5731 757 && s->out_format == FMT_MPEG1)
3ada94ba
BF
758 ff_mpeg1_encode_init(s);
759
760 /* init q matrix */
bd96be6e 761 for (i = 0; i < 64; i++) {
e3fcb143 762 int j = s->idsp.idct_permutation[i];
36ef5369 763 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
bd96be6e 764 s->mpeg_quant) {
3ada94ba
BF
765 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
766 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
bd96be6e 767 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
3ada94ba
BF
768 s->intra_matrix[j] =
769 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
bd96be6e
AD
770 } else {
771 /* mpeg1/2 */
3ada94ba
BF
772 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
773 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
774 }
bd96be6e 775 if (s->avctx->intra_matrix)
3ada94ba 776 s->intra_matrix[j] = s->avctx->intra_matrix[i];
bd96be6e 777 if (s->avctx->inter_matrix)
3ada94ba
BF
778 s->inter_matrix[j] = s->avctx->inter_matrix[i];
779 }
780
781 /* precompute matrix */
782 /* for mjpeg, we do include qscale in the matrix */
783 if (s->out_format != FMT_MJPEG) {
5dd8c08f 784 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
bd96be6e
AD
785 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
786 31, 1);
5dd8c08f 787 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
bd96be6e
AD
788 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
789 31, 0);
3ada94ba
BF
790 }
791
bd96be6e 792 if (ff_rate_control_init(s) < 0)
3ada94ba
BF
793 return -1;
794
8941971a
AK
795#if FF_API_ERROR_RATE
796 FF_DISABLE_DEPRECATION_WARNINGS
797 if (avctx->error_rate)
798 s->error_rate = avctx->error_rate;
799 FF_ENABLE_DEPRECATION_WARNINGS;
800#endif
801
b2c31710
AK
802#if FF_API_NORMALIZE_AQP
803 FF_DISABLE_DEPRECATION_WARNINGS
804 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
805 s->mpv_flags |= FF_MPV_FLAG_NAQ;
806 FF_ENABLE_DEPRECATION_WARNINGS;
807#endif
808
a2941c8c
AK
809#if FF_API_MV0
810 FF_DISABLE_DEPRECATION_WARNINGS
811 if (avctx->flags & CODEC_FLAG_MV0)
812 s->mpv_flags |= FF_MPV_FLAG_MV0;
813 FF_ENABLE_DEPRECATION_WARNINGS
814#endif
815
1c01b025
AK
816 if (avctx->b_frame_strategy == 2) {
817 for (i = 0; i < s->max_b_frames + 2; i++) {
818 s->tmp_frames[i] = av_frame_alloc();
819 if (!s->tmp_frames[i])
820 return AVERROR(ENOMEM);
821
822 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
823 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
824 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
825
826 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
827 if (ret < 0)
828 return ret;
829 }
830 }
831
3ada94ba 832 return 0;
1f8eb690
AK
833fail:
834 ff_MPV_encode_end(avctx);
835 return AVERROR_UNKNOWN;
3ada94ba
BF
836}
837
efd29844 838av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
3ada94ba
BF
839{
840 MpegEncContext *s = avctx->priv_data;
1c01b025 841 int i;
3ada94ba
BF
842
843 ff_rate_control_uninit(s);
844
efd29844 845 ff_MPV_common_end(s);
24abd806 846 if (CONFIG_MJPEG_ENCODER &&
bd96be6e 847 s->out_format == FMT_MJPEG)
3ada94ba
BF
848 ff_mjpeg_encode_close(s);
849
850 av_freep(&avctx->extradata);
851
1c01b025
AK
852 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
853 av_frame_free(&s->tmp_frames[i]);
854
0b0a7a75
AK
855 ff_free_picture_tables(&s->new_picture);
856 ff_mpeg_unref_picture(s, &s->new_picture);
857
858 av_freep(&s->avctx->stats_out);
859 av_freep(&s->ac_stats);
860
861 av_freep(&s->q_intra_matrix);
862 av_freep(&s->q_inter_matrix);
863 av_freep(&s->q_intra_matrix16);
864 av_freep(&s->q_inter_matrix16);
865 av_freep(&s->input_picture);
866 av_freep(&s->reordered_input_picture);
867 av_freep(&s->dct_offset);
868
3ada94ba
BF
869 return 0;
870}
871
bd96be6e
AD
872static int get_sae(uint8_t *src, int ref, int stride)
873{
3ada94ba 874 int x,y;
bd96be6e 875 int acc = 0;
3ada94ba 876
bd96be6e
AD
877 for (y = 0; y < 16; y++) {
878 for (x = 0; x < 16; x++) {
879 acc += FFABS(src[x + y * stride] - ref);
3ada94ba
BF
880 }
881 }
882
883 return acc;
884}
885
bd96be6e
AD
886static int get_intra_count(MpegEncContext *s, uint8_t *src,
887 uint8_t *ref, int stride)
888{
3ada94ba 889 int x, y, w, h;
bd96be6e 890 int acc = 0;
3ada94ba 891
bd96be6e
AD
892 w = s->width & ~15;
893 h = s->height & ~15;
3ada94ba 894
bd96be6e
AD
895 for (y = 0; y < h; y += 16) {
896 for (x = 0; x < w; x += 16) {
897 int offset = x + y * stride;
898 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
899 16);
c1661484 900 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
bd96be6e 901 int sae = get_sae(src + offset, mean, stride);
3ada94ba 902
bd96be6e 903 acc += sae + 500 < sad;
3ada94ba
BF
904 }
905 }
906 return acc;
907}
908
909
3f47d316 910static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
bd96be6e 911{
759001c5 912 Picture *pic = NULL;
3ada94ba 913 int64_t pts;
759001c5 914 int i, display_picture_number = 0, ret;
54553842
AK
915 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
916 (s->low_delay ? 0 : 1);
bd96be6e
AD
917 int direct = 1;
918
919 if (pic_arg) {
920 pts = pic_arg->pts;
3f47d316 921 display_picture_number = s->input_picture_number++;
bd96be6e
AD
922
923 if (pts != AV_NOPTS_VALUE) {
924 if (s->user_specified_pts != AV_NOPTS_VALUE) {
925 int64_t time = pts;
926 int64_t last = s->user_specified_pts;
927
928 if (time <= last) {
929 av_log(s->avctx, AV_LOG_ERROR,
930 "Error, Invalid timestamp=%"PRId64", "
931 "last=%"PRId64"\n", pts, s->user_specified_pts);
3ada94ba
BF
932 return -1;
933 }
445a7d48 934
3f47d316 935 if (!s->low_delay && display_picture_number == 1)
445a7d48 936 s->dts_delta = time - last;
3ada94ba 937 }
bd96be6e
AD
938 s->user_specified_pts = pts;
939 } else {
940 if (s->user_specified_pts != AV_NOPTS_VALUE) {
941 s->user_specified_pts =
942 pts = s->user_specified_pts + 1;
943 av_log(s->avctx, AV_LOG_INFO,
944 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
945 pts);
946 } else {
3f47d316 947 pts = display_picture_number;
3ada94ba
BF
948 }
949 }
950 }
951
04f4dbc2 952 if (pic_arg) {
759001c5 953 if (!pic_arg->buf[0]);
04f4dbc2
AK
954 direct = 0;
955 if (pic_arg->linesize[0] != s->linesize)
956 direct = 0;
957 if (pic_arg->linesize[1] != s->uvlinesize)
958 direct = 0;
959 if (pic_arg->linesize[2] != s->uvlinesize)
960 direct = 0;
961
93f30547 962 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
04f4dbc2
AK
963 pic_arg->linesize[1], s->linesize, s->uvlinesize);
964
965 if (direct) {
966 i = ff_find_unused_picture(s, 1);
967 if (i < 0)
968 return i;
969
759001c5 970 pic = &s->picture[i];
04f4dbc2
AK
971 pic->reference = 3;
972
f6774f90 973 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
759001c5
AK
974 return ret;
975 if (ff_alloc_picture(s, pic, 1) < 0) {
04f4dbc2
AK
976 return -1;
977 }
978 } else {
979 i = ff_find_unused_picture(s, 0);
980 if (i < 0)
981 return i;
3ada94ba 982
759001c5 983 pic = &s->picture[i];
04f4dbc2 984 pic->reference = 3;
3ada94ba 985
759001c5 986 if (ff_alloc_picture(s, pic, 0) < 0) {
04f4dbc2
AK
987 return -1;
988 }
3ada94ba 989
f6774f90 990 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
991 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
992 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
04f4dbc2
AK
993 // empty
994 } else {
995 int h_chroma_shift, v_chroma_shift;
996 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
997 &h_chroma_shift,
998 &v_chroma_shift);
999
1000 for (i = 0; i < 3; i++) {
1001 int src_stride = pic_arg->linesize[i];
1002 int dst_stride = i ? s->uvlinesize : s->linesize;
1003 int h_shift = i ? h_chroma_shift : 0;
1004 int v_shift = i ? v_chroma_shift : 0;
1005 int w = s->width >> h_shift;
1006 int h = s->height >> v_shift;
1007 uint8_t *src = pic_arg->data[i];
f6774f90 1008 uint8_t *dst = pic->f->data[i];
04f4dbc2
AK
1009
1010 if (!s->avctx->rc_buffer_size)
1011 dst += INPLACE_OFFSET;
1012
1013 if (src_stride == dst_stride)
1014 memcpy(dst, src, src_stride * h);
1015 else {
1016 while (h--) {
1017 memcpy(dst, src, w);
1018 dst += dst_stride;
1019 src += src_stride;
1020 }
3ada94ba
BF
1021 }
1022 }
1023 }
1024 }
f6774f90 1025 ret = av_frame_copy_props(pic->f, pic_arg);
22c87905
VG
1026 if (ret < 0)
1027 return ret;
1028
f6774f90 1029 pic->f->display_picture_number = display_picture_number;
1030 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
3ada94ba 1031 }
3ada94ba
BF
1032
1033 /* shift buffer entries */
bd96be6e
AD
1034 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1035 s->input_picture[i - 1] = s->input_picture[i];
3ada94ba 1036
bd96be6e 1037 s->input_picture[encoding_delay] = (Picture*) pic;
3ada94ba
BF
1038
1039 return 0;
1040}
1041
bd96be6e
AD
1042static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1043{
3ada94ba 1044 int x, y, plane;
bd96be6e
AD
1045 int score = 0;
1046 int64_t score64 = 0;
3ada94ba 1047
bd96be6e 1048 for (plane = 0; plane < 3; plane++) {
f6774f90 1049 const int stride = p->f->linesize[plane];
bd96be6e
AD
1050 const int bw = plane ? 1 : 2;
1051 for (y = 0; y < s->mb_height * bw; y++) {
1052 for (x = 0; x < s->mb_width * bw; x++) {
759001c5 1053 int off = p->shared ? 0 : 16;
f6774f90 1054 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1055 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
bd96be6e
AD
1056 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1057
1058 switch (s->avctx->frame_skip_exp) {
1059 case 0: score = FFMAX(score, v); break;
1060 case 1: score += FFABS(v); break;
1061 case 2: score += v * v; break;
1062 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1063 case 4: score64 += v * v * (int64_t)(v * v); break;
3ada94ba
BF
1064 }
1065 }
1066 }
1067 }
1068
bd96be6e
AD
1069 if (score)
1070 score64 = score;
3ada94ba 1071
bd96be6e 1072 if (score64 < s->avctx->frame_skip_threshold)
3ada94ba 1073 return 1;
bd96be6e 1074 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
3ada94ba
BF
1075 return 1;
1076 return 0;
1077}
1078
7f9aaa49
AK
1079static int encode_frame(AVCodecContext *c, AVFrame *frame)
1080{
1081 AVPacket pkt = { 0 };
1082 int ret, got_output;
1083
1084 av_init_packet(&pkt);
7f9aaa49
AK
1085 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1086 if (ret < 0)
1087 return ret;
1088
1089 ret = pkt.size;
1090 av_free_packet(&pkt);
1091 return ret;
1092}
1093
bd96be6e
AD
1094static int estimate_best_b_count(MpegEncContext *s)
1095{
9342ecf0 1096 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
71a861cf 1097 AVCodecContext *c = avcodec_alloc_context3(NULL);
bd96be6e 1098 const int scale = s->avctx->brd_scale;
3ada94ba 1099 int i, j, out_size, p_lambda, b_lambda, lambda2;
bd96be6e
AD
1100 int64_t best_rd = INT64_MAX;
1101 int best_b_count = -1;
1102
1103 assert(scale >= 0 && scale <= 3);
1104
1105 //emms_c();
1106 //s->next_picture_ptr->quality;
1107 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1108 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1109 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1110 if (!b_lambda) // FIXME we should do this somewhere else
1111 b_lambda = p_lambda;
1112 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1113 FF_LAMBDA_SHIFT;
1114
1115 c->width = s->width >> scale;
1116 c->height = s->height >> scale;
5fccedaa 1117 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
bd96be6e
AD
1118 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1119 c->mb_decision = s->avctx->mb_decision;
1120 c->me_cmp = s->avctx->me_cmp;
1121 c->mb_cmp = s->avctx->mb_cmp;
1122 c->me_sub_cmp = s->avctx->me_sub_cmp;
716d413c 1123 c->pix_fmt = AV_PIX_FMT_YUV420P;
bd96be6e
AD
1124 c->time_base = s->avctx->time_base;
1125 c->max_b_frames = s->max_b_frames;
3ada94ba 1126
0b950fe2 1127 if (avcodec_open2(c, codec, NULL) < 0)
3ada94ba
BF
1128 return -1;
1129
9342ecf0 1130 for (i = 0; i < s->max_b_frames + 2; i++) {
9342ecf0
AD
1131 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1132 s->next_picture_ptr;
3ada94ba 1133
9342ecf0
AD
1134 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1135 pre_input = *pre_input_ptr;
3ada94ba 1136
759001c5 1137 if (!pre_input.shared && i) {
f6774f90 1138 pre_input.f->data[0] += INPLACE_OFFSET;
1139 pre_input.f->data[1] += INPLACE_OFFSET;
1140 pre_input.f->data[2] += INPLACE_OFFSET;
3ada94ba
BF
1141 }
1142
c1661484
DB
1143 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1144 s->tmp_frames[i]->linesize[0],
1145 pre_input.f->data[0],
1146 pre_input.f->linesize[0],
1147 c->width, c->height);
1148 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1149 s->tmp_frames[i]->linesize[1],
1150 pre_input.f->data[1],
1151 pre_input.f->linesize[1],
1152 c->width >> 1, c->height >> 1);
1153 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1154 s->tmp_frames[i]->linesize[2],
1155 pre_input.f->data[2],
1156 pre_input.f->linesize[2],
1157 c->width >> 1, c->height >> 1);
3ada94ba
BF
1158 }
1159 }
1160
9342ecf0
AD
1161 for (j = 0; j < s->max_b_frames + 1; j++) {
1162 int64_t rd = 0;
3ada94ba 1163
9342ecf0 1164 if (!s->input_picture[j])
3ada94ba
BF
1165 break;
1166
9342ecf0 1167 c->error[0] = c->error[1] = c->error[2] = 0;
3ada94ba 1168
1c01b025
AK
1169 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1170 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
7f9aaa49 1171
1c01b025 1172 out_size = encode_frame(c, s->tmp_frames[0]);
7f9aaa49 1173
9342ecf0 1174 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
3ada94ba 1175
9342ecf0
AD
1176 for (i = 0; i < s->max_b_frames + 1; i++) {
1177 int is_p = i % (j + 1) == j || i == s->max_b_frames;
3ada94ba 1178
1c01b025 1179 s->tmp_frames[i + 1]->pict_type = is_p ?
9342ecf0 1180 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1c01b025 1181 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
7f9aaa49 1182
1c01b025 1183 out_size = encode_frame(c, s->tmp_frames[i + 1]);
7f9aaa49 1184
3ada94ba
BF
1185 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1186 }
1187
1188 /* get the delayed frames */
9342ecf0 1189 while (out_size) {
7f9aaa49 1190 out_size = encode_frame(c, NULL);
3ada94ba
BF
1191 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1192 }
1193
1194 rd += c->error[0] + c->error[1] + c->error[2];
1195
9342ecf0
AD
1196 if (rd < best_rd) {
1197 best_rd = rd;
1198 best_b_count = j;
3ada94ba
BF
1199 }
1200 }
1201
3ada94ba
BF
1202 avcodec_close(c);
1203 av_freep(&c);
1204
3ada94ba
BF
1205 return best_b_count;
1206}
1207
9342ecf0
AD
1208static int select_input_picture(MpegEncContext *s)
1209{
759001c5 1210 int i, ret;
3ada94ba 1211
9342ecf0
AD
1212 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1213 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1214 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
3ada94ba
BF
1215
1216 /* set next picture type & ordering */
9342ecf0
AD
1217 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1218 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1219 s->next_picture_ptr == NULL || s->intra_only) {
1220 s->reordered_input_picture[0] = s->input_picture[0];
f6774f90 1221 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1222 s->reordered_input_picture[0]->f->coded_picture_number =
9342ecf0
AD
1223 s->coded_picture_number++;
1224 } else {
3ada94ba
BF
1225 int b_frames;
1226
9342ecf0
AD
1227 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1228 if (s->picture_in_gop_number < s->gop_size &&
1229 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1230 // FIXME check that te gop check above is +-1 correct
f6774f90 1231 av_frame_unref(s->input_picture[0]->f);
3ada94ba
BF
1232
1233 emms_c();
1234 ff_vbv_update(s, 0);
1235
1236 goto no_output_pic;
1237 }
1238 }
1239
9342ecf0
AD
1240 if (s->flags & CODEC_FLAG_PASS2) {
1241 for (i = 0; i < s->max_b_frames + 1; i++) {
f6774f90 1242 int pict_num = s->input_picture[0]->f->display_picture_number + i;
3ada94ba 1243
9342ecf0 1244 if (pict_num >= s->rc_context.num_entries)
3ada94ba 1245 break;
9342ecf0
AD
1246 if (!s->input_picture[i]) {
1247 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
3ada94ba
BF
1248 break;
1249 }
1250
f6774f90 1251 s->input_picture[i]->f->pict_type =
3ada94ba
BF
1252 s->rc_context.entry[pict_num].new_pict_type;
1253 }
1254 }
1255
9342ecf0
AD
1256 if (s->avctx->b_frame_strategy == 0) {
1257 b_frames = s->max_b_frames;
1258 while (b_frames && !s->input_picture[b_frames])
1259 b_frames--;
1260 } else if (s->avctx->b_frame_strategy == 1) {
1261 for (i = 1; i < s->max_b_frames + 1; i++) {
1262 if (s->input_picture[i] &&
1263 s->input_picture[i]->b_frame_score == 0) {
1264 s->input_picture[i]->b_frame_score =
1265 get_intra_count(s,
f6774f90 1266 s->input_picture[i ]->f->data[0],
1267 s->input_picture[i - 1]->f->data[0],
9342ecf0 1268 s->linesize) + 1;
3ada94ba
BF
1269 }
1270 }
9342ecf0
AD
1271 for (i = 0; i < s->max_b_frames + 1; i++) {
1272 if (s->input_picture[i] == NULL ||
1273 s->input_picture[i]->b_frame_score - 1 >
1274 s->mb_num / s->avctx->b_sensitivity)
1275 break;
3ada94ba
BF
1276 }
1277
9342ecf0 1278 b_frames = FFMAX(0, i - 1);
3ada94ba
BF
1279
1280 /* reset scores */
9342ecf0
AD
1281 for (i = 0; i < b_frames + 1; i++) {
1282 s->input_picture[i]->b_frame_score = 0;
3ada94ba 1283 }
9342ecf0
AD
1284 } else if (s->avctx->b_frame_strategy == 2) {
1285 b_frames = estimate_best_b_count(s);
1286 } else {
3ada94ba 1287 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
9342ecf0 1288 b_frames = 0;
3ada94ba
BF
1289 }
1290
1291 emms_c();
3ada94ba 1292
9342ecf0 1293 for (i = b_frames - 1; i >= 0; i--) {
f6774f90 1294 int type = s->input_picture[i]->f->pict_type;
9342ecf0
AD
1295 if (type && type != AV_PICTURE_TYPE_B)
1296 b_frames = i;
3ada94ba 1297 }
f6774f90 1298 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
9342ecf0
AD
1299 b_frames == s->max_b_frames) {
1300 av_log(s->avctx, AV_LOG_ERROR,
1301 "warning, too many b frames in a row\n");
3ada94ba
BF
1302 }
1303
9342ecf0 1304 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
a249f0cc 1305 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
9342ecf0
AD
1306 s->gop_size > s->picture_in_gop_number) {
1307 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1308 } else {
1309 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1310 b_frames = 0;
f6774f90 1311 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
9342ecf0 1312 }
3ada94ba
BF
1313 }
1314
9342ecf0 1315 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
f6774f90 1316 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
3ada94ba
BF
1317 b_frames--;
1318
9342ecf0 1319 s->reordered_input_picture[0] = s->input_picture[b_frames];
f6774f90 1320 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1321 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1322 s->reordered_input_picture[0]->f->coded_picture_number =
9342ecf0
AD
1323 s->coded_picture_number++;
1324 for (i = 0; i < b_frames; i++) {
657ccb5a 1325 s->reordered_input_picture[i + 1] = s->input_picture[i];
f6774f90 1326 s->reordered_input_picture[i + 1]->f->pict_type =
9342ecf0 1327 AV_PICTURE_TYPE_B;
f6774f90 1328 s->reordered_input_picture[i + 1]->f->coded_picture_number =
9342ecf0 1329 s->coded_picture_number++;
3ada94ba
BF
1330 }
1331 }
1332 }
1333no_output_pic:
9342ecf0 1334 if (s->reordered_input_picture[0]) {
759001c5 1335 s->reordered_input_picture[0]->reference =
f6774f90 1336 s->reordered_input_picture[0]->f->pict_type !=
9342ecf0 1337 AV_PICTURE_TYPE_B ? 3 : 0;
3ada94ba 1338
759001c5
AK
1339 ff_mpeg_unref_picture(s, &s->new_picture);
1340 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1341 return ret;
3ada94ba 1342
759001c5 1343 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
9342ecf0
AD
1344 // input is a shared pix, so we can't modifiy it -> alloc a new
1345 // one & ensure that the shared one is reuseable
3ada94ba 1346
1ce1578e 1347 Picture *pic;
9342ecf0 1348 int i = ff_find_unused_picture(s, 0);
4f820131
AU
1349 if (i < 0)
1350 return i;
1ce1578e 1351 pic = &s->picture[i];
3ada94ba 1352
759001c5 1353 pic->reference = s->reordered_input_picture[0]->reference;
9342ecf0 1354 if (ff_alloc_picture(s, pic, 0) < 0) {
be548816
PP
1355 return -1;
1356 }
3ada94ba 1357
f6774f90 1358 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
22c87905
VG
1359 if (ret < 0)
1360 return ret;
3ada94ba 1361
759001c5 1362 /* mark us unused / free shared pic */
f6774f90 1363 av_frame_unref(s->reordered_input_picture[0]->f);
759001c5
AK
1364 s->reordered_input_picture[0]->shared = 0;
1365
9342ecf0
AD
1366 s->current_picture_ptr = pic;
1367 } else {
3ada94ba 1368 // input is not a shared pix -> reuse buffer for current_pix
9342ecf0
AD
1369 s->current_picture_ptr = s->reordered_input_picture[0];
1370 for (i = 0; i < 4; i++) {
f6774f90 1371 s->new_picture.f->data[i] += INPLACE_OFFSET;
3ada94ba
BF
1372 }
1373 }
759001c5
AK
1374 ff_mpeg_unref_picture(s, &s->current_picture);
1375 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1376 s->current_picture_ptr)) < 0)
1377 return ret;
3ada94ba 1378
f6774f90 1379 s->picture_number = s->new_picture.f->display_picture_number;
9342ecf0 1380 } else {
759001c5 1381 ff_mpeg_unref_picture(s, &s->new_picture);
3ada94ba 1382 }
be548816 1383 return 0;
3ada94ba
BF
1384}
1385
381a7225
AK
1386static void frame_end(MpegEncContext *s)
1387{
1388 int i;
1389
1390 if (s->unrestricted_mv &&
1391 s->current_picture.reference &&
1392 !s->intra_only) {
1393 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1394 int hshift = desc->log2_chroma_w;
1395 int vshift = desc->log2_chroma_h;
3c650efb
DB
1396 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1397 s->h_edge_pos, s->v_edge_pos,
1398 EDGE_WIDTH, EDGE_WIDTH,
1399 EDGE_TOP | EDGE_BOTTOM);
1400 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1401 s->h_edge_pos >> hshift,
1402 s->v_edge_pos >> vshift,
1403 EDGE_WIDTH >> hshift,
1404 EDGE_WIDTH >> vshift,
1405 EDGE_TOP | EDGE_BOTTOM);
1406 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1407 s->h_edge_pos >> hshift,
1408 s->v_edge_pos >> vshift,
1409 EDGE_WIDTH >> hshift,
1410 EDGE_WIDTH >> vshift,
1411 EDGE_TOP | EDGE_BOTTOM);
381a7225
AK
1412 }
1413
1414 emms_c();
1415
1416 s->last_pict_type = s->pict_type;
f6774f90 1417 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
381a7225
AK
1418 if (s->pict_type!= AV_PICTURE_TYPE_B)
1419 s->last_non_b_pict_type = s->pict_type;
1420
1421 if (s->encoding) {
1422 /* release non-reference frames */
1423 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1424 if (!s->picture[i].reference)
1425 ff_mpeg_unref_picture(s, &s->picture[i]);
1426 }
1427 }
1428
f6774f90 1429 s->avctx->coded_frame = s->current_picture_ptr->f;
381a7225
AK
1430
1431}
1432
aec25b1c
AK
1433static void update_noise_reduction(MpegEncContext *s)
1434{
1435 int intra, i;
1436
1437 for (intra = 0; intra < 2; intra++) {
1438 if (s->dct_count[intra] > (1 << 16)) {
1439 for (i = 0; i < 64; i++) {
1440 s->dct_error_sum[intra][i] >>= 1;
1441 }
1442 s->dct_count[intra] >>= 1;
1443 }
1444
1445 for (i = 0; i < 64; i++) {
1446 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1447 s->dct_count[intra] +
1448 s->dct_error_sum[intra][i] / 2) /
1449 (s->dct_error_sum[intra][i] + 1);
1450 }
1451 }
1452}
1453
1454static int frame_start(MpegEncContext *s)
1455{
1456 int ret;
1457
1458 /* mark & release old frames */
1459 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1460 s->last_picture_ptr != s->next_picture_ptr &&
f6774f90 1461 s->last_picture_ptr->f->buf[0]) {
aec25b1c
AK
1462 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1463 }
1464
f6774f90 1465 s->current_picture_ptr->f->pict_type = s->pict_type;
1466 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
aec25b1c
AK
1467
1468 ff_mpeg_unref_picture(s, &s->current_picture);
1469 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1470 s->current_picture_ptr)) < 0)
1471 return ret;
1472
1473 if (s->pict_type != AV_PICTURE_TYPE_B) {
1474 s->last_picture_ptr = s->next_picture_ptr;
1475 if (!s->droppable)
1476 s->next_picture_ptr = s->current_picture_ptr;
1477 }
1478
1479 if (s->last_picture_ptr) {
1480 ff_mpeg_unref_picture(s, &s->last_picture);
f6774f90 1481 if (s->last_picture_ptr->f->buf[0] &&
aec25b1c
AK
1482 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1483 s->last_picture_ptr)) < 0)
1484 return ret;
1485 }
1486 if (s->next_picture_ptr) {
1487 ff_mpeg_unref_picture(s, &s->next_picture);
f6774f90 1488 if (s->next_picture_ptr->f->buf[0] &&
aec25b1c
AK
1489 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1490 s->next_picture_ptr)) < 0)
1491 return ret;
1492 }
1493
1494 if (s->picture_structure!= PICT_FRAME) {
1495 int i;
1496 for (i = 0; i < 4; i++) {
1497 if (s->picture_structure == PICT_BOTTOM_FIELD) {
f6774f90 1498 s->current_picture.f->data[i] +=
1499 s->current_picture.f->linesize[i];
aec25b1c 1500 }
f6774f90 1501 s->current_picture.f->linesize[i] *= 2;
1502 s->last_picture.f->linesize[i] *= 2;
1503 s->next_picture.f->linesize[i] *= 2;
aec25b1c
AK
1504 }
1505 }
1506
1507 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1508 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1509 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1510 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1511 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1512 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1513 } else {
1514 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1515 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1516 }
1517
1518 if (s->dct_error_sum) {
1519 assert(s->avctx->noise_reduction && s->encoding);
1520 update_noise_reduction(s);
1521 }
1522
1523 return 0;
1524}
1525
445a7d48
AK
1526int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1527 const AVFrame *pic_arg, int *got_packet)
3ada94ba
BF
1528{
1529 MpegEncContext *s = avctx->priv_data;
445a7d48 1530 int i, stuffing_count, ret;
881a5e04 1531 int context_count = s->slice_context_count;
3ada94ba 1532
3ada94ba
BF
1533 s->picture_in_gop_number++;
1534
9342ecf0 1535 if (load_input_picture(s, pic_arg) < 0)
3ada94ba
BF
1536 return -1;
1537
9342ecf0 1538 if (select_input_picture(s) < 0) {
be548816
PP
1539 return -1;
1540 }
3ada94ba
BF
1541
1542 /* output? */
f6774f90 1543 if (s->new_picture.f->data[0]) {
5d42ac7f
AK
1544 if (!pkt->data &&
1545 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1546 return ret;
bdc1220e
MS
1547 if (s->mb_info) {
1548 s->mb_info_ptr = av_packet_new_side_data(pkt,
1549 AV_PKT_DATA_H263_MB_INFO,
1550 s->mb_width*s->mb_height*12);
1551 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1552 }
5d42ac7f
AK
1553
1554 for (i = 0; i < context_count; i++) {
1555 int start_y = s->thread_context[i]->start_mb_y;
1556 int end_y = s->thread_context[i]-> end_mb_y;
1557 int h = s->mb_height;
1558 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1559 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1560
1561 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1562 }
1563
f6774f90 1564 s->pict_type = s->new_picture.f->pict_type;
9342ecf0 1565 //emms_c();
aec25b1c
AK
1566 ret = frame_start(s);
1567 if (ret < 0)
1568 return ret;
3ada94ba
BF
1569vbv_retry:
1570 if (encode_picture(s, s->picture_number) < 0)
1571 return -1;
1572
3ada94ba
BF
1573 avctx->header_bits = s->header_bits;
1574 avctx->mv_bits = s->mv_bits;
1575 avctx->misc_bits = s->misc_bits;
1576 avctx->i_tex_bits = s->i_tex_bits;
1577 avctx->p_tex_bits = s->p_tex_bits;
1578 avctx->i_count = s->i_count;
9342ecf0
AD
1579 // FIXME f/b_count in avctx
1580 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
3ada94ba
BF
1581 avctx->skip_count = s->skip_count;
1582
381a7225 1583 frame_end(s);
3ada94ba 1584
49fb20cb 1585 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
3360ad99 1586 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
3ada94ba 1587
9342ecf0
AD
1588 if (avctx->rc_buffer_size) {
1589 RateControlContext *rcc = &s->rc_context;
1590 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
3ada94ba 1591
9342ecf0
AD
1592 if (put_bits_count(&s->pb) > max_size &&
1593 s->lambda < s->avctx->lmax) {
1594 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1595 (s->qscale + 1) / s->qscale);
1596 if (s->adaptive_quant) {
3ada94ba 1597 int i;
9342ecf0
AD
1598 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1599 s->lambda_table[i] =
1600 FFMAX(s->lambda_table[i] + 1,
1601 s->lambda_table[i] * (s->qscale + 1) /
1602 s->qscale);
3ada94ba 1603 }
aec25b1c 1604 s->mb_skipped = 0; // done in frame_start()
9342ecf0
AD
1605 // done in encode_picture() so we must undo it
1606 if (s->pict_type == AV_PICTURE_TYPE_P) {
1607 if (s->flipflop_rounding ||
36ef5369
AK
1608 s->codec_id == AV_CODEC_ID_H263P ||
1609 s->codec_id == AV_CODEC_ID_MPEG4)
3ada94ba
BF
1610 s->no_rounding ^= 1;
1611 }
9342ecf0
AD
1612 if (s->pict_type != AV_PICTURE_TYPE_B) {
1613 s->time_base = s->last_time_base;
1614 s->last_non_b_time = s->time - s->pp_time;
3ada94ba 1615 }
9342ecf0
AD
1616 for (i = 0; i < context_count; i++) {
1617 PutBitContext *pb = &s->thread_context[i]->pb;
3ada94ba
BF
1618 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1619 }
1620 goto vbv_retry;
1621 }
1622
1623 assert(s->avctx->rc_max_rate);
1624 }
1625
9342ecf0 1626 if (s->flags & CODEC_FLAG_PASS1)
3ada94ba
BF
1627 ff_write_pass1_stats(s);
1628
9342ecf0 1629 for (i = 0; i < 4; i++) {
f6774f90 1630 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1631 avctx->error[i] += s->current_picture_ptr->f->error[i];
3ada94ba
BF
1632 }
1633
9342ecf0
AD
1634 if (s->flags & CODEC_FLAG_PASS1)
1635 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1636 avctx->i_tex_bits + avctx->p_tex_bits ==
1637 put_bits_count(&s->pb));
3ada94ba
BF
1638 flush_put_bits(&s->pb);
1639 s->frame_bits = put_bits_count(&s->pb);
1640
9342ecf0
AD
1641 stuffing_count = ff_vbv_update(s, s->frame_bits);
1642 if (stuffing_count) {
1643 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1644 stuffing_count + 50) {
3ada94ba
BF
1645 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1646 return -1;
1647 }
1648
9342ecf0 1649 switch (s->codec_id) {
36ef5369
AK
1650 case AV_CODEC_ID_MPEG1VIDEO:
1651 case AV_CODEC_ID_MPEG2VIDEO:
9342ecf0 1652 while (stuffing_count--) {
3ada94ba
BF
1653 put_bits(&s->pb, 8, 0);
1654 }
1655 break;
36ef5369 1656 case AV_CODEC_ID_MPEG4:
3ada94ba
BF
1657 put_bits(&s->pb, 16, 0);
1658 put_bits(&s->pb, 16, 0x1C3);
1659 stuffing_count -= 4;
9342ecf0 1660 while (stuffing_count--) {
3ada94ba
BF
1661 put_bits(&s->pb, 8, 0xFF);
1662 }
1663 break;
1664 default:
1665 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1666 }
1667 flush_put_bits(&s->pb);
1668 s->frame_bits = put_bits_count(&s->pb);
1669 }
1670
1671 /* update mpeg1/2 vbv_delay for CBR */
9342ecf0
AD
1672 if (s->avctx->rc_max_rate &&
1673 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1674 s->out_format == FMT_MPEG1 &&
1675 90000LL * (avctx->rc_buffer_size - 1) <=
1676 s->avctx->rc_max_rate * 0xFFFFLL) {
4601e76a 1677 int vbv_delay, min_delay;
9342ecf0
AD
1678 double inbits = s->avctx->rc_max_rate *
1679 av_q2d(s->avctx->time_base);
1680 int minbits = s->frame_bits - 8 *
1681 (s->vbv_delay_ptr - s->pb.buf - 1);
1682 double bits = s->rc_context.buffer_index + minbits - inbits;
4601e76a 1683
9342ecf0
AD
1684 if (bits < 0)
1685 av_log(s->avctx, AV_LOG_ERROR,
1686 "Internal error, negative bits\n");
3ada94ba 1687
9342ecf0 1688 assert(s->repeat_first_field == 0);
3ada94ba 1689
9342ecf0
AD
1690 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1691 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1692 s->avctx->rc_max_rate;
4601e76a 1693
9342ecf0 1694 vbv_delay = FFMAX(vbv_delay, min_delay);
4601e76a 1695
3ada94ba
BF
1696 assert(vbv_delay < 0xFFFF);
1697
1698 s->vbv_delay_ptr[0] &= 0xF8;
9342ecf0
AD
1699 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1700 s->vbv_delay_ptr[1] = vbv_delay >> 5;
3ada94ba 1701 s->vbv_delay_ptr[2] &= 0x07;
9342ecf0
AD
1702 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1703 avctx->vbv_delay = vbv_delay * 300;
3ada94ba 1704 }
9342ecf0 1705 s->total_bits += s->frame_bits;
3ada94ba 1706 avctx->frame_bits = s->frame_bits;
445a7d48 1707
f6774f90 1708 pkt->pts = s->current_picture.f->pts;
1c7b71a5 1709 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
f6774f90 1710 if (!s->current_picture.f->coded_picture_number)
445a7d48
AK
1711 pkt->dts = pkt->pts - s->dts_delta;
1712 else
1713 pkt->dts = s->reordered_pts;
1c7b71a5 1714 s->reordered_pts = pkt->pts;
445a7d48
AK
1715 } else
1716 pkt->dts = pkt->pts;
f6774f90 1717 if (s->current_picture.f->key_frame)
445a7d48 1718 pkt->flags |= AV_PKT_FLAG_KEY;
bdc1220e
MS
1719 if (s->mb_info)
1720 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
9342ecf0 1721 } else {
9342ecf0 1722 s->frame_bits = 0;
3ada94ba 1723 }
9342ecf0 1724 assert((s->frame_bits & 7) == 0);
3ada94ba 1725
445a7d48
AK
1726 pkt->size = s->frame_bits / 8;
1727 *got_packet = !!pkt->size;
1728 return 0;
3ada94ba
BF
1729}
1730
9342ecf0
AD
1731static inline void dct_single_coeff_elimination(MpegEncContext *s,
1732 int n, int threshold)
3ada94ba 1733{
9342ecf0
AD
1734 static const char tab[64] = {
1735 3, 2, 2, 1, 1, 1, 1, 1,
1736 1, 1, 1, 1, 1, 1, 1, 1,
1737 1, 1, 1, 1, 1, 1, 1, 1,
1738 0, 0, 0, 0, 0, 0, 0, 0,
1739 0, 0, 0, 0, 0, 0, 0, 0,
1740 0, 0, 0, 0, 0, 0, 0, 0,
1741 0, 0, 0, 0, 0, 0, 0, 0,
1742 0, 0, 0, 0, 0, 0, 0, 0
1743 };
1744 int score = 0;
1745 int run = 0;
3ada94ba 1746 int i;
88bd7fdc 1747 int16_t *block = s->block[n];
9342ecf0 1748 const int last_index = s->block_last_index[n];
3ada94ba
BF
1749 int skip_dc;
1750
9342ecf0
AD
1751 if (threshold < 0) {
1752 skip_dc = 0;
1753 threshold = -threshold;
1754 } else
1755 skip_dc = 1;
3ada94ba 1756
bd107136 1757 /* Are all we could set to zero already zero? */
9342ecf0
AD
1758 if (last_index <= skip_dc - 1)
1759 return;
3ada94ba 1760
9342ecf0 1761 for (i = 0; i <= last_index; i++) {
3ada94ba
BF
1762 const int j = s->intra_scantable.permutated[i];
1763 const int level = FFABS(block[j]);
9342ecf0
AD
1764 if (level == 1) {
1765 if (skip_dc && i == 0)
1766 continue;
1767 score += tab[run];
1768 run = 0;
1769 } else if (level > 1) {
3ada94ba 1770 return;
9342ecf0 1771 } else {
3ada94ba
BF
1772 run++;
1773 }
1774 }
9342ecf0
AD
1775 if (score >= threshold)
1776 return;
1777 for (i = skip_dc; i <= last_index; i++) {
3ada94ba 1778 const int j = s->intra_scantable.permutated[i];
9342ecf0 1779 block[j] = 0;
3ada94ba 1780 }
9342ecf0
AD
1781 if (block[0])
1782 s->block_last_index[n] = 0;
1783 else
1784 s->block_last_index[n] = -1;
3ada94ba
BF
1785}
1786
88bd7fdc 1787static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
9342ecf0 1788 int last_index)
3ada94ba
BF
1789{
1790 int i;
9342ecf0
AD
1791 const int maxlevel = s->max_qcoeff;
1792 const int minlevel = s->min_qcoeff;
1793 int overflow = 0;
3ada94ba 1794
9342ecf0
AD
1795 if (s->mb_intra) {
1796 i = 1; // skip clipping of intra dc
1797 } else
1798 i = 0;
3ada94ba 1799
9342ecf0
AD
1800 for (; i <= last_index; i++) {
1801 const int j = s->intra_scantable.permutated[i];
3ada94ba
BF
1802 int level = block[j];
1803
9342ecf0
AD
1804 if (level > maxlevel) {
1805 level = maxlevel;
3ada94ba 1806 overflow++;
9342ecf0
AD
1807 } else if (level < minlevel) {
1808 level = minlevel;
3ada94ba
BF
1809 overflow++;
1810 }
1811
9342ecf0 1812 block[j] = level;
3ada94ba
BF
1813 }
1814
9342ecf0
AD
1815 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1816 av_log(s->avctx, AV_LOG_INFO,
1817 "warning, clipping %d dct coefficients to %d..%d\n",
1818 overflow, minlevel, maxlevel);
3ada94ba
BF
1819}
1820
9342ecf0
AD
1821static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1822{
3ada94ba 1823 int x, y;
9342ecf0
AD
1824 // FIXME optimize
1825 for (y = 0; y < 8; y++) {
1826 for (x = 0; x < 8; x++) {
3ada94ba 1827 int x2, y2;
9342ecf0
AD
1828 int sum = 0;
1829 int sqr = 0;
1830 int count = 0;
3ada94ba 1831
9342ecf0
AD
1832 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1833 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1834 int v = ptr[x2 + y2 * stride];
3ada94ba 1835 sum += v;
9342ecf0 1836 sqr += v * v;
3ada94ba
BF
1837 count++;
1838 }
1839 }
9342ecf0 1840 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
3ada94ba
BF
1841 }
1842 }
1843}
1844
9342ecf0
AD
1845static av_always_inline void encode_mb_internal(MpegEncContext *s,
1846 int motion_x, int motion_y,
1847 int mb_block_height,
1848 int mb_block_count)
3ada94ba
BF
1849{
1850 int16_t weight[8][64];
88bd7fdc 1851 int16_t orig[8][64];
9342ecf0
AD
1852 const int mb_x = s->mb_x;
1853 const int mb_y = s->mb_y;
3ada94ba
BF
1854 int i;
1855 int skip_dct[8];
9342ecf0 1856 int dct_offset = s->linesize * 8; // default for progressive frames
3ada94ba 1857 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
93f30547 1858 ptrdiff_t wrap_y, wrap_c;
3ada94ba 1859
9342ecf0
AD
1860 for (i = 0; i < mb_block_count; i++)
1861 skip_dct[i] = s->skipdct;
3ada94ba 1862
9342ecf0
AD
1863 if (s->adaptive_quant) {
1864 const int last_qp = s->qscale;
1865 const int mb_xy = mb_x + mb_y * s->mb_stride;
3ada94ba 1866
9342ecf0 1867 s->lambda = s->lambda_table[mb_xy];
3ada94ba
BF
1868 update_qscale(s);
1869
ff71a383 1870 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
759001c5 1871 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
9342ecf0 1872 s->dquant = s->qscale - last_qp;
3ada94ba 1873
9342ecf0
AD
1874 if (s->out_format == FMT_H263) {
1875 s->dquant = av_clip(s->dquant, -2, 2);
3ada94ba 1876
36ef5369 1877 if (s->codec_id == AV_CODEC_ID_MPEG4) {
9342ecf0
AD
1878 if (!s->mb_intra) {
1879 if (s->pict_type == AV_PICTURE_TYPE_B) {
1880 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1881 s->dquant = 0;
3ada94ba 1882 }
9342ecf0
AD
1883 if (s->mv_type == MV_TYPE_8X8)
1884 s->dquant = 0;
3ada94ba
BF
1885 }
1886 }
1887 }
1888 }
1889 ff_set_qscale(s, last_qp + s->dquant);
ff71a383 1890 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
3ada94ba
BF
1891 ff_set_qscale(s, s->qscale + s->dquant);
1892
1893 wrap_y = s->linesize;
1894 wrap_c = s->uvlinesize;
f6774f90 1895 ptr_y = s->new_picture.f->data[0] +
9342ecf0 1896 (mb_y * 16 * wrap_y) + mb_x * 16;
f6774f90 1897 ptr_cb = s->new_picture.f->data[1] +
9342ecf0 1898 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
f6774f90 1899 ptr_cr = s->new_picture.f->data[2] +
9342ecf0
AD
1900 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1901
1902 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1903 uint8_t *ebuf = s->edge_emu_buffer + 32;
458446ac
RB
1904 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1905 wrap_y, wrap_y,
1906 16, 16, mb_x * 16, mb_y * 16,
1907 s->width, s->height);
9342ecf0 1908 ptr_y = ebuf;
458446ac
RB
1909 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1910 wrap_c, wrap_c,
1911 8, mb_block_height, mb_x * 8, mb_y * 8,
8c53d39e 1912 s->width >> 1, s->height >> 1);
9342ecf0 1913 ptr_cb = ebuf + 18 * wrap_y;
458446ac
RB
1914 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1915 wrap_c, wrap_c,
1916 8, mb_block_height, mb_x * 8, mb_y * 8,
8c53d39e 1917 s->width >> 1, s->height >> 1);
9342ecf0 1918 ptr_cr = ebuf + 18 * wrap_y + 8;
3ada94ba
BF
1919 }
1920
1921 if (s->mb_intra) {
9342ecf0 1922 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1923 int progressive_score, interlaced_score;
1924
9342ecf0
AD
1925 s->interlaced_dct = 0;
1926 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1927 NULL, wrap_y, 8) +
1928 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1929 NULL, wrap_y, 8) - 400;
1930
1931 if (progressive_score > 0) {
1932 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1933 NULL, wrap_y * 2, 8) +
1934 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1935 NULL, wrap_y * 2, 8);
1936 if (progressive_score > interlaced_score) {
1937 s->interlaced_dct = 1;
1938
1939 dct_offset = wrap_y;
1940 wrap_y <<= 1;
3ada94ba 1941 if (s->chroma_format == CHROMA_422)
9342ecf0 1942 wrap_c <<= 1;
3ada94ba
BF
1943 }
1944 }
1945 }
1946
f46bb608
DB
1947 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
1948 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
1949 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
1950 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3ada94ba 1951
9342ecf0
AD
1952 if (s->flags & CODEC_FLAG_GRAY) {
1953 skip_dct[4] = 1;
1954 skip_dct[5] = 1;
1955 } else {
f46bb608
DB
1956 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1957 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
9342ecf0 1958 if (!s->chroma_y_shift) { /* 422 */
f46bb608
DB
1959 s->pdsp.get_pixels(s->block[6],
1960 ptr_cb + (dct_offset >> 1), wrap_c);
1961 s->pdsp.get_pixels(s->block[7],
1962 ptr_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
1963 }
1964 }
9342ecf0 1965 } else {
3ada94ba
BF
1966 op_pixels_func (*op_pix)[4];
1967 qpel_mc_func (*op_qpix)[16];
1968 uint8_t *dest_y, *dest_cb, *dest_cr;
1969
1970 dest_y = s->dest[0];
1971 dest_cb = s->dest[1];
1972 dest_cr = s->dest[2];
1973
9342ecf0 1974 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
f4fed5a2 1975 op_pix = s->hdsp.put_pixels_tab;
368f5035 1976 op_qpix = s->qdsp.put_qpel_pixels_tab;
9342ecf0 1977 } else {
f4fed5a2 1978 op_pix = s->hdsp.put_no_rnd_pixels_tab;
368f5035 1979 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
3ada94ba
BF
1980 }
1981
1982 if (s->mv_dir & MV_DIR_FORWARD) {
7a851153 1983 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
f6774f90 1984 s->last_picture.f->data,
7a851153 1985 op_pix, op_qpix);
f4fed5a2 1986 op_pix = s->hdsp.avg_pixels_tab;
368f5035 1987 op_qpix = s->qdsp.avg_qpel_pixels_tab;
3ada94ba
BF
1988 }
1989 if (s->mv_dir & MV_DIR_BACKWARD) {
7a851153 1990 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
f6774f90 1991 s->next_picture.f->data,
7a851153 1992 op_pix, op_qpix);
3ada94ba
BF
1993 }
1994
9342ecf0 1995 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1996 int progressive_score, interlaced_score;
1997
9342ecf0
AD
1998 s->interlaced_dct = 0;
1999 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
2000 ptr_y, wrap_y,
2001 8) +
2002 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
2003 ptr_y + wrap_y * 8, wrap_y,
2004 8) - 400;
2005
2006 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2007 progressive_score -= 400;
2008
2009 if (progressive_score > 0) {
2010 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
2011 ptr_y,
2012 wrap_y * 2, 8) +
2013 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
2014 ptr_y + wrap_y,
2015 wrap_y * 2, 8);
2016
2017 if (progressive_score > interlaced_score) {
2018 s->interlaced_dct = 1;
2019
2020 dct_offset = wrap_y;
2021 wrap_y <<= 1;
3ada94ba 2022 if (s->chroma_format == CHROMA_422)
9342ecf0 2023 wrap_c <<= 1;
3ada94ba
BF
2024 }
2025 }
2026 }
2027
f46bb608
DB
2028 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2029 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2030 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2031 dest_y + dct_offset, wrap_y);
2032 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2033 dest_y + dct_offset + 8, wrap_y);
3ada94ba 2034
9342ecf0
AD
2035 if (s->flags & CODEC_FLAG_GRAY) {
2036 skip_dct[4] = 1;
2037 skip_dct[5] = 1;
2038 } else {
f46bb608
DB
2039 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2040 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
9342ecf0 2041 if (!s->chroma_y_shift) { /* 422 */
f46bb608
DB
2042 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2043 dest_cb + (dct_offset >> 1), wrap_c);
2044 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2045 dest_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
2046 }
2047 }
2048 /* pre quantization */
9342ecf0
AD
2049 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2050 2 * s->qscale * s->qscale) {
2051 // FIXME optimize
2052 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
2053 wrap_y, 8) < 20 * s->qscale)
2054 skip_dct[0] = 1;
2055 if (s->dsp.sad[1](NULL, ptr_y + 8,
2056 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2057 skip_dct[1] = 1;
2058 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
2059 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
2060 skip_dct[2] = 1;
2061 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
2062 dest_y + dct_offset + 8,
2063 wrap_y, 8) < 20 * s->qscale)
2064 skip_dct[3] = 1;
2065 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2066 wrap_c, 8) < 20 * s->qscale)
2067 skip_dct[4] = 1;
2068 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2069 wrap_c, 8) < 20 * s->qscale)
2070 skip_dct[5] = 1;
2071 if (!s->chroma_y_shift) { /* 422 */
2072 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2073 dest_cb + (dct_offset >> 1),
2074 wrap_c, 8) < 20 * s->qscale)
2075 skip_dct[6] = 1;
2076 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2077 dest_cr + (dct_offset >> 1),
2078 wrap_c, 8) < 20 * s->qscale)
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){
efd29844 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)
2343 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2344 else if(w==8 && h==8)
2345 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
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){
f6774f90 2367 return s->dsp.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->dsp.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->dsp.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{
f6774f90 2371 return s->dsp.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->dsp.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->dsp.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)
efd29844 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
efd29844 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 3156 MERGE(er.error_count);
3ada94ba 3157 MERGE(padding_bug_score);
f6774f90 3158 MERGE(current_picture.f->error[0]);
3159 MERGE(current_picture.f->error[1]);
3160 MERGE(current_picture.f->error[2]);
3ada94ba
BF
3161
3162 if(dst->avctx->noise_reduction){
3163 for(i=0; i<64; i++){
3164 MERGE(dct_error_sum[0][i]);
3165 MERGE(dct_error_sum[1][i]);
3166 }
3167 }
3168
3169 assert(put_bits_count(&src->pb) % 8 ==0);
3170 assert(put_bits_count(&dst->pb) % 8 ==0);
9f51c682 3171 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3ada94ba
BF
3172 flush_put_bits(&dst->pb);
3173}
3174
3175static int estimate_qp(MpegEncContext *s, int dry_run){
3176 if (s->next_lambda){
f6774f90 3177 s->current_picture_ptr->f->quality =
3178 s->current_picture.f->quality = s->next_lambda;
3ada94ba
BF
3179 if(!dry_run) s->next_lambda= 0;
3180 } else if (!s->fixed_qscale) {
f6774f90 3181 s->current_picture_ptr->f->quality =
3182 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3183 if (s->current_picture.f->quality < 0)
3ada94ba
BF
3184 return -1;