movenc: add fallback audio track tref support
[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 int encoding_delay = s->max_b_frames ? s->max_b_frames
966 : (s->low_delay ? 0 : 1);
967 int flush_offset = 1;
968 int direct = 1;
969
970 if (pic_arg) {
971 pts = pic_arg->pts;
972 display_picture_number = s->input_picture_number++;
973
974 if (pts != AV_NOPTS_VALUE) {
975 if (s->user_specified_pts != AV_NOPTS_VALUE) {
976 int64_t time = pts;
977 int64_t last = s->user_specified_pts;
978
979 if (time <= last) {
980 av_log(s->avctx, AV_LOG_ERROR,
981 "Error, Invalid timestamp=%"PRId64", "
982 "last=%"PRId64"\n", pts, s->user_specified_pts);
983 return -1;
984 }
985
986 if (!s->low_delay && display_picture_number == 1)
987 s->dts_delta = time - last;
988 }
989 s->user_specified_pts = pts;
990 } else {
991 if (s->user_specified_pts != AV_NOPTS_VALUE) {
992 s->user_specified_pts =
993 pts = s->user_specified_pts + 1;
994 av_log(s->avctx, AV_LOG_INFO,
995 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
996 pts);
997 } else {
998 pts = display_picture_number;
999 }
1000 }
1001
1002 if (!pic_arg->buf[0] ||
1003 pic_arg->linesize[0] != s->linesize ||
1004 pic_arg->linesize[1] != s->uvlinesize ||
1005 pic_arg->linesize[2] != s->uvlinesize)
1006 direct = 0;
1007 if ((s->width & 15) || (s->height & 15))
1008 direct = 0;
1009
1010 ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
1011 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1012
1013 i = ff_find_unused_picture(s->avctx, s->picture, direct);
1014 if (i < 0)
1015 return i;
1016
1017 pic = &s->picture[i];
1018 pic->reference = 3;
1019
1020 if (direct) {
1021 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1022 return ret;
1023 }
1024 ret = alloc_picture(s, pic, direct);
1025 if (ret < 0)
1026 return ret;
1027
1028 if (!direct) {
1029 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1030 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1031 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1032 // empty
1033 } else {
1034 int h_chroma_shift, v_chroma_shift;
1035 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1036 &h_chroma_shift,
1037 &v_chroma_shift);
1038
1039 for (i = 0; i < 3; i++) {
1040 int src_stride = pic_arg->linesize[i];
1041 int dst_stride = i ? s->uvlinesize : s->linesize;
1042 int h_shift = i ? h_chroma_shift : 0;
1043 int v_shift = i ? v_chroma_shift : 0;
1044 int w = s->width >> h_shift;
1045 int h = s->height >> v_shift;
1046 uint8_t *src = pic_arg->data[i];
1047 uint8_t *dst = pic->f->data[i];
1048
1049 if (!s->avctx->rc_buffer_size)
1050 dst += INPLACE_OFFSET;
1051
1052 if (src_stride == dst_stride)
1053 memcpy(dst, src, src_stride * h);
1054 else {
1055 int h2 = h;
1056 uint8_t *dst2 = dst;
1057 while (h2--) {
1058 memcpy(dst2, src, w);
1059 dst2 += dst_stride;
1060 src += src_stride;
1061 }
1062 }
1063 if ((s->width & 15) || (s->height & 15)) {
1064 s->mpvencdsp.draw_edges(dst, dst_stride,
1065 w, h,
1066 16 >> h_shift,
1067 16 >> v_shift,
1068 EDGE_BOTTOM);
1069 }
1070 }
1071 }
1072 }
1073 ret = av_frame_copy_props(pic->f, pic_arg);
1074 if (ret < 0)
1075 return ret;
1076
1077 pic->f->display_picture_number = display_picture_number;
1078 pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1079 } else {
1080 /* Flushing: When we have not received enough input frames,
1081 * ensure s->input_picture[0] contains the first picture */
1082 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1083 if (s->input_picture[flush_offset])
1084 break;
1085
1086 if (flush_offset <= 1)
1087 flush_offset = 1;
1088 else
1089 encoding_delay = encoding_delay - flush_offset + 1;
1090 }
1091
1092 /* shift buffer entries */
1093 for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1094 s->input_picture[i - flush_offset] = s->input_picture[i];
1095
1096 s->input_picture[encoding_delay] = (Picture*) pic;
1097
1098 return 0;
1099 }
1100
1101 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1102 {
1103 int x, y, plane;
1104 int score = 0;
1105 int64_t score64 = 0;
1106
1107 for (plane = 0; plane < 3; plane++) {
1108 const int stride = p->f->linesize[plane];
1109 const int bw = plane ? 1 : 2;
1110 for (y = 0; y < s->mb_height * bw; y++) {
1111 for (x = 0; x < s->mb_width * bw; x++) {
1112 int off = p->shared ? 0 : 16;
1113 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1114 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1115 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1116
1117 switch (s->avctx->frame_skip_exp) {
1118 case 0: score = FFMAX(score, v); break;
1119 case 1: score += FFABS(v); break;
1120 case 2: score += v * v; break;
1121 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1122 case 4: score64 += v * v * (int64_t)(v * v); break;
1123 }
1124 }
1125 }
1126 }
1127
1128 if (score)
1129 score64 = score;
1130
1131 if (score64 < s->avctx->frame_skip_threshold)
1132 return 1;
1133 if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1134 return 1;
1135 return 0;
1136 }
1137
1138 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1139 {
1140 AVPacket pkt = { 0 };
1141 int ret, got_output;
1142
1143 av_init_packet(&pkt);
1144 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1145 if (ret < 0)
1146 return ret;
1147
1148 ret = pkt.size;
1149 av_packet_unref(&pkt);
1150 return ret;
1151 }
1152
1153 static int estimate_best_b_count(MpegEncContext *s)
1154 {
1155 AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1156 AVCodecContext *c = avcodec_alloc_context3(NULL);
1157 const int scale = s->avctx->brd_scale;
1158 int i, j, out_size, p_lambda, b_lambda, lambda2;
1159 int64_t best_rd = INT64_MAX;
1160 int best_b_count = -1;
1161
1162 if (!c)
1163 return AVERROR(ENOMEM);
1164 assert(scale >= 0 && scale <= 3);
1165
1166 //emms_c();
1167 //s->next_picture_ptr->quality;
1168 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1169 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1170 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1171 if (!b_lambda) // FIXME we should do this somewhere else
1172 b_lambda = p_lambda;
1173 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1174 FF_LAMBDA_SHIFT;
1175
1176 c->width = s->width >> scale;
1177 c->height = s->height >> scale;
1178 c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1179 c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1180 c->mb_decision = s->avctx->mb_decision;
1181 c->me_cmp = s->avctx->me_cmp;
1182 c->mb_cmp = s->avctx->mb_cmp;
1183 c->me_sub_cmp = s->avctx->me_sub_cmp;
1184 c->pix_fmt = AV_PIX_FMT_YUV420P;
1185 c->time_base = s->avctx->time_base;
1186 c->max_b_frames = s->max_b_frames;
1187
1188 if (avcodec_open2(c, codec, NULL) < 0)
1189 return -1;
1190
1191 for (i = 0; i < s->max_b_frames + 2; i++) {
1192 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1193 s->next_picture_ptr;
1194
1195 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1196 pre_input = *pre_input_ptr;
1197
1198 if (!pre_input.shared && i) {
1199 pre_input.f->data[0] += INPLACE_OFFSET;
1200 pre_input.f->data[1] += INPLACE_OFFSET;
1201 pre_input.f->data[2] += INPLACE_OFFSET;
1202 }
1203
1204 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1205 s->tmp_frames[i]->linesize[0],
1206 pre_input.f->data[0],
1207 pre_input.f->linesize[0],
1208 c->width, c->height);
1209 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1210 s->tmp_frames[i]->linesize[1],
1211 pre_input.f->data[1],
1212 pre_input.f->linesize[1],
1213 c->width >> 1, c->height >> 1);
1214 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1215 s->tmp_frames[i]->linesize[2],
1216 pre_input.f->data[2],
1217 pre_input.f->linesize[2],
1218 c->width >> 1, c->height >> 1);
1219 }
1220 }
1221
1222 for (j = 0; j < s->max_b_frames + 1; j++) {
1223 int64_t rd = 0;
1224
1225 if (!s->input_picture[j])
1226 break;
1227
1228 c->error[0] = c->error[1] = c->error[2] = 0;
1229
1230 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1231 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1232
1233 out_size = encode_frame(c, s->tmp_frames[0]);
1234
1235 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1236
1237 for (i = 0; i < s->max_b_frames + 1; i++) {
1238 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1239
1240 s->tmp_frames[i + 1]->pict_type = is_p ?
1241 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1242 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1243
1244 out_size = encode_frame(c, s->tmp_frames[i + 1]);
1245
1246 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1247 }
1248
1249 /* get the delayed frames */
1250 while (out_size) {
1251 out_size = encode_frame(c, NULL);
1252 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1253 }
1254
1255 rd += c->error[0] + c->error[1] + c->error[2];
1256
1257 if (rd < best_rd) {
1258 best_rd = rd;
1259 best_b_count = j;
1260 }
1261 }
1262
1263 avcodec_close(c);
1264 av_freep(&c);
1265
1266 return best_b_count;
1267 }
1268
1269 static int select_input_picture(MpegEncContext *s)
1270 {
1271 int i, ret;
1272
1273 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1274 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1275 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1276
1277 /* set next picture type & ordering */
1278 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1279 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1280 !s->next_picture_ptr || s->intra_only) {
1281 s->reordered_input_picture[0] = s->input_picture[0];
1282 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1283 s->reordered_input_picture[0]->f->coded_picture_number =
1284 s->coded_picture_number++;
1285 } else {
1286 int b_frames;
1287
1288 if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1289 if (s->picture_in_gop_number < s->gop_size &&
1290 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1291 // FIXME check that te gop check above is +-1 correct
1292 av_frame_unref(s->input_picture[0]->f);
1293
1294 emms_c();
1295 ff_vbv_update(s, 0);
1296
1297 goto no_output_pic;
1298 }
1299 }
1300
1301 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1302 for (i = 0; i < s->max_b_frames + 1; i++) {
1303 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1304
1305 if (pict_num >= s->rc_context.num_entries)
1306 break;
1307 if (!s->input_picture[i]) {
1308 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1309 break;
1310 }
1311
1312 s->input_picture[i]->f->pict_type =
1313 s->rc_context.entry[pict_num].new_pict_type;
1314 }
1315 }
1316
1317 if (s->avctx->b_frame_strategy == 0) {
1318 b_frames = s->max_b_frames;
1319 while (b_frames && !s->input_picture[b_frames])
1320 b_frames--;
1321 } else if (s->avctx->b_frame_strategy == 1) {
1322 for (i = 1; i < s->max_b_frames + 1; i++) {
1323 if (s->input_picture[i] &&
1324 s->input_picture[i]->b_frame_score == 0) {
1325 s->input_picture[i]->b_frame_score =
1326 get_intra_count(s,
1327 s->input_picture[i ]->f->data[0],
1328 s->input_picture[i - 1]->f->data[0],
1329 s->linesize) + 1;
1330 }
1331 }
1332 for (i = 0; i < s->max_b_frames + 1; i++) {
1333 if (!s->input_picture[i] ||
1334 s->input_picture[i]->b_frame_score - 1 >
1335 s->mb_num / s->avctx->b_sensitivity)
1336 break;
1337 }
1338
1339 b_frames = FFMAX(0, i - 1);
1340
1341 /* reset scores */
1342 for (i = 0; i < b_frames + 1; i++) {
1343 s->input_picture[i]->b_frame_score = 0;
1344 }
1345 } else if (s->avctx->b_frame_strategy == 2) {
1346 b_frames = estimate_best_b_count(s);
1347 } else {
1348 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1349 b_frames = 0;
1350 }
1351
1352 emms_c();
1353
1354 for (i = b_frames - 1; i >= 0; i--) {
1355 int type = s->input_picture[i]->f->pict_type;
1356 if (type && type != AV_PICTURE_TYPE_B)
1357 b_frames = i;
1358 }
1359 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1360 b_frames == s->max_b_frames) {
1361 av_log(s->avctx, AV_LOG_ERROR,
1362 "warning, too many b frames in a row\n");
1363 }
1364
1365 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1366 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1367 s->gop_size > s->picture_in_gop_number) {
1368 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1369 } else {
1370 if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1371 b_frames = 0;
1372 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1373 }
1374 }
1375
1376 if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1377 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1378 b_frames--;
1379
1380 s->reordered_input_picture[0] = s->input_picture[b_frames];
1381 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1382 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1383 s->reordered_input_picture[0]->f->coded_picture_number =
1384 s->coded_picture_number++;
1385 for (i = 0; i < b_frames; i++) {
1386 s->reordered_input_picture[i + 1] = s->input_picture[i];
1387 s->reordered_input_picture[i + 1]->f->pict_type =
1388 AV_PICTURE_TYPE_B;
1389 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1390 s->coded_picture_number++;
1391 }
1392 }
1393 }
1394 no_output_pic:
1395 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1396
1397 if (s->reordered_input_picture[0]) {
1398 s->reordered_input_picture[0]->reference =
1399 s->reordered_input_picture[0]->f->pict_type !=
1400 AV_PICTURE_TYPE_B ? 3 : 0;
1401
1402 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1403 return ret;
1404
1405 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1406 // input is a shared pix, so we can't modifiy it -> alloc a new
1407 // one & ensure that the shared one is reuseable
1408
1409 Picture *pic;
1410 int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1411 if (i < 0)
1412 return i;
1413 pic = &s->picture[i];
1414
1415 pic->reference = s->reordered_input_picture[0]->reference;
1416 if (alloc_picture(s, pic, 0) < 0) {
1417 return -1;
1418 }
1419
1420 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1421 if (ret < 0)
1422 return ret;
1423
1424 /* mark us unused / free shared pic */
1425 av_frame_unref(s->reordered_input_picture[0]->f);
1426 s->reordered_input_picture[0]->shared = 0;
1427
1428 s->current_picture_ptr = pic;
1429 } else {
1430 // input is not a shared pix -> reuse buffer for current_pix
1431 s->current_picture_ptr = s->reordered_input_picture[0];
1432 for (i = 0; i < 4; i++) {
1433 s->new_picture.f->data[i] += INPLACE_OFFSET;
1434 }
1435 }
1436 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1437 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1438 s->current_picture_ptr)) < 0)
1439 return ret;
1440
1441 s->picture_number = s->new_picture.f->display_picture_number;
1442 }
1443 return 0;
1444 }
1445
1446 static void frame_end(MpegEncContext *s)
1447 {
1448 int i;
1449
1450 if (s->unrestricted_mv &&
1451 s->current_picture.reference &&
1452 !s->intra_only) {
1453 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1454 int hshift = desc->log2_chroma_w;
1455 int vshift = desc->log2_chroma_h;
1456 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1457 s->h_edge_pos, s->v_edge_pos,
1458 EDGE_WIDTH, EDGE_WIDTH,
1459 EDGE_TOP | EDGE_BOTTOM);
1460 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1461 s->h_edge_pos >> hshift,
1462 s->v_edge_pos >> vshift,
1463 EDGE_WIDTH >> hshift,
1464 EDGE_WIDTH >> vshift,
1465 EDGE_TOP | EDGE_BOTTOM);
1466 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1467 s->h_edge_pos >> hshift,
1468 s->v_edge_pos >> vshift,
1469 EDGE_WIDTH >> hshift,
1470 EDGE_WIDTH >> vshift,
1471 EDGE_TOP | EDGE_BOTTOM);
1472 }
1473
1474 emms_c();
1475
1476 s->last_pict_type = s->pict_type;
1477 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1478 if (s->pict_type!= AV_PICTURE_TYPE_B)
1479 s->last_non_b_pict_type = s->pict_type;
1480
1481 if (s->encoding) {
1482 /* release non-reference frames */
1483 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1484 if (!s->picture[i].reference)
1485 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1486 }
1487 }
1488
1489 #if FF_API_CODED_FRAME
1490 FF_DISABLE_DEPRECATION_WARNINGS
1491 av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1492 FF_ENABLE_DEPRECATION_WARNINGS
1493 #endif
1494 #if FF_API_ERROR_FRAME
1495 FF_DISABLE_DEPRECATION_WARNINGS
1496 memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1497 sizeof(s->current_picture.encoding_error));
1498 FF_ENABLE_DEPRECATION_WARNINGS
1499 #endif
1500 }
1501
1502 static void update_noise_reduction(MpegEncContext *s)
1503 {
1504 int intra, i;
1505
1506 for (intra = 0; intra < 2; intra++) {
1507 if (s->dct_count[intra] > (1 << 16)) {
1508 for (i = 0; i < 64; i++) {
1509 s->dct_error_sum[intra][i] >>= 1;
1510 }
1511 s->dct_count[intra] >>= 1;
1512 }
1513
1514 for (i = 0; i < 64; i++) {
1515 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1516 s->dct_count[intra] +
1517 s->dct_error_sum[intra][i] / 2) /
1518 (s->dct_error_sum[intra][i] + 1);
1519 }
1520 }
1521 }
1522
1523 static int frame_start(MpegEncContext *s)
1524 {
1525 int ret;
1526
1527 /* mark & release old frames */
1528 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1529 s->last_picture_ptr != s->next_picture_ptr &&
1530 s->last_picture_ptr->f->buf[0]) {
1531 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1532 }
1533
1534 s->current_picture_ptr->f->pict_type = s->pict_type;
1535 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1536
1537 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1538 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1539 s->current_picture_ptr)) < 0)
1540 return ret;
1541
1542 if (s->pict_type != AV_PICTURE_TYPE_B) {
1543 s->last_picture_ptr = s->next_picture_ptr;
1544 if (!s->droppable)
1545 s->next_picture_ptr = s->current_picture_ptr;
1546 }
1547
1548 if (s->last_picture_ptr) {
1549 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1550 if (s->last_picture_ptr->f->buf[0] &&
1551 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1552 s->last_picture_ptr)) < 0)
1553 return ret;
1554 }
1555 if (s->next_picture_ptr) {
1556 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1557 if (s->next_picture_ptr->f->buf[0] &&
1558 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1559 s->next_picture_ptr)) < 0)
1560 return ret;
1561 }
1562
1563 if (s->picture_structure!= PICT_FRAME) {
1564 int i;
1565 for (i = 0; i < 4; i++) {
1566 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1567 s->current_picture.f->data[i] +=
1568 s->current_picture.f->linesize[i];
1569 }
1570 s->current_picture.f->linesize[i] *= 2;
1571 s->last_picture.f->linesize[i] *= 2;
1572 s->next_picture.f->linesize[i] *= 2;
1573 }
1574 }
1575
1576 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1577 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1578 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1579 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1580 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1581 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1582 } else {
1583 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1584 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1585 }
1586
1587 if (s->dct_error_sum) {
1588 assert(s->avctx->noise_reduction && s->encoding);
1589 update_noise_reduction(s);
1590 }
1591
1592 return 0;
1593 }
1594
1595 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1596 const AVFrame *pic_arg, int *got_packet)
1597 {
1598 MpegEncContext *s = avctx->priv_data;
1599 int i, stuffing_count, ret;
1600 int context_count = s->slice_context_count;
1601
1602 s->picture_in_gop_number++;
1603
1604 if (load_input_picture(s, pic_arg) < 0)
1605 return -1;
1606
1607 if (select_input_picture(s) < 0) {
1608 return -1;
1609 }
1610
1611 /* output? */
1612 if (s->new_picture.f->data[0]) {
1613 uint8_t *sd;
1614 if (!pkt->data &&
1615 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1616 return ret;
1617 if (s->mb_info) {
1618 s->mb_info_ptr = av_packet_new_side_data(pkt,
1619 AV_PKT_DATA_H263_MB_INFO,
1620 s->mb_width*s->mb_height*12);
1621 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1622 }
1623
1624 for (i = 0; i < context_count; i++) {
1625 int start_y = s->thread_context[i]->start_mb_y;
1626 int end_y = s->thread_context[i]-> end_mb_y;
1627 int h = s->mb_height;
1628 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1629 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1630
1631 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1632 }
1633
1634 s->pict_type = s->new_picture.f->pict_type;
1635 //emms_c();
1636 ret = frame_start(s);
1637 if (ret < 0)
1638 return ret;
1639 vbv_retry:
1640 if (encode_picture(s, s->picture_number) < 0)
1641 return -1;
1642
1643 avctx->header_bits = s->header_bits;
1644 avctx->mv_bits = s->mv_bits;
1645 avctx->misc_bits = s->misc_bits;
1646 avctx->i_tex_bits = s->i_tex_bits;
1647 avctx->p_tex_bits = s->p_tex_bits;
1648 avctx->i_count = s->i_count;
1649 // FIXME f/b_count in avctx
1650 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1651 avctx->skip_count = s->skip_count;
1652
1653 frame_end(s);
1654
1655 sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
1656 sizeof(int));
1657 if (!sd)
1658 return AVERROR(ENOMEM);
1659 *(int *)sd = s->current_picture.f->quality;
1660
1661 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1662 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1663
1664 if (avctx->rc_buffer_size) {
1665 RateControlContext *rcc = &s->rc_context;
1666 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1667
1668 if (put_bits_count(&s->pb) > max_size &&
1669 s->lambda < s->lmax) {
1670 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1671 (s->qscale + 1) / s->qscale);
1672 if (s->adaptive_quant) {
1673 int i;
1674 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1675 s->lambda_table[i] =
1676 FFMAX(s->lambda_table[i] + 1,
1677 s->lambda_table[i] * (s->qscale + 1) /
1678 s->qscale);
1679 }
1680 s->mb_skipped = 0; // done in frame_start()
1681 // done in encode_picture() so we must undo it
1682 if (s->pict_type == AV_PICTURE_TYPE_P) {
1683 if (s->flipflop_rounding ||
1684 s->codec_id == AV_CODEC_ID_H263P ||
1685 s->codec_id == AV_CODEC_ID_MPEG4)
1686 s->no_rounding ^= 1;
1687 }
1688 if (s->pict_type != AV_PICTURE_TYPE_B) {
1689 s->time_base = s->last_time_base;
1690 s->last_non_b_time = s->time - s->pp_time;
1691 }
1692 for (i = 0; i < context_count; i++) {
1693 PutBitContext *pb = &s->thread_context[i]->pb;
1694 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1695 }
1696 goto vbv_retry;
1697 }
1698
1699 assert(s->avctx->rc_max_rate);
1700 }
1701
1702 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1703 ff_write_pass1_stats(s);
1704
1705 for (i = 0; i < 4; i++) {
1706 s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1707 avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1708 }
1709
1710 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1711 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1712 avctx->i_tex_bits + avctx->p_tex_bits ==
1713 put_bits_count(&s->pb));
1714 flush_put_bits(&s->pb);
1715 s->frame_bits = put_bits_count(&s->pb);
1716
1717 stuffing_count = ff_vbv_update(s, s->frame_bits);
1718 if (stuffing_count) {
1719 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1720 stuffing_count + 50) {
1721 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1722 return -1;
1723 }
1724
1725 switch (s->codec_id) {
1726 case AV_CODEC_ID_MPEG1VIDEO:
1727 case AV_CODEC_ID_MPEG2VIDEO:
1728 while (stuffing_count--) {
1729 put_bits(&s->pb, 8, 0);
1730 }
1731 break;
1732 case AV_CODEC_ID_MPEG4:
1733 put_bits(&s->pb, 16, 0);
1734 put_bits(&s->pb, 16, 0x1C3);
1735 stuffing_count -= 4;
1736 while (stuffing_count--) {
1737 put_bits(&s->pb, 8, 0xFF);
1738 }
1739 break;
1740 default:
1741 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1742 }
1743 flush_put_bits(&s->pb);
1744 s->frame_bits = put_bits_count(&s->pb);
1745 }
1746
1747 /* update mpeg1/2 vbv_delay for CBR */
1748 if (s->avctx->rc_max_rate &&
1749 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1750 s->out_format == FMT_MPEG1 &&
1751 90000LL * (avctx->rc_buffer_size - 1) <=
1752 s->avctx->rc_max_rate * 0xFFFFLL) {
1753 int vbv_delay, min_delay;
1754 double inbits = s->avctx->rc_max_rate *
1755 av_q2d(s->avctx->time_base);
1756 int minbits = s->frame_bits - 8 *
1757 (s->vbv_delay_ptr - s->pb.buf - 1);
1758 double bits = s->rc_context.buffer_index + minbits - inbits;
1759
1760 if (bits < 0)
1761 av_log(s->avctx, AV_LOG_ERROR,
1762 "Internal error, negative bits\n");
1763
1764 assert(s->repeat_first_field == 0);
1765
1766 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1767 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1768 s->avctx->rc_max_rate;
1769
1770 vbv_delay = FFMAX(vbv_delay, min_delay);
1771
1772 assert(vbv_delay < 0xFFFF);
1773
1774 s->vbv_delay_ptr[0] &= 0xF8;
1775 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1776 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1777 s->vbv_delay_ptr[2] &= 0x07;
1778 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1779 avctx->vbv_delay = vbv_delay * 300;
1780 }
1781 s->total_bits += s->frame_bits;
1782 avctx->frame_bits = s->frame_bits;
1783
1784 pkt->pts = s->current_picture.f->pts;
1785 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1786 if (!s->current_picture.f->coded_picture_number)
1787 pkt->dts = pkt->pts - s->dts_delta;
1788 else
1789 pkt->dts = s->reordered_pts;
1790 s->reordered_pts = pkt->pts;
1791 } else
1792 pkt->dts = pkt->pts;
1793 if (s->current_picture.f->key_frame)
1794 pkt->flags |= AV_PKT_FLAG_KEY;
1795 if (s->mb_info)
1796 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1797 } else {
1798 s->frame_bits = 0;
1799 }
1800 assert((s->frame_bits & 7) == 0);
1801
1802 pkt->size = s->frame_bits / 8;
1803 *got_packet = !!pkt->size;
1804 return 0;
1805 }
1806
1807 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1808 int n, int threshold)
1809 {
1810 static const char tab[64] = {
1811 3, 2, 2, 1, 1, 1, 1, 1,
1812 1, 1, 1, 1, 1, 1, 1, 1,
1813 1, 1, 1, 1, 1, 1, 1, 1,
1814 0, 0, 0, 0, 0, 0, 0, 0,
1815 0, 0, 0, 0, 0, 0, 0, 0,
1816 0, 0, 0, 0, 0, 0, 0, 0,
1817 0, 0, 0, 0, 0, 0, 0, 0,
1818 0, 0, 0, 0, 0, 0, 0, 0
1819 };
1820 int score = 0;
1821 int run = 0;
1822 int i;
1823 int16_t *block = s->block[n];
1824 const int last_index = s->block_last_index[n];
1825 int skip_dc;
1826
1827 if (threshold < 0) {
1828 skip_dc = 0;
1829 threshold = -threshold;
1830 } else
1831 skip_dc = 1;
1832
1833 /* Are all we could set to zero already zero? */
1834 if (last_index <= skip_dc - 1)
1835 return;
1836
1837 for (i = 0; i <= last_index; i++) {
1838 const int j = s->intra_scantable.permutated[i];
1839 const int level = FFABS(block[j]);
1840 if (level == 1) {
1841 if (skip_dc && i == 0)
1842 continue;
1843 score += tab[run];
1844 run = 0;
1845 } else if (level > 1) {
1846 return;
1847 } else {
1848 run++;
1849 }
1850 }
1851 if (score >= threshold)
1852 return;
1853 for (i = skip_dc; i <= last_index; i++) {
1854 const int j = s->intra_scantable.permutated[i];
1855 block[j] = 0;
1856 }
1857 if (block[0])
1858 s->block_last_index[n] = 0;
1859 else
1860 s->block_last_index[n] = -1;
1861 }
1862
1863 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1864 int last_index)
1865 {
1866 int i;
1867 const int maxlevel = s->max_qcoeff;
1868 const int minlevel = s->min_qcoeff;
1869 int overflow = 0;
1870
1871 if (s->mb_intra) {
1872 i = 1; // skip clipping of intra dc
1873 } else
1874 i = 0;
1875
1876 for (; i <= last_index; i++) {
1877 const int j = s->intra_scantable.permutated[i];
1878 int level = block[j];
1879
1880 if (level > maxlevel) {
1881 level = maxlevel;
1882 overflow++;
1883 } else if (level < minlevel) {
1884 level = minlevel;
1885 overflow++;
1886 }
1887
1888 block[j] = level;
1889 }
1890
1891 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1892 av_log(s->avctx, AV_LOG_INFO,
1893 "warning, clipping %d dct coefficients to %d..%d\n",
1894 overflow, minlevel, maxlevel);
1895 }
1896
1897 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1898 {
1899 int x, y;
1900 // FIXME optimize
1901 for (y = 0; y < 8; y++) {
1902 for (x = 0; x < 8; x++) {
1903 int x2, y2;
1904 int sum = 0;
1905 int sqr = 0;
1906 int count = 0;
1907
1908 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1909 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1910 int v = ptr[x2 + y2 * stride];
1911 sum += v;
1912 sqr += v * v;
1913 count++;
1914 }
1915 }
1916 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1917 }
1918 }
1919 }
1920
1921 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1922 int motion_x, int motion_y,
1923 int mb_block_height,
1924 int mb_block_count)
1925 {
1926 int16_t weight[8][64];
1927 int16_t orig[8][64];
1928 const int mb_x = s->mb_x;
1929 const int mb_y = s->mb_y;
1930 int i;
1931 int skip_dct[8];
1932 int dct_offset = s->linesize * 8; // default for progressive frames
1933 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1934 ptrdiff_t wrap_y, wrap_c;
1935
1936 for (i = 0; i < mb_block_count; i++)
1937 skip_dct[i] = s->skipdct;
1938
1939 if (s->adaptive_quant) {
1940 const int last_qp = s->qscale;
1941 const int mb_xy = mb_x + mb_y * s->mb_stride;
1942
1943 s->lambda = s->lambda_table[mb_xy];
1944 update_qscale(s);
1945
1946 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1947 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1948 s->dquant = s->qscale - last_qp;
1949
1950 if (s->out_format == FMT_H263) {
1951 s->dquant = av_clip(s->dquant, -2, 2);
1952
1953 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1954 if (!s->mb_intra) {
1955 if (s->pict_type == AV_PICTURE_TYPE_B) {
1956 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1957 s->dquant = 0;
1958 }
1959 if (s->mv_type == MV_TYPE_8X8)
1960 s->dquant = 0;
1961 }
1962 }
1963 }
1964 }
1965 ff_set_qscale(s, last_qp + s->dquant);
1966 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1967 ff_set_qscale(s, s->qscale + s->dquant);
1968
1969 wrap_y = s->linesize;
1970 wrap_c = s->uvlinesize;
1971 ptr_y = s->new_picture.f->data[0] +
1972 (mb_y * 16 * wrap_y) + mb_x * 16;
1973 ptr_cb = s->new_picture.f->data[1] +
1974 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1975 ptr_cr = s->new_picture.f->data[2] +
1976 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1977
1978 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1979 uint8_t *ebuf = s->sc.edge_emu_buffer + 32;
1980 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1981 wrap_y, wrap_y,
1982 16, 16, mb_x * 16, mb_y * 16,
1983 s->width, s->height);
1984 ptr_y = ebuf;
1985 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1986 wrap_c, wrap_c,
1987 8, mb_block_height, mb_x * 8, mb_y * 8,
1988 s->width >> 1, s->height >> 1);
1989 ptr_cb = ebuf + 18 * wrap_y;
1990 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1991 wrap_c, wrap_c,
1992 8, mb_block_height, mb_x * 8, mb_y * 8,
1993 s->width >> 1, s->height >> 1);
1994 ptr_cr = ebuf + 18 * wrap_y + 8;
1995 }
1996
1997 if (s->mb_intra) {
1998 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
1999 int progressive_score, interlaced_score;
2000
2001 s->interlaced_dct = 0;
2002 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2003 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2004 NULL, wrap_y, 8) - 400;
2005
2006 if (progressive_score > 0) {
2007 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2008 NULL, wrap_y * 2, 8) +
2009 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2010 NULL, wrap_y * 2, 8);
2011 if (progressive_score > interlaced_score) {
2012 s->interlaced_dct = 1;
2013
2014 dct_offset = wrap_y;
2015 wrap_y <<= 1;
2016 if (s->chroma_format == CHROMA_422)
2017 wrap_c <<= 1;
2018 }
2019 }
2020 }
2021
2022 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2023 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2024 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2025 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2026
2027 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2028 skip_dct[4] = 1;
2029 skip_dct[5] = 1;
2030 } else {
2031 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2032 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2033 if (!s->chroma_y_shift) { /* 422 */
2034 s->pdsp.get_pixels(s->block[6],
2035 ptr_cb + (dct_offset >> 1), wrap_c);
2036 s->pdsp.get_pixels(s->block[7],
2037 ptr_cr + (dct_offset >> 1), wrap_c);
2038 }
2039 }
2040 } else {
2041 op_pixels_func (*op_pix)[4];
2042 qpel_mc_func (*op_qpix)[16];
2043 uint8_t *dest_y, *dest_cb, *dest_cr;
2044
2045 dest_y = s->dest[0];
2046 dest_cb = s->dest[1];
2047 dest_cr = s->dest[2];
2048
2049 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2050 op_pix = s->hdsp.put_pixels_tab;
2051 op_qpix = s->qdsp.put_qpel_pixels_tab;
2052 } else {
2053 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2054 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2055 }
2056
2057 if (s->mv_dir & MV_DIR_FORWARD) {
2058 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2059 s->last_picture.f->data,
2060 op_pix, op_qpix);
2061 op_pix = s->hdsp.avg_pixels_tab;
2062 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2063 }
2064 if (s->mv_dir & MV_DIR_BACKWARD) {
2065 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2066 s->next_picture.f->data,
2067 op_pix, op_qpix);
2068 }
2069
2070 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2071 int progressive_score, interlaced_score;
2072
2073 s->interlaced_dct = 0;
2074 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2075 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2076 ptr_y + wrap_y * 8,
2077 wrap_y, 8) - 400;
2078
2079 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2080 progressive_score -= 400;
2081
2082 if (progressive_score > 0) {
2083 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2084 wrap_y * 2, 8) +
2085 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2086 ptr_y + wrap_y,
2087 wrap_y * 2, 8);
2088
2089 if (progressive_score > interlaced_score) {
2090 s->interlaced_dct = 1;
2091
2092 dct_offset = wrap_y;
2093 wrap_y <<= 1;
2094 if (s->chroma_format == CHROMA_422)
2095 wrap_c <<= 1;
2096 }
2097 }
2098 }
2099
2100 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2101 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2102 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2103 dest_y + dct_offset, wrap_y);
2104 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2105 dest_y + dct_offset + 8, wrap_y);
2106
2107 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2108 skip_dct[4] = 1;
2109 skip_dct[5] = 1;
2110 } else {
2111 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2112 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2113 if (!s->chroma_y_shift) { /* 422 */
2114 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2115 dest_cb + (dct_offset >> 1), wrap_c);
2116 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2117 dest_cr + (dct_offset >> 1), wrap_c);
2118 }
2119 }
2120 /* pre quantization */
2121 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2122 2 * s->qscale * s->qscale) {
2123 // FIXME optimize
2124 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2125 skip_dct[0] = 1;
2126 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2127 skip_dct[1] = 1;
2128 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2129 wrap_y, 8) < 20 * s->qscale)
2130 skip_dct[2] = 1;
2131 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2132 wrap_y, 8) < 20 * s->qscale)
2133 skip_dct[3] = 1;
2134 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2135 skip_dct[4] = 1;
2136 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2137 skip_dct[5] = 1;
2138 if (!s->chroma_y_shift) { /* 422 */
2139 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2140 dest_cb + (dct_offset >> 1),
2141 wrap_c, 8) < 20 * s->qscale)
2142 skip_dct[6] = 1;
2143 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2144 dest_cr + (dct_offset >> 1),
2145 wrap_c, 8) < 20 * s->qscale)
2146 skip_dct[7] = 1;
2147 }
2148 }
2149 }
2150
2151 if (s->quantizer_noise_shaping) {
2152 if (!skip_dct[0])
2153 get_visual_weight(weight[0], ptr_y , wrap_y);
2154 if (!skip_dct[1])
2155 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2156 if (!skip_dct[2])
2157 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2158 if (!skip_dct[3])
2159 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2160 if (!skip_dct[4])
2161 get_visual_weight(weight[4], ptr_cb , wrap_c);
2162 if (!skip_dct[5])
2163 get_visual_weight(weight[5], ptr_cr , wrap_c);
2164 if (!s->chroma_y_shift) { /* 422 */
2165 if (!skip_dct[6])
2166 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2167 wrap_c);
2168 if (!skip_dct[7])
2169 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2170 wrap_c);
2171 }
2172 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2173 }
2174
2175 /* DCT & quantize */
2176 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2177 {
2178 for (i = 0; i < mb_block_count; i++) {
2179 if (!skip_dct[i]) {
2180 int overflow;
2181 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2182 // FIXME we could decide to change to quantizer instead of
2183 // clipping
2184 // JS: I don't think that would be a good idea it could lower
2185 // quality instead of improve it. Just INTRADC clipping
2186 // deserves changes in quantizer
2187 if (overflow)
2188 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2189 } else
2190 s->block_last_index[i] = -1;
2191 }
2192 if (s->quantizer_noise_shaping) {
2193 for (i = 0; i < mb_block_count; i++) {
2194 if (!skip_dct[i]) {
2195 s->block_last_index[i] =
2196 dct_quantize_refine(s, s->block[i], weight[i],
2197 orig[i], i, s->qscale);
2198 }
2199 }
2200 }
2201
2202 if (s->luma_elim_threshold && !s->mb_intra)
2203 for (i = 0; i < 4; i++)
2204 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2205 if (s->chroma_elim_threshold && !s->mb_intra)
2206 for (i = 4; i < mb_block_count; i++)
2207 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2208
2209 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2210 for (i = 0; i < mb_block_count; i++) {
2211 if (s->block_last_index[i] == -1)
2212 s->coded_score[i] = INT_MAX / 256;
2213 }
2214 }
2215 }
2216
2217 if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2218 s->block_last_index[4] =
2219 s->block_last_index[5] = 0;
2220 s->block[4][0] =
2221 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2222 }
2223
2224 // non c quantize code returns incorrect block_last_index FIXME
2225 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2226 for (i = 0; i < mb_block_count; i++) {
2227 int j;
2228 if (s->block_last_index[i] > 0) {
2229 for (j = 63; j > 0; j--) {
2230 if (s->block[i][s->intra_scantable.permutated[j]])
2231 break;
2232 }
2233 s->block_last_index[i] = j;
2234 }
2235 }
2236 }
2237
2238 /* huffman encode */
2239 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2240 case AV_CODEC_ID_MPEG1VIDEO:
2241 case AV_CODEC_ID_MPEG2VIDEO:
2242 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2243 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2244 break;
2245 case AV_CODEC_ID_MPEG4:
2246 if (CONFIG_MPEG4_ENCODER)
2247 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2248 break;
2249 case AV_CODEC_ID_MSMPEG4V2:
2250 case AV_CODEC_ID_MSMPEG4V3:
2251 case AV_CODEC_ID_WMV1:
2252 if (CONFIG_MSMPEG4_ENCODER)
2253 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2254 break;
2255 case AV_CODEC_ID_WMV2:
2256 if (CONFIG_WMV2_ENCODER)
2257 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2258 break;
2259 case AV_CODEC_ID_H261:
2260 if (CONFIG_H261_ENCODER)
2261 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2262 break;
2263 case AV_CODEC_ID_H263:
2264 case AV_CODEC_ID_H263P:
2265 case AV_CODEC_ID_FLV1:
2266 case AV_CODEC_ID_RV10:
2267 case AV_CODEC_ID_RV20:
2268 if (CONFIG_H263_ENCODER)
2269 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2270 break;
2271 case AV_CODEC_ID_MJPEG:
2272 if (CONFIG_MJPEG_ENCODER)
2273 ff_mjpeg_encode_mb(s, s->block);
2274 break;
2275 default:
2276 assert(0);
2277 }
2278 }
2279
2280 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2281 {
2282 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2283 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2284 }
2285
2286 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2287 int i;
2288
2289 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2290
2291 /* mpeg1 */
2292 d->mb_skip_run= s->mb_skip_run;
2293 for(i=0; i<3; i++)
2294 d->last_dc[i] = s->last_dc[i];
2295
2296 /* statistics */
2297 d->mv_bits= s->mv_bits;
2298 d->i_tex_bits= s->i_tex_bits;
2299 d->p_tex_bits= s->p_tex_bits;
2300 d->i_count= s->i_count;
2301 d->f_count= s->f_count;
2302 d->b_count= s->b_count;
2303 d->skip_count= s->skip_count;
2304 d->misc_bits= s->misc_bits;
2305 d->last_bits= 0;
2306
2307 d->mb_skipped= 0;
2308 d->qscale= s->qscale;
2309 d->dquant= s->dquant;
2310
2311 d->esc3_level_length= s->esc3_level_length;
2312 }
2313
2314 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2315 int i;
2316
2317 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2318 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2319
2320 /* mpeg1 */
2321 d->mb_skip_run= s->mb_skip_run;
2322 for(i=0; i<3; i++)
2323 d->last_dc[i] = s->last_dc[i];
2324
2325 /* statistics */
2326 d->mv_bits= s->mv_bits;
2327 d->i_tex_bits= s->i_tex_bits;
2328 d->p_tex_bits= s->p_tex_bits;
2329 d->i_count= s->i_count;
2330 d->f_count= s->f_count;
2331 d->b_count= s->b_count;
2332 d->skip_count= s->skip_count;
2333 d->misc_bits= s->misc_bits;
2334
2335 d->mb_intra= s->mb_intra;
2336 d->mb_skipped= s->mb_skipped;
2337 d->mv_type= s->mv_type;
2338 d->mv_dir= s->mv_dir;
2339 d->pb= s->pb;
2340 if(s->data_partitioning){
2341 d->pb2= s->pb2;
2342 d->tex_pb= s->tex_pb;
2343 }
2344 d->block= s->block;
2345 for(i=0; i<8; i++)
2346 d->block_last_index[i]= s->block_last_index[i];
2347 d->interlaced_dct= s->interlaced_dct;
2348 d->qscale= s->qscale;
2349
2350 d->esc3_level_length= s->esc3_level_length;
2351 }
2352
2353 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2354 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2355 int *dmin, int *next_block, int motion_x, int motion_y)
2356 {
2357 int score;
2358 uint8_t *dest_backup[3];
2359
2360 copy_context_before_encode(s, backup, type);
2361
2362 s->block= s->blocks[*next_block];
2363 s->pb= pb[*next_block];
2364 if(s->data_partitioning){
2365 s->pb2 = pb2 [*next_block];
2366 s->tex_pb= tex_pb[*next_block];
2367 }
2368
2369 if(*next_block){
2370 memcpy(dest_backup, s->dest, sizeof(s->dest));
2371 s->dest[0] = s->sc.rd_scratchpad;
2372 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2373 s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2374 assert(s->linesize >= 32); //FIXME
2375 }
2376
2377 encode_mb(s, motion_x, motion_y);
2378
2379 score= put_bits_count(&s->pb);
2380 if(s->data_partitioning){
2381 score+= put_bits_count(&s->pb2);
2382 score+= put_bits_count(&s->tex_pb);
2383 }
2384
2385 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2386 ff_mpv_decode_mb(s, s->block);
2387
2388 score *= s->lambda2;
2389 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2390 }
2391
2392 if(*next_block){
2393 memcpy(s->dest, dest_backup, sizeof(s->dest));
2394 }
2395
2396 if(score<*dmin){
2397 *dmin= score;
2398 *next_block^=1;
2399
2400 copy_context_after_encode(best, s, type);
2401 }
2402 }
2403
2404 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2405 uint32_t *sq = ff_square_tab + 256;
2406 int acc=0;
2407 int x,y;
2408
2409 if(w==16 && h==16)
2410 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2411 else if(w==8 && h==8)
2412 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2413
2414 for(y=0; y<h; y++){
2415 for(x=0; x<w; x++){
2416 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2417 }
2418 }
2419
2420 assert(acc>=0);
2421
2422 return acc;
2423 }
2424
2425 static int sse_mb(MpegEncContext *s){
2426 int w= 16;
2427 int h= 16;
2428
2429 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2430 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2431
2432 if(w==16 && h==16)
2433 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2434 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) +
2435 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) +
2436 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);
2437 }else{
2438 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) +
2439 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) +
2440 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);
2441 }
2442 else
2443 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)
2444 +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)
2445 +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);
2446 }
2447
2448 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2449 MpegEncContext *s= *(void**)arg;
2450
2451
2452 s->me.pre_pass=1;
2453 s->me.dia_size= s->avctx->pre_dia_size;
2454 s->first_slice_line=1;
2455 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2456 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2457 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2458 }
2459 s->first_slice_line=0;
2460 }
2461
2462 s->me.pre_pass=0;
2463
2464 return 0;
2465 }
2466
2467 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2468 MpegEncContext *s= *(void**)arg;
2469
2470 s->me.dia_size= s->avctx->dia_size;
2471 s->first_slice_line=1;
2472 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2473 s->mb_x=0; //for block init below
2474 ff_init_block_index(s);
2475 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2476 s->block_index[0]+=2;
2477 s->block_index[1]+=2;
2478 s->block_index[2]+=2;
2479 s->block_index[3]+=2;
2480
2481 /* compute motion vector & mb_type and store in context */
2482 if(s->pict_type==AV_PICTURE_TYPE_B)
2483 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2484 else
2485 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2486 }
2487 s->first_slice_line=0;
2488 }
2489 return 0;
2490 }
2491
2492 static int mb_var_thread(AVCodecContext *c, void *arg){
2493 MpegEncContext *s= *(void**)arg;
2494 int mb_x, mb_y;
2495
2496 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2497 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2498 int xx = mb_x * 16;
2499 int yy = mb_y * 16;
2500 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2501 int varc;
2502 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2503
2504 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2505 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2506
2507 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2508 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2509 s->me.mb_var_sum_temp += varc;
2510 }
2511 }
2512 return 0;
2513 }
2514
2515 static void write_slice_end(MpegEncContext *s){
2516 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2517 if(s->partitioned_frame){
2518 ff_mpeg4_merge_partitions(s);
2519 }
2520
2521 ff_mpeg4_stuffing(&s->pb);
2522 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2523 ff_mjpeg_encode_stuffing(&s->pb);
2524 }
2525
2526 avpriv_align_put_bits(&s->pb);
2527 flush_put_bits(&s->pb);
2528
2529 if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2530 s->misc_bits+= get_bits_diff(s);
2531 }
2532
2533 static void write_mb_info(MpegEncContext *s)
2534 {
2535 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2536 int offset = put_bits_count(&s->pb);
2537 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2538 int gobn = s->mb_y / s->gob_index;
2539 int pred_x, pred_y;
2540 if (CONFIG_H263_ENCODER)
2541 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2542 bytestream_put_le32(&ptr, offset);
2543 bytestream_put_byte(&ptr, s->qscale);
2544 bytestream_put_byte(&ptr, gobn);
2545 bytestream_put_le16(&ptr, mba);
2546 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2547 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2548 /* 4MV not implemented */
2549 bytestream_put_byte(&ptr, 0); /* hmv2 */
2550 bytestream_put_byte(&ptr, 0); /* vmv2 */
2551 }
2552
2553 static void update_mb_info(MpegEncContext *s, int startcode)
2554 {
2555 if (!s->mb_info)
2556 return;
2557 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2558 s->mb_info_size += 12;
2559 s->prev_mb_info = s->last_mb_info;
2560 }
2561 if (startcode) {
2562 s->prev_mb_info = put_bits_count(&s->pb)/8;
2563 /* This might have incremented mb_info_size above, and we return without
2564 * actually writing any info into that slot yet. But in that case,
2565 * this will be called again at the start of the after writing the
2566 * start code, actually writing the mb info. */
2567 return;
2568 }
2569
2570 s->last_mb_info = put_bits_count(&s->pb)/8;
2571 if (!s->mb_info_size)
2572 s->mb_info_size += 12;
2573 write_mb_info(s);
2574 }
2575
2576 static int encode_thread(AVCodecContext *c, void *arg){
2577 MpegEncContext *s= *(void**)arg;
2578 int mb_x, mb_y, pdif = 0;
2579 int chr_h= 16>>s->chroma_y_shift;
2580 int i, j;
2581 MpegEncContext best_s = { 0 }, backup_s;
2582 uint8_t bit_buf[2][MAX_MB_BYTES];
2583 uint8_t bit_buf2[2][MAX_MB_BYTES];
2584 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2585 PutBitContext pb[2], pb2[2], tex_pb[2];
2586
2587 for(i=0; i<2; i++){
2588 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2589 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2590 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2591 }
2592
2593 s->last_bits= put_bits_count(&s->pb);
2594 s->mv_bits=0;
2595 s->misc_bits=0;
2596 s->i_tex_bits=0;
2597 s->p_tex_bits=0;
2598 s->i_count=0;
2599 s->f_count=0;
2600 s->b_count=0;
2601 s->skip_count=0;
2602
2603 for(i=0; i<3; i++){
2604 /* init last dc values */
2605 /* note: quant matrix value (8) is implied here */
2606 s->last_dc[i] = 128 << s->intra_dc_precision;
2607
2608 s->current_picture.encoding_error[i] = 0;
2609 }
2610 s->mb_skip_run = 0;
2611 memset(s->last_mv, 0, sizeof(s->last_mv));
2612
2613 s->last_mv_dir = 0;
2614
2615 switch(s->codec_id){
2616 case AV_CODEC_ID_H263:
2617 case AV_CODEC_ID_H263P:
2618 case AV_CODEC_ID_FLV1:
2619 if (CONFIG_H263_ENCODER)
2620 s->gob_index = H263_GOB_HEIGHT(s->height);
2621 break;
2622 case AV_CODEC_ID_MPEG4:
2623 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2624 ff_mpeg4_init_partitions(s);
2625 break;
2626 }
2627
2628 s->resync_mb_x=0;
2629 s->resync_mb_y=0;
2630 s->first_slice_line = 1;
2631 s->ptr_lastgob = s->pb.buf;
2632 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2633 s->mb_x=0;
2634 s->mb_y= mb_y;
2635
2636 ff_set_qscale(s, s->qscale);
2637 ff_init_block_index(s);
2638
2639 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2640 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2641 int mb_type= s->mb_type[xy];
2642 // int d;
2643 int dmin= INT_MAX;
2644 int dir;
2645
2646 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2647 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2648 return -1;
2649 }
2650 if(s->data_partitioning){
2651 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2652 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2653 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2654 return -1;
2655 }
2656 }
2657
2658 s->mb_x = mb_x;
2659 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2660 ff_update_block_index(s);
2661
2662 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2663 ff_h261_reorder_mb_index(s);
2664 xy= s->mb_y*s->mb_stride + s->mb_x;
2665 mb_type= s->mb_type[xy];
2666 }
2667
2668 /* write gob / video packet header */
2669 if(s->rtp_mode){
2670 int current_packet_size, is_gob_start;
2671
2672 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2673
2674 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2675
2676 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2677
2678 switch(s->codec_id){
2679 case AV_CODEC_ID_H263:
2680 case AV_CODEC_ID_H263P:
2681 if(!s->h263_slice_structured)
2682 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2683 break;
2684 case AV_CODEC_ID_MPEG2VIDEO:
2685 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2686 case AV_CODEC_ID_MPEG1VIDEO:
2687 if(s->mb_skip_run) is_gob_start=0;
2688 break;
2689 }
2690
2691 if(is_gob_start){
2692 if(s->start_mb_y != mb_y || mb_x!=0){
2693 write_slice_end(s);
2694
2695 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2696 ff_mpeg4_init_partitions(s);
2697 }
2698 }
2699
2700 assert((put_bits_count(&s->pb)&7) == 0);
2701 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2702
2703 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2704 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2705 int d = 100 / s->error_rate;
2706 if(r % d == 0){
2707 current_packet_size=0;
2708 s->pb.buf_ptr= s->ptr_lastgob;
2709 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2710 }
2711 }
2712
2713 if (s->avctx->rtp_callback){
2714 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2715 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2716 }
2717 update_mb_info(s, 1);
2718
2719 switch(s->codec_id){
2720 case AV_CODEC_ID_MPEG4:
2721 if (CONFIG_MPEG4_ENCODER) {
2722 ff_mpeg4_encode_video_packet_header(s);
2723 ff_mpeg4_clean_buffers(s);
2724 }
2725 break;
2726 case AV_CODEC_ID_MPEG1VIDEO:
2727 case AV_CODEC_ID_MPEG2VIDEO:
2728 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2729 ff_mpeg1_encode_slice_header(s);
2730 ff_mpeg1_clean_buffers(s);
2731 }
2732 break;
2733 case AV_CODEC_ID_H263:
2734 case AV_CODEC_ID_H263P:
2735 if (CONFIG_H263_ENCODER)
2736 ff_h263_encode_gob_header(s, mb_y);
2737 break;
2738 }
2739
2740 if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
2741 int bits= put_bits_count(&s->pb);
2742 s->misc_bits+= bits - s->last_bits;
2743 s->last_bits= bits;
2744 }
2745
2746 s->ptr_lastgob += current_packet_size;
2747 s->first_slice_line=1;
2748 s->resync_mb_x=mb_x;
2749 s->resync_mb_y=mb_y;
2750 }
2751 }
2752
2753 if( (s->resync_mb_x == s->mb_x)
2754 && s->resync_mb_y+1 == s->mb_y){
2755 s->first_slice_line=0;
2756 }
2757
2758 s->mb_skipped=0;
2759 s->dquant=0; //only for QP_RD
2760
2761 update_mb_info(s, 0);
2762
2763 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
2764 int next_block=0;
2765 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2766
2767 copy_context_before_encode(&backup_s, s, -1);
2768 backup_s.pb= s->pb;
2769 best_s.data_partitioning= s->data_partitioning;
2770 best_s.partitioned_frame= s->partitioned_frame;
2771 if(s->data_partitioning){
2772 backup_s.pb2= s->pb2;
2773 backup_s.tex_pb= s->tex_pb;
2774 }
2775
2776 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2777 s->mv_dir = MV_DIR_FORWARD;
2778 s->mv_type = MV_TYPE_16X16;
2779 s->mb_intra= 0;
2780 s->mv[0][0][0] = s->p_mv_table[xy][0];
2781 s->mv[0][0][1] = s->p_mv_table[xy][1];
2782 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2783 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2784 }
2785 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2786 s->mv_dir = MV_DIR_FORWARD;
2787 s->mv_type = MV_TYPE_FIELD;
2788 s->mb_intra= 0;
2789 for(i=0; i<2; i++){
2790 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2791 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2792 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2793 }
2794 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2795 &dmin, &next_block, 0, 0);
2796 }
2797 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2798 s->mv_dir = MV_DIR_FORWARD;
2799 s->mv_type = MV_TYPE_16X16;
2800 s->mb_intra= 0;
2801 s->mv[0][0][0] = 0;
2802 s->mv[0][0][1] = 0;
2803 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2804 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2805 }
2806 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2807 s->mv_dir = MV_DIR_FORWARD;
2808 s->mv_type = MV_TYPE_8X8;
2809 s->mb_intra= 0;
2810 for(i=0; i<4; i++){
2811 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2812 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2813 }
2814 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2815 &dmin, &next_block, 0, 0);
2816 }
2817 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2818 s->mv_dir = MV_DIR_FORWARD;
2819 s->mv_type = MV_TYPE_16X16;
2820 s->mb_intra= 0;
2821 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2822 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2823 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2824 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2825 }
2826 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2827 s->mv_dir = MV_DIR_BACKWARD;
2828 s->mv_type = MV_TYPE_16X16;
2829 s->mb_intra= 0;
2830 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2831 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2832 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2833 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2834 }
2835 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2836 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2837 s->mv_type = MV_TYPE_16X16;
2838 s->mb_intra= 0;
2839 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2840 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2841 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2842 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2843 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2844 &dmin, &next_block, 0, 0);
2845 }
2846 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2847 s->mv_dir = MV_DIR_FORWARD;
2848 s->mv_type = MV_TYPE_FIELD;
2849 s->mb_intra= 0;
2850 for(i=0; i<2; i++){
2851 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2852 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2853 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2854 }
2855 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2856 &dmin, &next_block, 0, 0);
2857 }
2858 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2859 s->mv_dir = MV_DIR_BACKWARD;
2860 s->mv_type = MV_TYPE_FIELD;
2861 s->mb_intra= 0;
2862 for(i=0; i<2; i++){
2863 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2864 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2865 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2866 }
2867 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2868 &dmin, &next_block, 0