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