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