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