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