dv: Split DV data table declarations into their own header
[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;
8c53d39e
RB
1702 s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1703 mb_y * 16, s->width, s->height);
9342ecf0 1704 ptr_y = ebuf;
8c53d39e
RB
1705 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1706 mb_block_height, mb_x * 8, mb_y * 8,
1707 s->width >> 1, s->height >> 1);
9342ecf0 1708 ptr_cb = ebuf + 18 * wrap_y;
8c53d39e
RB
1709 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1710 mb_block_height, mb_x * 8, mb_y * 8,
1711 s->width >> 1, s->height >> 1);
9342ecf0 1712 ptr_cr = ebuf + 18 * wrap_y + 8;
3ada94ba
BF
1713 }
1714
1715 if (s->mb_intra) {
9342ecf0 1716 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1717 int progressive_score, interlaced_score;
1718
9342ecf0
AD
1719 s->interlaced_dct = 0;
1720 progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1721 NULL, wrap_y, 8) +
1722 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1723 NULL, wrap_y, 8) - 400;
1724
1725 if (progressive_score > 0) {
1726 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1727 NULL, wrap_y * 2, 8) +
1728 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1729 NULL, wrap_y * 2, 8);
1730 if (progressive_score > interlaced_score) {
1731 s->interlaced_dct = 1;
1732
1733 dct_offset = wrap_y;
1734 wrap_y <<= 1;
3ada94ba 1735 if (s->chroma_format == CHROMA_422)
9342ecf0 1736 wrap_c <<= 1;
3ada94ba
BF
1737 }
1738 }
1739 }
1740
9342ecf0
AD
1741 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1742 s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1743 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1744 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
3ada94ba 1745
9342ecf0
AD
1746 if (s->flags & CODEC_FLAG_GRAY) {
1747 skip_dct[4] = 1;
1748 skip_dct[5] = 1;
1749 } else {
3ada94ba
BF
1750 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1751 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
9342ecf0
AD
1752 if (!s->chroma_y_shift) { /* 422 */
1753 s->dsp.get_pixels(s->block[6],
1754 ptr_cb + (dct_offset >> 1), wrap_c);
1755 s->dsp.get_pixels(s->block[7],
1756 ptr_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
1757 }
1758 }
9342ecf0 1759 } else {
3ada94ba
BF
1760 op_pixels_func (*op_pix)[4];
1761 qpel_mc_func (*op_qpix)[16];
1762 uint8_t *dest_y, *dest_cb, *dest_cr;
1763
1764 dest_y = s->dest[0];
1765 dest_cb = s->dest[1];
1766 dest_cr = s->dest[2];
1767
9342ecf0 1768 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
f4fed5a2 1769 op_pix = s->hdsp.put_pixels_tab;
9342ecf0
AD
1770 op_qpix = s->dsp.put_qpel_pixels_tab;
1771 } else {
f4fed5a2 1772 op_pix = s->hdsp.put_no_rnd_pixels_tab;
9342ecf0 1773 op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
3ada94ba
BF
1774 }
1775
1776 if (s->mv_dir & MV_DIR_FORWARD) {
7a851153
MR
1777 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1778 s->last_picture.f.data,
1779 op_pix, op_qpix);
f4fed5a2 1780 op_pix = s->hdsp.avg_pixels_tab;
9342ecf0 1781 op_qpix = s->dsp.avg_qpel_pixels_tab;
3ada94ba
BF
1782 }
1783 if (s->mv_dir & MV_DIR_BACKWARD) {
7a851153
MR
1784 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1785 s->next_picture.f.data,
1786 op_pix, op_qpix);
3ada94ba
BF
1787 }
1788
9342ecf0 1789 if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
3ada94ba
BF
1790 int progressive_score, interlaced_score;
1791
9342ecf0
AD
1792 s->interlaced_dct = 0;
1793 progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1794 ptr_y, wrap_y,
1795 8) +
1796 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1797 ptr_y + wrap_y * 8, wrap_y,
1798 8) - 400;
1799
1800 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1801 progressive_score -= 400;
1802
1803 if (progressive_score > 0) {
1804 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1805 ptr_y,
1806 wrap_y * 2, 8) +
1807 s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1808 ptr_y + wrap_y,
1809 wrap_y * 2, 8);
1810
1811 if (progressive_score > interlaced_score) {
1812 s->interlaced_dct = 1;
1813
1814 dct_offset = wrap_y;
1815 wrap_y <<= 1;
3ada94ba 1816 if (s->chroma_format == CHROMA_422)
9342ecf0 1817 wrap_c <<= 1;
3ada94ba
BF
1818 }
1819 }
1820 }
1821
9342ecf0
AD
1822 s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1823 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1824 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1825 dest_y + dct_offset, wrap_y);
1826 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1827 dest_y + dct_offset + 8, wrap_y);
3ada94ba 1828
9342ecf0
AD
1829 if (s->flags & CODEC_FLAG_GRAY) {
1830 skip_dct[4] = 1;
1831 skip_dct[5] = 1;
1832 } else {
3ada94ba
BF
1833 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1834 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
9342ecf0
AD
1835 if (!s->chroma_y_shift) { /* 422 */
1836 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1837 dest_cb + (dct_offset >> 1), wrap_c);
1838 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1839 dest_cr + (dct_offset >> 1), wrap_c);
3ada94ba
BF
1840 }
1841 }
1842 /* pre quantization */
9342ecf0
AD
1843 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1844 2 * s->qscale * s->qscale) {
1845 // FIXME optimize
1846 if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1847 wrap_y, 8) < 20 * s->qscale)
1848 skip_dct[0] = 1;
1849 if (s->dsp.sad[1](NULL, ptr_y + 8,
1850 dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1851 skip_dct[1] = 1;
1852 if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1853 dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1854 skip_dct[2] = 1;
1855 if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1856 dest_y + dct_offset + 8,
1857 wrap_y, 8) < 20 * s->qscale)
1858 skip_dct[3] = 1;
1859 if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1860 wrap_c, 8) < 20 * s->qscale)
1861 skip_dct[4] = 1;
1862 if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1863 wrap_c, 8) < 20 * s->qscale)
1864 skip_dct[5] = 1;
1865 if (!s->chroma_y_shift) { /* 422 */
1866 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1867 dest_cb + (dct_offset >> 1),
1868 wrap_c, 8) < 20 * s->qscale)
1869 skip_dct[6] = 1;
1870 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1871 dest_cr + (dct_offset >> 1),
1872 wrap_c, 8) < 20 * s->qscale)
1873 skip_dct[7] = 1;
3ada94ba
BF
1874 }
1875 }
1876 }
1877
23bfcc06 1878 if (s->quantizer_noise_shaping) {
9342ecf0
AD
1879 if (!skip_dct[0])
1880 get_visual_weight(weight[0], ptr_y , wrap_y);
1881 if (!skip_dct[1])
1882 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
1883 if (!skip_dct[2])
1884 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
1885 if (!skip_dct[3])
1886 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
1887 if (!skip_dct[4])
1888 get_visual_weight(weight[4], ptr_cb , wrap_c);
1889 if (!skip_dct[5])
1890 get_visual_weight(weight[5], ptr_cr , wrap_c);
1891 if (!s->chroma_y_shift) { /* 422 */
1892 if (!skip_dct[6])
1893 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
1894 wrap_c);
1895 if (!skip_dct[7])
1896 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
1897 wrap_c);
3ada94ba 1898 }
88bd7fdc 1899 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
3ada94ba
BF
1900 }
1901
1902 /* DCT & quantize */
9342ecf0 1903 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
3ada94ba 1904 {
9342ecf0
AD
1905 for (i = 0; i < mb_block_count; i++) {
1906 if (!skip_dct[i]) {
3ada94ba
BF
1907 int overflow;
1908 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
9342ecf0
AD
1909 // FIXME we could decide to change to quantizer instead of
1910 // clipping
1911 // JS: I don't think that would be a good idea it could lower
1912 // quality instead of improve it. Just INTRADC clipping
1913 // deserves changes in quantizer
1914 if (overflow)
1915 clip_coeffs(s, s->block[i], s->block_last_index[i]);
1916 } else
1917 s->block_last_index[i] = -1;
3ada94ba 1918 }
23bfcc06 1919 if (s->quantizer_noise_shaping) {
9342ecf0
AD
1920 for (i = 0; i < mb_block_count; i++) {
1921 if (!skip_dct[i]) {
1922 s->block_last_index[i] =
1923 dct_quantize_refine(s, s->block[i], weight[i],
1924 orig[i], i, s->qscale);
3ada94ba
BF
1925 }
1926 }
1927 }
1928
9342ecf0
AD
1929 if (s->luma_elim_threshold && !s->mb_intra)
1930 for (i = 0; i < 4; i++)
3ada94ba 1931 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
9342ecf0
AD
1932 if (s->chroma_elim_threshold && !s->mb_intra)
1933 for (i = 4; i < mb_block_count; i++)
3ada94ba
BF
1934 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
1935
af3d804f 1936 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
9342ecf0
AD
1937 for (i = 0; i < mb_block_count; i++) {
1938 if (s->block_last_index[i] == -1)
1939 s->coded_score[i] = INT_MAX / 256;
3ada94ba
BF
1940 }
1941 }
1942 }
1943
9342ecf0
AD
1944 if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
1945 s->block_last_index[4] =
1946 s->block_last_index[5] = 0;
1947 s->block[4][0] =
1948 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
3ada94ba
BF
1949 }
1950
9342ecf0 1951 // non c quantize code returns incorrect block_last_index FIXME
99560a4c 1952 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
9342ecf0 1953 for (i = 0; i < mb_block_count; i++) {
3ada94ba 1954 int j;
9342ecf0
AD
1955 if (s->block_last_index[i] > 0) {
1956 for (j = 63; j > 0; j--) {
1957 if (s->block[i][s->intra_scantable.permutated[j]])
1958 break;
3ada94ba 1959 }
9342ecf0 1960 s->block_last_index[i] = j;
3ada94ba
BF
1961 }
1962 }
1963 }
1964
1965 /* huffman encode */
1966 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
36ef5369
AK
1967 case AV_CODEC_ID_MPEG1VIDEO:
1968 case AV_CODEC_ID_MPEG2VIDEO:
49fb20cb 1969 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
d6c8dcb8 1970 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
56be950a 1971 break;
36ef5369 1972 case AV_CODEC_ID_MPEG4:
49fb20cb 1973 if (CONFIG_MPEG4_ENCODER)
6f13a371 1974 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
674eeb5f 1975 break;
36ef5369
AK
1976 case AV_CODEC_ID_MSMPEG4V2:
1977 case AV_CODEC_ID_MSMPEG4V3:
1978 case AV_CODEC_ID_WMV1:
49fb20cb 1979 if (CONFIG_MSMPEG4_ENCODER)
04d38225 1980 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
3ada94ba 1981 break;
36ef5369 1982 case AV_CODEC_ID_WMV2:
49fb20cb 1983 if (CONFIG_WMV2_ENCODER)
3ada94ba
BF
1984 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
1985 break;
36ef5369 1986 case AV_CODEC_ID_H261:
49fb20cb 1987 if (CONFIG_H261_ENCODER)
3ada94ba
BF
1988 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
1989 break;
36ef5369
AK
1990 case AV_CODEC_ID_H263:
1991 case AV_CODEC_ID_H263P:
1992 case AV_CODEC_ID_FLV1:
1993 case AV_CODEC_ID_RV10:
1994 case AV_CODEC_ID_RV20:
0bd48530 1995 if (CONFIG_H263_ENCODER)
ddce8953 1996 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
674eeb5f 1997 break;
36ef5369 1998 case AV_CODEC_ID_MJPEG:
49fb20cb 1999 if (CONFIG_MJPEG_ENCODER)
3ada94ba
BF
2000 ff_mjpeg_encode_mb(s, s->block);
2001 break;
2002 default:
2003 assert(0);
2004 }
2005}
2006
2007static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2008{
2009 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2010 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2011}
2012
3ada94ba
BF
2013static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2014 int i;
2015
be73d76b 2016 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
3ada94ba
BF
2017
2018 /* mpeg1 */
2019 d->mb_skip_run= s->mb_skip_run;
2020 for(i=0; i<3; i++)
9342ecf0 2021 d->last_dc[i] = s->last_dc[i];
3ada94ba
BF
2022
2023 /* statistics */
2024 d->mv_bits= s->mv_bits;
2025 d->i_tex_bits= s->i_tex_bits;
2026 d->p_tex_bits= s->p_tex_bits;
2027 d->i_count= s->i_count;
2028 d->f_count= s->f_count;
2029 d->b_count= s->b_count;
2030 d->skip_count= s->skip_count;
2031 d->misc_bits= s->misc_bits;
2032 d->last_bits= 0;
2033
2034 d->mb_skipped= 0;
2035 d->qscale= s->qscale;
2036 d->dquant= s->dquant;
9f175aa0
MN
2037
2038 d->esc3_level_length= s->esc3_level_length;
3ada94ba
BF
2039}
2040
2041static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2042 int i;
2043
2044 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
be73d76b 2045 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
3ada94ba
BF
2046
2047 /* mpeg1 */
2048 d->mb_skip_run= s->mb_skip_run;
2049 for(i=0; i<3; i++)
9342ecf0 2050 d->last_dc[i] = s->last_dc[i];
3ada94ba
BF
2051
2052 /* statistics */
2053 d->mv_bits= s->mv_bits;
2054 d->i_tex_bits= s->i_tex_bits;
2055 d->p_tex_bits= s->p_tex_bits;
2056 d->i_count= s->i_count;
2057 d->f_count= s->f_count;
2058 d->b_count= s->b_count;
2059 d->skip_count= s->skip_count;
2060 d->misc_bits= s->misc_bits;
2061
2062 d->mb_intra= s->mb_intra;
2063 d->mb_skipped= s->mb_skipped;
2064 d->mv_type= s->mv_type;
2065 d->mv_dir= s->mv_dir;
2066 d->pb= s->pb;
2067 if(s->data_partitioning){
2068 d->pb2= s->pb2;
2069 d->tex_pb= s->tex_pb;
2070 }
2071 d->block= s->block;
2072 for(i=0; i<8; i++)
2073 d->block_last_index[i]= s->block_last_index[i];
2074 d->interlaced_dct= s->interlaced_dct;
2075 d->qscale= s->qscale;
9f175aa0
MN
2076
2077 d->esc3_level_length= s->esc3_level_length;
3ada94ba
BF
2078}
2079
2080static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2081 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2082 int *dmin, int *next_block, int motion_x, int motion_y)
2083{
2084 int score;
2085 uint8_t *dest_backup[3];
2086
2087 copy_context_before_encode(s, backup, type);
2088
2089 s->block= s->blocks[*next_block];
2090 s->pb= pb[*next_block];
2091 if(s->data_partitioning){
2092 s->pb2 = pb2 [*next_block];
2093 s->tex_pb= tex_pb[*next_block];
2094 }
2095
2096 if(*next_block){
2097 memcpy(dest_backup, s->dest, sizeof(s->dest));
2098 s->dest[0] = s->rd_scratchpad;
2099 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2100 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2101 assert(s->linesize >= 32); //FIXME
2102 }
2103
2104 encode_mb(s, motion_x, motion_y);
2105
2106 score= put_bits_count(&s->pb);
2107 if(s->data_partitioning){
2108 score+= put_bits_count(&s->pb2);
2109 score+= put_bits_count(&s->tex_pb);
2110 }
2111
2112 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
efd29844 2113 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2114
2115 score *= s->lambda2;
2116 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2117 }
2118
2119 if(*next_block){
2120 memcpy(s->dest, dest_backup, sizeof(s->dest));
2121 }
2122
2123 if(score<*dmin){
2124 *dmin= score;
2125 *next_block^=1;
2126
2127 copy_context_after_encode(best, s, type);
2128 }
2129}
2130
2131static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2132 uint32_t *sq = ff_squareTbl + 256;
2133 int acc=0;
2134 int x,y;
2135
2136 if(w==16 && h==16)
2137 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2138 else if(w==8 && h==8)
2139 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2140
2141 for(y=0; y<h; y++){
2142 for(x=0; x<w; x++){
2143 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2144 }
2145 }
2146
2147 assert(acc>=0);
2148
2149 return acc;
2150}
2151
2152static int sse_mb(MpegEncContext *s){
2153 int w= 16;
2154 int h= 16;
2155
2156 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2157 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2158
2159 if(w==16 && h==16)
2160 if(s->avctx->mb_cmp == FF_CMP_NSSE){
657ccb5a
DB
2161 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)
2162 +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)
2163 +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 2164 }else{
657ccb5a
DB
2165 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)
2166 +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)
2167 +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
2168 }
2169 else
657ccb5a
DB
2170 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)
2171 +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)
2172 +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
2173}
2174
2175static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3a84713a 2176 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2177
2178
2179 s->me.pre_pass=1;
2180 s->me.dia_size= s->avctx->pre_dia_size;
2181 s->first_slice_line=1;
2182 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2183 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2184 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2185 }
2186 s->first_slice_line=0;
2187 }
2188
2189 s->me.pre_pass=0;
2190
2191 return 0;
2192}
2193
2194static int estimate_motion_thread(AVCodecContext *c, void *arg){
3a84713a 2195 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2196
2197 ff_check_alignment();
2198
2199 s->me.dia_size= s->avctx->dia_size;
2200 s->first_slice_line=1;
2201 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2202 s->mb_x=0; //for block init below
2203 ff_init_block_index(s);
2204 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2205 s->block_index[0]+=2;
2206 s->block_index[1]+=2;
2207 s->block_index[2]+=2;
2208 s->block_index[3]+=2;
2209
2210 /* compute motion vector & mb_type and store in context */
975a1447 2211 if(s->pict_type==AV_PICTURE_TYPE_B)
3ada94ba
BF
2212 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2213 else
2214 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2215 }
2216 s->first_slice_line=0;
2217 }
2218 return 0;
2219}
2220
2221static int mb_var_thread(AVCodecContext *c, void *arg){
3a84713a 2222 MpegEncContext *s= *(void**)arg;
3ada94ba
BF
2223 int mb_x, mb_y;
2224
2225 ff_check_alignment();
2226
2227 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2228 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2229 int xx = mb_x * 16;
2230 int yy = mb_y * 16;
657ccb5a 2231 uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
3ada94ba
BF
2232 int varc;
2233 int sum = s->dsp.pix_sum(pix, s->linesize);
2234
05795f35 2235 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
3ada94ba
BF
2236
2237 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2238 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2239 s->me.mb_var_sum_temp += varc;
2240 }
2241 }
2242 return 0;
2243}
2244
2245static void write_slice_end(MpegEncContext *s){
36ef5369 2246 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
3ada94ba
BF
2247 if(s->partitioned_frame){
2248 ff_mpeg4_merge_partitions(s);
2249 }
2250
2251 ff_mpeg4_stuffing(&s->pb);
49fb20cb 2252 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
3ada94ba
BF
2253 ff_mjpeg_encode_stuffing(&s->pb);
2254 }
2255
9f51c682 2256 avpriv_align_put_bits(&s->pb);
3ada94ba
BF
2257 flush_put_bits(&s->pb);
2258
2259 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2260 s->misc_bits+= get_bits_diff(s);
2261}
2262
bdc1220e
MS
2263static void write_mb_info(MpegEncContext *s)
2264{
2265 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2266 int offset = put_bits_count(&s->pb);
2267 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2268 int gobn = s->mb_y / s->gob_index;
2269 int pred_x, pred_y;
2270 if (CONFIG_H263_ENCODER)
2271 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2272 bytestream_put_le32(&ptr, offset);
2273 bytestream_put_byte(&ptr, s->qscale);
2274 bytestream_put_byte(&ptr, gobn);
2275 bytestream_put_le16(&ptr, mba);
2276 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2277 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2278 /* 4MV not implemented */
2279 bytestream_put_byte(&ptr, 0); /* hmv2 */
2280 bytestream_put_byte(&ptr, 0); /* vmv2 */
2281}
2282
2283static void update_mb_info(MpegEncContext *s, int startcode)
2284{
2285 if (!s->mb_info)
2286 return;
2287 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2288 s->mb_info_size += 12;
2289 s->prev_mb_info = s->last_mb_info;
2290 }
2291 if (startcode) {
2292 s->prev_mb_info = put_bits_count(&s->pb)/8;
2293 /* This might have incremented mb_info_size above, and we return without
2294 * actually writing any info into that slot yet. But in that case,
2295 * this will be called again at the start of the after writing the
2296 * start code, actually writing the mb info. */
2297 return;
2298 }
2299
2300 s->last_mb_info = put_bits_count(&s->pb)/8;
2301 if (!s->mb_info_size)
2302 s->mb_info_size += 12;
2303 write_mb_info(s);
2304}
2305
3ada94ba 2306static int encode_thread(AVCodecContext *c, void *arg){
3a84713a 2307 MpegEncContext *s= *(void**)arg;
3ada94ba 2308 int mb_x, mb_y, pdif = 0;
ec7e2582 2309 int chr_h= 16>>s->chroma_y_shift;
3ada94ba
BF
2310 int i, j;
2311 MpegEncContext best_s, backup_s;
2312 uint8_t bit_buf[2][MAX_MB_BYTES];
2313 uint8_t bit_buf2[2][MAX_MB_BYTES];
2314 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2315 PutBitContext pb[2], pb2[2], tex_pb[2];
3ada94ba
BF
2316
2317 ff_check_alignment();
2318
2319 for(i=0; i<2; i++){
2320 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2321 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2322 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2323 }
2324
2325 s->last_bits= put_bits_count(&s->pb);
2326 s->mv_bits=0;
2327 s->misc_bits=0;
2328 s->i_tex_bits=0;
2329 s->p_tex_bits=0;
2330 s->i_count=0;
2331 s->f_count=0;
2332 s->b_count=0;
2333 s->skip_count=0;
2334
2335 for(i=0; i<3; i++){
2336 /* init last dc values */
2337 /* note: quant matrix value (8) is implied here */
2338 s->last_dc[i] = 128 << s->intra_dc_precision;
2339
657ccb5a 2340 s->current_picture.f.error[i] = 0;
3ada94ba
BF
2341 }
2342 s->mb_skip_run = 0;
2343 memset(s->last_mv, 0, sizeof(s->last_mv));
2344
2345 s->last_mv_dir = 0;
2346
2347 switch(s->codec_id){
36ef5369
AK
2348 case AV_CODEC_ID_H263:
2349 case AV_CODEC_ID_H263P:
2350 case AV_CODEC_ID_FLV1:
0bd48530 2351 if (CONFIG_H263_ENCODER)
674eeb5f 2352 s->gob_index = ff_h263_get_gob_height(s);
3ada94ba 2353 break;
36ef5369 2354 case AV_CODEC_ID_MPEG4:
49fb20cb 2355 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3ada94ba
BF
2356 ff_mpeg4_init_partitions(s);
2357 break;
2358 }
2359
2360 s->resync_mb_x=0;
2361 s->resync_mb_y=0;
2362 s->first_slice_line = 1;
2363 s->ptr_lastgob = s->pb.buf;
2364 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3ada94ba
BF
2365 s->mb_x=0;
2366 s->mb_y= mb_y;
2367
2368 ff_set_qscale(s, s->qscale);
2369 ff_init_block_index(s);
2370
2371 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2372 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2373 int mb_type= s->mb_type[xy];
2374// int d;
2375 int dmin= INT_MAX;
2376 int dir;
2377
2378 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2379 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2380 return -1;
2381 }
2382 if(s->data_partitioning){
2383 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2384 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2385 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2386 return -1;
2387 }
2388 }
2389
2390 s->mb_x = mb_x;
2391 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2392 ff_update_block_index(s);
2393
36ef5369 2394 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3ada94ba
BF
2395 ff_h261_reorder_mb_index(s);
2396 xy= s->mb_y*s->mb_stride + s->mb_x;
2397 mb_type= s->mb_type[xy];
2398 }
2399
2400 /* write gob / video packet header */
2401 if(s->rtp_mode){
2402 int current_packet_size, is_gob_start;
2403
2404 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2405
2406 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2407
2408 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2409
2410 switch(s->codec_id){
36ef5369
AK
2411 case AV_CODEC_ID_H263:
2412 case AV_CODEC_ID_H263P:
3ada94ba
BF
2413 if(!s->h263_slice_structured)
2414 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2415 break;
36ef5369 2416 case AV_CODEC_ID_MPEG2VIDEO:
3ada94ba 2417 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
36ef5369 2418 case AV_CODEC_ID_MPEG1VIDEO:
3ada94ba
BF
2419 if(s->mb_skip_run) is_gob_start=0;
2420 break;
2421 }
2422
2423 if(is_gob_start){
2424 if(s->start_mb_y != mb_y || mb_x!=0){
2425 write_slice_end(s);
2426
36ef5369 2427 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3ada94ba
BF
2428 ff_mpeg4_init_partitions(s);
2429 }
2430 }
2431
2432 assert((put_bits_count(&s->pb)&7) == 0);
fb53b4a0 2433 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3ada94ba 2434
8941971a 2435 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3ada94ba 2436 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
8941971a 2437 int d = 100 / s->error_rate;
3ada94ba
BF
2438 if(r % d == 0){
2439 current_packet_size=0;
3ada94ba 2440 s->pb.buf_ptr= s->ptr_lastgob;
fb53b4a0 2441 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3ada94ba
BF
2442 }
2443 }
2444
2445 if (s->avctx->rtp_callback){
2446 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2447 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2448 }
bdc1220e 2449 update_mb_info(s, 1);
3ada94ba
BF
2450
2451 switch(s->codec_id){
36ef5369 2452 case AV_CODEC_ID_MPEG4:
49fb20cb 2453 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2454 ff_mpeg4_encode_video_packet_header(s);
2455 ff_mpeg4_clean_buffers(s);
eb75a698 2456 }
3ada94ba 2457 break;
36ef5369
AK
2458 case AV_CODEC_ID_MPEG1VIDEO:
2459 case AV_CODEC_ID_MPEG2VIDEO:
49fb20cb 2460 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
56be950a
AJ
2461 ff_mpeg1_encode_slice_header(s);
2462 ff_mpeg1_clean_buffers(s);
a6bc5731 2463 }
3ada94ba 2464 break;
36ef5369
AK
2465 case AV_CODEC_ID_H263:
2466 case AV_CODEC_ID_H263P:
965424da 2467 if (CONFIG_H263_ENCODER)
ddce8953 2468 ff_h263_encode_gob_header(s, mb_y);
3ada94ba
BF
2469 break;
2470 }
2471
2472 if(s->flags&CODEC_FLAG_PASS1){
2473 int bits= put_bits_count(&s->pb);
2474 s->misc_bits+= bits - s->last_bits;
2475 s->last_bits= bits;
2476 }
2477
2478 s->ptr_lastgob += current_packet_size;
2479 s->first_slice_line=1;
2480 s->resync_mb_x=mb_x;
2481 s->resync_mb_y=mb_y;
2482 }
2483 }
2484
2485 if( (s->resync_mb_x == s->mb_x)
2486 && s->resync_mb_y+1 == s->mb_y){
2487 s->first_slice_line=0;
2488 }
2489
2490 s->mb_skipped=0;
2491 s->dquant=0; //only for QP_RD
2492
bdc1220e
MS
2493 update_mb_info(s, 0);
2494
ff71a383 2495 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
2496 int next_block=0;
2497 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2498
2499 copy_context_before_encode(&backup_s, s, -1);
2500 backup_s.pb= s->pb;
2501 best_s.data_partitioning= s->data_partitioning;
2502 best_s.partitioned_frame= s->partitioned_frame;
2503 if(s->data_partitioning){
2504 backup_s.pb2= s->pb2;
2505 backup_s.tex_pb= s->tex_pb;
2506 }
2507
2508 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2509 s->mv_dir = MV_DIR_FORWARD;
2510 s->mv_type = MV_TYPE_16X16;
2511 s->mb_intra= 0;
2512 s->mv[0][0][0] = s->p_mv_table[xy][0];
2513 s->mv[0][0][1] = s->p_mv_table[xy][1];
2514 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2515 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2516 }
2517 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2518 s->mv_dir = MV_DIR_FORWARD;
2519 s->mv_type = MV_TYPE_FIELD;
2520 s->mb_intra= 0;
2521 for(i=0; i<2; i++){
2522 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2523 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2524 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2525 }
2526 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2527 &dmin, &next_block, 0, 0);
2528 }
2529 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2530 s->mv_dir = MV_DIR_FORWARD;
2531 s->mv_type = MV_TYPE_16X16;
2532 s->mb_intra= 0;
2533 s->mv[0][0][0] = 0;
2534 s->mv[0][0][1] = 0;
2535 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2536 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2537 }
2538 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2539 s->mv_dir = MV_DIR_FORWARD;
2540 s->mv_type = MV_TYPE_8X8;
2541 s->mb_intra= 0;
2542 for(i=0; i<4; i++){
759001c5
AK
2543 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2544 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3ada94ba
BF
2545 }
2546 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2547 &dmin, &next_block, 0, 0);
2548 }
2549 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2550 s->mv_dir = MV_DIR_FORWARD;
2551 s->mv_type = MV_TYPE_16X16;
2552 s->mb_intra= 0;
2553 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2554 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2555 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2556 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2557 }
2558 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2559 s->mv_dir = MV_DIR_BACKWARD;
2560 s->mv_type = MV_TYPE_16X16;
2561 s->mb_intra= 0;
2562 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2563 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2564 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2565 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2566 }
2567 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2568 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2569 s->mv_type = MV_TYPE_16X16;
2570 s->mb_intra= 0;
2571 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2572 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2573 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2574 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2575 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2576 &dmin, &next_block, 0, 0);
2577 }
2578 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2579 s->mv_dir = MV_DIR_FORWARD;
2580 s->mv_type = MV_TYPE_FIELD;
2581 s->mb_intra= 0;
2582 for(i=0; i<2; i++){
2583 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2584 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2585 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2586 }
2587 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2588 &dmin, &next_block, 0, 0);
2589 }
2590 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2591 s->mv_dir = MV_DIR_BACKWARD;
2592 s->mv_type = MV_TYPE_FIELD;
2593 s->mb_intra= 0;
2594 for(i=0; i<2; i++){
2595 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2596 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2597 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2598 }
2599 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2600 &dmin, &next_block, 0, 0);
2601 }
2602 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2603 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2604 s->mv_type = MV_TYPE_FIELD;
2605 s->mb_intra= 0;
2606 for(dir=0; dir<2; dir++){
2607 for(i=0; i<2; i++){
2608 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2609 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2610 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2611 }
2612 }
2613 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2614 &dmin, &next_block, 0, 0);
2615 }
2616 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2617 s->mv_dir = 0;
2618 s->mv_type = MV_TYPE_16X16;
2619 s->mb_intra= 1;
2620 s->mv[0][0][0] = 0;
2621 s->mv[0][0][1] = 0;
2622 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2623 &dmin, &next_block, 0, 0);
2624 if(s->h263_pred || s->h263_aic){
2625 if(best_s.mb_intra)
2626 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2627 else
2628 ff_clean_intra_table_entries(s); //old mode?
2629 }
2630 }
2631
ff71a383 2632 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3ada94ba
BF
2633 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2634 const int last_qp= backup_s.qscale;
2635 int qpi, qp, dc[6];
88bd7fdc 2636 int16_t ac[6][16];
3ada94ba
BF
2637 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2638 static const int dquant_tab[4]={-1,1,-2,2};
2639
2640 assert(backup_s.dquant == 0);
2641
2642 //FIXME intra
2643 s->mv_dir= best_s.mv_dir;
2644 s->mv_type = MV_TYPE_16X16;
2645 s->mb_intra= best_s.mb_intra;
2646 s->mv[0][0][0] = best_s.mv[0][0][0];
2647 s->mv[0][0][1] = best_s.mv[0][0][1];
2648 s->mv[1][0][0] = best_s.mv[1][0][0];
2649 s->mv[1][0][1] = best_s.mv[1][0][1];
2650
975a1447 2651 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3ada94ba
BF
2652 for(; qpi<4; qpi++){
2653 int dquant= dquant_tab[qpi];
2654 qp= last_qp + dquant;
2655 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2656 continue;
2657 backup_s.dquant= dquant;
2658 if(s->mb_intra && s->dc_val[0]){
2659 for(i=0; i<6; i++){
2660 dc[i]= s->dc_val[0][ s->block_index[i] ];
88bd7fdc 2661 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3ada94ba
BF
2662 }
2663 }
2664
2665 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2666 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2667 if(best_s.qscale != qp){
2668 if(s->mb_intra && s->dc_val[0]){
2669 for(i=0; i<6; i++){
2670 s->dc_val[0][ s->block_index[i] ]= dc[i];
88bd7fdc 2671 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3ada94ba
BF
2672 }
2673 }
2674 }
2675 }
2676 }
2677 }
49fb20cb 2678 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3ada94ba
BF
2679 int mx= s->b_direct_mv_table[xy][0];
2680 int my= s->b_direct_mv_table[xy][1];
2681
2682 backup_s.dquant = 0;
2683 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2684 s->mb_intra= 0;
2685 ff_mpeg4_set_direct_mv(s, mx, my);
2686 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2687 &dmin, &next_block, mx, my);
2688 }
49fb20cb 2689 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3ada94ba
BF
2690 backup_s.dquant = 0;
2691 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2692 s->mb_intra= 0;
2693 ff_mpeg4_set_direct_mv(s, 0, 0);
2694 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2695 &dmin, &next_block, 0, 0);
2696 }
ed019b8e 2697 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3ada94ba
BF
2698 int coded=0;
2699 for(i=0; i<6; i++)
2700 coded |= s->block_last_index[i];
2701 if(coded){
2702 int mx,my;
2703 memcpy(s->mv, best_s.mv, sizeof(s->mv));
49fb20cb 2704 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3ada94ba
BF
2705 mx=my=0; //FIXME find the one we actually used
2706 ff_mpeg4_set_direct_mv(s, mx, my);
2707 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2708 mx= s->mv[1][0][0];
2709 my= s->mv[1][0][1];
2710 }else{
2711 mx= s->mv[0][0][0];
2712 my= s->mv[0][0][1];
2713 }
2714
2715 s->mv_dir= best_s.mv_dir;
2716 s->mv_type = best_s.mv_type;
2717 s->mb_intra= 0;
2718/* s->mv[0][0][0] = best_s.mv[0][0][0];
2719 s->mv[0][0][1] = best_s.mv[0][0][1];
2720 s->mv[1][0][0] = best_s.mv[1][0][0];
2721 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2722 backup_s.dquant= 0;
2723 s->skipdct=1;
2724 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2725 &dmin, &next_block, mx, my);
2726 s->skipdct=0;
2727 }
2728 }
2729
759001c5 2730 s->current_picture.qscale_table[xy] = best_s.qscale;
3ada94ba
BF
2731
2732 copy_context_after_encode(s, &best_s, -1);
2733
2734 pb_bits_count= put_bits_count(&s->pb);
2735 flush_put_bits(&s->pb);
9f51c682 2736 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3ada94ba
BF
2737 s->pb= backup_s.pb;
2738
2739 if(s->data_partitioning){
2740 pb2_bits_count= put_bits_count(&s->pb2);
2741 flush_put_bits(&s->pb2);
9f51c682 2742 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3ada94ba
BF
2743 s->pb2= backup_s.pb2;
2744
2745 tex_pb_bits_count= put_bits_count(&s->tex_pb);
2746 flush_put_bits(&s->tex_pb);
9f51c682 2747 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3ada94ba
BF
2748 s->tex_pb= backup_s.tex_pb;
2749 }
2750 s->last_bits= put_bits_count(&s->pb);
2751
f34121f3 2752 if (CONFIG_H263_ENCODER &&
975a1447 2753 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3ada94ba
BF
2754 ff_h263_update_motion_val(s);
2755
2756 if(next_block==0){ //FIXME 16 vs linesize16
f4fed5a2
RB
2757 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2758 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2759 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3ada94ba
BF
2760 }
2761
2762 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
efd29844 2763 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2764 } else {
2765 int motion_x = 0, motion_y = 0;
2766 s->mv_type=MV_TYPE_16X16;
2767 // only one MB-Type possible
2768
2769 switch(mb_type){
2770 case CANDIDATE_MB_TYPE_INTRA:
2771 s->mv_dir = 0;
2772 s->mb_intra= 1;
2773 motion_x= s->mv[0][0][0] = 0;
2774 motion_y= s->mv[0][0][1] = 0;
2775 break;
2776 case CANDIDATE_MB_TYPE_INTER:
2777 s->mv_dir = MV_DIR_FORWARD;
2778 s->mb_intra= 0;
2779 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2780 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2781 break;
2782 case CANDIDATE_MB_TYPE_INTER_I:
2783 s->mv_dir = MV_DIR_FORWARD;
2784 s->mv_type = MV_TYPE_FIELD;
2785 s->mb_intra= 0;
2786 for(i=0; i<2; i++){
2787 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2788 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2789 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2790 }
2791 break;
2792 case CANDIDATE_MB_TYPE_INTER4V:
2793 s->mv_dir = MV_DIR_FORWARD;
2794 s->mv_type = MV_TYPE_8X8;
2795 s->mb_intra= 0;
2796 for(i=0; i<4; i++){
759001c5
AK
2797 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2798 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3ada94ba
BF
2799 }
2800 break;
2801 case CANDIDATE_MB_TYPE_DIRECT:
49fb20cb 2802 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2803 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2804 s->mb_intra= 0;
2805 motion_x=s->b_direct_mv_table[xy][0];
2806 motion_y=s->b_direct_mv_table[xy][1];
2807 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
eb75a698 2808 }
3ada94ba
BF
2809 break;
2810 case CANDIDATE_MB_TYPE_DIRECT0:
49fb20cb 2811 if (CONFIG_MPEG4_ENCODER) {
674eeb5f
AJ
2812 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2813 s->mb_intra= 0;
2814 ff_mpeg4_set_direct_mv(s, 0, 0);
eb75a698 2815 }
3ada94ba
BF
2816 break;
2817 case CANDIDATE_MB_TYPE_BIDIR:
2818 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2819 s->mb_intra= 0;
2820 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2821 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2822 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2823 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2824 break;
2825 case CANDIDATE_MB_TYPE_BACKWARD:
2826 s->mv_dir = MV_DIR_BACKWARD;
2827 s->mb_intra= 0;
2828 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2829 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2830 break;
2831 case CANDIDATE_MB_TYPE_FORWARD:
2832 s->mv_dir = MV_DIR_FORWARD;
2833 s->mb_intra= 0;
2834 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2835 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3ada94ba
BF
2836 break;
2837 case CANDIDATE_MB_TYPE_FORWARD_I:
2838 s->mv_dir = MV_DIR_FORWARD;
2839 s->mv_type = MV_TYPE_FIELD;
2840 s->mb_intra= 0;
2841 for(i=0; i<2; i++){
2842 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2843 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2844 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2845 }
2846 break;
2847 case CANDIDATE_MB_TYPE_BACKWARD_I:
2848 s->mv_dir = MV_DIR_BACKWARD;
2849 s->mv_type = MV_TYPE_FIELD;
2850 s->mb_intra= 0;
2851 for(i=0; i<2; i++){
2852 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2853 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2854 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2855 }
2856 break;
2857 case CANDIDATE_MB_TYPE_BIDIR_I:
2858 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2859 s->mv_type = MV_TYPE_FIELD;
2860 s->mb_intra= 0;
2861 for(dir=0; dir<2; dir++){
2862 for(i=0; i<2; i++){
2863 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2864 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2865 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2866 }
2867 }
2868 break;
2869 default:
2870 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
2871 }
2872
2873 encode_mb(s, motion_x, motion_y);
2874
2875 // RAL: Update last macroblock type
2876 s->last_mv_dir = s->mv_dir;
2877
f34121f3 2878 if (CONFIG_H263_ENCODER &&
975a1447 2879 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3ada94ba
BF
2880 ff_h263_update_motion_val(s);
2881
efd29844 2882 ff_MPV_decode_mb(s, s->block);
3ada94ba
BF
2883 }
2884
2885 /* clean the MV table in IPS frames for direct mode in B frames */
2886 if(s->mb_intra /* && I,P,S_TYPE */){
2887 s->p_mv_table[xy][0]=0;
2888 s->p_mv_table[xy][1]=0;
2889 }
2890
2891 if(s->flags&CODEC_FLAG_PSNR){
2892 int w= 16;
2893 int h= 16;
2894
2895 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2896 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2897
657ccb5a
DB
2898 s->current_picture.f.error[0] += sse(
2899 s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3ada94ba 2900 s->dest[0], w, h, s->linesize);
657ccb5a
DB
2901 s->current_picture.f.error[1] += sse(
2902 s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
ec7e2582 2903 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
657ccb5a
DB
2904 s->current_picture.f.error[2] += sse(
2905 s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
ec7e2582 2906 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3ada94ba
BF
2907 }
2908 if(s->loop_filter){
f34121f3 2909 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3ada94ba
BF
2910 ff_h263_loop_filter(s);
2911 }
1218777f
DB
2912 av_dlog(s->avctx, "MB %d %d bits\n",
2913 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3ada94ba
BF
2914 }
2915 }
2916
2917 //not beautiful here but we must write it before flushing so it has to be here
975a1447 2918 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
04d38225 2919 ff_msmpeg4_encode_ext_header(s);
3ada94ba
BF
2920
2921 write_slice_end(s);
2922
2923 /* Send the last GOB if RTP */
2924 if (s->avctx->rtp_callback) {
2925 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
fb53b4a0 2926 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3ada94ba
BF
2927 /* Call the RTP callback to send the last GOB */
2928 emms_c();
2929 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
2930 }
2931
2932 return 0;
2933}
2934
2935#define MERGE(field) dst->field += src->field; src->field=0
2936static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
2937 MERGE(me.scene_change_score);
2938 MERGE(me.mc_mb_var_sum_temp);
2939 MERGE(me.mb_var_sum_temp);
2940}
2941
2942static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
2943 int i;
2944
2945 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
2946 MERGE(dct_count[1]);
2947 MERGE(mv_bits);
2948 MERGE(i_tex_bits);
2949 MERGE(p_tex_bits);
2950 MERGE(i_count);
2951 MERGE(f_count);
2952 MERGE(b_count);
2953 MERGE(skip_count);
2954 MERGE(misc_bits);
54974c62 2955 MERGE(er.error_count);
3ada94ba 2956 MERGE(padding_bug_score);
657ccb5a
DB
2957 MERGE(current_picture.f.error[0]);
2958 MERGE(current_picture.f.error[1]);
2959 MERGE(current_picture.f.error[2]);
3ada94ba
BF
2960
2961 if(dst->avctx->noise_reduction){
2962 for(i=0; i<64; i++){
2963 MERGE(dct_error_sum[0][i]);
2964 MERGE(dct_error_sum[1][i]);
2965 }
2966 }
2967
2968 assert(put_bits_count(&src->pb) % 8 ==0);
2969 assert(put_bits_count(&dst->pb) % 8 ==0);
9f51c682 2970 avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3ada94ba
BF
2971 flush_put_bits(&dst->pb);
2972}
2973
2974static int estimate_qp(MpegEncContext *s, int dry_run){
2975 if (s->next_lambda){
657ccb5a
DB
2976 s->current_picture_ptr->f.quality =
2977 s->current_picture.f.quality = s->next_lambda;
3ada94ba
BF
2978 if(!dry_run) s->next_lambda= 0;
2979 } else if (!s->fixed_qscale) {
657ccb5a
DB
2980 s->current_picture_ptr->f.quality =
2981 s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
2982 if (s->current_picture.f.quality < 0)
3ada94ba
BF
2983 return -1;
2984 }
2985
2986 if(s->adaptive_quant){
2987 switch(s->codec_id){
36ef5369 2988 case AV_CODEC_ID_MPEG4:
49fb20cb 2989 if (CONFIG_MPEG4_ENCODER)
674eeb5f 2990 ff_clean_mpeg4_qscales(s);
3ada94ba 2991 break;
36ef5369
AK
2992 case AV_CODEC_ID_H263:
2993 case AV_CODEC_ID_H263P:
2994 case AV_CODEC_ID_FLV1:
0bd48530 2995 if (CONFIG_H263_ENCODER)
674eeb5f 2996 ff_clean_h263_qscales(s);
3ada94ba 2997 break;
ccc4b918
MN
2998 default:
2999 ff_init_qscale_tab(s);
3ada94ba
BF
3000 }
3001
3002 s->lambda= s->lambda_table[0];
3003 //FIXME broken
3004 }else
657ccb5a 3005 s->lambda = s->current_picture.f.quality;
3ada94ba
BF
3006 update_qscale(s);
3007 return 0;
3008}
3009
7da31a80
AJ
3010/* must be called before writing the header */
3011static void set_frame_distances(MpegEncContext * s){
95a06eb4 3012 assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
657ccb5a 3013 s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
7da31a80 3014
975a1447 3015 if(s->pict_type==AV_PICTURE_TYPE_B){
7da31a80
AJ
3016 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3017 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3018 }else{
3019 s->pp_time= s->time - s->last_non_b_time;
3020 s->last_non_b_time= s->time;
3021 assert(s->picture_number==0 || s->pp_time > 0);
3022 }
3023}
3024
3ada94ba
BF
3025static int encode_picture(MpegEncContext *s, int picture_number)
3026{
f1d8763a 3027 int i, ret;
3ada94ba 3028 int bits;
881a5e04 3029 int context_count = s->slice_context_count;
3ada94ba
BF
3030
3031 s->picture_number = picture_number;
3032
3033 /* Reset the average MB variance */
3034 s->me.mb_var_sum_temp =
3035 s->me.mc_mb_var_sum_temp = 0;
3036
3037 /* we need to initialize some time vars before we can encode b-frames */
3038 // RAL: Condition added for MPEG1VIDEO
36ef5369 3039 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
7da31a80 3040 set_frame_distances(s);
36ef5369 3041 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
7da31a80 3042 ff_set_mpeg4_time(s);
3ada94ba
BF
3043
3044 s->me.scene_change_score=0;
3045
e6dba5df 3046// s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3ada94ba 3047
975a1447 3048 if(s->pict_type==AV_PICTURE_TYPE_I){
3ada94ba
BF
3049 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3050 else s->no_rounding=0;
975a1447 3051 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
36ef5369 3052 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3ada94ba
BF
3053 s->no_rounding ^= 1;
3054 }
3055
3056 if(s->flags & CODEC_FLAG_PASS2){
3057 if (estimate_qp(s,1) < 0)
3058 return -1;
3059 ff_get_2pass_fcode(s);
3060 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
975a1447 3061 if(s->pict_type==AV_PICTURE_TYPE_B)
3ada94ba
BF
3062 s->lambda= s->last_lambda_for[s->pict_type];
3063 else
3064 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3065 update_qscale(s);
3066 }
3067
3068 s->mb_intra=0; //for the rate distortion & bit compare functions
6a9c8594 3069 for(i=1; i<context_count; i++){
f1d8763a
JG
3070 ret = ff_update_duplicate_context(s->thread_context[i], s);
3071 if (ret < 0)
3072 return ret;
3ada94ba
BF
3073 }
3074
719f3702
MN
3075 if(ff_init_me(s)<0)
3076 return -1;
3ada94ba
BF
3077
3078 /* Estimate motion for every MB */
975a1447 3079 if(s->pict_type != AV_PICTURE_TYPE_I){
3ada94ba
BF
3080 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3081 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
6e7b50b4 3082 if (s->pict_type != AV_PICTURE_TYPE_B) {
975a1447 3083 if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
6a9c8594 3084 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3ada94ba
BF
3085 }
3086 }
3087
6a9c8594 3088 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
975a1447 3089 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3ada94ba
BF
3090 /* I-Frame */
3091 for(i=0; i<s->mb_stride*s->mb_height; i++)
3092 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3093
3094 if(!s->fixed_qscale){
3095 /* finding spatial complexity for I-frame rate control */
6a9c8594 3096 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3ada94ba
BF
3097 }
3098 }
6a9c8594 3099 for(i=1; i<context_count; i++){
3ada94ba
BF
3100 merge_context_after_me(s, s->thread_context[i]);
3101 }
3102 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3103 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3104 emms_c();
3105
975a1447
SS
3106 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3107 s->pict_type= AV_PICTURE_TYPE_I;
3ada94ba
BF
3108 for(i=0; i<s->mb_stride*s->mb_height; i++)
3109 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
1218777f
DB
3110 av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3111 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3ada94ba
BF
3112 }
3113
3114 if(!s->umvplus){
975a1447 3115 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3ada94ba
BF
3116 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3117
3118 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3119 int a,b;
3120 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3121 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
159ef4b0 3122 s->f_code= FFMAX3(s->f_code, a, b);
3ada94ba
BF
3123 }
3124
3125 ff_fix_long_p_mvs(s);
3126 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3127 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3128 int j;
3129 for(i=0; i<2; i++){
3130 for(j=0; j<2; j++)
3131 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3132 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3133 }
3134 }
3135 }
3136
975a1447 3137 if(s->pict_type==AV_PICTURE_TYPE_B){
3ada94ba
BF
3138 int a, b;
3139
3140 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3141 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3142 s->f_code = FFMAX(a, b);
3143
3144 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3145 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3146 s->b_code = FFMAX(a, b);
3147
3148 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3149 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3150 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3151 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3152 if(s->flags & CODEC_FLAG_INTERLACED_ME){
3153 int dir, j;
3154 for(dir=0; dir<2; dir++){
3155 for(i=0; i<2; i++){
3156 for(j=0; j<2; j++){
3157 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3158 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3159 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3160 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3161 }
3162 }
3163 }
3164 }
3165 }
3166 }
3167
3168 if (estimate_qp(s, 0) < 0)
3169 return -1;
3170
975a1447 3171 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3ada94ba
BF
3172 s->qscale= 3; //reduce clipping problems
3173
3174 if (s->out_format == FMT_MJPEG) {
3175 /* for mjpeg, we do include qscale in the matrix */
3ada94ba
BF
3176 for(i=1;i<64;i++){
3177 int j= s->dsp.idct_permutation[i];
3178
3179 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3180 }
6506c3d2 3181 s->y_dc_scale_table=
53f66cee
MN
3182 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3183 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
69cea75f 3184 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3ada94ba
BF
3185 s->in