e5ff3ed70e194fac5b0a13d2a6239693341bc55a
[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 if (s->reordered_input_picture[0]) {
1386 s->reordered_input_picture[0]->reference =
1387 s->reordered_input_picture[0]->f->pict_type !=
1388 AV_PICTURE_TYPE_B ? 3 : 0;
1389
1390 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1391 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1392 return ret;
1393
1394 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1395 // input is a shared pix, so we can't modifiy it -> alloc a new
1396 // one & ensure that the shared one is reuseable
1397
1398 Picture *pic;
1399 int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1400 if (i < 0)
1401 return i;
1402 pic = &s->picture[i];
1403
1404 pic->reference = s->reordered_input_picture[0]->reference;
1405 if (alloc_picture(s, pic, 0) < 0) {
1406 return -1;
1407 }
1408
1409 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1410 if (ret < 0)
1411 return ret;
1412
1413 /* mark us unused / free shared pic */
1414 av_frame_unref(s->reordered_input_picture[0]->f);
1415 s->reordered_input_picture[0]->shared = 0;
1416
1417 s->current_picture_ptr = pic;
1418 } else {
1419 // input is not a shared pix -> reuse buffer for current_pix
1420 s->current_picture_ptr = s->reordered_input_picture[0];
1421 for (i = 0; i < 4; i++) {
1422 s->new_picture.f->data[i] += INPLACE_OFFSET;
1423 }
1424 }
1425 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1426 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1427 s->current_picture_ptr)) < 0)
1428 return ret;
1429
1430 s->picture_number = s->new_picture.f->display_picture_number;
1431 } else {
1432 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1433 }
1434 return 0;
1435 }
1436
1437 static void frame_end(MpegEncContext *s)
1438 {
1439 int i;
1440
1441 if (s->unrestricted_mv &&
1442 s->current_picture.reference &&
1443 !s->intra_only) {
1444 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1445 int hshift = desc->log2_chroma_w;
1446 int vshift = desc->log2_chroma_h;
1447 s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1448 s->h_edge_pos, s->v_edge_pos,
1449 EDGE_WIDTH, EDGE_WIDTH,
1450 EDGE_TOP | EDGE_BOTTOM);
1451 s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1452 s->h_edge_pos >> hshift,
1453 s->v_edge_pos >> vshift,
1454 EDGE_WIDTH >> hshift,
1455 EDGE_WIDTH >> vshift,
1456 EDGE_TOP | EDGE_BOTTOM);
1457 s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1458 s->h_edge_pos >> hshift,
1459 s->v_edge_pos >> vshift,
1460 EDGE_WIDTH >> hshift,
1461 EDGE_WIDTH >> vshift,
1462 EDGE_TOP | EDGE_BOTTOM);
1463 }
1464
1465 emms_c();
1466
1467 s->last_pict_type = s->pict_type;
1468 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1469 if (s->pict_type!= AV_PICTURE_TYPE_B)
1470 s->last_non_b_pict_type = s->pict_type;
1471
1472 if (s->encoding) {
1473 /* release non-reference frames */
1474 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1475 if (!s->picture[i].reference)
1476 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1477 }
1478 }
1479
1480 #if FF_API_CODED_FRAME
1481 FF_DISABLE_DEPRECATION_WARNINGS
1482 av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1483 FF_ENABLE_DEPRECATION_WARNINGS
1484 #endif
1485 #if FF_API_ERROR_FRAME
1486 FF_DISABLE_DEPRECATION_WARNINGS
1487 memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1488 sizeof(s->current_picture.encoding_error));
1489 FF_ENABLE_DEPRECATION_WARNINGS
1490 #endif
1491 }
1492
1493 static void update_noise_reduction(MpegEncContext *s)
1494 {
1495 int intra, i;
1496
1497 for (intra = 0; intra < 2; intra++) {
1498 if (s->dct_count[intra] > (1 << 16)) {
1499 for (i = 0; i < 64; i++) {
1500 s->dct_error_sum[intra][i] >>= 1;
1501 }
1502 s->dct_count[intra] >>= 1;
1503 }
1504
1505 for (i = 0; i < 64; i++) {
1506 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1507 s->dct_count[intra] +
1508 s->dct_error_sum[intra][i] / 2) /
1509 (s->dct_error_sum[intra][i] + 1);
1510 }
1511 }
1512 }
1513
1514 static int frame_start(MpegEncContext *s)
1515 {
1516 int ret;
1517
1518 /* mark & release old frames */
1519 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1520 s->last_picture_ptr != s->next_picture_ptr &&
1521 s->last_picture_ptr->f->buf[0]) {
1522 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1523 }
1524
1525 s->current_picture_ptr->f->pict_type = s->pict_type;
1526 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1527
1528 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1529 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1530 s->current_picture_ptr)) < 0)
1531 return ret;
1532
1533 if (s->pict_type != AV_PICTURE_TYPE_B) {
1534 s->last_picture_ptr = s->next_picture_ptr;
1535 if (!s->droppable)
1536 s->next_picture_ptr = s->current_picture_ptr;
1537 }
1538
1539 if (s->last_picture_ptr) {
1540 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1541 if (s->last_picture_ptr->f->buf[0] &&
1542 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1543 s->last_picture_ptr)) < 0)
1544 return ret;
1545 }
1546 if (s->next_picture_ptr) {
1547 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1548 if (s->next_picture_ptr->f->buf[0] &&
1549 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1550 s->next_picture_ptr)) < 0)
1551 return ret;
1552 }
1553
1554 if (s->picture_structure!= PICT_FRAME) {
1555 int i;
1556 for (i = 0; i < 4; i++) {
1557 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1558 s->current_picture.f->data[i] +=
1559 s->current_picture.f->linesize[i];
1560 }
1561 s->current_picture.f->linesize[i] *= 2;
1562 s->last_picture.f->linesize[i] *= 2;
1563 s->next_picture.f->linesize[i] *= 2;
1564 }
1565 }
1566
1567 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1568 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1569 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1570 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1571 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1572 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1573 } else {
1574 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1575 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1576 }
1577
1578 if (s->dct_error_sum) {
1579 assert(s->avctx->noise_reduction && s->encoding);
1580 update_noise_reduction(s);
1581 }
1582
1583 return 0;
1584 }
1585
1586 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1587 const AVFrame *pic_arg, int *got_packet)
1588 {
1589 MpegEncContext *s = avctx->priv_data;
1590 int i, stuffing_count, ret;
1591 int context_count = s->slice_context_count;
1592
1593 s->picture_in_gop_number++;
1594
1595 if (load_input_picture(s, pic_arg) < 0)
1596 return -1;
1597
1598 if (select_input_picture(s) < 0) {
1599 return -1;
1600 }
1601
1602 /* output? */
1603 if (s->new_picture.f->data[0]) {
1604 uint8_t *sd;
1605 if (!pkt->data &&
1606 (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1607 return ret;
1608 if (s->mb_info) {
1609 s->mb_info_ptr = av_packet_new_side_data(pkt,
1610 AV_PKT_DATA_H263_MB_INFO,
1611 s->mb_width*s->mb_height*12);
1612 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1613 }
1614
1615 for (i = 0; i < context_count; i++) {
1616 int start_y = s->thread_context[i]->start_mb_y;
1617 int end_y = s->thread_context[i]-> end_mb_y;
1618 int h = s->mb_height;
1619 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1620 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1621
1622 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1623 }
1624
1625 s->pict_type = s->new_picture.f->pict_type;
1626 //emms_c();
1627 ret = frame_start(s);
1628 if (ret < 0)
1629 return ret;
1630 vbv_retry:
1631 if (encode_picture(s, s->picture_number) < 0)
1632 return -1;
1633
1634 avctx->header_bits = s->header_bits;
1635 avctx->mv_bits = s->mv_bits;
1636 avctx->misc_bits = s->misc_bits;
1637 avctx->i_tex_bits = s->i_tex_bits;
1638 avctx->p_tex_bits = s->p_tex_bits;
1639 avctx->i_count = s->i_count;
1640 // FIXME f/b_count in avctx
1641 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1642 avctx->skip_count = s->skip_count;
1643
1644 frame_end(s);
1645
1646 sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
1647 sizeof(int));
1648 if (!sd)
1649 return AVERROR(ENOMEM);
1650 *(int *)sd = s->current_picture.f->quality;
1651
1652 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1653 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1654
1655 if (avctx->rc_buffer_size) {
1656 RateControlContext *rcc = &s->rc_context;
1657 int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1658
1659 if (put_bits_count(&s->pb) > max_size &&
1660 s->lambda < s->lmax) {
1661 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1662 (s->qscale + 1) / s->qscale);
1663 if (s->adaptive_quant) {
1664 int i;
1665 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1666 s->lambda_table[i] =
1667 FFMAX(s->lambda_table[i] + 1,
1668 s->lambda_table[i] * (s->qscale + 1) /
1669 s->qscale);
1670 }
1671 s->mb_skipped = 0; // done in frame_start()
1672 // done in encode_picture() so we must undo it
1673 if (s->pict_type == AV_PICTURE_TYPE_P) {
1674 if (s->flipflop_rounding ||
1675 s->codec_id == AV_CODEC_ID_H263P ||
1676 s->codec_id == AV_CODEC_ID_MPEG4)
1677 s->no_rounding ^= 1;
1678 }
1679 if (s->pict_type != AV_PICTURE_TYPE_B) {
1680 s->time_base = s->last_time_base;
1681 s->last_non_b_time = s->time - s->pp_time;
1682 }
1683 for (i = 0; i < context_count; i++) {
1684 PutBitContext *pb = &s->thread_context[i]->pb;
1685 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1686 }
1687 goto vbv_retry;
1688 }
1689
1690 assert(s->avctx->rc_max_rate);
1691 }
1692
1693 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1694 ff_write_pass1_stats(s);
1695
1696 for (i = 0; i < 4; i++) {
1697 s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1698 avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1699 }
1700
1701 if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1702 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1703 avctx->i_tex_bits + avctx->p_tex_bits ==
1704 put_bits_count(&s->pb));
1705 flush_put_bits(&s->pb);
1706 s->frame_bits = put_bits_count(&s->pb);
1707
1708 stuffing_count = ff_vbv_update(s, s->frame_bits);
1709 if (stuffing_count) {
1710 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1711 stuffing_count + 50) {
1712 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1713 return -1;
1714 }
1715
1716 switch (s->codec_id) {
1717 case AV_CODEC_ID_MPEG1VIDEO:
1718 case AV_CODEC_ID_MPEG2VIDEO:
1719 while (stuffing_count--) {
1720 put_bits(&s->pb, 8, 0);
1721 }
1722 break;
1723 case AV_CODEC_ID_MPEG4:
1724 put_bits(&s->pb, 16, 0);
1725 put_bits(&s->pb, 16, 0x1C3);
1726 stuffing_count -= 4;
1727 while (stuffing_count--) {
1728 put_bits(&s->pb, 8, 0xFF);
1729 }
1730 break;
1731 default:
1732 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1733 }
1734 flush_put_bits(&s->pb);
1735 s->frame_bits = put_bits_count(&s->pb);
1736 }
1737
1738 /* update mpeg1/2 vbv_delay for CBR */
1739 if (s->avctx->rc_max_rate &&
1740 s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1741 s->out_format == FMT_MPEG1 &&
1742 90000LL * (avctx->rc_buffer_size - 1) <=
1743 s->avctx->rc_max_rate * 0xFFFFLL) {
1744 int vbv_delay, min_delay;
1745 double inbits = s->avctx->rc_max_rate *
1746 av_q2d(s->avctx->time_base);
1747 int minbits = s->frame_bits - 8 *
1748 (s->vbv_delay_ptr - s->pb.buf - 1);
1749 double bits = s->rc_context.buffer_index + minbits - inbits;
1750
1751 if (bits < 0)
1752 av_log(s->avctx, AV_LOG_ERROR,
1753 "Internal error, negative bits\n");
1754
1755 assert(s->repeat_first_field == 0);
1756
1757 vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1758 min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1759 s->avctx->rc_max_rate;
1760
1761 vbv_delay = FFMAX(vbv_delay, min_delay);
1762
1763 assert(vbv_delay < 0xFFFF);
1764
1765 s->vbv_delay_ptr[0] &= 0xF8;
1766 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1767 s->vbv_delay_ptr[1] = vbv_delay >> 5;
1768 s->vbv_delay_ptr[2] &= 0x07;
1769 s->vbv_delay_ptr[2] |= vbv_delay << 3;
1770 avctx->vbv_delay = vbv_delay * 300;
1771 }
1772 s->total_bits += s->frame_bits;
1773 avctx->frame_bits = s->frame_bits;
1774
1775 pkt->pts = s->current_picture.f->pts;
1776 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1777 if (!s->current_picture.f->coded_picture_number)
1778 pkt->dts = pkt->pts - s->dts_delta;
1779 else
1780 pkt->dts = s->reordered_pts;
1781 s->reordered_pts = pkt->pts;
1782 } else
1783 pkt->dts = pkt->pts;
1784 if (s->current_picture.f->key_frame)
1785 pkt->flags |= AV_PKT_FLAG_KEY;
1786 if (s->mb_info)
1787 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1788 } else {
1789 s->frame_bits = 0;
1790 }
1791 assert((s->frame_bits & 7) == 0);
1792
1793 pkt->size = s->frame_bits / 8;
1794 *got_packet = !!pkt->size;
1795 return 0;
1796 }
1797
1798 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1799 int n, int threshold)
1800 {
1801 static const char tab[64] = {
1802 3, 2, 2, 1, 1, 1, 1, 1,
1803 1, 1, 1, 1, 1, 1, 1, 1,
1804 1, 1, 1, 1, 1, 1, 1, 1,
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 0, 0, 0, 0, 0, 0, 0, 0
1810 };
1811 int score = 0;
1812 int run = 0;
1813 int i;
1814 int16_t *block = s->block[n];
1815 const int last_index = s->block_last_index[n];
1816 int skip_dc;
1817
1818 if (threshold < 0) {
1819 skip_dc = 0;
1820 threshold = -threshold;
1821 } else
1822 skip_dc = 1;
1823
1824 /* Are all we could set to zero already zero? */
1825 if (last_index <= skip_dc - 1)
1826 return;
1827
1828 for (i = 0; i <= last_index; i++) {
1829 const int j = s->intra_scantable.permutated[i];
1830 const int level = FFABS(block[j]);
1831 if (level == 1) {
1832 if (skip_dc && i == 0)
1833 continue;
1834 score += tab[run];
1835 run = 0;
1836 } else if (level > 1) {
1837 return;
1838 } else {
1839 run++;
1840 }
1841 }
1842 if (score >= threshold)
1843 return;
1844 for (i = skip_dc; i <= last_index; i++) {
1845 const int j = s->intra_scantable.permutated[i];
1846 block[j] = 0;
1847 }
1848 if (block[0])
1849 s->block_last_index[n] = 0;
1850 else
1851 s->block_last_index[n] = -1;
1852 }
1853
1854 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1855 int last_index)
1856 {
1857 int i;
1858 const int maxlevel = s->max_qcoeff;
1859 const int minlevel = s->min_qcoeff;
1860 int overflow = 0;
1861
1862 if (s->mb_intra) {
1863 i = 1; // skip clipping of intra dc
1864 } else
1865 i = 0;
1866
1867 for (; i <= last_index; i++) {
1868 const int j = s->intra_scantable.permutated[i];
1869 int level = block[j];
1870
1871 if (level > maxlevel) {
1872 level = maxlevel;
1873 overflow++;
1874 } else if (level < minlevel) {
1875 level = minlevel;
1876 overflow++;
1877 }
1878
1879 block[j] = level;
1880 }
1881
1882 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1883 av_log(s->avctx, AV_LOG_INFO,
1884 "warning, clipping %d dct coefficients to %d..%d\n",
1885 overflow, minlevel, maxlevel);
1886 }
1887
1888 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1889 {
1890 int x, y;
1891 // FIXME optimize
1892 for (y = 0; y < 8; y++) {
1893 for (x = 0; x < 8; x++) {
1894 int x2, y2;
1895 int sum = 0;
1896 int sqr = 0;
1897 int count = 0;
1898
1899 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1900 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1901 int v = ptr[x2 + y2 * stride];
1902 sum += v;
1903 sqr += v * v;
1904 count++;
1905 }
1906 }
1907 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1908 }
1909 }
1910 }
1911
1912 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1913 int motion_x, int motion_y,
1914 int mb_block_height,
1915 int mb_block_count)
1916 {
1917 int16_t weight[8][64];
1918 int16_t orig[8][64];
1919 const int mb_x = s->mb_x;
1920 const int mb_y = s->mb_y;
1921 int i;
1922 int skip_dct[8];
1923 int dct_offset = s->linesize * 8; // default for progressive frames
1924 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1925 ptrdiff_t wrap_y, wrap_c;
1926
1927 for (i = 0; i < mb_block_count; i++)
1928 skip_dct[i] = s->skipdct;
1929
1930 if (s->adaptive_quant) {
1931 const int last_qp = s->qscale;
1932 const int mb_xy = mb_x + mb_y * s->mb_stride;
1933
1934 s->lambda = s->lambda_table[mb_xy];
1935 update_qscale(s);
1936
1937 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1938 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1939 s->dquant = s->qscale - last_qp;
1940
1941 if (s->out_format == FMT_H263) {
1942 s->dquant = av_clip(s->dquant, -2, 2);
1943
1944 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1945 if (!s->mb_intra) {
1946 if (s->pict_type == AV_PICTURE_TYPE_B) {
1947 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1948 s->dquant = 0;
1949 }
1950 if (s->mv_type == MV_TYPE_8X8)
1951 s->dquant = 0;
1952 }
1953 }
1954 }
1955 }
1956 ff_set_qscale(s, last_qp + s->dquant);
1957 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1958 ff_set_qscale(s, s->qscale + s->dquant);
1959
1960 wrap_y = s->linesize;
1961 wrap_c = s->uvlinesize;
1962 ptr_y = s->new_picture.f->data[0] +
1963 (mb_y * 16 * wrap_y) + mb_x * 16;
1964 ptr_cb = s->new_picture.f->data[1] +
1965 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1966 ptr_cr = s->new_picture.f->data[2] +
1967 (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1968
1969 if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1970 uint8_t *ebuf = s->sc.edge_emu_buffer + 32;
1971 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1972 wrap_y, wrap_y,
1973 16, 16, mb_x * 16, mb_y * 16,
1974 s->width, s->height);
1975 ptr_y = ebuf;
1976 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1977 wrap_c, wrap_c,
1978 8, mb_block_height, mb_x * 8, mb_y * 8,
1979 s->width >> 1, s->height >> 1);
1980 ptr_cb = ebuf + 18 * wrap_y;
1981 s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1982 wrap_c, wrap_c,
1983 8, mb_block_height, mb_x * 8, mb_y * 8,
1984 s->width >> 1, s->height >> 1);
1985 ptr_cr = ebuf + 18 * wrap_y + 8;
1986 }
1987
1988 if (s->mb_intra) {
1989 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
1990 int progressive_score, interlaced_score;
1991
1992 s->interlaced_dct = 0;
1993 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1994 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1995 NULL, wrap_y, 8) - 400;
1996
1997 if (progressive_score > 0) {
1998 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1999 NULL, wrap_y * 2, 8) +
2000 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2001 NULL, wrap_y * 2, 8);
2002 if (progressive_score > interlaced_score) {
2003 s->interlaced_dct = 1;
2004
2005 dct_offset = wrap_y;
2006 wrap_y <<= 1;
2007 if (s->chroma_format == CHROMA_422)
2008 wrap_c <<= 1;
2009 }
2010 }
2011 }
2012
2013 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2014 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2015 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2016 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2017
2018 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2019 skip_dct[4] = 1;
2020 skip_dct[5] = 1;
2021 } else {
2022 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2023 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2024 if (!s->chroma_y_shift) { /* 422 */
2025 s->pdsp.get_pixels(s->block[6],
2026 ptr_cb + (dct_offset >> 1), wrap_c);
2027 s->pdsp.get_pixels(s->block[7],
2028 ptr_cr + (dct_offset >> 1), wrap_c);
2029 }
2030 }
2031 } else {
2032 op_pixels_func (*op_pix)[4];
2033 qpel_mc_func (*op_qpix)[16];
2034 uint8_t *dest_y, *dest_cb, *dest_cr;
2035
2036 dest_y = s->dest[0];
2037 dest_cb = s->dest[1];
2038 dest_cr = s->dest[2];
2039
2040 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2041 op_pix = s->hdsp.put_pixels_tab;
2042 op_qpix = s->qdsp.put_qpel_pixels_tab;
2043 } else {
2044 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2045 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2046 }
2047
2048 if (s->mv_dir & MV_DIR_FORWARD) {
2049 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2050 s->last_picture.f->data,
2051 op_pix, op_qpix);
2052 op_pix = s->hdsp.avg_pixels_tab;
2053 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2054 }
2055 if (s->mv_dir & MV_DIR_BACKWARD) {
2056 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2057 s->next_picture.f->data,
2058 op_pix, op_qpix);
2059 }
2060
2061 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2062 int progressive_score, interlaced_score;
2063
2064 s->interlaced_dct = 0;
2065 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2066 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2067 ptr_y + wrap_y * 8,
2068 wrap_y, 8) - 400;
2069
2070 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2071 progressive_score -= 400;
2072
2073 if (progressive_score > 0) {
2074 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2075 wrap_y * 2, 8) +
2076 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2077 ptr_y + wrap_y,
2078 wrap_y * 2, 8);
2079
2080 if (progressive_score > interlaced_score) {
2081 s->interlaced_dct = 1;
2082
2083 dct_offset = wrap_y;
2084 wrap_y <<= 1;
2085 if (s->chroma_format == CHROMA_422)
2086 wrap_c <<= 1;
2087 }
2088 }
2089 }
2090
2091 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2092 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2093 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2094 dest_y + dct_offset, wrap_y);
2095 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2096 dest_y + dct_offset + 8, wrap_y);
2097
2098 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2099 skip_dct[4] = 1;
2100 skip_dct[5] = 1;
2101 } else {
2102 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2103 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2104 if (!s->chroma_y_shift) { /* 422 */
2105 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2106 dest_cb + (dct_offset >> 1), wrap_c);
2107 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2108 dest_cr + (dct_offset >> 1), wrap_c);
2109 }
2110 }
2111 /* pre quantization */
2112 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2113 2 * s->qscale * s->qscale) {
2114 // FIXME optimize
2115 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2116 skip_dct[0] = 1;
2117 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2118 skip_dct[1] = 1;
2119 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2120 wrap_y, 8) < 20 * s->qscale)
2121 skip_dct[2] = 1;
2122 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2123 wrap_y, 8) < 20 * s->qscale)
2124 skip_dct[3] = 1;
2125 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2126 skip_dct[4] = 1;
2127 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2128 skip_dct[5] = 1;
2129 if (!s->chroma_y_shift) { /* 422 */
2130 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2131 dest_cb + (dct_offset >> 1),
2132 wrap_c, 8) < 20 * s->qscale)
2133 skip_dct[6] = 1;
2134 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2135 dest_cr + (dct_offset >> 1),
2136 wrap_c, 8) < 20 * s->qscale)
2137 skip_dct[7] = 1;
2138 }
2139 }
2140 }
2141
2142 if (s->quantizer_noise_shaping) {
2143 if (!skip_dct[0])
2144 get_visual_weight(weight[0], ptr_y , wrap_y);
2145 if (!skip_dct[1])
2146 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2147 if (!skip_dct[2])
2148 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2149 if (!skip_dct[3])
2150 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2151 if (!skip_dct[4])
2152 get_visual_weight(weight[4], ptr_cb , wrap_c);
2153 if (!skip_dct[5])
2154 get_visual_weight(weight[5], ptr_cr , wrap_c);
2155 if (!s->chroma_y_shift) { /* 422 */
2156 if (!skip_dct[6])
2157 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2158 wrap_c);
2159 if (!skip_dct[7])
2160 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2161 wrap_c);
2162 }
2163 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2164 }
2165
2166 /* DCT & quantize */
2167 assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2168 {
2169 for (i = 0; i < mb_block_count; i++) {
2170 if (!skip_dct[i]) {
2171 int overflow;
2172 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2173 // FIXME we could decide to change to quantizer instead of
2174 // clipping
2175 // JS: I don't think that would be a good idea it could lower
2176 // quality instead of improve it. Just INTRADC clipping
2177 // deserves changes in quantizer
2178 if (overflow)
2179 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2180 } else
2181 s->block_last_index[i] = -1;
2182 }
2183 if (s->quantizer_noise_shaping) {
2184 for (i = 0; i < mb_block_count; i++) {
2185 if (!skip_dct[i]) {
2186 s->block_last_index[i] =
2187 dct_quantize_refine(s, s->block[i], weight[i],
2188 orig[i], i, s->qscale);
2189 }
2190 }
2191 }
2192
2193 if (s->luma_elim_threshold && !s->mb_intra)
2194 for (i = 0; i < 4; i++)
2195 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2196 if (s->chroma_elim_threshold && !s->mb_intra)
2197 for (i = 4; i < mb_block_count; i++)
2198 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2199
2200 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2201 for (i = 0; i < mb_block_count; i++) {
2202 if (s->block_last_index[i] == -1)
2203 s->coded_score[i] = INT_MAX / 256;
2204 }
2205 }
2206 }
2207
2208 if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2209 s->block_last_index[4] =
2210 s->block_last_index[5] = 0;
2211 s->block[4][0] =
2212 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2213 }
2214
2215 // non c quantize code returns incorrect block_last_index FIXME
2216 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2217 for (i = 0; i < mb_block_count; i++) {
2218 int j;
2219 if (s->block_last_index[i] > 0) {
2220 for (j = 63; j > 0; j--) {
2221 if (s->block[i][s->intra_scantable.permutated[j]])
2222 break;
2223 }
2224 s->block_last_index[i] = j;
2225 }
2226 }
2227 }
2228
2229 /* huffman encode */
2230 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2231 case AV_CODEC_ID_MPEG1VIDEO:
2232 case AV_CODEC_ID_MPEG2VIDEO:
2233 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2234 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2235 break;
2236 case AV_CODEC_ID_MPEG4:
2237 if (CONFIG_MPEG4_ENCODER)
2238 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2239 break;
2240 case AV_CODEC_ID_MSMPEG4V2:
2241 case AV_CODEC_ID_MSMPEG4V3:
2242 case AV_CODEC_ID_WMV1:
2243 if (CONFIG_MSMPEG4_ENCODER)
2244 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2245 break;
2246 case AV_CODEC_ID_WMV2:
2247 if (CONFIG_WMV2_ENCODER)
2248 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2249 break;
2250 case AV_CODEC_ID_H261:
2251 if (CONFIG_H261_ENCODER)
2252 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2253 break;
2254 case AV_CODEC_ID_H263:
2255 case AV_CODEC_ID_H263P:
2256 case AV_CODEC_ID_FLV1:
2257 case AV_CODEC_ID_RV10:
2258 case AV_CODEC_ID_RV20:
2259 if (CONFIG_H263_ENCODER)
2260 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2261 break;
2262 case AV_CODEC_ID_MJPEG:
2263 if (CONFIG_MJPEG_ENCODER)
2264 ff_mjpeg_encode_mb(s, s->block);
2265 break;
2266 default:
2267 assert(0);
2268 }
2269 }
2270
2271 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2272 {
2273 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2274 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2275 }
2276
2277 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2278 int i;
2279
2280 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2281
2282 /* mpeg1 */
2283 d->mb_skip_run= s->mb_skip_run;
2284 for(i=0; i<3; i++)
2285 d->last_dc[i] = s->last_dc[i];
2286
2287 /* statistics */
2288 d->mv_bits= s->mv_bits;
2289 d->i_tex_bits= s->i_tex_bits;
2290 d->p_tex_bits= s->p_tex_bits;
2291 d->i_count= s->i_count;
2292 d->f_count= s->f_count;
2293 d->b_count= s->b_count;
2294 d->skip_count= s->skip_count;
2295 d->misc_bits= s->misc_bits;
2296 d->last_bits= 0;
2297
2298 d->mb_skipped= 0;
2299 d->qscale= s->qscale;
2300 d->dquant= s->dquant;
2301
2302 d->esc3_level_length= s->esc3_level_length;
2303 }
2304
2305 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2306 int i;
2307
2308 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2309 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2310
2311 /* mpeg1 */
2312 d->mb_skip_run= s->mb_skip_run;
2313 for(i=0; i<3; i++)
2314 d->last_dc[i] = s->last_dc[i];
2315
2316 /* statistics */
2317 d->mv_bits= s->mv_bits;
2318 d->i_tex_bits= s->i_tex_bits;
2319 d->p_tex_bits= s->p_tex_bits;
2320 d->i_count= s->i_count;
2321 d->f_count= s->f_count;
2322 d->b_count= s->b_count;
2323 d->skip_count= s->skip_count;
2324 d->misc_bits= s->misc_bits;
2325
2326 d->mb_intra= s->mb_intra;
2327 d->mb_skipped= s->mb_skipped;
2328 d->mv_type= s->mv_type;
2329 d->mv_dir= s->mv_dir;
2330 d->pb= s->pb;
2331 if(s->data_partitioning){
2332 d->pb2= s->pb2;
2333 d->tex_pb= s->tex_pb;
2334 }
2335 d->block= s->block;
2336 for(i=0; i<8; i++)
2337 d->block_last_index[i]= s->block_last_index[i];
2338 d->interlaced_dct= s->interlaced_dct;
2339 d->qscale= s->qscale;
2340
2341 d->esc3_level_length= s->esc3_level_length;
2342 }
2343
2344 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2345 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2346 int *dmin, int *next_block, int motion_x, int motion_y)
2347 {
2348 int score;
2349 uint8_t *dest_backup[3];
2350
2351 copy_context_before_encode(s, backup, type);
2352
2353 s->block= s->blocks[*next_block];
2354 s->pb= pb[*next_block];
2355 if(s->data_partitioning){
2356 s->pb2 = pb2 [*next_block];
2357 s->tex_pb= tex_pb[*next_block];
2358 }
2359
2360 if(*next_block){
2361 memcpy(dest_backup, s->dest, sizeof(s->dest));
2362 s->dest[0] = s->sc.rd_scratchpad;
2363 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2364 s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2365 assert(s->linesize >= 32); //FIXME
2366 }
2367
2368 encode_mb(s, motion_x, motion_y);
2369
2370 score= put_bits_count(&s->pb);
2371 if(s->data_partitioning){
2372 score+= put_bits_count(&s->pb2);
2373 score+= put_bits_count(&s->tex_pb);
2374 }
2375
2376 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2377 ff_mpv_decode_mb(s, s->block);
2378
2379 score *= s->lambda2;
2380 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2381 }
2382
2383 if(*next_block){
2384 memcpy(s->dest, dest_backup, sizeof(s->dest));
2385 }
2386
2387 if(score<*dmin){
2388 *dmin= score;
2389 *next_block^=1;
2390
2391 copy_context_after_encode(best, s, type);
2392 }
2393 }
2394
2395 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2396 uint32_t *sq = ff_square_tab + 256;
2397 int acc=0;
2398 int x,y;
2399
2400 if(w==16 && h==16)
2401 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2402 else if(w==8 && h==8)
2403 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2404
2405 for(y=0; y<h; y++){
2406 for(x=0; x<w; x++){
2407 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2408 }
2409 }
2410
2411 assert(acc>=0);
2412
2413 return acc;
2414 }
2415
2416 static int sse_mb(MpegEncContext *s){
2417 int w= 16;
2418 int h= 16;
2419
2420 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2421 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2422
2423 if(w==16 && h==16)
2424 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2425 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) +
2426 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) +
2427 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);
2428 }else{
2429 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) +
2430 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) +
2431 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);
2432 }
2433 else
2434 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)
2435 +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)
2436 +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);
2437 }
2438
2439 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2440 MpegEncContext *s= *(void**)arg;
2441
2442
2443 s->me.pre_pass=1;
2444 s->me.dia_size= s->avctx->pre_dia_size;
2445 s->first_slice_line=1;
2446 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2447 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2448 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2449 }
2450 s->first_slice_line=0;
2451 }
2452
2453 s->me.pre_pass=0;
2454
2455 return 0;
2456 }
2457
2458 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2459 MpegEncContext *s= *(void**)arg;
2460
2461 s->me.dia_size= s->avctx->dia_size;
2462 s->first_slice_line=1;
2463 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2464 s->mb_x=0; //for block init below
2465 ff_init_block_index(s);
2466 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2467 s->block_index[0]+=2;
2468 s->block_index[1]+=2;
2469 s->block_index[2]+=2;
2470 s->block_index[3]+=2;
2471
2472 /* compute motion vector & mb_type and store in context */
2473 if(s->pict_type==AV_PICTURE_TYPE_B)
2474 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2475 else
2476 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2477 }
2478 s->first_slice_line=0;
2479 }
2480 return 0;
2481 }
2482
2483 static int mb_var_thread(AVCodecContext *c, void *arg){
2484 MpegEncContext *s= *(void**)arg;
2485 int mb_x, mb_y;
2486
2487 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2488 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2489 int xx = mb_x * 16;
2490 int yy = mb_y * 16;
2491 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2492 int varc;
2493 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2494
2495 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2496 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2497
2498 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2499 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2500 s->me.mb_var_sum_temp += varc;
2501 }
2502 }
2503 return 0;
2504 }
2505
2506 static void write_slice_end(MpegEncContext *s){
2507 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2508 if(s->partitioned_frame){
2509 ff_mpeg4_merge_partitions(s);
2510 }
2511
2512 ff_mpeg4_stuffing(&s->pb);
2513 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2514 ff_mjpeg_encode_stuffing(&s->pb);
2515 }
2516
2517 avpriv_align_put_bits(&s->pb);
2518 flush_put_bits(&s->pb);
2519
2520 if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2521 s->misc_bits+= get_bits_diff(s);
2522 }
2523
2524 static void write_mb_info(MpegEncContext *s)
2525 {
2526 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2527 int offset = put_bits_count(&s->pb);
2528 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2529 int gobn = s->mb_y / s->gob_index;
2530 int pred_x, pred_y;
2531 if (CONFIG_H263_ENCODER)
2532 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2533 bytestream_put_le32(&ptr, offset);
2534 bytestream_put_byte(&ptr, s->qscale);
2535 bytestream_put_byte(&ptr, gobn);
2536 bytestream_put_le16(&ptr, mba);
2537 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2538 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2539 /* 4MV not implemented */
2540 bytestream_put_byte(&ptr, 0); /* hmv2 */
2541 bytestream_put_byte(&ptr, 0); /* vmv2 */
2542 }
2543
2544 static void update_mb_info(MpegEncContext *s, int startcode)
2545 {
2546 if (!s->mb_info)
2547 return;
2548 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2549 s->mb_info_size += 12;
2550 s->prev_mb_info = s->last_mb_info;
2551 }
2552 if (startcode) {
2553 s->prev_mb_info = put_bits_count(&s->pb)/8;
2554 /* This might have incremented mb_info_size above, and we return without
2555 * actually writing any info into that slot yet. But in that case,
2556 * this will be called again at the start of the after writing the
2557 * start code, actually writing the mb info. */
2558 return;
2559 }
2560
2561 s->last_mb_info = put_bits_count(&s->pb)/8;
2562 if (!s->mb_info_size)
2563 s->mb_info_size += 12;
2564 write_mb_info(s);
2565 }
2566
2567 static int encode_thread(AVCodecContext *c, void *arg){
2568 MpegEncContext *s= *(void**)arg;
2569 int mb_x, mb_y, pdif = 0;
2570 int chr_h= 16>>s->chroma_y_shift;
2571 int i, j;
2572 MpegEncContext best_s = { 0 }, backup_s;
2573 uint8_t bit_buf[2][MAX_MB_BYTES];
2574 uint8_t bit_buf2[2][MAX_MB_BYTES];
2575 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2576 PutBitContext pb[2], pb2[2], tex_pb[2];
2577
2578 for(i=0; i<2; i++){
2579 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2580 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2581 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2582 }
2583
2584 s->last_bits= put_bits_count(&s->pb);
2585 s->mv_bits=0;
2586 s->misc_bits=0;
2587 s->i_tex_bits=0;
2588 s->p_tex_bits=0;
2589 s->i_count=0;
2590 s->f_count=0;
2591 s->b_count=0;
2592 s->skip_count=0;
2593
2594 for(i=0; i<3; i++){
2595 /* init last dc values */
2596 /* note: quant matrix value (8) is implied here */
2597 s->last_dc[i] = 128 << s->intra_dc_precision;
2598
2599 s->current_picture.encoding_error[i] = 0;
2600 }
2601 s->mb_skip_run = 0;
2602 memset(s->last_mv, 0, sizeof(s->last_mv));
2603
2604 s->last_mv_dir = 0;
2605
2606 switch(s->codec_id){
2607 case AV_CODEC_ID_H263:
2608 case AV_CODEC_ID_H263P:
2609 case AV_CODEC_ID_FLV1:
2610 if (CONFIG_H263_ENCODER)
2611 s->gob_index = H263_GOB_HEIGHT(s->height);
2612 break;
2613 case AV_CODEC_ID_MPEG4:
2614 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2615 ff_mpeg4_init_partitions(s);
2616 break;
2617 }
2618
2619 s->resync_mb_x=0;
2620 s->resync_mb_y=0;
2621 s->first_slice_line = 1;
2622 s->ptr_lastgob = s->pb.buf;
2623 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2624 s->mb_x=0;
2625 s->mb_y= mb_y;
2626
2627 ff_set_qscale(s, s->qscale);
2628 ff_init_block_index(s);
2629
2630 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2631 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2632 int mb_type= s->mb_type[xy];
2633 // int d;
2634 int dmin= INT_MAX;
2635 int dir;
2636
2637 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2638 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2639 return -1;
2640 }
2641 if(s->data_partitioning){
2642 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2643 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2644 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2645 return -1;
2646 }
2647 }
2648
2649 s->mb_x = mb_x;
2650 s->mb_y = mb_y; // moved into loop, can get changed by H.261
2651 ff_update_block_index(s);
2652
2653 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2654 ff_h261_reorder_mb_index(s);
2655 xy= s->mb_y*s->mb_stride + s->mb_x;
2656 mb_type= s->mb_type[xy];
2657 }
2658
2659 /* write gob / video packet header */
2660 if(s->rtp_mode){
2661 int current_packet_size, is_gob_start;
2662
2663 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2664
2665 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2666
2667 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2668
2669 switch(s->codec_id){
2670 case AV_CODEC_ID_H263:
2671 case AV_CODEC_ID_H263P:
2672 if(!s->h263_slice_structured)
2673 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2674 break;
2675 case AV_CODEC_ID_MPEG2VIDEO:
2676 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2677 case AV_CODEC_ID_MPEG1VIDEO:
2678 if(s->mb_skip_run) is_gob_start=0;
2679 break;
2680 }
2681
2682 if(is_gob_start){
2683 if(s->start_mb_y != mb_y || mb_x!=0){
2684 write_slice_end(s);
2685
2686 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2687 ff_mpeg4_init_partitions(s);
2688 }
2689 }
2690
2691 assert((put_bits_count(&s->pb)&7) == 0);
2692 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2693
2694 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2695 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2696 int d = 100 / s->error_rate;
2697 if(r % d == 0){
2698 current_packet_size=0;
2699 s->pb.buf_ptr= s->ptr_lastgob;
2700 assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2701 }
2702 }
2703
2704 if (s->avctx->rtp_callback){
2705 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2706 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2707 }
2708 update_mb_info(s, 1);
2709
2710 switch(s->codec_id){
2711 case AV_CODEC_ID_MPEG4:
2712 if (CONFIG_MPEG4_ENCODER) {
2713 ff_mpeg4_encode_video_packet_header(s);
2714 ff_mpeg4_clean_buffers(s);
2715 }
2716 break;
2717 case AV_CODEC_ID_MPEG1VIDEO:
2718 case AV_CODEC_ID_MPEG2VIDEO:
2719 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2720 ff_mpeg1_encode_slice_header(s);
2721 ff_mpeg1_clean_buffers(s);
2722 }
2723 break;
2724 case AV_CODEC_ID_H263:
2725 case AV_CODEC_ID_H263P:
2726 if (CONFIG_H263_ENCODER)
2727 ff_h263_encode_gob_header(s, mb_y);
2728 break;
2729 }
2730
2731 if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
2732 int bits= put_bits_count(&s->pb);
2733 s->misc_bits+= bits - s->last_bits;
2734 s->last_bits= bits;
2735 }
2736
2737 s->ptr_lastgob += current_packet_size;
2738 s->first_slice_line=1;
2739 s->resync_mb_x=mb_x;
2740 s->resync_mb_y=mb_y;
2741 }
2742 }
2743
2744 if( (s->resync_mb_x == s->mb_x)
2745 && s->resync_mb_y+1 == s->mb_y){
2746 s->first_slice_line=0;
2747 }
2748
2749 s->mb_skipped=0;
2750 s->dquant=0; //only for QP_RD
2751
2752 update_mb_info(s, 0);
2753
2754 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
2755 int next_block=0;
2756 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2757
2758 copy_context_before_encode(&backup_s, s, -1);
2759 backup_s.pb= s->pb;
2760 best_s.data_partitioning= s->data_partitioning;
2761 best_s.partitioned_frame= s->partitioned_frame;
2762 if(s->data_partitioning){
2763 backup_s.pb2= s->pb2;
2764 backup_s.tex_pb= s->tex_pb;
2765 }
2766
2767 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2768 s->mv_dir = MV_DIR_FORWARD;
2769 s->mv_type = MV_TYPE_16X16;
2770 s->mb_intra= 0;
2771 s->mv[0][0][0] = s->p_mv_table[xy][0];
2772 s->mv[0][0][1] = s->p_mv_table[xy][1];
2773 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2774 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2775 }
2776 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2777 s->mv_dir = MV_DIR_FORWARD;
2778 s->mv_type = MV_TYPE_FIELD;
2779 s->mb_intra= 0;
2780 for(i=0; i<2; i++){
2781 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2782 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2783 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2784 }
2785 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2786 &dmin, &next_block, 0, 0);
2787 }
2788 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2789 s->mv_dir = MV_DIR_FORWARD;
2790 s->mv_type = MV_TYPE_16X16;
2791 s->mb_intra= 0;
2792 s->mv[0][0][0] = 0;
2793 s->mv[0][0][1] = 0;
2794 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2795 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2796 }
2797 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2798 s->mv_dir = MV_DIR_FORWARD;
2799 s->mv_type = MV_TYPE_8X8;
2800 s->mb_intra= 0;
2801 for(i=0; i<4; i++){
2802 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2803 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2804 }
2805 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2806 &dmin, &next_block, 0, 0);
2807 }
2808 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2809 s->mv_dir = MV_DIR_FORWARD;
2810 s->mv_type = MV_TYPE_16X16;
2811 s->mb_intra= 0;
2812 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2813 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2814 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2815 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2816 }
2817 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2818 s->mv_dir = MV_DIR_BACKWARD;
2819 s->mv_type = MV_TYPE_16X16;
2820 s->mb_intra= 0;
2821 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2822 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2823 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2824 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2825 }
2826 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2827 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2828 s->mv_type = MV_TYPE_16X16;
2829 s->mb_intra= 0;
2830 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2831 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2832 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2833 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2834 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2835 &dmin, &next_block, 0, 0);
2836 }
2837 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2838 s->mv_dir = MV_DIR_FORWARD;
2839 s->mv_type = MV_TYPE_FIELD;
2840 s->mb_intra= 0;
2841 for(i=0; i<2; i++){
2842 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2843 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2844 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2845 }
2846 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2847 &dmin, &next_block, 0, 0);
2848 }
2849 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2850 s->mv_dir = MV_DIR_BACKWARD;
2851 s->mv_type = MV_TYPE_FIELD;
2852 s->mb_intra= 0;
2853 for(i=0; i<2; i++){
2854 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2855 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2856 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2857 }
2858 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2859 &dmin, &next_block, 0, 0);
2860 }
2861 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2862 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2863 s->mv_type = MV_TYPE_FIELD;
2864 s->mb_intra= 0;
2865 for(dir=0; dir<2; dir++){
2866 for(i=0; i<2; i++){
2867 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2868 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2869 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2870 }
2871 }
2872 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2873 &dmin, &next_block, 0, 0);
2874 }
2875 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2876 s->mv_dir = 0;
2877 s->mv_type = MV_TYPE_16X16;
2878 s->mb_intra= 1;
2879 s->mv[0][0][0] = 0;
2880 s->mv[0][0][1] = 0;
2881 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2882 &dmin, &next_block, 0, 0);
2883 if(s->h263_pred || s->h263_aic){
2884 if(best_s.mb_intra)
2885 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2886 else
2887 ff_clean_intra_table_entries(s); //old mode?
2888 }
2889 }
2890
2891 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2892 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2893 const int last_qp= backup_s.qscale;
2894 int qpi, qp, dc[6];
2895 int16_t ac[6][16];
2896 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2897 static const int dquant_tab[4]={-1,1,-2,2};
2898
2899 assert(backup_s.dquant == 0);
2900
2901 //FIXME intra
2902 s->mv_dir= best_s.mv_dir;
2903 s->mv_type = MV_TYPE_16X16;
2904 s->mb_intra= best_s.mb_intra;
2905 s->mv[0][0][0] = best_s.mv[0][0][0];
2906 s->mv[0][0][1] = best_s.mv[0][0][1];
2907 s->mv[1][0][0] = best_s.mv[1][0][0];
2908 s->mv[1][0][1] = best_s.mv[1][0][1];
2909
2910 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2911 for(; qpi<4; qpi++){
2912 int dquant= dquant_tab[qpi];
2913 qp= last_qp + dquant;
2914 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2915 continue;
2916 backup_s.dquant= dquant;
2917 if(s->mb_intra && s->dc_val[0]){
2918 for(i=0; i<6; i++){
2919 dc[i]= s->dc_val[0][ s->block_index[i] ];
2920 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2921 }
2922 }
2923
2924 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2925 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2926 if(best_s.qscale != qp){
2927 if(s->mb_intra && s->dc_val[0]){
2928 for(i=0; i<6; i++){
2929 s->dc_val[0][ s->block_index[i] ]= dc[i];
2930 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2931 }
2932 }
2933 }
2934 }
2935 }
2936 }
2937 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2938 int mx= s->b_direct_mv_table[xy][0];
2939 int my= s->b_direct_mv_table[xy][1];
2940
2941 backup_s.dquant = 0;
2942 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2943 s->mb_intra= 0;
2944 ff_mpeg4_set_direct_mv(s, mx, my);
2945 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2946 &dmin, &next_block, mx, my);
2947 }
2948 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2949 backup_s.dquant = 0;
2950 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2951 s->mb_intra= 0;
2952 ff_mpeg4_set_direct_mv(s, 0, 0);
2953 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2954 &dmin, &next_block, 0, 0);
2955 }
2956 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2957 int coded=0;
2958 for(i=0; i<6; i++)
2959 coded |= s->block_last_index[i];
2960 if(coded){
2961 int mx,my;
2962 memcpy(s->mv, best_s.mv, sizeof(s->mv));
2963 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2964 mx=my=0; //FIXME find the one we actually used
2965 ff_mpeg4_set_direct_mv(s, mx, my);
2966 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2967 mx= s->mv[1][0][0];
2968 my= s->mv[1][0][1];
2969 }else{
2970 mx= s->mv[0][0][0];
2971 my= s->mv[0][0][1];
2972 }
2973
2974 s->mv_dir= best_s.mv_dir;
2975 s->mv_type = best_s.mv_type;
2976 s->mb_intra= 0;
2977 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2978 s->mv[0][0][1] = best_s.mv[0][0][1];
2979 s->mv[1][0][0] = best_s.mv[1][0][0];
2980 s->mv[1][0][1] = best_s.mv[1][0][1];*/
2981 backup_s.dquant= 0;
2982 s->skipdct=1;
2983 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2984 &dmin, &next_block, mx, my);
2985 s->skipdct=0;
2986 }
2987 }
2988
2989 s->current_picture.qscale_table[xy] = best_s.qscale;
2990
2991 copy_context_after_encode(s, &best_s, -1);
2992
2993 pb_bits_count= put_bits_count(&s->pb);
2994 flush_put_bits(&s->pb);
2995 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2996 s->pb= backup_s.pb;
2997
2998 if(s->data_partitioning){
2999 pb2_bits_count= put_bits_count(&s->pb2);
3000 flush_put_bits(&s->pb2);
3001 avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3002 s->pb2= backup_s.pb2;
3003
3004 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3005 flush_put_bits(&s->tex_pb);
3006 avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3007 s->tex_pb= backup_s.tex_pb;
3008 }
3009 s->last_bits= put_bits_count(&s->pb);
3010
3011 if (CONFIG_H263_ENCODER &&
3012 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3013 ff_h263_update_motion_val(s);
3014
3015 if(next_block==0){ //FIXME 16 vs linesize16
3016 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3017 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3018 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3019 }
3020
3021 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3022 ff_mpv_decode_mb(s, s->block);
3023 } else {
3024 int motion_x = 0, motion_y = 0;
3025 s->mv_type=MV_TYPE_16X16;
3026 // only one MB-Type possible
3027
3028 switch(mb_type){
3029 case CANDIDATE_MB_TYPE_INTRA:
3030 s->mv_dir = 0;
3031 s->mb_intra= 1;
3032 motion_x= s->mv[0][0][0] = 0;
3033 motion_y= s->mv[0][0][1] = 0;
3034 break;
3035 case CANDIDATE_MB_TYPE_INTER:
3036 s->mv_dir = MV_DIR_FORWARD;
3037 s->mb_intra= 0;
3038 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3039 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3040 break;
3041 case CANDIDATE_MB_TYPE_INTER_I:
3042 s->mv_dir = MV_DIR_FORWARD;
3043 s->mv_type = MV_TYPE_FIELD;
3044 s->mb_intra= 0;
3045 for(i=0; i<2; i++){
3046 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3047 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3048 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3049 }
3050 break;
3051 case CANDIDATE_MB_TYPE_INTER4V:
3052 s->mv_dir = MV_DIR_FORWARD;
3053 s->mv_type = MV_TYPE_8X8;
3054 s->mb_intra= 0;
3055 for(i=0; i<4; i++){
3056 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3057 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3058 }
3059 break;
3060 case CANDIDATE_MB_TYPE_DIRECT:
3061 if (CONFIG_MPEG4_ENCODER) {
3062 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3063 s->mb_intra= 0;
3064 motion_x=s->b_direct_mv_table[xy][0];
3065 motion_y=s->b_direct_mv_table[xy][1];
3066 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3067 }
3068 break;
3069 case CANDIDATE_MB_TYPE_DIRECT0:
3070 if (CONFIG_MPEG4_ENCODER) {
3071 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3072 s->mb_intra= 0;
3073 ff_mpeg4_set_direct_mv(s, 0, 0);
3074 }
3075 break;
3076 case CANDIDATE_MB_TYPE_BIDIR:
3077 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3078 s->mb_intra= 0;
3079 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3080 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3081 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3082 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3083 break;
3084 case CANDIDATE_MB_TYPE_BACKWARD:
3085 s->mv_dir = MV_DIR_BACKWARD;
3086 s->mb_intra= 0;
3087 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3088 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3089 break;
3090 case CANDIDATE_MB_TYPE_FORWARD:
3091 s->mv_dir = MV_DIR_FORWARD;
3092 s->mb_intra= 0;
3093 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3094 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3095 break;
3096 case CANDIDATE_MB_TYPE_FORWARD_I:
3097 s->mv_dir = MV_DIR_FORWARD;
3098 s->mv_type = MV_TYPE_FIELD;
3099 s->mb_intra= 0;
3100 for(i=0; i<2; i++){
3101 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3102 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3103 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3104 }
3105 break;
3106 case CANDIDATE_MB_TYPE_BACKWARD_I:
3107 s->mv_dir = MV_DIR_BACKWARD;
3108 s->mv_type = MV_TYPE_FIELD;
3109 s->mb_intra= 0;
3110 for(i=0; i<2; i++){
3111 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3112 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3113 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3114 }
3115 break;
3116 case CANDIDATE_MB_TYPE_BIDIR_I:
3117 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3118 s->mv_type = MV_TYPE_FIELD;
3119 s->mb_intra= 0;
3120 for(dir=0; dir<2; dir++){
3121 for(i=0; i<2; i++){
3122 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3123 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3124 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3125 }
3126 }
3127 break;
3128 default:
3129 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3130 }
3131
3132 encode_mb(s, motion_x, motion_y);
3133
3134 // RAL: Update last macroblock type
3135 s->last_mv_dir = s->mv_dir;
3136
3137 if (CONFIG_H263_ENCODER &&
3138 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3139 ff_h263_update_motion_val(s);
3140
3141 ff_mpv_decode_mb(s, s->block);
3142 }
3143
3144 /* clean the MV table in IPS frames for direct mode in B frames */
3145 if(s->mb_intra /* && I,P,S_TYPE */){
3146 s->p_mv_table[xy][0]=0;
3147 s->p_mv_table[xy][1]=0;
3148 }
3149
3150 if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3151 int w= 16;
3152 int h= 16;
3153
3154 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3155 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3156
3157 s->current_picture.encoding_error[0] += sse(
3158 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3159 s->dest[0], w, h, s->linesize);
3160 s->current_picture.encoding_error[1] += sse(
3161 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3162 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3163 s->current_picture.encoding_error[2] += sse(
3164 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3165 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3166 }
3167 if(s->loop_filter){
3168 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3169 ff_h263_loop_filter(s);
3170 }
3171 ff_dlog(s->avctx, "MB %d %d bits\n",
3172 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3173 }
3174 }
3175
3176 //not beautiful here but we must write it before flushing so it has to be here
3177 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3178 ff_msmpeg4_encode_ext_header(s);
3179
3180 write_slice_end(s);
3181
3182 /* Send the last GOB if RTP */
3183 if (s->avctx->rtp_callback) {
3184 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3185 pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3186 /* Call the RTP callback to send the last GOB */
3187 emms_c();
3188 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3189 }
3190
3191 return 0;
3192 }
3193
3194 #define MERGE(field) dst->field += src->field; src->field=0
3195 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3196 MERGE(me.scene_change_score);
3197 MERGE(me.mc_mb_var_sum_temp);
3198 MERGE(me.mb_var_sum_temp);
3199 }
3200
3201 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3202 int i;
3203
3204 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3205 MERGE(dct_count[1]);
3206 MERGE(mv_bits);
3207 MERGE(i_tex_bits);
3208 MERGE(p_tex_bits);
3209 MERGE(i_count);
3210 MERGE(f_count);
3211 MERGE(b_count);
3212 MERGE(skip_count);
3213 MERGE(misc_bits);
3214 MERGE(er.error_count);