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