hevc: parse display orientation SEI message
[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"
3ada94ba 40#include "dsputil.h"
e3fcb143 41#include "idctdsp.h"
eee2000b 42#include "mpeg12.h"
3ada94ba 43#include "mpegvideo.h"
66ac3dbf 44#include "h261.h"
c46eeae2 45#include "h263.h"
adcb8392 46#include "mjpegenc_common.h"
9734b8ba 47#include "mathops.h"
e0c16e4e 48#include "mpegutils.h"
3ada94ba
BF
49#include "mjpegenc.h"
50#include "msmpeg4.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);
368f5035
DB
706 ff_qpeldsp_init(&s->qdsp);
707
f6774f90 708 s->avctx->coded_frame = s->current_picture.f;
1f8eb690
AK
709
710 if (s->msmpeg4_version) {
711 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
712 2 * 2 * (MAX_LEVEL + 1) *
713 (MAX_RUN + 1) * 2 * sizeof(int), fail);
714 }
715 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
716
717 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
719 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
720 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
722 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
723 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
724 MAX_PICTURE_COUNT * sizeof(Picture *), fail);
725
726 if (s->avctx->noise_reduction) {
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
728 2 * 64 * sizeof(uint16_t), fail);
729 }
730
cff480e4
MS
731 if (CONFIG_H263_ENCODER)
732 ff_h263dsp_init(&s->h263dsp);
bd96be6e 733 if (!s->dct_quantize)
99560a4c 734 s->dct_quantize = ff_dct_quantize_c;
bd96be6e
AD
735 if (!s->denoise_dct)
736 s->denoise_dct = denoise_dct_c;
53727262 737 s->fast_dct_quantize = s->dct_quantize;
bd96be6e
AD
738 if (avctx->trellis)
739 s->dct_quantize = dct_quantize_trellis_c;
53727262 740
bd96be6e
AD
741 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
742 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
01bc48f4 743
bd96be6e 744 s->quant_precision = 5;
3ada94ba
BF
745
746 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
747 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
748
49fb20cb 749 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
3ada94ba 750 ff_h261_encode_init(s);
f34121f3 751 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
ddce8953 752 ff_h263_encode_init(s);
49fb20cb 753 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3ada94ba 754 ff_msmpeg4_encode_init(s);
49fb20cb 755 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
a6bc5731 756 && s->out_format == FMT_MPEG1)
3ada94ba
BF
757 ff_mpeg1_encode_init(s);
758
759 /* init q matrix */
bd96be6e 760 for (i = 0; i < 64; i++) {
e3fcb143 761 int j = s->idsp.idct_permutation[i];
36ef5369 762 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
bd96be6e 763 s->mpeg_quant) {
3ada94ba
BF
764 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
765 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
bd96be6e 766 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
3ada94ba
BF
767 s->intra_matrix[j] =
768 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
bd96be6e
AD
769 } else {
770 /* mpeg1/2 */
3ada94ba
BF
771 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
772 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
773 }
bd96be6e 774 if (s->avctx->intra_matrix)
3ada94ba 775 s->intra_matrix[j] = s->avctx->intra_matrix[i];
bd96be6e 776 if (s->avctx->inter_matrix)
3ada94ba
BF
777 s->inter_matrix[j] = s->avctx->inter_matrix[i];
778 }
779
780 /* precompute matrix */
781 /* for mjpeg, we do include qscale in the matrix */
782 if (s->out_format != FMT_MJPEG) {
5dd8c08f 783 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
bd96be6e
AD
784 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
785 31, 1);
5dd8c08f 786 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
bd96be6e
AD
787 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
788 31, 0);
3ada94ba
BF
789 }
790
bd96be6e 791 if (ff_rate_control_init(s) < 0)
3ada94ba
BF
792 return -1;
793
8941971a
AK
794#if FF_API_ERROR_RATE
795 FF_DISABLE_DEPRECATION_WARNINGS
796 if (avctx->error_rate)
797 s->error_rate = avctx->error_rate;
798 FF_ENABLE_DEPRECATION_WARNINGS;
799#endif
800
b2c31710
AK
801#if FF_API_NORMALIZE_AQP
802 FF_DISABLE_DEPRECATION_WARNINGS
803 if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
804 s->mpv_flags |= FF_MPV_FLAG_NAQ;
805 FF_ENABLE_DEPRECATION_WARNINGS;
806#endif
807
a2941c8c
AK
808#if FF_API_MV0
809 FF_DISABLE_DEPRECATION_WARNINGS
810 if (avctx->flags & CODEC_FLAG_MV0)
811 s->mpv_flags |= FF_MPV_FLAG_MV0;
812 FF_ENABLE_DEPRECATION_WARNINGS
813#endif
814
1c01b025
AK
815 if (avctx->b_frame_strategy == 2) {
816 for (i = 0; i < s->max_b_frames + 2; i++) {
817 s->tmp_frames[i] = av_frame_alloc();
818 if (!s->tmp_frames[i])
819 return AVERROR(ENOMEM);
820
821 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
822 s->tmp_frames[i]->width = s->width >> avctx->brd_scale;
823 s->tmp_frames[i]->height = s->height >> avctx->brd_scale;
824
825 ret = av_frame_get_buffer(s->tmp_frames[i], 32);
826 if (ret < 0)
827 return ret;
828 }
829 }
830
3ada94ba 831 return 0;
1f8eb690
AK
832fail:
833 ff_MPV_encode_end(avctx);
834 return AVERROR_UNKNOWN;
3ada94ba
BF
835}
836
efd29844 837av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
3ada94ba
BF
838{
839 MpegEncContext *s = avctx->priv_data;
1c01b025 840 int i;
3ada94ba
BF
841
842 ff_rate_control_uninit(s);
843
efd29844 844 ff_MPV_common_end(s);
24abd806 845 if (CONFIG_MJPEG_ENCODER &&
bd96be6e 846 s->out_format == FMT_MJPEG)
3ada94ba
BF
847 ff_mjpeg_encode_close(s);
848
849 av_freep(&avctx->extradata);
850
1c01b025
AK
851 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
852 av_frame_free(&s->tmp_frames[i]);
853
0b0a7a75
AK
854 ff_free_picture_tables(&s->new_picture);
855 ff_mpeg_unref_picture(s, &s->new_picture);
856
857 av_freep(&s->avctx->stats_out);
858 av_freep(&s->ac_stats);
859
860 av_freep(&s->q_intra_matrix);
861 av_freep(&s->q_inter_matrix);
862 av_freep(&s->q_intra_matrix16);
863 av_freep(&s->q_inter_matrix16);
864 av_freep(&s->input_picture);
865 av_freep(&s->reordered_input_picture);
866 av_freep(&s->dct_offset);
867
3ada94ba
BF
868 return 0;
869}
870
bd96be6e
AD
871static int get_sae(uint8_t *src, int ref, int stride)
872{
3ada94ba 873 int x,y;
bd96be6e 874 int acc = 0;
3ada94ba 875
bd96be6e
AD
876 for (y = 0; y < 16; y++) {
877 for (x = 0; x < 16; x++) {
878 acc += FFABS(src[x + y * stride] - ref);
3ada94ba
BF
879 }
880 }
881
882 return acc;
883}
884
bd96be6e
AD
885static int get_intra_count(MpegEncContext *s, uint8_t *src,
886 uint8_t *ref, int stride)
887{
3ada94ba 888 int x, y, w, h;
bd96be6e 889 int acc = 0;
3ada94ba 890
bd96be6e
AD
891 w = s->width & ~15;
892 h = s->height & ~15;
3ada94ba 893
bd96be6e
AD
894 for (y = 0; y < h; y += 16) {
895 for (x = 0; x < w; x += 16) {
896 int offset = x + y * stride;
897 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
898 16);
c1661484 899 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
bd96be6e 900 int sae = get_sae(src + offset, mean, stride);
3ada94ba 901
bd96be6e 902 acc += sae + 500 < sad;
3ada94ba
BF
903 }
904 }
905 return acc;
906}
907
908
3f47d316 909static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
bd96be6e 910{
759001c5 911 Picture *pic = NULL;
3ada94ba 912 int64_t pts;
759001c5 913 int i, display_picture_number = 0, ret;
54553842
AK
914 const int encoding_delay = s->max_b_frames ? s->max_b_frames :
915 (s->low_delay ? 0 : 1);
bd96be6e
AD
916 int direct = 1;
917
918 if (pic_arg) {
919 pts = pic_arg->pts;
3f47d316 920 display_picture_number = s->input_picture_number++;
bd96be6e
AD
921
922 if (pts != AV_NOPTS_VALUE) {
923 if (s->user_specified_pts != AV_NOPTS_VALUE) {
924 int64_t time = pts;
925 int64_t last = s->user_specified_pts;
926
927 if (time <= last) {
928 av_log(s->avctx, AV_LOG_ERROR,
929 "Error, Invalid timestamp=%"PRId64", "
930 "last=%"PRId64"\n", pts, s->user_specified_pts);
3ada94ba
BF
931 return -1;
932 }
445a7d48 933
3f47d316 934 if (!s->low_delay && display_picture_number == 1)
445a7d48 935 s->dts_delta = time - last;
3ada94ba 936 }
bd96be6e
AD
937 s->user_specified_pts = pts;
938 } else {
939 if (s->user_specified_pts != AV_NOPTS_VALUE) {
940 s->user_specified_pts =
941 pts = s->user_specified_pts + 1;
942 av_log(s->avctx, AV_LOG_INFO,
943 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
944 pts);
945 } else {
3f47d316 946 pts = display_picture_number;
3ada94ba
BF
947 }
948 }
949 }
950
04f4dbc2 951 if (pic_arg) {
759001c5 952 if (!pic_arg->buf[0]);
04f4dbc2
AK
953 direct = 0;
954 if (pic_arg->linesize[0] != s->linesize)
955 direct = 0;
956 if (pic_arg->linesize[1] != s->uvlinesize)
957 direct = 0;
958 if (pic_arg->linesize[2] != s->uvlinesize)
959 direct = 0;
960
93f30547 961 av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
04f4dbc2
AK
962 pic_arg->linesize[1], s->linesize, s->uvlinesize);
963
964 if (direct) {
965 i = ff_find_unused_picture(s, 1);
966 if (i < 0)
967 return i;
968
759001c5 969 pic = &s->picture[i];
04f4dbc2
AK
970 pic->reference = 3;
971
f6774f90 972 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
759001c5
AK
973 return ret;
974 if (ff_alloc_picture(s, pic, 1) < 0) {
04f4dbc2
AK
975 return -1;
976 }
977 } else {
978 i = ff_find_unused_picture(s, 0);
979 if (i < 0)
980 return i;
3ada94ba 981
759001c5 982 pic = &s->picture[i];
04f4dbc2 983 pic->reference = 3;
3ada94ba 984
759001c5 985 if (ff_alloc_picture(s, pic, 0) < 0) {
04f4dbc2
AK
986 return -1;
987 }
3ada94ba 988
f6774f90 989 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
990 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
991 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
04f4dbc2
AK
992 // empty
993 } else {
994 int h_chroma_shift, v_chroma_shift;
995 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
996 &h_chroma_shift,
997 &v_chroma_shift);
998
999 for (i = 0; i < 3; i++) {
1000 int src_stride = pic_arg->linesize[i];
1001 int dst_stride = i ? s->uvlinesize : s->linesize;
1002 int h_shift = i ? h_chroma_shift : 0;
1003 int v_shift = i ? v_chroma_shift : 0;
1004 int w = s->width >> h_shift;
1005 int h = s->height >> v_shift;
1006 uint8_t *src = pic_arg->data[i];
f6774f90 1007 uint8_t *dst = pic->f->data[i];
04f4dbc2
AK
1008
1009 if (!s->avctx->rc_buffer_size)
1010 dst += INPLACE_OFFSET;
1011
1012 if (src_stride == dst_stride)
1013 memcpy(dst, src, src_stride * h);
1014 else {
1015 while (h--) {
1016 memcpy(dst, src, w);
1017 dst += dst_stride;
1018 src += src_stride;
1019 }
3ada94ba
BF
1020 }
1021 }
1022 }
1023 }
f6774f90 1024 ret = av_frame_copy_props(pic->f, pic_arg);
22c87905
VG
1025 if (ret < 0)
1026 return ret;
1027
f6774f90 1028 pic->f->display_picture_number = display_picture_number;
1029 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
3ada94ba 1030 }
3ada94ba
BF
1031
1032 /* shift buffer entries */
bd96be6e
AD
1033 for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1034 s->input_picture[i - 1] = s->input_picture[i];
3ada94ba 1035
bd96be6e 1036 s->input_picture[encoding_delay] = (Picture*) pic;
3ada94ba
BF
1037
1038 return 0;
1039}
1040
bd96be6e
AD
1041static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1042{
3ada94ba 1043 int x, y, plane;
bd96be6e
AD
1044 int score = 0;
1045 int64_t score64 = 0;
3ada94ba 1046
bd96be6e 1047 for (plane = 0; plane < 3; plane++) {
f6774f90 1048 const int stride = p->f->linesize[plane];
bd96be6e
AD
1049 const int bw = plane ? 1 : 2;
1050 for (y = 0; y < s->mb_height * bw; y++) {
1051 for (x = 0; x < s->mb_width * bw; x++) {
759001c5 1052 int off = p->shared ? 0 : 16;
f6774f90 1053 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1054 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
bd96be6e
AD
1055 int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1056
1057 switch (s->avctx->frame_skip_exp) {
1058 case 0: score = FFMAX(score, v); break;
1059 case 1: score += FFABS(v); break;
1060 case 2: score += v * v; break;
1061 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1062 case 4: score64 += v * v * (int64_t)(v * v); break;
3ada94ba
BF
1063 }
1064 }
1065 }
1066 }
1067
bd96be6e
AD
1068 if (score)
1069 score64 = score;
3ada94ba 1070
bd96be6e 1071 if (score64 < s->avctx->frame_skip_threshold)
3ada94ba 1072 return 1;
bd96be6e 1073 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
3ada94ba
BF
1074 return 1;
1075 return 0;
1076}
1077
7f9aaa49
AK
1078static int encode_frame(AVCodecContext *c, AVFrame *frame)
1079{
1080 AVPacket pkt = { 0 };
1081 int ret, got_output;
1082
1083 av_init_packet(&pkt);
7f9aaa49
AK
1084 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1085 if (ret < 0)
1086 return ret;
1087
1088 ret = pkt.size;
1089 av_free_packet(&pkt);
1090 return ret;
1091}
1092
bd96be6e
AD
1093static int estimate_best_b_count(MpegEncContext *s)
1094{
9342ecf0 1095 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
71a861cf 1096 AVCodecContext *c = avcodec_alloc_context3(NULL);
bd96be6e 1097 const int scale = s->avctx->brd_scale;
3ada94ba 1098 int i, j, out_size, p_lambda, b_lambda, lambda2;
bd96be6e
AD
1099 int64_t best_rd = INT64_MAX;
1100 int best_b_count = -1;
1101
1102 assert(scale >= 0 && scale <= 3);
1103
1104 //emms_c();
1105 //s->next_picture_ptr->quality;
1106 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1107 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1108 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1109 if (!b_lambda) // FIXME we should do this somewhere else
1110 b_lambda = p_lambda;
1111 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1112 FF_LAMBDA_SHIFT;
1113
1114 c->width = s->width >> scale;
1115 c->height = s->height >> scale;
5fccedaa 1116 c->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
bd96be6e
AD
1117 c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1118 c->mb_decision = s->avctx->mb_decision;
1119 c->me_cmp = s->avctx->me_cmp;
1120 c->mb_cmp = s->avctx->mb_cmp;
1121 c->me_sub_cmp = s->avctx->me_sub_cmp;
716d413c 1122 c->pix_fmt = AV_PIX_FMT_YUV420P;
bd96be6e
AD
1123 c->time_base = s->avctx->time_base;
1124 c->max_b_frames = s->max_b_frames;
3ada94ba 1125
0b950fe2 1126 if (avcodec_open2(c, codec, NULL) < 0)
3ada94ba
BF
1127 return -1;
1128
9342ecf0 1129 for (i = 0; i < s->max_b_frames + 2; i++) {
9342ecf0
AD
1130 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1131 s->next_picture_ptr;
3ada94ba 1132
9342ecf0
AD
1133 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1134 pre_input = *pre_input_ptr;
3ada94ba 1135
759001c5 1136 if (!pre_input.shared && i) {
f6774f90 1137 pre_input.f->data[0] += INPLACE_OFFSET;
1138 pre_input.f->data[1] += INPLACE_OFFSET;
1139 pre_input.f->data[2] += INPLACE_OFFSET;
3ada94ba
BF
1140 }
1141
c1661484
DB
1142 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1143 s->tmp_frames[i]->linesize[0],
1144 pre_input.f->data[0],
1145 pre_input.f->linesize[0],
1146 c->width, c->height);
1147 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1148 s->tmp_frames[i]->linesize[1],
1149 pre_input.f->data[1],
1150 pre_input.f->linesize[1],
1151 c->width >> 1, c->height >> 1);
1152 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1153 s->tmp_frames[i]->linesize[2],
1154 pre_input.f->data[2],
1155 pre_input.f->linesize[2],
1156 c->width >> 1, c->height >> 1);
3ada94ba
BF
1157 }
1158 }
1159
9342ecf0
AD
1160 for (j = 0; j < s->max_b_frames + 1; j++) {
1161 int64_t rd = 0;
3ada94ba 1162
9342ecf0 1163 if (!s->input_picture[j])
3ada94ba
BF
1164 break;
1165
9342ecf0 1166 c->error[0] = c->error[1] = c->error[2] = 0;
3ada94ba 1167
1c01b025
AK
1168 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1169 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
7f9aaa49 1170
1c01b025 1171 out_size = encode_frame(c, s->tmp_frames[0]);
7f9aaa49 1172
9342ecf0 1173 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
3ada94ba 1174
9342ecf0
AD
1175 for (i = 0; i < s->max_b_frames + 1; i++) {
1176 int is_p = i % (j + 1) == j || i == s->max_b_frames;
3ada94ba 1177
1c01b025 1178 s->tmp_frames[i + 1]->pict_type = is_p ?
9342ecf0 1179 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1c01b025 1180 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
7f9aaa49 1181
1c01b025 1182 out_size = encode_frame(c, s->tmp_frames[i + 1]);
7f9aaa49 1183
3ada94ba
BF
1184 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1185 }
1186
1187 /* get the delayed frames */
9342ecf0 1188 while (out_size) {
7f9aaa49 1189 out_size = encode_frame(c, NULL);
3ada94ba
BF
1190 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1191 }
1192
1193 rd += c->error[0] + c->error[1] + c->error[2];
1194
9342ecf0
AD
1195 if (rd < best_rd) {
1196 best_rd = rd;
1197 best_b_count = j;
3ada94ba
BF
1198 }
1199 }
1200
3ada94ba
BF
1201 avcodec_close(c);
1202 av_freep(&c);
1203
3ada94ba
BF
1204 return best_b_count;
1205}
1206
9342ecf0
AD
1207static int select_input_picture(MpegEncContext *s)
1208{
759001c5 1209 int i, ret;
3ada94ba 1210
9342ecf0
AD
1211 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1212 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1213 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
3ada94ba
BF
1214
1215 /* set next picture type & ordering */
9342ecf0
AD
1216 if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1217 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1218 s->next_picture_ptr == NULL || s->intra_only) {
1219 s->reordered_input_picture[0] = s->input_picture[0];
f6774f90 1220 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1221 s->reordered_input_picture[0]->f->coded_picture_number =
9342ecf0
AD
1222 s->coded_picture_number++;
1223 } else {
3ada94ba
BF
1224 int b_frames;
1225
9342ecf0
AD
1226 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1227 if (s->picture_in_gop_number < s->gop_size &&
1228 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1229 // FIXME check that te gop check above is +-1 correct
f6774f90 1230 av_frame_unref(s->input_picture[0]->f);
3ada94ba
BF
1231
1232 emms_c();
1233 ff_vbv_update(s, 0);
1234
1235 goto no_output_pic;
1236 }
1237 }
1238
9342ecf0
AD
1239 if (s->flags & CODEC_FLAG_PASS2) {
1240 for (i = 0; i < s->max_b_frames + 1; i++) {
f6774f90 1241 int pict_num = s->input_picture[0]->f->display_picture_number + i;
3ada94ba 1242
9342ecf0 1243 if (pict_num >= s->rc_context.num_entries)
3ada94ba 1244 break;
9342ecf0
AD
1245 if (!s->input_picture[i]) {
1246 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
3ada94ba
BF
1247 break;
1248 }
1249
f6774f90 1250 s->input_picture[i]->f->pict_type =
3ada94ba
BF
1251 s->rc_context.entry[pict_num].new_pict_type;
1252 }
1253 }
1254
9342ecf0
AD
1255 if (s->avctx->b_frame_strategy == 0) {
1256 b_frames = s->max_b_frames;
1257 while (b_frames && !s->input_picture[b_frames])
1258 b_frames--;
1259 } else if (s->avctx->b_frame_strategy == 1) {
1260 for (i = 1; i < s->max_b_frames + 1; i++) {
1261 if (s->input_picture[i] &&
1262 s->input_picture[i]->b_frame_score == 0) {
1263 s->input_picture[i]->b_frame_score =
1264 get_intra_count(s,
f6774f90 1265 s->input_picture[i ]->f->data[0],
1266 s->input_picture[i - 1]->f->data[0],
9342ecf0 1267 s->linesize) + 1;
3ada94ba
BF
1268 }
1269 }
9342ecf0
AD
1270 for (i = 0; i < s->max_b_frames + 1; i++) {
1271 if (s->input_picture[i] == NULL ||
1272 s->input_picture[i]->b_frame_score - 1 >
1273 s->mb_num / s->avctx->b_sensitivity)
1274 break;
3ada94ba
BF
1275 }
1276
9342ecf0 1277 b_frames = FFMAX(0, i - 1);
3ada94ba
BF
1278
1279 /* reset scores */
9342ecf0
AD
1280 for (i = 0; i < b_frames + 1; i++) {
1281 s->input_picture[i]->b_frame_score = 0;
3ada94ba 1282 }
9342ecf0
AD
1283 } else if (s->avctx->b_frame_strategy == 2) {
1284 b_frames = estimate_best_b_count(s);
1285 } else {
3ada94ba 1286 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
9342ecf0 1287 b_frames = 0;
3ada94ba
BF
1288 }
1289
1290 emms_c();
3ada94ba 1291
9342ecf0 1292 for (i = b_frames - 1; i >= 0; i--) {
f6774f90 1293 int type = s->input_picture[i]->f->pict_type;
9342ecf0
AD
1294 if (type && type != AV_PICTURE_TYPE_B)
1295 b_frames = i;
3ada94ba 1296 }
f6774f90 1297 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
9342ecf0
AD
1298 b_frames == s->max_b_frames) {
1299 av_log(s->avctx, AV_LOG_ERROR,
1300 "warning, too many b frames in a row\n");
3ada94ba
BF
1301 }
1302
9342ecf0 1303 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
a249f0cc 1304 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
9342ecf0
AD
1305 s->gop_size > s->picture_in_gop_number) {
1306 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1307 } else {
1308 if (s->flags & CODEC_FLAG_CLOSED_GOP)
1309 b_frames = 0;
f6774f90 1310 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
9342ecf0 1311 }
3ada94ba
BF
1312 }
1313
9342ecf0 1314 if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
f6774f90 1315 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
3ada94ba
BF
1316 b_frames--;
1317
9342ecf0 1318 s->reordered_input_picture[0] = s->input_picture[b_frames];
f6774f90 1319 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1320 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1321 s->reordered_input_picture[0]->f->coded_picture_number =
9342ecf0
AD
1322 s->coded_picture_number++;
1323 for (i = 0; i < b_frames; i++) {
657ccb5a 1324 s->reordered_input_picture[i + 1] = s->input_picture[i];
f6774f90 1325 s->reordered_input_picture[i + 1]->f->pict_type =
9342ecf0 1326 AV_PICTURE_TYPE_B;
f6774f90 1327 s->reordered_input_picture[i + 1]->f->coded_picture_number =
9342ecf0 1328 s->coded_picture_number++;
3ada94ba
BF
1329 }
1330 }
1331 }
1332no_output_pic:
9342ecf0 1333 if (s->reordered_input_picture[0]) {
759001c5 1334 s->reordered_input_picture[0]->reference =
f6774f90 1335 s->reordered_input_picture[0]->f->pict_type !=
9342ecf0 1336 AV_PICTURE_TYPE_B ? 3 : 0;
3ada94ba 1337
759001c5
AK
1338 ff_mpeg_unref_picture(s, &s->new_picture);
1339 if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1340 return ret;
3ada94ba 1341
759001c5 1342 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
9342ecf0
AD
1343 // input is a shared pix, so we can't modifiy it -> alloc a new
1344 // one & ensure that the shared one is reuseable
3ada94ba 1345
1ce1578e 1346 Picture *pic;
9342ecf0 1347 int i = ff_find_unused_picture(s, 0);
4f820131
AU
1348 if (i < 0)
1349 return i;
1ce1578e 1350 pic = &s->picture[i];
3ada94ba 1351
759001c5 1352 pic->reference = s->reordered_input_picture[0]->reference;
9342ecf0 1353 if (ff_alloc_picture(s, pic, 0) < 0) {
be548816
PP
1354 return -1;
1355 }
3ada94ba 1356
f6774f90 1357 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
22c87905
VG
1358 if (ret < 0)
1359 return ret;
3ada94ba 1360
759001c5 1361 /* mark us unused / free shared pic */
f6774f90 1362 av_frame_unref(s->reordered_input_picture[0]->f);
759001c5
AK
1363 s->reordered_input_picture[0]->shared = 0;
1364
9342ecf0
AD
1365 s->current_picture_ptr = pic;
1366 } else {
3ada94ba 1367 // input is not a shared pix -> reuse buffer for current_pix
9342ecf0
AD
1368 s->current_picture_ptr = s->reordered_input_picture[0];
1369 for (i = 0; i < 4; i++) {
f6774f90 1370 s->new_picture.f->data[i] += INPLACE_OFFSET;
3ada94ba
BF
1371 }
1372 }
759001c5
AK
1373 ff_mpeg_unref_picture(s, &s->current_picture);
1374 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1375 s->current_picture_ptr)) < 0)
1376 return ret;
3ada94ba 1377
f6774f90 1378 s->picture_number = s->new_picture.f->display_picture_number;
9342ecf0 1379 } else {
759001c5 1380 ff_mpeg_unref_picture(s, &s->new_picture);
3ada94ba 1381 }
be548816 1382 return 0;
3ada94ba
BF
1383}
1384
381a7225
AK
1385static void frame_end(MpegEncContext *s)
1386{
1387 int i;
1388
1389 if (s->unrestricted_mv &&
1390 s->current_picture.reference &&
1391 !s->intra_only) {
1392 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1393 int hshift = desc->log2_chroma_w;
1394 int vshift = desc->log2_chroma_h;
3c650efb
DB
1395 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1396 s->h_edge_pos, s->v_edge_pos,
1397 EDGE_WIDTH, EDGE_WIDTH,
1398 EDGE_TOP | EDGE_BOTTOM);
1399 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1400 s->h_edge_pos >> hshift,
1401 s->v_edge_pos >> vshift,
1402 EDGE_WIDTH >> hshift,
1403 EDGE_WIDTH >> vshift,
1404 EDGE_TOP | EDGE_BOTTOM);
1405 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1406 s->h_edge_pos >> hshift,
1407 s->v_edge_pos >> vshift,
1408 EDGE_WIDTH >> hshift,
1409 EDGE_WIDTH >> vshift,
1410 EDGE_TOP | EDGE_BOTTOM);
381a7225
AK
1411 }
1412
1413 emms_c();
1414
1415 s->last_pict_type = s->pict_type;
f6774f90 1416 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
381a7225
AK
1417 if (s->pict_type!= AV_PICTURE_TYPE_B)
1418 s->last_non_b_pict_type = s->pict_type;
1419
1420 if (s->encoding) {
1421 /* release non-reference frames */
1422 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1423 if (!s->picture[i].reference)
1424 ff_mpeg_unref_picture(s, &s->picture[i]);
1425 }
1426 }
1427
f6774f90 1428 s->avctx->coded_frame = s->current_picture_ptr->f;
381a7225
AK
1429
1430}
1431
aec25b1c
AK
1432static void update_noise_reduction(MpegEncContext *s)
1433{
1434 int intra, i;
1435
1436 for (intra = 0; intra < 2; intra++) {
1437 if (s->dct_count[intra] > (1 << 16)) {
1438 for (i = 0; i < 64; i++) {
1439 s->dct_error_sum[intra][i] >>= 1;
1440 }
1441 s->dct_count[intra] >>= 1;
1442 }
1443
1444 for (i = 0; i < 64; i++) {
1445 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1446 s->dct_count[intra] +
1447 s->dct_error_sum[intra][i] / 2) /
1448 (s->dct_error_sum[intra][i] + 1);
1449 }
1450 }
1451}
1452
1453static int frame_start(MpegEncContext *s)
1454{
1455 int ret;
1456
1457 /* mark & release old frames */
1458 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1459 s->last_picture_ptr != s->next_picture_ptr &&
f6774f90 1460 s->last_picture_ptr->f->buf[0]) {
aec25b1c
AK
1461 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1462 }
1463
f6774f90 1464 s->current_picture_ptr->f->pict_type = s->pict_type;
1465 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
aec25b1c
AK
1466
1467 ff_mpeg_unref_picture(s, &s->current_picture);
1468 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1469 s->current_picture_ptr)) < 0)
1470 return ret;
1471
1472 if (s->pict_type != AV_PICTURE_TYPE_B) {
1473 s->last_picture_ptr = s->next_picture_ptr;
1474 if (!s->droppable)
1475 s->next_picture_ptr = s->current_picture_ptr;
1476 }
1477
1478 if (s->last_picture_ptr) {
1479 ff_mpeg_unref_picture(s, &s->last_picture);
f6774f90 1480 if (s->last_picture_ptr->f->buf[0] &&
aec25b1c
AK
1481 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1482 s->last_picture_ptr)) < 0)
1483 return ret;
1484 }
1485 if (s->next_picture_ptr) {
1486 ff_mpeg_unref_picture(s, &s->next_picture);
f6774f90 1487 if (s->next_picture_ptr->f->buf[0] &&
aec25b1c
AK
1488 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1489 s->next_picture_ptr)) < 0)
1490 return ret;
1491 }
1492
1493 if (s->picture_structure!= PICT_FRAME) {
1494 int i;
1495 for (i = 0; i < 4; i++) {
1496 if (s->picture_structure == PICT_BOTTOM_FIELD) {
f6774f90 1497 s->current_picture.f->data[i] +=
1498 s->current_picture.f->linesize[i];
aec25b1c 1499 }
f6774f90 1500 s->current_picture.f->linesize[i] *= 2;
1501 s->last_picture.f->linesize[i] *= 2;
1502 s->next_picture.f->linesize[i] *= 2;
aec25b1c
AK
1503 }
1504 }
1505
1506 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1507 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1508 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1509 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1510 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1511 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1512 } else {
1513 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1514 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1515 }
1516
1517 if (s->dct_error_sum) {
1518 assert(s->avctx->noise_reduction && s->encoding);
1519 update_noise_reduction(s);
1520 }
1521
1522 return 0;
1523}
1524
445a7d48
AK
1525int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1526 const AVFrame *pic_arg, int *got_packet)
3ada94ba
BF
1527{
1528 MpegEncContext *s = avctx->priv_data;
445a7d48 1529 int i, stuffing_count, ret;
881a5e04 1530 int context_count = s->slice_context_count;
3ada94ba 1531
3ada94ba
BF
1532 s->picture_in_gop_number++;
1533
9342ecf0 1534 if (load_input_picture(s, pic_arg) < 0)
3ada94ba
BF
1535 return -1;
1536
9342ecf0 1537 if (select_input_picture(s) < 0) {
be548816
PP
1538 return -1;
1539 }
3ada94ba
BF
1540
1541 /* output? */
f6774f90 1542 if (s->new_picture.f->data[0]) {
5d42ac7f
AK
1543 if (!pkt->data &&
1544 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1545 return ret;
bdc1220e
MS
1546 if (s->mb_info) {
1547 s->mb_info_ptr = av_packet_new_side_data(pkt,
1548 AV_PKT_DATA_H263_MB_INFO,
1549 s->mb_width*s->mb_height*12);
1550 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1551 }
5d42ac7f
AK
1552
1553 for (i = 0; i < context_count; i++) {
1554 int start_y = s->thread_context[i]->start_mb_y;
1555 int end_y = s->thread_context[i]-> end_mb_y;
1556 int h = s->mb_height;
1557 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1558 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1559
1560 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1561 }
1562
f6774f90 1563 s->pict_type = s->new_picture.f->pict_type;
9342ecf0 1564 //emms_c();
aec25b1c
AK
1565 ret = frame_start(s);
1566 if (ret < 0)
1567 return ret;
3ada94ba
BF
1568vbv_retry:
1569 if (encode_picture(s, s->picture_number) < 0)
1570 return -1;
1571
3ada94ba
BF
1572 avctx->header_bits = s->header_bits;
1573 avctx->mv_bits = s->mv_bits;
1574 avctx->misc_bits = s->misc_bits;
1575 avctx->i_tex_bits = s->i_tex_bits;
1576 avctx->p_tex_bits = s->p_tex_bits;
1577 avctx->i_count = s->i_count;
9342ecf0
AD
1578 // FIXME f/b_count in avctx
1579 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
3ada94ba
BF
1580 avctx->skip_count = s->skip_count;
1581
381a7225 1582 frame_end(s);
3ada94ba 1583
49fb20cb 1584 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
3360ad99 1585 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
3ada94ba 1586
9342ecf0
AD
1587 if (avctx->rc_buffer_size) {
1588 RateControlContext *rcc = &s->rc_context;
1589 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
3ada94ba 1590
9342ecf0
AD
1591 if (put_bits_count(&s->pb) > max_size &&
1592 s->lambda < s->avctx->lmax) {
1593 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1594 (s->qscale + 1) / s->qscale);
1595 if (s->adaptive_quant) {
3ada94ba 1596 int i;
9342ecf0
AD
1597 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1598 s->lambda_table[i] =
1599 FFMAX(s->lambda_table[i] + 1,
1600 s->lambda_table[i] * (s->qscale + 1) /
1601 s->qscale);
3ada94ba 1602 }
aec25b1c 1603 s->mb_skipped = 0; // done in frame_start()
9342ecf0
AD
1604 // done in encode_picture() so we must undo it
1605 if (s->pict_type == AV_PICTURE_TYPE_P) {
1606 if (s->flipflop_rounding ||
36ef5369
AK
1607 s->codec_id == AV_CODEC_ID_H263P ||
1608 s->codec_id == AV_CODEC_ID_MPEG4)
3ada94ba
BF
1609 s->no_rounding ^= 1;
1610 }
9342ecf0
AD
1611 if (s->pict_type != AV_PICTURE_TYPE_B) {
1612 s->time_base = s->last_time_base;
1613 s->last_non_b_time = s->time - s->pp_time;
3ada94ba 1614 }
9342ecf0
AD
1615 for (i = 0; i < context_count; i++) {
1616 PutBitContext *pb = &s->thread_context[i]->pb;
3ada94ba
BF
1617 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1618 }
1619 goto vbv_retry;
1620 }
1621
1622 assert(s->avctx->rc_max_rate);
1623 }
1624
9342ecf0 1625 if (s->flags & CODEC_FLAG_PASS1)
3ada94ba
BF
1626 ff_write_pass1_stats(s);
1627
9342ecf0 1628 for (i = 0; i < 4; i++) {
f6774f90 1629 s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1630 avctx->error[i] += s->current_picture_ptr->f->error[i];
3ada94ba
BF
1631 }
1632
9342ecf0
AD
1633 if (s->flags & CODEC_FLAG_PASS1)
1634 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1635 avctx->i_tex_bits + avctx->p_tex_bits ==
1636 put_bits_count(&s->pb));
3ada94ba
BF
1637 flush_put_bits(&s->pb);
1638 s->frame_bits = put_bits_count(&s->pb);
1639
9342ecf0
AD
1640 stuffing_count = ff_vbv_update(s, s->frame_bits);
1641 if (stuffing_count) {
1642 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1643 stuffing_count + 50) {
3ada94ba
BF
1644 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1645 return -1;
1646 }
1647
9342ecf0 1648 switch (s->codec_id) {
36ef5369
AK
1649 case AV_CODEC_ID_MPEG1VIDEO:
1650 case AV_CODEC_ID_MPEG2VIDEO:
9342ecf0 1651 while (stuffing_count--) {
3ada94ba
BF
1652 put_bits(&s->pb, 8, 0);
1653 }
1654 break;
36ef5369 1655 case AV_CODEC_ID_MPEG4:
3ada94ba
BF
1656 put_bits(&s->pb, 16, 0);
1657 put_bits(&s->pb, 16, 0x1C3);
1658 stuffing_count -= 4;
9342ecf0 1659 while (stuffing_count--) {
3ada94ba
BF
1660 put_bits(&s->pb, 8, 0xFF);
1661 }
1662 break;
1663 default:
1664 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1665 }
1666 flush_put_bits(&s->pb);
1667 s->frame_bits = put_bits_count(&s->pb);
1668 }
1669
1670 /* update mpeg1/2 vbv_delay for CBR */
9342ecf0
AD
1671 if (s->avctx->rc_max_rate &&
1672 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1673 s->out_format == FMT_MPEG1 &&
1674 90000LL * (avctx->rc_buffer_size - 1) <=
1675 s->avctx->rc_max_rate * 0xFFFFLL) {
4601e76a 1676 int vbv_delay, min_delay;
9342ecf0
AD
1677 double inbits = s->avctx->rc_max_rate *
1678 av_q2d(s->avctx->time_base);
1679 int minbits = s->frame_bits - 8 *
1680 (s->vbv_delay_ptr - s->pb.buf - 1);
1681 double bits = s->rc_context.buffer_index + minbits - inbits;
4601e76a 1682
9342ecf0
AD
1683 if (bits < 0)
1684 av_log(s->avctx, AV_LOG_ERROR,
1685 "Internal error, negative bits\n");
3ada94ba 1686
9342ecf0 1687 assert(s->repeat_first_field == 0);
3ada94ba 1688
9342ecf0
AD
1689 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1690 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1691 s->avctx->rc_max_rate;
4601e76a 1692
9342ecf0 1693 vbv_delay = FFMAX(vbv_delay, min_delay);
4601e76a 1694
3ada94ba
BF
1695 assert(vbv_delay < 0xFFFF);
1696
1697 s->vbv_delay_ptr[0] &= 0xF8;
9342ecf0
AD
1698 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1699 s->vbv_delay_ptr[1] = vbv_delay >> 5;
3ada94ba 1700 s->vbv_delay_ptr[2] &= 0x07;
9342ecf0
AD
1701 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1702 avctx->vbv_delay = vbv_delay * 300;
3ada94ba 1703 }
9342ecf0 1704 s->total_bits += s->frame_bits;
3ada94ba 1705 avctx->frame_bits = s->frame_bits;
445a7d48 1706
f6774f90 1707 pkt->pts = s->current_picture.f->pts;
1c7b71a5 1708 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
f6774f90 1709 if (!s->current_picture.f->coded_picture_number)
445a7d48
AK
1710 pkt->dts = pkt->pts - s->dts_delta;
1711 else
1712 pkt->dts = s->reordered_pts;
1c7b71a5 1713 s->reordered_pts = pkt->pts;
445a7d48
AK
1714 } else
1715 pkt->dts = pkt->pts;
f6774f90 1716 if (s->current_picture.f->key_frame)
445a7d48 1717 pkt->flags |= AV_PKT_FLAG_KEY;
bdc1220e
MS
1718 if (s->mb_info)
1719 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
9342ecf0 1720 } else {
9342ecf0 1721 s->frame_bits = 0;
3ada94ba 1722 }
9342ecf0 1723 assert((s->frame_bits & 7) == 0);
3ada94ba 1724
445a7d48
AK
1725 pkt->size = s->frame_bits / 8;
1726 *got_packet = !!pkt->size;
1727 return 0;
3ada94ba
BF
1728}
1729
9342ecf0
AD
1730static inline void dct_single_coeff_elimination(MpegEncContext *s,
1731 int n, int threshold)
3ada94ba 1732{
9342ecf0
AD
1733 static const char tab[64] = {
1734 3, 2, 2, 1, 1, 1, 1, 1,
1735 1, 1, 1, 1, 1, 1, 1, 1,
1736 1, 1, 1, 1, 1, 1, 1, 1,
1737 0, 0, 0, 0, 0, 0, 0, 0,
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 };
1743 int score = 0;
1744 int run = 0;
3ada94ba 1745 int i;
88bd7fdc 1746 int16_t *block = s->block[n];
9342ecf0 1747 const int last_index = s->block_last_index[n];
3ada94ba
BF
1748 int skip_dc;
1749
9342ecf0
AD
1750 if (threshold < 0) {
1751 skip_dc = 0;
1752 threshold = -threshold;
1753 } else
1754 skip_dc = 1;
3ada94ba 1755
bd107136 1756 /* Are all we could set to zero already zero? */
9342ecf0
AD
1757 if (last_index <= skip_dc - 1)
1758 return;
3ada94ba 1759
9342ecf0 1760 for (i = 0; i <= last_index; i++) {
3ada94ba
BF
1761 const int j = s->intra_scantable.permutated[i];
1762 const int level = FFABS(block[j]);
9342ecf0
AD
1763 if (level == 1) {
1764 if (skip_dc && i == 0)
1765 continue;
1766 score += tab[run];
1767 run = 0;
1768 } else if (level > 1) {
3ada94ba 1769 return;
9342ecf0 1770 } else {
3ada94ba
BF
1771 run++;
1772 }
1773 }
9342ecf0
AD
1774 if (score >= threshold)
1775 return;
1776 for (i = skip_dc; i <= last_index; i++) {
3ada94ba 1777 const int j = s->intra_scantable.permutated[i];
9342ecf0 1778 block[j] = 0;
3ada94ba 1779 }
9342ecf0
AD
1780 if (block[0])
1781 s->block_last_index[n] = 0;
1782 else
1783 s->block_last_index[n] = -1;
3ada94ba
BF
1784}
1785
88bd7fdc 1786static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
9342ecf0 1787 int last_index)
3ada94ba
BF
1788{
1789 int i;
9342ecf0
AD
1790 const int maxlevel = s->max_qcoeff;
1791 const int minlevel = s->min_qcoeff;
1792 int overflow = 0;
3ada94ba 1793
9342ecf0
AD
1794 if (s->mb_intra) {
1795 i = 1; // skip clipping of intra dc
1796 } else
1797 i = 0;
3ada94ba 1798
9342ecf0
AD
1799 for (; i <= last_index; i++) {
1800 const int j = s->intra_scantable.permutated[i];
3ada94ba
BF
1801 int level = block[j];
1802
9342ecf0
AD
1803 if (level > maxlevel) {
1804 level = maxlevel;
3ada94ba 1805 overflow++;
9342ecf0
AD
1806 } else if (level < minlevel) {
1807 level = minlevel;
3ada94ba
BF
1808 overflow++;
1809 }
1810
9342ecf0 1811 block[j] = level;
3ada94ba
BF
1812 }
1813
9342ecf0
AD
1814 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1815 av_log(s->avctx, AV_LOG_INFO,
1816 "warning, clipping %d dct coefficients to %d..%d\n",
1817 overflow, minlevel, maxlevel);
3ada94ba
BF
1818}
1819
9342ecf0
AD
1820static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1821{
3ada94ba 1822 int x, y;
9342ecf0
AD
1823 // FIXME optimize
1824 for (y = 0; y < 8; y++) {
1825 for (x = 0; x < 8; x++) {
3ada94ba 1826 int x2, y2;
9342ecf0
AD
1827 int sum = 0;
1828 int sqr = 0;
1829 int count = 0;
3ada94ba 1830
9342ecf0
AD
1831 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1832 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1833 int v = ptr[x2 + y2 * stride];
3ada94ba 1834 sum += v;
9342ecf0 1835 sqr += v * v;
3ada94ba
BF
1836 count++;
1837 }
1838 }
9342ecf0 1839 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
3ada94ba
BF
1840 }
1841 }
1842}
1843
9342ecf0
AD
1844static av_always_inline void encode_mb_internal(MpegEncContext *s,
1845 int motion_x, int motion_y,
1846 int mb_block_height,
1847 int mb_block_count)
3ada94ba
BF
1848{
1849 int16_t weight[8][64];
88bd7fdc 1850 int16_t orig[8][64];
9342ecf0
AD
1851 const int mb_x = s->mb_x;
1852 const int mb_y = s->mb_y;
3ada94ba
BF
1853 int i;
1854 int skip_dct[8];
9342ecf0 1855 int dct_offset = s->linesize * 8; // default for progressive frames
3ada94ba 1856 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
93f30547 1857 ptrdiff_t wrap_y, wrap_c;
3ada94ba 1858
9342ecf0
AD
1859 for (i = 0; i < mb_block_count; i++)
1860 skip_dct[i] = s->skipdct;
3ada94ba 1861
9342ecf0
AD
1862 if (s->adaptive_quant) {
1863 const int last_qp = s->qscale;
1864 const int mb_xy = mb_x + mb_y * s->mb_stride;
3ada94ba 1865
9342ecf0 1866 s->lambda = s->lambda_table[mb_xy];
3ada94ba
BF
1867 update_qscale(s);
1868
ff71a383 1869 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
759001c5 1870 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
9342ecf0 1871 s->dquant = s->qscale - last_qp;
3ada94ba 1872
9342ecf0
AD
1873 if (s->out_format == FMT_H263) {
1874 s->dquant = av_clip(s->dquant, -2, 2);
3ada94ba 1875
36ef5369 1876 if (s->codec_id == AV_CODEC_ID_MPEG4) {
9342ecf0
AD
1877 if (!s->mb_intra) {
1878 if (s->pict_type == AV_PICTURE_TYPE_B) {
1879 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1880 s->dquant = 0;
3ada94ba 1881 }
9342ecf0
AD
1882 if (s->mv_type == MV_TYPE_8X8)
1883 s->dquant = 0;
3ada94ba
BF
1884 }
1885 }
1886 }
1887 }
1888 ff_set_qscale(s, last_qp + s->dquant);
ff71a383 1889 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
3ada94ba
BF
1890 ff_set_qscale(s, s->qscale + s->dquant);
1891
1892 wrap_y = s->linesize;
1893 wrap_c = s->uvlinesize;
f6774f90 1894 ptr_y = s->new_picture.f->data[0] +
9342ecf0 1895 (mb_y * 16 * wrap_y) + mb_x * 16;
f6774f90 1896 ptr_cb = s->new_picture.f->data[1] +
9342ecf0 1897 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
f6774f90 1898 ptr_cr = s->new_picture.f->data[2] +
9342ecf0
AD
1899 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1900
1901 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1902 uint8_t *ebuf = s->edge_emu_buffer + 32;
458446ac
RB
1903 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1904 wrap_y, wrap_y,
1905 16, 16, mb_x * 16, mb_y * 16,
1906 s->width, s->height);
9342ecf0 1907 ptr_y = ebuf;
458446ac
RB
1908 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1909 wrap_c, wrap_c,
1910 8, mb_block_height, mb_x * 8, mb_y * 8,
8c53d39e 1911 s->width >> 1, s->height >> 1);
9342ecf0 1912 ptr_cb = ebuf + 18 * wrap_y;
458446ac
RB
1913 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1914 wrap_c, wrap_c,
1915 8, mb_block_height, mb_x * 8, mb_y * 8,
8c53d39e 1916 s->width >> 1, s->height >> 1);
9342ecf0 1917 ptr_cr = ebuf + 18 * wrap_y + 8;
3ada94ba
BF
1918 }
1919
1920 if (s->mb_intra) {
9342ecf0 1921 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1922 int progressive_score, interlaced_score;
1923
9342ecf0
AD
1924 s->interlaced_dct = 0;
1925 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1926 NULL, wrap_y, 8) +
1927 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1928 NULL, wrap_y, 8) - 400;
1929
1930 if (progressive_score > 0) {
1931 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1932 NULL, wrap_y * 2, 8) +
1933 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1934 NULL, wrap_y * 2, 8);
1935 if (progressive_score > interlaced_score) {
1936 s->interlaced_dct = 1;
1937
1938 dct_offset = wrap_y;
1939 wrap_y <<= 1;
3ada94ba 1940 if (s->chroma_format == CHROMA_422)
9342ecf0 1941 wrap_c <<= 1;
3ada94ba
BF
1942 }
1943 }
1944 }
1945
9342ecf0
AD
1946 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1947 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1948 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1949 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
3ada94ba 1950
9342ecf0
AD
1951 if (s->flags & CODEC_FLAG_GRAY) {
1952 skip_dct[4] = 1;
1953 skip_dct[5] = 1;
1954 } else {
3ada94ba
BF
1955 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1956 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
9342ecf0
AD
1957 if (!s->chroma_y_shift) { /* 422 */
1958 s->dsp.get_pixels(s->block[6],
1959 ptr_cb + (dct_offset >> 1), wrap_c);
1960 s->dsp.get_pixels(s->block[7],
1961 ptr_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
1962 }
1963 }
9342ecf0 1964 } else {
3ada94ba
BF
1965 op_pixels_func (*op_pix)[4];
1966 qpel_mc_func (*op_qpix)[16];
1967 uint8_t *dest_y, *dest_cb, *dest_cr;
1968
1969 dest_y = s->dest[0];
1970 dest_cb = s->dest[1];
1971 dest_cr = s->dest[2];
1972
9342ecf0 1973 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
f4fed5a2 1974 op_pix = s->hdsp.put_pixels_tab;
368f5035 1975 op_qpix = s->qdsp.put_qpel_pixels_tab;
9342ecf0 1976 } else {
f4fed5a2 1977 op_pix = s->hdsp.put_no_rnd_pixels_tab;
368f5035 1978 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
3ada94ba
BF
1979 }
1980
1981 if (s->mv_dir & MV_DIR_FORWARD) {
7a851153 1982 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
f6774f90 1983 s->last_picture.f->data,
7a851153 1984 op_pix, op_qpix);
f4fed5a2 1985 op_pix = s->hdsp.avg_pixels_tab;
368f5035 1986 op_qpix = s->qdsp.avg_qpel_pixels_tab;
3ada94ba
BF
1987 }
1988 if (s->mv_dir & MV_DIR_BACKWARD) {
7a851153 1989 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
f6774f90 1990 s->next_picture.f->data,
7a851153 1991 op_pix, op_qpix);
3ada94ba
BF
1992 }
1993
9342ecf0 1994 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1995 int progressive_score, interlaced_score;
1996
9342ecf0
AD
1997 s->interlaced_dct = 0;
1998 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1999 ptr_y, wrap_y,
2000 8) +
2001 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
2002 ptr_y + wrap_y * 8, wrap_y,
2003 8) - 400;
2004
2005 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2006 progressive_score -= 400;
2007
2008 if (progressive_score > 0) {
2009 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
2010 ptr_y,
2011 wrap_y * 2, 8) +
2012 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
2013 ptr_y + wrap_y,
2014 wrap_y * 2, 8);
2015
2016 if (progressive_score > interlaced_score) {
2017 s->interlaced_dct = 1;
2018
2019 dct_offset = wrap_y;
2020 wrap_y <<= 1;
3ada94ba 2021 if (s->chroma_format == CHROMA_422)
9342ecf0 2022 wrap_c <<= 1;
3ada94ba
BF
2023 }
2024 }
2025 }
2026
9342ecf0
AD
2027 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2028 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2029 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2030 dest_y + dct_offset, wrap_y);
2031 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2032 dest_y + dct_offset + 8, wrap_y);
3ada94ba 2033
9342ecf0
AD
2034 if (s->flags & CODEC_FLAG_GRAY) {
2035 skip_dct[4] = 1;
2036 skip_dct[5] = 1;
2037 } else {
3ada94ba
BF
2038 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2039 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
9342ecf0
AD
2040 if (!s->chroma_y_shift) { /* 422 */
2041 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2042 dest_cb + (dct_offset >> 1), wrap_c);
2043 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2044 dest_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
2045 }
2046 }
2047 /* pre quantization */
9342ecf0
AD
2048 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2049 2 * s->qscale * s->qscale) {
2050 // FIXME optimize
2051 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
2052 wrap_y, 8) < 20 * s->qscale)
2053 skip_dct[0] = 1;
2054 if (s->dsp.sad[1](NULL, ptr_y + 8,
2055 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2056 skip_dct[1] = 1;
2057 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
2058 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
2059 skip_dct[2] = 1;
2060 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
2061 dest_y + dct_offset + 8,
2062 wrap_y, 8) < 20 * s->qscale)
2063 skip_dct[3] = 1;
2064 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
2065 wrap_c, 8) < 20 * s->qscale)
2066 skip_dct[4] = 1;
2067 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
2068 wrap_c, 8) < 20 * s->qscale)
2069 skip_dct[5] = 1;
2070 if (!s->chroma_y_shift) { /* 422 */
2071 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2072 dest_cb + (dct_offset >> 1),
2073 wrap_c, 8) < 20 * s->qscale)
2074 skip_dct[6] = 1;
2075 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2076 dest_cr + (dct_offset >> 1),
2077 wrap_c, 8) < 20 * s->qscale)
2078 skip_dct[7] = 1;
3ada94ba
BF
2079 }
2080 }
2081 }
2082
23bfcc06 2083 if (s->quantizer_noise_shaping) {
9342ecf0
AD
2084 if (!skip_dct[0])
2085 get_visual_weight(weight[0], ptr_y , wrap_y);
2086 if (!skip_dct[1])
2087 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2088 if (!skip_dct[2])
2089 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2090 if (!skip_dct[3])
2091 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2092 if (!skip_dct[4])
2093 get_visual_weight(weight[4], ptr_cb , wrap_c);
2094 if (!skip_dct[5])
2095 get_visual_weight(weight[5], ptr_cr , wrap_c);
2096 if (!s->chroma_y_shift) { /* 422 */
2097 if (!skip_dct[6])
2098 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2099 wrap_c);
2100 if (!skip_dct[7])
2101 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2102 wrap_c);
3ada94ba 2103 }
88bd7fdc 2104 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
3ada94ba
BF
2105 }
2106
2107 /* DCT & quantize */
9342ecf0 2108 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
3ada94ba 2109 {
9342ecf0
AD
2110 for (i = 0; i < mb_block_count; i++) {
2111 if (!skip_dct[i]) {
3ada94ba
BF
2112 int overflow;
2113 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
9342ecf0
AD
2114 // FIXME we could decide to change to quantizer instead of
2115 // clipping
2116 // JS: I don't think that would be a good idea it could lower
2117 // quality instead of improve it. Just INTRADC clipping
2118 // deserves changes in quantizer
2119 if (overflow)
2120 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2121 } else
2122 s->block_last_index[i] = -1;
3ada94ba 2123 }
23bfcc06 2124 if (s->quantizer_noise_shaping) {
9342ecf0
AD
2125 for (i = 0; i < mb_block_count; i++) {
2126 if (!skip_dct[i]) {
2127 s->block_last_index[i] =
2128 dct_quantize_refine(s, s->block[i], weight[i],
2129 orig[i], i, s->qscale);
3ada94ba
BF
2130 }
2131 }
2132 }
2133
9342ecf0
AD
2134 if (s->luma_elim_threshold && !s->mb_intra)
2135 for (i = 0; i < 4; i++)
3ada94ba 2136 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
9342ecf0
AD
2137 if (s->chroma_elim_threshold && !s->mb_intra)
2138 for (i = 4; i < mb_block_count; i++)
3ada94ba
BF
2139 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2140
af3d804f 2141 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
9342ecf0
AD
2142 for (i = 0; i < mb_block_count; i++) {
2143 if (s->block_last_index[i] == -1)
2144 s->coded_score[i] = INT_MAX / 256;
3ada94ba
BF
2145 }
2146 }
2147 }
2148
9342ecf0
AD
2149 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2150 s->block_last_index[4] =
2151 s->block_last_index[5] = 0;
2152 s->block[4][0] =
2153 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
3ada94ba
BF
2154 }
2155
9342ecf0 2156 // non c quantize code returns incorrect block_last_index FIXME
99560a4c 2157 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
9342ecf0 2158 for (i = 0; i < mb_block_count; i++) {
3ada94ba 2159 int j;
9342ecf0
AD
2160 if (s->block_last_index[i] > 0) {
2161 for (j = 63; j > 0; j--) {
2162 if (s->block[i][s->intra_scantable.permutated[j]])
2163 break;
3ada94ba 2164 }
9342ecf0 2165 s->block_last_index[i] = j;
3ada94ba
BF
2166 }
2167 }
2168 }
2169
2170 /* huffman encode */
2171 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
36ef5369
AK
2172 case AV_CODEC_ID_MPEG1VIDEO:
2173 case AV_CODEC_ID_MPEG2VIDEO:
49fb20cb 2174 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
d6c8dcb8 2175 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
56be950a 2176 break;
36ef5369 2177 case AV_CODEC_ID_MPEG4:
49fb20cb 2178 if (CONFIG_MPEG4_ENCODER)
6f13a371 2179 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
674eeb5f 2180 break;
36ef5369
AK
2181 case AV_CODEC_ID_MSMPEG4V2:
2182 case AV_CODEC_ID_MSMPEG4V3:
2183 case AV_CODEC_ID_WMV1:
49fb20cb 2184 if (CONFIG_MSMPEG4_ENCODER)
04d38225 2185 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
3ada94ba 2186 break;
36ef5369 2187 case AV_CODEC_ID_WMV2:
49fb20cb 2188 if (CONFIG_WMV2_ENCODER)
3ada94ba
BF
2189 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2190 break;
36ef5369 2191 case AV_CODEC_ID_H261:
49fb20cb 2192 if (CONFIG_H261_ENCODER)
3ada94ba
BF
2193 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2194 break;
36ef5369
AK
2195 case AV_CODEC_ID_H263:
2196 case AV_CODEC_ID_H263P:
2197 case AV_CODEC_ID_FLV1:
2198 case AV_CODEC_ID_RV10:
2199 case AV_CODEC_ID_RV20:
0bd48530 2200 if (CONFIG_H263_ENCODER)
ddce8953 2201 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
674eeb5f 2202 break;
36ef5369 2203 case AV_CODEC_ID_MJPEG:
49fb20cb 2204 if (CONFIG_MJPEG_ENCODER)
3ada94ba
BF
2205 ff_mjpeg_encode_mb(s, s->block);
2206 break;
2207 default:
2208 assert(0);
2209 }
2210}
2211
2212static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2213{
2214 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2215 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2216}
2217
3ada94ba
BF
2218static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2219 int i;
2220
be73d76b 2221 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
3ada94ba
BF
2222
2223 /* mpeg1 */
2224 d->mb_skip_run= s->mb_skip_run;
2225 for(i=0; i<3; i++)
9342ecf0 2226 d->last_dc[i] = s->last_dc[i];
3ada94ba
BF
2227
2228 /* statistics */
2229 d->mv_bits= s->mv_bits;
2230 d->i_tex_bits= s->i_tex_bits;
2231 d->p_tex_bits= s->p_tex_bits;
2232 d->i_count= s->i_count;
2233 d->f_count= s->f_count;
2234 d->b_count= s->b_count;
2235 d->skip_count= s->skip_count;
2236 d->misc_bits= s->misc_bits;
2237 d->last_bits= 0;
2238
2239 d->mb_skipped= 0;
2240 d->qscale= s->qscale;
2241 d->dquant= s->dquant;
9f175aa0
MN
2242
2243 d->esc3_level_length= s->esc3_level_length;
3ada94ba
BF
2244}
2245
2246static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2247 int i;
2248
2249 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
be73d76b 2250 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
3ada94ba
BF
2251
2252 /* mpeg1 */
2253 d->mb_skip_run= s->mb_skip_run;
2254 for(i=0; i<3; i++)
9342ecf0 2255 d->last_dc[i] = s->last_dc[i];
3ada94ba
BF
2256
2257 /* statistics */
2258 d->mv_bits= s->mv_bits;
2259 d->i_tex_bits= s->i_tex_bits;
2260 d->p_tex_bits= s->p_tex_bits;
2261 d->i_count= s->i_count;
2262 d->f_count= s->f_count;
2263 d->b_count= s->b_count;
2264 d->skip_count= s->skip_count;
2265 d->misc_bits= s->misc_bits;
2266
2267 d->mb_intra= s->mb_intra;
2268 d->mb_skipped= s->mb_skipped;
2269 d->mv_type= s->mv_type;
2270 d->mv_dir= s->mv_dir;
2271 d->pb= s->pb;
2272 if(s->data_partitioning){
2273 d->pb2= s->pb2;
2274 d->tex_pb= s->tex_pb;
2275 }
2276 d->block= s->block;
2277 for(i=0; i<8; i++)
2278 d->block_last_index[i]= s->block_last_index[i];
2279 d->interlaced_dct= s->interlaced_dct;
2280 d->qscale= s->qscale;
9f175aa0
MN
2281
2282 d->esc3_level_length= s->esc3_level_length;
3ada94ba
BF
2283}
2284
2285static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2286 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2287 int *dmin, int *next_block, int motion_x, int motion_y)
2288{
2289 int score;
2290 uint8_t *dest_backup[3];
2291
2292 copy_context_before_encode(s, backup, type);
2293
2294 s->block= s->blocks[*next_block];
2295 s->pb= pb[*next_block];
2296 if(s->data_partitioning){
2297 s->pb2 = pb2 [*next_block];
2298 s->tex_pb= tex_pb[*next_block];
2299 }
2300
2301 if(*next_block){
2302 memcpy(dest_backup, s->dest, sizeof(s->dest));
2303 s->dest[0] = s->rd_scratchpad;
2304 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2305 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2306 assert(s->linesize >= 32); //FIXME
2307 }
2308
2309 encode_mb(s, motion_x, motion_y);
2310
2311 score= put_bits_count(&s->pb);
2312 if(s->data_partitioning){
2313 score+= put_bits_count(&s->pb2);
2314 score+= put_bits_count(&s->tex_pb);
2315 }
2316
2317 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
efd29844 2318 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2319
2320 score *= s->lambda2;
2321 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2322 }
2323
2324 if(*next_block){
2325 memcpy(s->dest, dest_backup, sizeof(s->dest));
2326 }
2327
2328 if(score<*dmin){
2329 *dmin= score;
2330 *next_block^=1;
2331
2332 copy_context_after_encode(best, s, type);
2333 }
2334}
2335
2336static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
05563cca 2337 uint32_t *sq = ff_square_tab + 256;
3ada94ba
BF
2338 int acc=0;
2339 int x,y;
2340
2341 if(w==16 && h==16)
2342 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2343 else if(w==8 && h==8)
2344 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2345
2346 for(y=0; y<h; y++){
2347 for(x=0; x<w; x++){
2348 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2349 }
2350 }
2351
2352 assert(acc>=0);
2353
2354 return acc;
2355}
2356
2357static int sse_mb(MpegEncContext *s){
2358 int w= 16;
2359 int h= 16;
2360
2361 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2362 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2363
2364 if(w==16 && h==16)
2365 if(s->avctx->mb_cmp == FF_CMP_NSSE){
f6774f90 2366 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)
2367 +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)
2368 +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 2369 }else{
f6774f90 2370 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)
2371 +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)
2372 +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
2373 }
2374 else
f6774f90 2375 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)
2376 +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)
2377 +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
2378}
2379
2380static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3a84713a 2381 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2382
2383
2384 s->me.pre_pass=1;
2385 s->me.dia_size= s->avctx->pre_dia_size;
2386 s->first_slice_line=1;
2387 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2388 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2389 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2390 }
2391 s->first_slice_line=0;
2392 }
2393
2394 s->me.pre_pass=0;
2395
2396 return 0;
2397}
2398
2399static int estimate_motion_thread(AVCodecContext *c, void *arg){
3a84713a 2400 MpegEncContext *s= *(void**)arg;
3ada94ba 2401
3ada94ba
BF
2402 s->me.dia_size= s->avctx->dia_size;
2403 s->first_slice_line=1;
2404 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2405 s->mb_x=0; //for block init below
2406 ff_init_block_index(s);
2407 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2408 s->block_index[0]+=2;
2409 s->block_index[1]+=2;
2410 s->block_index[2]+=2;
2411 s->block_index[3]+=2;
2412
2413 /* compute motion vector & mb_type and store in context */
975a1447 2414 if(s->pict_type==AV_PICTURE_TYPE_B)
3ada94ba
BF
2415 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2416 else
2417 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2418 }
2419 s->first_slice_line=0;
2420 }
2421 return 0;
2422}
2423
2424static int mb_var_thread(AVCodecContext *c, void *arg){
3a84713a 2425 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2426 int mb_x, mb_y;
2427
3ada94ba
BF
2428 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2429 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2430 int xx = mb_x * 16;
2431 int yy = mb_y * 16;
f6774f90 2432 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
3ada94ba 2433 int varc;
c1661484 2434 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
3ada94ba 2435
c1661484
DB
2436 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2437 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
3ada94ba
BF
2438
2439 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2440 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2441 s->me.mb_var_sum_temp += varc;
2442 }
2443 }
2444 return 0;
2445}
2446
2447static void write_slice_end(MpegEncContext *s){
36ef5369 2448 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
3ada94ba
BF
2449 if(s->partitioned_frame){
2450 ff_mpeg4_merge_partitions(s);
2451 }
2452
2453 ff_mpeg4_stuffing(&s->pb);
49fb20cb 2454 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
3ada94ba
BF
2455 ff_mjpeg_encode_stuffing(&s->pb);
2456 }
2457
9f51c682 2458 avpriv_align_put_bits(&s->pb);
3ada94ba
BF
2459 flush_put_bits(&s->pb);
2460
2461 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2462 s->misc_bits+= get_bits_diff(s);
2463}
2464
bdc1220e
MS
2465static void write_mb_info(MpegEncContext *s)
2466{
2467 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2468 int offset = put_bits_count(&s->pb);
2469 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2470 int gobn = s->mb_y / s->gob_index;
2471 int pred_x, pred_y;
2472 if (CONFIG_H263_ENCODER)
2473 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2474 bytestream_put_le32(&ptr, offset);
2475 bytestream_put_byte(&ptr, s->qscale);
2476 bytestream_put_byte(&ptr, gobn);
2477 bytestream_put_le16(&ptr, mba);
2478 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2479 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2480 /* 4MV not implemented */
2481 bytestream_put_byte(&ptr, 0); /* hmv2 */
2482 bytestream_put_byte(&ptr, 0); /* vmv2 */
2483}
2484
2485static void update_mb_info(MpegEncContext *s, int startcode)
2486{
2487 if (!s->mb_info)
2488 return;
2489 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2490 s->mb_info_size += 12;
2491 s->prev_mb_info = s->last_mb_info;
2492 }
2493 if (startcode) {
2494 s->prev_mb_info = put_bits_count(&s->pb)/8;
2495 /* This might have incremented mb_info_size above, and we return without
2496 * actually writing any info into that slot yet. But in that case,
2497 * this will be called again at the start of the after writing the
2498 * start code, actually writing the mb info. */
2499 return;
2500 }
2501
2502 s->last_mb_info = put_bits_count(&s->pb)/8;
2503 if (!s->mb_info_size)
2504 s->mb_info_size += 12;
2505 write_mb_info(s);
2506}
2507
3ada94ba 2508static int encode_thread(AVCodecContext *c, void *arg){
3a84713a 2509 MpegEncContext *s= *(void**)arg;
3ada94ba 2510 int mb_x, mb_y, pdif = 0;
ec7e2582 2511 int chr_h= 16>>s->chroma_y_shift;
3ada94ba
BF
2512 int i, j;
2513 MpegEncContext best_s, backup_s;
2514 uint8_t bit_buf[2][MAX_MB_BYTES];
2515 uint8_t bit_buf2[2][MAX_MB_BYTES];
2516 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2517 PutBitContext pb[2], pb2[2], tex_pb[2];
3ada94ba 2518
3ada94ba
BF
2519 for(i=0; i<2; i++){
2520 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2521 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2522 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2523 }
2524
2525 s->last_bits= put_bits_count(&s->pb);
2526 s->mv_bits=0;
2527 s->misc_bits=0;
2528 s->i_tex_bits=0;
2529 s->p_tex_bits=0;
2530 s->i_count=0;
2531 s->f_count=0;
2532 s->b_count=0;
2533 s->skip_count=0;
2534
2535 for(i=0; i<3; i++){
2536 /* init last dc values */
2537 /* note: quant matrix value (8) is implied here */
2538 s->last_dc[i] = 128 << s->intra_dc_precision;
2539
f6774f90 2540 s->current_picture.f->error[i] = 0;
3ada94ba
BF
2541 }
2542 s->mb_skip_run = 0;
2543 memset(s->last_mv, 0, sizeof(s->last_mv));
2544
2545 s->last_mv_dir = 0;
2546
2547 switch(s->codec_id){
36ef5369
AK
2548 case AV_CODEC_ID_H263:
2549 case AV_CODEC_ID_H263P:
2550 case AV_CODEC_ID_FLV1:
0bd48530 2551 if (CONFIG_H263_ENCODER)
674eeb5f 2552 s->gob_index = ff_h263_get_gob_height(s);
3ada94ba 2553 break;
36ef5369 2554 case AV_CODEC_ID_MPEG4:
49fb20cb 2555 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3ada94ba
BF
2556 ff_mpeg4_init_partitions(s);
2557 break;
2558 }
2559
2560 s->resync_mb_x=0;
2561 s->resync_mb_y=0;
2562 s->first_slice_line = 1;
2563 s->ptr_lastgob = s->pb.buf;
2564 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3ada94ba
BF
2565 s->mb_x=0;
2566 s->mb_y= mb_y;
2567
2568 ff_set_qscale(s, s->qscale);
2569 ff_init_block_index(s);
2570
2571 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2572 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2573 int mb_type= s->mb_type[xy];
2574// int d;
2575 int dmin= INT_MAX;
2576 int dir;
2577
2578 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2579 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2580 return -1;
2581 }
2582 if(s->data_partitioning){
2583 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2584 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2585 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2586 return -1;
2587 }
2588 }
2589
2590 s->mb_x = mb_x;
2591 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2592 ff_update_block_index(s);
2593
36ef5369 2594 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3ada94ba
BF
2595 ff_h261_reorder_mb_index(s);
2596 xy= s->mb_y*s->mb_stride + s->mb_x;
2597 mb_type= s->mb_type[xy];
2598 }
2599
2600 /* write gob / video packet header */
2601 if(s->rtp_mode){
2602 int current_packet_size, is_gob_start;
2603
2604 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2605
2606 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2607
2608 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2609
2610 switch(s->codec_id){
36ef5369
AK
2611 case AV_CODEC_ID_H263:
2612 case AV_CODEC_ID_H263P:
3ada94ba
BF
2613 if(!s->h263_slice_structured)
2614 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2615 break;
36ef5369 2616 case AV_CODEC_ID_MPEG2VIDEO:
3ada94ba 2617 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
36ef5369 2618 case AV_CODEC_ID_MPEG1VIDEO:
3ada94ba
BF
2619 if(s->mb_skip_run) is_gob_start=0;
2620 break;
2621 }
2622
2623 if(is_gob_start){
2624 if(s->start_mb_y != mb_y || mb_x!=0){
2625 write_slice_end(s);
2626
36ef5369 2627 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3ada94ba
BF
2628 ff_mpeg4_init_partitions(s);
2629 }
2630 }
2631
2632 assert((put_bits_count(&s->pb)&7) == 0);
fb53b4a0 2633 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3ada94ba 2634
8941971a 2635 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3ada94ba 2636 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
8941971a 2637 int d = 100 / s->error_rate;
3ada94ba
BF
2638 if(r % d == 0){
2639 current_packet_size=0;
3ada94ba 2640 s->pb.buf_ptr= s->ptr_lastgob;
fb53b4a0 2641 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3ada94ba
BF
2642 }
2643 }
2644
2645 if (s->avctx->rtp_callback){
2646 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2647 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2648 }
bdc1220e 2649 update_mb_info(s, 1);
3ada94ba
BF
2650
2651 switch(s->codec_id){
36ef5369 2652 case AV_CODEC_ID_MPEG4:
49fb20cb 2653 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2654 ff_mpeg4_encode_video_packet_header(s);
2655 ff_mpeg4_clean_buffers(s);
eb75a698 2656 }
3ada94ba 2657 break;
36ef5369
AK
2658 case AV_CODEC_ID_MPEG1VIDEO:
2659 case AV_CODEC_ID_MPEG2VIDEO:
49fb20cb 2660 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
56be950a
AJ
2661 ff_mpeg1_encode_slice_header(s);
2662 ff_mpeg1_clean_buffers(s);
a6bc5731 2663 }
3ada94ba 2664 break;
36ef5369
AK
2665 case AV_CODEC_ID_H263:
2666 case AV_CODEC_ID_H263P:
965424da 2667 if (CONFIG_H263_ENCODER)
ddce8953 2668 ff_h263_encode_gob_header(s, mb_y);
3ada94ba
BF
2669 break;
2670 }
2671
2672 if(s->flags&CODEC_FLAG_PASS1){
2673 int bits= put_bits_count(&s->pb);
2674 s->misc_bits+= bits - s->last_bits;
2675 s->last_bits= bits;
2676 }
2677
2678 s->ptr_lastgob += current_packet_size;
2679 s->first_slice_line=1;
2680 s->resync_mb_x=mb_x;
2681 s->resync_mb_y=mb_y;
2682 }
2683 }
2684
2685 if( (s->resync_mb_x == s->mb_x)
2686 && s->resync_mb_y+1 == s->mb_y){
2687 s->first_slice_line=0;
2688 }
2689
2690 s->mb_skipped=0;
2691 s->dquant=0; //only for QP_RD
2692
bdc1220e
MS
2693 update_mb_info(s, 0);
2694
ff71a383 2695 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
2696 int next_block=0;
2697 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2698
2699 copy_context_before_encode(&backup_s, s, -1);
2700 backup_s.pb= s->pb;
2701 best_s.data_partitioning= s->data_partitioning;
2702 best_s.partitioned_frame= s->partitioned_frame;
2703 if(s->data_partitioning){
2704 backup_s.pb2= s->pb2;
2705 backup_s.tex_pb= s->tex_pb;
2706 }
2707
2708 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2709 s->mv_dir = MV_DIR_FORWARD;
2710 s->mv_type = MV_TYPE_16X16;
2711 s->mb_intra= 0;
2712 s->mv[0][0][0] = s->p_mv_table[xy][0];
2713 s->mv[0][0][1] = s->p_mv_table[xy][1];
2714 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2715 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2716 }
2717 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2718 s->mv_dir = MV_DIR_FORWARD;
2719 s->mv_type = MV_TYPE_FIELD;
2720 s->mb_intra= 0;
2721 for(i=0; i<2; i++){
2722 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2723 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2724 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2725 }
2726 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2727 &dmin, &next_block, 0, 0);
2728 }
2729 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2730 s->mv_dir = MV_DIR_FORWARD;
2731 s->mv_type = MV_TYPE_16X16;
2732 s->mb_intra= 0;
2733 s->mv[0][0][0] = 0;
2734 s->mv[0][0][1] = 0;
2735 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2736 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2737 }
2738 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2739 s->mv_dir = MV_DIR_FORWARD;
2740 s->mv_type = MV_TYPE_8X8;
2741 s->mb_intra= 0;
2742 for(i=0; i<4; i++){
759001c5
AK
2743 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2744 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3ada94ba
BF
2745 }
2746 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2747 &dmin, &next_block, 0, 0);
2748 }
2749 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2750 s->mv_dir = MV_DIR_FORWARD;
2751 s->mv_type = MV_TYPE_16X16;
2752 s->mb_intra= 0;
2753 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2754 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2755 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2756 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2757 }
2758 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2759 s->mv_dir = MV_DIR_BACKWARD;
2760 s->mv_type = MV_TYPE_16X16;
2761 s->mb_intra= 0;
2762 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2763 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2764 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2765 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2766 }
2767 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2768 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2769 s->mv_type = MV_TYPE_16X16;
2770 s->mb_intra= 0;
2771 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2772 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2773 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2774 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2775 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2776 &dmin, &next_block, 0, 0);
2777 }
2778 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2779 s->mv_dir = MV_DIR_FORWARD;
2780 s->mv_type = MV_TYPE_FIELD;
2781 s->mb_intra= 0;
2782 for(i=0; i<2; i++){
2783 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2784 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2785 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2786 }
2787 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2788 &dmin, &next_block, 0, 0);
2789 }
2790 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2791 s->mv_dir = MV_DIR_BACKWARD;
2792 s->mv_type = MV_TYPE_FIELD;
2793 s->mb_intra= 0;
2794 for(i=0; i<2; i++){
2795 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2796 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2797 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2798 }
2799 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2800 &dmin, &next_block, 0, 0);
2801 }
2802 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2803 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2804 s->mv_type = MV_TYPE_FIELD;
2805 s->mb_intra= 0;
2806 for(dir=0; dir<2; dir++){
2807 for(i=0; i<2; i++){
2808 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2809 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2810 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2811 }
2812 }
2813 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2814 &dmin, &next_block, 0, 0);
2815 }
2816 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2817 s->mv_dir = 0;
2818 s->mv_type = MV_TYPE_16X16;
2819 s->mb_intra= 1;
2820 s->mv[0][0][0] = 0;
2821 s->mv[0][0][1] = 0;
2822 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2823 &dmin, &next_block, 0, 0);
2824 if(s->h263_pred || s->h263_aic){
2825 if(best_s.mb_intra)
2826 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2827 else
2828 ff_clean_intra_table_entries(s); //old mode?
2829 }
2830 }
2831
ff71a383 2832 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3ada94ba
BF
2833 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2834 const int last_qp= backup_s.qscale;
2835 int qpi, qp, dc[6];
88bd7fdc 2836 int16_t ac[6][16];
3ada94ba
BF
2837 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2838 static const int dquant_tab[4]={-1,1,-2,2};
2839
2840 assert(backup_s.dquant == 0);
2841
2842 //FIXME intra
2843 s->mv_dir= best_s.mv_dir;
2844 s->mv_type = MV_TYPE_16X16;
2845 s->mb_intra= best_s.mb_intra;
2846 s->mv[0][0][0] = best_s.mv[0][0][0];
2847 s->mv[0][0][1] = best_s.mv[0][0][1];
2848 s->mv[1][0][0] = best_s.mv[1][0][0];
2849 s->mv[1][0][1] = best_s.mv[1][0][1];
2850
975a1447 2851 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3ada94ba
BF
2852 for(; qpi<4; qpi++){
2853 int dquant= dquant_tab[qpi];
2854 qp= last_qp + dquant;
2855 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2856 continue;
2857 backup_s.dquant= dquant;
2858 if(s->mb_intra && s->dc_val[0]){
2859 for(i=0; i<6; i++){
2860 dc[i]= s->dc_val[0][ s->block_index[i] ];
88bd7fdc 2861 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3ada94ba
BF
2862 }
2863 }
2864
2865 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2866 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2867 if(best_s.qscale != qp){
2868 if(s->mb_intra && s->dc_val[0]){
2869 for(i=0; i<6; i++){
2870 s->dc_val[0][ s->block_index[i] ]= dc[i];
88bd7fdc 2871 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3ada94ba
BF
2872 }
2873 }
2874 }
2875 }
2876 }
2877 }
49fb20cb 2878 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3ada94ba
BF
2879 int mx= s->b_direct_mv_table[xy][0];
2880 int my= s->b_direct_mv_table[xy][1];
2881
2882 backup_s.dquant = 0;
2883 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2884 s->mb_intra= 0;
2885 ff_mpeg4_set_direct_mv(s, mx, my);
2886 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2887 &dmin, &next_block, mx, my);
2888 }
49fb20cb 2889 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3ada94ba
BF
2890 backup_s.dquant = 0;
2891 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2892 s->mb_intra= 0;
2893 ff_mpeg4_set_direct_mv(s, 0, 0);
2894 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2895 &dmin, &next_block, 0, 0);
2896 }
ed019b8e 2897 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3ada94ba
BF
2898 int coded=0;
2899 for(i=0; i<6; i++)
2900 coded |= s->block_last_index[i];
2901 if(coded){
2902 int mx,my;
2903 memcpy(s->mv, best_s.mv, sizeof(s->mv));
49fb20cb 2904 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3ada94ba
BF
2905 mx=my=0; //FIXME find the one we actually used
2906 ff_mpeg4_set_direct_mv(s, mx, my);
2907 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2908 mx= s->mv[1][0][0];
2909 my= s->mv[1][0][1];
2910 }else{
2911 mx= s->mv[0][0][0];
2912 my= s->mv[0][0][1];
2913 }
2914
2915 s->mv_dir= best_s.mv_dir;
2916 s->mv_type = best_s.mv_type;
2917 s->mb_intra= 0;
2918/* s->mv[0][0][0] = best_s.mv[0][0][0];
2919 s->mv[0][0][1] = best_s.mv[0][0][1];
2920 s->mv[1][0][0] = best_s.mv[1][0][0];
2921 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2922 backup_s.dquant= 0;
2923 s->skipdct=1;
2924 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2925 &dmin, &next_block, mx, my);
2926 s->skipdct=0;
2927 }
2928 }
2929
759001c5 2930 s->current_picture.qscale_table[xy] = best_s.qscale;
3ada94ba
BF
2931
2932 copy_context_after_encode(s, &best_s, -1);
2933
2934 pb_bits_count= put_bits_count(&s->pb);
2935 flush_put_bits(&s->pb);
9f51c682 2936 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3ada94ba
BF
2937 s->pb= backup_s.pb;
2938
2939 if(s->data_partitioning){
2940 pb2_bits_count= put_bits_count(&s->pb2);
2941 flush_put_bits(&s->pb2);
9f51c682 2942 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3ada94ba
BF
2943 s->pb2= backup_s.pb2;
2944
2945 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2946 flush_put_bits(&s->tex_pb);
9f51c682 2947 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3ada94ba
BF
2948 s->tex_pb= backup_s.tex_pb;
2949 }
2950 s->last_bits= put_bits_count(&s->pb);
2951
f34121f3 2952 if (CONFIG_H263_ENCODER &&
975a1447 2953 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3ada94ba
BF
2954 ff_h263_update_motion_val(s);
2955
2956 if(next_block==0){ //FIXME 16 vs linesize16
f4fed5a2
RB
2957 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2958 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2959 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3ada94ba
BF
2960 }
2961
2962 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
efd29844 2963 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2964 } else {
2965 int motion_x = 0, motion_y = 0;
2966 s->mv_type=MV_TYPE_16X16;
2967 // only one MB-Type possible
2968
2969 switch(mb_type){
2970 case CANDIDATE_MB_TYPE_INTRA:
2971 s->mv_dir = 0;
2972 s->mb_intra= 1;
2973 motion_x= s->mv[0][0][0] = 0;
2974 motion_y= s->mv[0][0][1] = 0;
2975 break;
2976 case CANDIDATE_MB_TYPE_INTER:
2977 s->mv_dir = MV_DIR_FORWARD;
2978 s->mb_intra= 0;
2979 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2980 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2981 break;
2982 case CANDIDATE_MB_TYPE_INTER_I:
2983 s->mv_dir = MV_DIR_FORWARD;
2984 s->mv_type = MV_TYPE_FIELD;
2985 s->mb_intra= 0;
2986 for(i=0; i<2; i++){
2987 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2988 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2989 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2990 }
2991 break;
2992 case CANDIDATE_MB_TYPE_INTER4V:
2993 s->mv_dir = MV_DIR_FORWARD;
2994 s->mv_type = MV_TYPE_8X8;
2995 s->mb_intra= 0;
2996 for(i=0; i<4; i++){
759001c5
AK
2997 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2998 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3ada94ba
BF
2999 }
3000 break;
3001 case CANDIDATE_MB_TYPE_DIRECT:
49fb20cb 3002 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
3003 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3004 s->mb_intra= 0;
3005 motion_x=s->b_direct_mv_table[xy][0];
3006 motion_y=s->b_direct_mv_table[xy][1];
3007 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
eb75a698 3008 }
3ada94ba
BF
3009 break;
3010 case CANDIDATE_MB_TYPE_DIRECT0:
49fb20cb 3011 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
3012 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3013 s->mb_intra= 0;
3014 ff_mpeg4_set_direct_mv(s, 0, 0);
eb75a698 3015 }
3ada94ba
BF
3016 break;
3017 case CANDIDATE_MB_TYPE_BIDIR:
3018 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3019 s->mb_intra= 0;
3020 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3021 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3022 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3023 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3024 break;
3025 case CANDIDATE_MB_TYPE_BACKWARD:
3026 s->mv_dir = MV_DIR_BACKWARD;
3027 s->mb_intra= 0;
3028 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3029 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3030 break;
3031 case CANDIDATE_MB_TYPE_FORWARD:
3032 s->mv_dir = MV_DIR_FORWARD;
3033 s->mb_intra= 0;
3034 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3035 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3ada94ba
BF
3036 break;
3037 case CANDIDATE_MB_TYPE_FORWARD_I:
3038 s->mv_dir = MV_DIR_FORWARD;
3039 s->mv_type = MV_TYPE_FIELD;
3040 s->mb_intra= 0;
3041 for(i=0; i<2; i++){
3042 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3043 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3044 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3045 }
3046 break;
3047 case CANDIDATE_MB_TYPE_BACKWARD_I:
3048 s->mv_dir = MV_DIR_BACKWARD;
3049 s->mv_type = MV_TYPE_FIELD;
3050 s->mb_intra= 0;
3051 for(i=0; i<2; i++){
3052 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3053 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3054 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3055 }
3056 break;
3057 case CANDIDATE_MB_TYPE_BIDIR_I:
3058 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3059 s->mv_type = MV_TYPE_FIELD;
3060 s->mb_intra= 0;
3061 for(dir=0; dir<2; dir++){
3062 for(i=0; i<2; i++){
3063 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3064 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3065 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3066 }
3067 }
3068 break;
3069 default:
3070 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3071 }
3072
3073 encode_mb(s, motion_x, motion_y);
3074
3075 // RAL: Update last macroblock type
3076 s->last_mv_dir = s->mv_dir;
3077
f34121f3 3078 if (CONFIG_H263_ENCODER &&
975a1447 3079 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3ada94ba
BF
3080 ff_h263_update_motion_val(s);
3081
efd29844 3082 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
3083 }
3084
3085 /* clean the MV table in IPS frames for direct mode in B frames */
3086 if(s->mb_intra /* && I,P,S_TYPE */){
3087 s->p_mv_table[xy][0]=0;
3088 s->p_mv_table[xy][1]=0;
3089 }
3090
3091 if(s->flags&CODEC_FLAG_PSNR){
3092 int w= 16;
3093 int h= 16;
3094
3095 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3096 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3097
f6774f90 3098 s->current_picture.f->error[0] += sse(
3099 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3ada94ba 3100 s->dest[0], w, h, s->linesize);
f6774f90 3101 s->current_picture.f->error[1] += sse(
3102 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
ec7e2582 3103 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
f6774f90 3104 s->current_picture.f->error[2] += sse(
3105 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
ec7e2582 3106 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3ada94ba
BF
3107 }
3108 if(s->loop_filter){
f34121f3 3109 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3ada94ba
BF
3110 ff_h263_loop_filter(s);
3111 }
1218777f
DB
3112 av_dlog(s->avctx, "MB %d %d bits\n",
3113 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3ada94ba
BF
3114 }
3115 }
3116
3117 //not beautiful here but we must write it before flushing so it has to be here
975a1447 3118 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
04d38225 3119 ff_msmpeg4_encode_ext_header(s);
3ada94ba
BF
3120
3121 write_slice_end(s);
3122
3123 /* Send the last GOB if RTP */
3124 if (s->avctx->rtp_callback) {
3125 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
fb53b4a0 3126 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3ada94ba
BF
3127 /* Call the RTP callback to send the last GOB */
3128 emms_c();
3129 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3130 }
3131
3132 return 0;
3133}
3134
3135#define MERGE(field) dst->field += src->field; src->field=0
3136static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3137 MERGE(me.scene_change_score);
3138 MERGE(me.mc_mb_var_sum_temp);
3139 MERGE(me.mb_var_sum_temp);
3140}
3141
3142static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3143 int i;
3144
3145 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3146 MERGE(dct_count[1]);
3147 MERGE(mv_bits);
3148 MERGE(i_tex_bits);
3149 MERGE(p_tex_bits);
3150 MERGE(i_count);
3151 MERGE(f_count);
3152 MERGE(b_count);
3153 MERGE(skip_count);
3154 MERGE(misc_bits);
54974c62 3155 MERGE(er.error_count);
3ada94ba 3156 MERGE(padding_bug_score);
f6774f90 3157 MERGE(current_picture.f->error[0]);
3158 MERGE(current_picture.f->error[1]);
3159 MERGE(current_picture.f->error[2]);
3ada94ba
BF
3160
3161 if(dst->avctx->noise_reduction){
3162 for(i=0; i<64; i++){
3163 MERGE(dct_error_sum[0][i]);
3164 MERGE(dct_error_sum[1][i]);
3165 }
3166 }
3167
3168 assert(put_bits_count(&src->pb) % 8 ==0);
3169 assert(put_bits_count(&dst->pb) % 8 ==0);
9f51c682 3170 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3ada94ba
BF
3171 flush_put_bits(&dst->pb);
3172}
3173
3174static int estimate_qp(MpegEncContext *s, int dry_run){
3175 if (s->next_lambda){
f6774f90 3176 s->current_picture_ptr->f->quality =
3177 s->current_picture.f->quality = s->next_lambda;
3ada94ba
BF
3178 if(!dry_run) s->next_lambda= 0;
3179 } else if (!s->fixed_qscale) {
f6774f90 3180 s->current_picture_ptr->f->quality =
3181 s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3182 if (s->current_picture.f->quality < 0)
3ada94ba
BF
3183 return -1;
3184 }
3185
3186