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