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 FFmpeg.
9 *
10 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /*
26 * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
27 */
28
29 /**
30 * @file
31 * The simplest mpeg encoder (well, it was the simplest!).
32 */
33
34 #include <stdint.h>
35
36 #include "libavutil/internal.h"
37 #include "libavutil/intmath.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/mem_internal.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/thread.h"
43 #include "avcodec.h"
44 #include "dct.h"
45 #include "idctdsp.h"
46 #include "mpeg12.h"
47 #include "mpegvideo.h"
48 #include "mpegvideodata.h"
49 #include "h261.h"
50 #include "h263.h"
51 #include "h263data.h"
52 #include "mjpegenc_common.h"
53 #include "mathops.h"
54 #include "mpegutils.h"
55 #include "mjpegenc.h"
56 #include "speedhqenc.h"
57 #include "msmpeg4.h"
58 #include "pixblockdsp.h"
59 #include "qpeldsp.h"
60 #include "faandct.h"
61 #include "thread.h"
62 #include "aandcttab.h"
63 #include "flv.h"
64 #include "mpeg4video.h"
65 #include "internal.h"
66 #include "bytestream.h"
67 #include "wmv2.h"
68 #include "rv10.h"
69 #include "packet_internal.h"
70 #include <limits.h>
71 #include "sp5x.h"
72
73 #define QUANT_BIAS_SHIFT 8
74
75 #define QMAT_SHIFT_MMX 16
76 #define QMAT_SHIFT 21
77
78 static int encode_picture(MpegEncContext *s, int picture_number);
79 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
80 static int sse_mb(MpegEncContext *s);
81 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
82 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
83
84 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
85 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
86
87 const AVOption ff_mpv_generic_options[] = {
88 FF_MPV_COMMON_OPTS
89 { NULL },
90 };
91
ff_convert_matrix(MpegEncContext * s,int (* qmat)[64],uint16_t (* qmat16)[2][64],const uint16_t * quant_matrix,int bias,int qmin,int qmax,int intra)92 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
93 uint16_t (*qmat16)[2][64],
94 const uint16_t *quant_matrix,
95 int bias, int qmin, int qmax, int intra)
96 {
97 FDCTDSPContext *fdsp = &s->fdsp;
98 int qscale;
99 int shift = 0;
100
101 for (qscale = qmin; qscale <= qmax; qscale++) {
102 int i;
103 int qscale2;
104
105 if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
106 else qscale2 = qscale << 1;
107
108 if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
109 #if CONFIG_FAANDCT
110 fdsp->fdct == ff_faandct ||
111 #endif /* CONFIG_FAANDCT */
112 fdsp->fdct == ff_jpeg_fdct_islow_10) {
113 for (i = 0; i < 64; i++) {
114 const int j = s->idsp.idct_permutation[i];
115 int64_t den = (int64_t) qscale2 * quant_matrix[j];
116 /* 16 <= qscale * quant_matrix[i] <= 7905
117 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
118 * 19952 <= x <= 249205026
119 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
120 * 3444240 >= (1 << 36) / (x) >= 275 */
121
122 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
123 }
124 } else if (fdsp->fdct == ff_fdct_ifast) {
125 for (i = 0; i < 64; i++) {
126 const int j = s->idsp.idct_permutation[i];
127 int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
128 /* 16 <= qscale * quant_matrix[i] <= 7905
129 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
130 * 19952 <= x <= 249205026
131 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
132 * 3444240 >= (1 << 36) / (x) >= 275 */
133
134 qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
135 }
136 } else {
137 for (i = 0; i < 64; i++) {
138 const int j = s->idsp.idct_permutation[i];
139 int64_t den = (int64_t) qscale2 * quant_matrix[j];
140 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
141 * Assume x = qscale * quant_matrix[i]
142 * So 16 <= x <= 7905
143 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
144 * so 32768 >= (1 << 19) / (x) >= 67 */
145 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
146 //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
147 // (qscale * quant_matrix[i]);
148 qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
149
150 if (qmat16[qscale][0][i] == 0 ||
151 qmat16[qscale][0][i] == 128 * 256)
152 qmat16[qscale][0][i] = 128 * 256 - 1;
153 qmat16[qscale][1][i] =
154 ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
155 qmat16[qscale][0][i]);
156 }
157 }
158
159 for (i = intra; i < 64; i++) {
160 int64_t max = 8191;
161 if (fdsp->fdct == ff_fdct_ifast) {
162 max = (8191LL * ff_aanscales[i]) >> 14;
163 }
164 while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
165 shift++;
166 }
167 }
168 }
169 if (shift) {
170 av_log(s->avctx, AV_LOG_INFO,
171 "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
172 QMAT_SHIFT - shift);
173 }
174 }
175
update_qscale(MpegEncContext * s)176 static inline void update_qscale(MpegEncContext *s)
177 {
178 if (s->q_scale_type == 1 && 0) {
179 int i;
180 int bestdiff=INT_MAX;
181 int best = 1;
182
183 for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
184 int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
185 if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
186 (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
187 continue;
188 if (diff < bestdiff) {
189 bestdiff = diff;
190 best = i;
191 }
192 }
193 s->qscale = best;
194 } else {
195 s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
196 (FF_LAMBDA_SHIFT + 7);
197 s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
198 }
199
200 s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
201 FF_LAMBDA_SHIFT;
202 }
203
ff_write_quant_matrix(PutBitContext * pb,uint16_t * matrix)204 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
205 {
206 int i;
207
208 if (matrix) {
209 put_bits(pb, 1, 1);
210 for (i = 0; i < 64; i++) {
211 put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
212 }
213 } else
214 put_bits(pb, 1, 0);
215 }
216
217 /**
218 * init s->current_picture.qscale_table from s->lambda_table
219 */
ff_init_qscale_tab(MpegEncContext * s)220 void ff_init_qscale_tab(MpegEncContext *s)
221 {
222 int8_t * const qscale_table = s->current_picture.qscale_table;
223 int i;
224
225 for (i = 0; i < s->mb_num; i++) {
226 unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
227 int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
228 qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
229 s->avctx->qmax);
230 }
231 }
232
update_duplicate_context_after_me(MpegEncContext * dst,MpegEncContext * src)233 static void update_duplicate_context_after_me(MpegEncContext *dst,
234 MpegEncContext *src)
235 {
236 #define COPY(a) dst->a= src->a
237 COPY(pict_type);
238 COPY(current_picture);
239 COPY(f_code);
240 COPY(b_code);
241 COPY(qscale);
242 COPY(lambda);
243 COPY(lambda2);
244 COPY(picture_in_gop_number);
245 COPY(gop_picture_number);
246 COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
247 COPY(progressive_frame); // FIXME don't set in encode_header
248 COPY(partitioned_frame); // FIXME don't set in encode_header
249 #undef COPY
250 }
251
mpv_encode_init_static(void)252 static void mpv_encode_init_static(void)
253 {
254 for (int i = -16; i < 16; i++)
255 default_fcode_tab[i + MAX_MV] = 1;
256 }
257
258 /**
259 * Set the given MpegEncContext to defaults for encoding.
260 * the changed fields will not depend upon the prior state of the MpegEncContext.
261 */
mpv_encode_defaults(MpegEncContext * s)262 static void mpv_encode_defaults(MpegEncContext *s)
263 {
264 static AVOnce init_static_once = AV_ONCE_INIT;
265
266 ff_mpv_common_defaults(s);
267
268 ff_thread_once(&init_static_once, mpv_encode_init_static);
269
270 s->me.mv_penalty = default_mv_penalty;
271 s->fcode_tab = default_fcode_tab;
272
273 s->input_picture_number = 0;
274 s->picture_in_gop_number = 0;
275 }
276
ff_dct_encode_init(MpegEncContext * s)277 av_cold int ff_dct_encode_init(MpegEncContext *s)
278 {
279 if (ARCH_X86)
280 ff_dct_encode_init_x86(s);
281
282 if (CONFIG_H263_ENCODER)
283 ff_h263dsp_init(&s->h263dsp);
284 if (!s->dct_quantize)
285 s->dct_quantize = ff_dct_quantize_c;
286 if (!s->denoise_dct)
287 s->denoise_dct = denoise_dct_c;
288 s->fast_dct_quantize = s->dct_quantize;
289 if (s->avctx->trellis)
290 s->dct_quantize = dct_quantize_trellis_c;
291
292 return 0;
293 }
294
295 /* init video encoder */
ff_mpv_encode_init(AVCodecContext * avctx)296 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
297 {
298 MpegEncContext *s = avctx->priv_data;
299 AVCPBProperties *cpb_props;
300 int i, ret, format_supported;
301
302 mpv_encode_defaults(s);
303
304 switch (avctx->codec_id) {
305 case AV_CODEC_ID_MPEG2VIDEO:
306 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
307 avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
308 av_log(avctx, AV_LOG_ERROR,
309 "only YUV420 and YUV422 are supported\n");
310 return AVERROR(EINVAL);
311 }
312 break;
313 case AV_CODEC_ID_MJPEG:
314 case AV_CODEC_ID_AMV:
315 format_supported = 0;
316 /* JPEG color space */
317 if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
318 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
319 avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
320 (avctx->color_range == AVCOL_RANGE_JPEG &&
321 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
322 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
323 avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
324 format_supported = 1;
325 /* MPEG color space */
326 else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
327 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
328 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
329 avctx->pix_fmt == AV_PIX_FMT_YUV444P))
330 format_supported = 1;
331
332 if (!format_supported) {
333 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
334 return AVERROR(EINVAL);
335 }
336 break;
337 case AV_CODEC_ID_SPEEDHQ:
338 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
339 avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
340 avctx->pix_fmt != AV_PIX_FMT_YUV444P) {
341 av_log(avctx, AV_LOG_ERROR,
342 "only YUV420/YUV422/YUV444 are supported (no alpha support yet)\n");
343 return AVERROR(EINVAL);
344 }
345 break;
346 default:
347 if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
348 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
349 return AVERROR(EINVAL);
350 }
351 }
352
353 switch (avctx->pix_fmt) {
354 case AV_PIX_FMT_YUVJ444P:
355 case AV_PIX_FMT_YUV444P:
356 s->chroma_format = CHROMA_444;
357 break;
358 case AV_PIX_FMT_YUVJ422P:
359 case AV_PIX_FMT_YUV422P:
360 s->chroma_format = CHROMA_422;
361 break;
362 case AV_PIX_FMT_YUVJ420P:
363 case AV_PIX_FMT_YUV420P:
364 default:
365 s->chroma_format = CHROMA_420;
366 break;
367 }
368
369 avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
370
371 #if FF_API_PRIVATE_OPT
372 FF_DISABLE_DEPRECATION_WARNINGS
373 if (avctx->rtp_payload_size)
374 s->rtp_payload_size = avctx->rtp_payload_size;
375 if (avctx->me_penalty_compensation)
376 s->me_penalty_compensation = avctx->me_penalty_compensation;
377 if (avctx->pre_me)
378 s->me_pre = avctx->pre_me;
379 FF_ENABLE_DEPRECATION_WARNINGS
380 #endif
381
382 s->bit_rate = avctx->bit_rate;
383 s->width = avctx->width;
384 s->height = avctx->height;
385 if (avctx->gop_size > 600 &&
386 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
387 av_log(avctx, AV_LOG_WARNING,
388 "keyframe interval too large!, reducing it from %d to %d\n",
389 avctx->gop_size, 600);
390 avctx->gop_size = 600;
391 }
392 s->gop_size = avctx->gop_size;
393 s->avctx = avctx;
394 if (avctx->max_b_frames > MAX_B_FRAMES) {
395 av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
396 "is %d.\n", MAX_B_FRAMES);
397 avctx->max_b_frames = MAX_B_FRAMES;
398 }
399 s->max_b_frames = avctx->max_b_frames;
400 s->codec_id = avctx->codec->id;
401 s->strict_std_compliance = avctx->strict_std_compliance;
402 s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
403 s->rtp_mode = !!s->rtp_payload_size;
404 s->intra_dc_precision = avctx->intra_dc_precision;
405
406 // workaround some differences between how applications specify dc precision
407 if (s->intra_dc_precision < 0) {
408 s->intra_dc_precision += 8;
409 } else if (s->intra_dc_precision >= 8)
410 s->intra_dc_precision -= 8;
411
412 if (s->intra_dc_precision < 0) {
413 av_log(avctx, AV_LOG_ERROR,
414 "intra dc precision must be positive, note some applications use"
415 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
416 return AVERROR(EINVAL);
417 }
418
419 if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
420 s->huffman = 0;
421
422 if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
423 av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
424 return AVERROR(EINVAL);
425 }
426 s->user_specified_pts = AV_NOPTS_VALUE;
427
428 if (s->gop_size <= 1) {
429 s->intra_only = 1;
430 s->gop_size = 12;
431 } else {
432 s->intra_only = 0;
433 }
434
435 /* Fixed QSCALE */
436 s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
437
438 s->adaptive_quant = (avctx->lumi_masking ||
439 avctx->dark_masking ||
440 avctx->temporal_cplx_masking ||
441 avctx->spatial_cplx_masking ||
442 avctx->p_masking ||
443 s->border_masking ||
444 (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
445 !s->fixed_qscale;
446
447 s->loop_filter = !!(avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
448
449 if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
450 switch(avctx->codec_id) {
451 case AV_CODEC_ID_MPEG1VIDEO:
452 case AV_CODEC_ID_MPEG2VIDEO:
453 avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
454 break;
455 case AV_CODEC_ID_MPEG4:
456 case AV_CODEC_ID_MSMPEG4V1:
457 case AV_CODEC_ID_MSMPEG4V2:
458 case AV_CODEC_ID_MSMPEG4V3:
459 if (avctx->rc_max_rate >= 15000000) {
460 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
461 } else if(avctx->rc_max_rate >= 2000000) {
462 avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000LL) * (320- 80) / (15000000 - 2000000);
463 } else if(avctx->rc_max_rate >= 384000) {
464 avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000LL) * ( 80- 40) / ( 2000000 - 384000);
465 } else
466 avctx->rc_buffer_size = 40;
467 avctx->rc_buffer_size *= 16384;
468 break;
469 }
470 if (avctx->rc_buffer_size) {
471 av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
472 }
473 }
474
475 if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
476 av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
477 return AVERROR(EINVAL);
478 }
479
480 if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
481 av_log(avctx, AV_LOG_INFO,
482 "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
483 }
484
485 if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
486 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
487 return AVERROR(EINVAL);
488 }
489
490 if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
491 av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
492 return AVERROR(EINVAL);
493 }
494
495 if (avctx->rc_max_rate &&
496 avctx->rc_max_rate == avctx->bit_rate &&
497 avctx->rc_max_rate != avctx->rc_min_rate) {
498 av_log(avctx, AV_LOG_INFO,
499 "impossible bitrate constraints, this will fail\n");
500 }
501
502 if (avctx->rc_buffer_size &&
503 avctx->bit_rate * (int64_t)avctx->time_base.num >
504 avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
505 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
506 return AVERROR(EINVAL);
507 }
508
509 if (!s->fixed_qscale &&
510 avctx->bit_rate * av_q2d(avctx->time_base) >
511 avctx->bit_rate_tolerance) {
512 av_log(avctx, AV_LOG_WARNING,
513 "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
514 avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
515 }
516
517 if (avctx->rc_max_rate &&
518 avctx->rc_min_rate == avctx->rc_max_rate &&
519 (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
520 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
521 90000LL * (avctx->rc_buffer_size - 1) >
522 avctx->rc_max_rate * 0xFFFFLL) {
523 av_log(avctx, AV_LOG_INFO,
524 "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
525 "specified vbv buffer is too large for the given bitrate!\n");
526 }
527
528 if ((avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
529 s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
530 s->codec_id != AV_CODEC_ID_FLV1) {
531 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
532 return AVERROR(EINVAL);
533 }
534
535 if (s->obmc && avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
536 av_log(avctx, AV_LOG_ERROR,
537 "OBMC is only supported with simple mb decision\n");
538 return AVERROR(EINVAL);
539 }
540
541 if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
542 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
543 return AVERROR(EINVAL);
544 }
545
546 if (s->max_b_frames &&
547 s->codec_id != AV_CODEC_ID_MPEG4 &&
548 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
549 s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
550 av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
551 return AVERROR(EINVAL);
552 }
553 if (s->max_b_frames < 0) {
554 av_log(avctx, AV_LOG_ERROR,
555 "max b frames must be 0 or positive for mpegvideo based encoders\n");
556 return AVERROR(EINVAL);
557 }
558
559 if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
560 s->codec_id == AV_CODEC_ID_H263 ||
561 s->codec_id == AV_CODEC_ID_H263P) &&
562 (avctx->sample_aspect_ratio.num > 255 ||
563 avctx->sample_aspect_ratio.den > 255)) {
564 av_log(avctx, AV_LOG_WARNING,
565 "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
566 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
567 av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
568 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
569 }
570
571 if ((s->codec_id == AV_CODEC_ID_H263 ||
572 s->codec_id == AV_CODEC_ID_H263P) &&
573 (avctx->width > 2048 ||
574 avctx->height > 1152 )) {
575 av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
576 return AVERROR(EINVAL);
577 }
578 if ((s->codec_id == AV_CODEC_ID_H263 ||
579 s->codec_id == AV_CODEC_ID_H263P) &&
580 ((avctx->width &3) ||
581 (avctx->height&3) )) {
582 av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
583 return AVERROR(EINVAL);
584 }
585
586 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
587 (avctx->width > 4095 ||
588 avctx->height > 4095 )) {
589 av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
590 return AVERROR(EINVAL);
591 }
592
593 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
594 (avctx->width > 16383 ||
595 avctx->height > 16383 )) {
596 av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
597 return AVERROR(EINVAL);
598 }
599
600 if (s->codec_id == AV_CODEC_ID_RV10 &&
601 (avctx->width &15 ||
602 avctx->height&15 )) {
603 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
604 return AVERROR(EINVAL);
605 }
606
607 if (s->codec_id == AV_CODEC_ID_RV20 &&
608 (avctx->width &3 ||
609 avctx->height&3 )) {
610 av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
611 return AVERROR(EINVAL);
612 }
613
614 if ((s->codec_id == AV_CODEC_ID_WMV1 ||
615 s->codec_id == AV_CODEC_ID_WMV2) &&
616 avctx->width & 1) {
617 av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
618 return AVERROR(EINVAL);
619 }
620
621 if ((avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
622 s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
623 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
624 return AVERROR(EINVAL);
625 }
626
627 #if FF_API_PRIVATE_OPT
628 FF_DISABLE_DEPRECATION_WARNINGS
629 if (avctx->mpeg_quant)
630 s->mpeg_quant = 1;
631 FF_ENABLE_DEPRECATION_WARNINGS
632 #endif
633
634 // FIXME mpeg2 uses that too
635 if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
636 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
637 av_log(avctx, AV_LOG_ERROR,
638 "mpeg2 style quantization not supported by codec\n");
639 return AVERROR(EINVAL);
640 }
641
642 if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
643 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
644 return AVERROR(EINVAL);
645 }
646
647 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
648 avctx->mb_decision != FF_MB_DECISION_RD) {
649 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
650 return AVERROR(EINVAL);
651 }
652
653 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
654 (s->codec_id == AV_CODEC_ID_AMV ||
655 s->codec_id == AV_CODEC_ID_MJPEG)) {
656 // Used to produce garbage with MJPEG.
657 av_log(avctx, AV_LOG_ERROR,
658 "QP RD is no longer compatible with MJPEG or AMV\n");
659 return AVERROR(EINVAL);
660 }
661
662 #if FF_API_PRIVATE_OPT
663 FF_DISABLE_DEPRECATION_WARNINGS
664 if (avctx->scenechange_threshold)
665 s->scenechange_threshold = avctx->scenechange_threshold;
666 FF_ENABLE_DEPRECATION_WARNINGS
667 #endif
668
669 if (s->scenechange_threshold < 1000000000 &&
670 (avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
671 av_log(avctx, AV_LOG_ERROR,
672 "closed gop with scene change detection are not supported yet, "
673 "set threshold to 1000000000\n");
674 return AVERROR_PATCHWELCOME;
675 }
676
677 if (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
678 if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
679 s->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
680 av_log(avctx, AV_LOG_ERROR,
681 "low delay forcing is only available for mpeg2, "
682 "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
683 return AVERROR(EINVAL);
684 }
685 if (s->max_b_frames != 0) {
686 av_log(avctx, AV_LOG_ERROR,
687 "B-frames cannot be used with low delay\n");
688 return AVERROR(EINVAL);
689 }
690 }
691
692 if (s->q_scale_type == 1) {
693 if (avctx->qmax > 28) {
694 av_log(avctx, AV_LOG_ERROR,
695 "non linear quant only supports qmax <= 28 currently\n");
696 return AVERROR_PATCHWELCOME;
697 }
698 }
699
700 if (avctx->slices > 1 &&
701 (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
702 av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
703 return AVERROR(EINVAL);
704 }
705
706 if (avctx->thread_count > 1 &&
707 s->codec_id != AV_CODEC_ID_MPEG4 &&
708 s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
709 s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
710 s->codec_id != AV_CODEC_ID_MJPEG &&
711 (s->codec_id != AV_CODEC_ID_H263P)) {
712 av_log(avctx, AV_LOG_ERROR,
713 "multi threaded encoding not supported by codec\n");
714 return AVERROR_PATCHWELCOME;
715 }
716
717 if (avctx->thread_count < 1) {
718 av_log(avctx, AV_LOG_ERROR,
719 "automatic thread number detection not supported by codec, "
720 "patch welcome\n");
721 return AVERROR_PATCHWELCOME;
722 }
723
724 if (!avctx->time_base.den || !avctx->time_base.num) {
725 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
726 return AVERROR(EINVAL);
727 }
728
729 #if FF_API_PRIVATE_OPT
730 FF_DISABLE_DEPRECATION_WARNINGS
731 if (avctx->b_frame_strategy)
732 s->b_frame_strategy = avctx->b_frame_strategy;
733 if (avctx->b_sensitivity != 40)
734 s->b_sensitivity = avctx->b_sensitivity;
735 FF_ENABLE_DEPRECATION_WARNINGS
736 #endif
737
738 if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
739 av_log(avctx, AV_LOG_INFO,
740 "notice: b_frame_strategy only affects the first pass\n");
741 s->b_frame_strategy = 0;
742 }
743
744 i = av_gcd(avctx->time_base.den, avctx->time_base.num);
745 if (i > 1) {
746 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
747 avctx->time_base.den /= i;
748 avctx->time_base.num /= i;
749 //return -1;
750 }
751
752 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id == AV_CODEC_ID_AMV || s->codec_id == AV_CODEC_ID_SPEEDHQ) {
753 // (a + x * 3 / 8) / x
754 s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
755 s->inter_quant_bias = 0;
756 } else {
757 s->intra_quant_bias = 0;
758 // (a - x / 4) / x
759 s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
760 }
761
762 if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
763 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
764 return AVERROR(EINVAL);
765 }
766
767 av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
768
769 if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
770 avctx->time_base.den > (1 << 16) - 1) {
771 av_log(avctx, AV_LOG_ERROR,
772 "timebase %d/%d not supported by MPEG 4 standard, "
773 "the maximum admitted value for the timebase denominator "
774 "is %d\n", avctx->time_base.num, avctx->time_base.den,
775 (1 << 16) - 1);
776 return AVERROR(EINVAL);
777 }
778 s->time_increment_bits = av_log2(avctx->time_base.den - 1) + 1;
779
780 switch (avctx->codec->id) {
781 case AV_CODEC_ID_MPEG1VIDEO:
782 s->out_format = FMT_MPEG1;
783 s->low_delay = !!(avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
784 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
785 break;
786 case AV_CODEC_ID_MPEG2VIDEO:
787 s->out_format = FMT_MPEG1;
788 s->low_delay = !!(avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
789 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
790 s->rtp_mode = 1;
791 break;
792 case AV_CODEC_ID_MJPEG:
793 case AV_CODEC_ID_AMV:
794 s->out_format = FMT_MJPEG;
795 s->intra_only = 1; /* force intra only for jpeg */
796 if (!CONFIG_MJPEG_ENCODER)
797 return AVERROR_ENCODER_NOT_FOUND;
798 if ((ret = ff_mjpeg_encode_init(s)) < 0)
799 return ret;
800 avctx->delay = 0;
801 s->low_delay = 1;
802 break;
803 case AV_CODEC_ID_SPEEDHQ:
804 s->out_format = FMT_SPEEDHQ;
805 s->intra_only = 1; /* force intra only for SHQ */
806 if (!CONFIG_SPEEDHQ_ENCODER)
807 return AVERROR_ENCODER_NOT_FOUND;
808 if ((ret = ff_speedhq_encode_init(s)) < 0)
809 return ret;
810 avctx->delay = 0;
811 s->low_delay = 1;
812 break;
813 case AV_CODEC_ID_H261:
814 if (!CONFIG_H261_ENCODER)
815 return AVERROR_ENCODER_NOT_FOUND;
816 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
817 av_log(avctx, AV_LOG_ERROR,
818 "The specified picture size of %dx%d is not valid for the "
819 "H.261 codec.\nValid sizes are 176x144, 352x288\n",
820 s->width, s->height);
821 return AVERROR(EINVAL);
822 }
823 s->out_format = FMT_H261;
824 avctx->delay = 0;
825 s->low_delay = 1;
826 s->rtp_mode = 0; /* Sliced encoding not supported */
827 break;
828 case AV_CODEC_ID_H263:
829 if (!CONFIG_H263_ENCODER)
830 return AVERROR_ENCODER_NOT_FOUND;
831 if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
832 s->width, s->height) == 8) {
833 av_log(avctx, AV_LOG_ERROR,
834 "The specified picture size of %dx%d is not valid for "
835 "the H.263 codec.\nValid sizes are 128x96, 176x144, "
836 "352x288, 704x576, and 1408x1152. "
837 "Try H.263+.\n", s->width, s->height);
838 return AVERROR(EINVAL);
839 }
840 s->out_format = FMT_H263;
841 avctx->delay = 0;
842 s->low_delay = 1;
843 break;
844 case AV_CODEC_ID_H263P:
845 s->out_format = FMT_H263;
846 s->h263_plus = 1;
847 /* Fx */
848 s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
849 s->modified_quant = s->h263_aic;
850 s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
851 s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
852
853 /* /Fx */
854 /* These are just to be sure */
855 avctx->delay = 0;
856 s->low_delay = 1;
857 break;
858 case AV_CODEC_ID_FLV1:
859 s->out_format = FMT_H263;
860 s->h263_flv = 2; /* format = 1; 11-bit codes */
861 s->unrestricted_mv = 1;
862 s->rtp_mode = 0; /* don't allow GOB */
863 avctx->delay = 0;
864 s->low_delay = 1;
865 break;
866 case AV_CODEC_ID_RV10:
867 s->out_format = FMT_H263;
868 avctx->delay = 0;
869 s->low_delay = 1;
870 break;
871 case AV_CODEC_ID_RV20:
872 s->out_format = FMT_H263;
873 avctx->delay = 0;
874 s->low_delay = 1;
875 s->modified_quant = 1;
876 s->h263_aic = 1;
877 s->h263_plus = 1;
878 s->loop_filter = 1;
879 s->unrestricted_mv = 0;
880 break;
881 case AV_CODEC_ID_MPEG4:
882 s->out_format = FMT_H263;
883 s->h263_pred = 1;
884 s->unrestricted_mv = 1;
885 s->low_delay = s->max_b_frames ? 0 : 1;
886 avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
887 break;
888 case AV_CODEC_ID_MSMPEG4V2:
889 s->out_format = FMT_H263;
890 s->h263_pred = 1;
891 s->unrestricted_mv = 1;
892 s->msmpeg4_version = 2;
893 avctx->delay = 0;
894 s->low_delay = 1;
895 break;
896 case AV_CODEC_ID_MSMPEG4V3:
897 s->out_format = FMT_H263;
898 s->h263_pred = 1;
899 s->unrestricted_mv = 1;
900 s->msmpeg4_version = 3;
901 s->flipflop_rounding = 1;
902 avctx->delay = 0;
903 s->low_delay = 1;
904 break;
905 case AV_CODEC_ID_WMV1:
906 s->out_format = FMT_H263;
907 s->h263_pred = 1;
908 s->unrestricted_mv = 1;
909 s->msmpeg4_version = 4;
910 s->flipflop_rounding = 1;
911 avctx->delay = 0;
912 s->low_delay = 1;
913 break;
914 case AV_CODEC_ID_WMV2:
915 s->out_format = FMT_H263;
916 s->h263_pred = 1;
917 s->unrestricted_mv = 1;
918 s->msmpeg4_version = 5;
919 s->flipflop_rounding = 1;
920 avctx->delay = 0;
921 s->low_delay = 1;
922 break;
923 default:
924 return AVERROR(EINVAL);
925 }
926
927 #if FF_API_PRIVATE_OPT
928 FF_DISABLE_DEPRECATION_WARNINGS
929 if (avctx->noise_reduction)
930 s->noise_reduction = avctx->noise_reduction;
931 FF_ENABLE_DEPRECATION_WARNINGS
932 #endif
933
934 avctx->has_b_frames = !s->low_delay;
935
936 s->encoding = 1;
937
938 s->progressive_frame =
939 s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
940 AV_CODEC_FLAG_INTERLACED_ME) ||
941 s->alternate_scan);
942
943 /* init */
944 ff_mpv_idct_init(s);
945 if ((ret = ff_mpv_common_init(s)) < 0)
946 return ret;
947
948 ff_fdctdsp_init(&s->fdsp, avctx);
949 ff_me_cmp_init(&s->mecc, avctx);
950 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
951 ff_pixblockdsp_init(&s->pdsp, avctx);
952 ff_qpeldsp_init(&s->qdsp);
953
954 if (s->msmpeg4_version) {
955 int ac_stats_size = 2 * 2 * (MAX_LEVEL + 1) * (MAX_RUN + 1) * 2 * sizeof(int);
956 if (!(s->ac_stats = av_mallocz(ac_stats_size)))
957 return AVERROR(ENOMEM);
958 }
959
960 if (!(avctx->stats_out = av_mallocz(256)) ||
961 !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix, 32) ||
962 !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix, 32) ||
963 !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix, 32) ||
964 !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix16, 32) ||
965 !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix16, 32) ||
966 !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16, 32) ||
967 !FF_ALLOCZ_TYPED_ARRAY(s->input_picture, MAX_PICTURE_COUNT) ||
968 !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_PICTURE_COUNT))
969 return AVERROR(ENOMEM);
970
971 if (s->noise_reduction) {
972 if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_offset, 2))
973 return AVERROR(ENOMEM);
974 }
975
976 ff_dct_encode_init(s);
977
978 if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
979 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
980
981 if (s->slice_context_count > 1) {
982 s->rtp_mode = 1;
983
984 if (avctx->codec_id == AV_CODEC_ID_H263P)
985 s->h263_slice_structured = 1;
986 }
987
988 s->quant_precision = 5;
989
990 #if FF_API_PRIVATE_OPT
991 FF_DISABLE_DEPRECATION_WARNINGS
992 if (avctx->frame_skip_threshold)
993 s->frame_skip_threshold = avctx->frame_skip_threshold;
994 if (avctx->frame_skip_factor)
995 s->frame_skip_factor = avctx->frame_skip_factor;
996 if (avctx->frame_skip_exp)
997 s->frame_skip_exp = avctx->frame_skip_exp;
998 if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
999 s->frame_skip_cmp = avctx->frame_skip_cmp;
1000 FF_ENABLE_DEPRECATION_WARNINGS
1001 #endif
1002
1003 ff_set_cmp(&s->mecc, s->mecc.ildct_cmp, avctx->ildct_cmp);
1004 ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
1005
1006 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
1007 ff_h261_encode_init(s);
1008 if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
1009 ff_h263_encode_init(s);
1010 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
1011 ff_msmpeg4_encode_init(s);
1012 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
1013 && s->out_format == FMT_MPEG1)
1014 ff_mpeg1_encode_init(s);
1015
1016 /* init q matrix */
1017 for (i = 0; i < 64; i++) {
1018 int j = s->idsp.idct_permutation[i];
1019 if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
1020 s->mpeg_quant) {
1021 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1022 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1023 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1024 s->intra_matrix[j] =
1025 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1026 } else if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
1027 s->intra_matrix[j] =
1028 s->inter_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1029 } else {
1030 /* MPEG-1/2 */
1031 s->chroma_intra_matrix[j] =
1032 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1033 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1034 }
1035 if (avctx->intra_matrix)
1036 s->intra_matrix[j] = avctx->intra_matrix[i];
1037 if (avctx->inter_matrix)
1038 s->inter_matrix[j] = avctx->inter_matrix[i];
1039 }
1040
1041 /* precompute matrix */
1042 /* for mjpeg, we do include qscale in the matrix */
1043 if (s->out_format != FMT_MJPEG) {
1044 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
1045 s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1046 31, 1);
1047 ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
1048 s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1049 31, 0);
1050 }
1051
1052 if ((ret = ff_rate_control_init(s)) < 0)
1053 return ret;
1054
1055 #if FF_API_PRIVATE_OPT
1056 FF_DISABLE_DEPRECATION_WARNINGS
1057 if (avctx->brd_scale)
1058 s->brd_scale = avctx->brd_scale;
1059
1060 if (avctx->prediction_method)
1061 s->pred = avctx->prediction_method + 1;
1062 FF_ENABLE_DEPRECATION_WARNINGS
1063 #endif
1064
1065 if (s->b_frame_strategy == 2) {
1066 for (i = 0; i < s->max_b_frames + 2; i++) {
1067 s->tmp_frames[i] = av_frame_alloc();
1068 if (!s->tmp_frames[i])
1069 return AVERROR(ENOMEM);
1070
1071 s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1072 s->tmp_frames[i]->width = s->width >> s->brd_scale;
1073 s->tmp_frames[i]->height = s->height >> s->brd_scale;
1074
1075 ret = av_frame_get_buffer(s->tmp_frames[i], 0);
1076 if (ret < 0)
1077 return ret;
1078 }
1079 }
1080
1081 cpb_props = ff_add_cpb_side_data(avctx);
1082 if (!cpb_props)
1083 return AVERROR(ENOMEM);
1084 cpb_props->max_bitrate = avctx->rc_max_rate;
1085 cpb_props->min_bitrate = avctx->rc_min_rate;
1086 cpb_props->avg_bitrate = avctx->bit_rate;
1087 cpb_props->buffer_size = avctx->rc_buffer_size;
1088
1089 return 0;
1090 }
1091
ff_mpv_encode_end(AVCodecContext * avctx)1092 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1093 {
1094 MpegEncContext *s = avctx->priv_data;
1095 int i;
1096
1097 ff_rate_control_uninit(s);
1098
1099 ff_mpv_common_end(s);
1100 if (CONFIG_MJPEG_ENCODER &&
1101 s->out_format == FMT_MJPEG)
1102 ff_mjpeg_encode_close(s);
1103
1104 av_freep(&avctx->extradata);
1105
1106 for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1107 av_frame_free(&s->tmp_frames[i]);
1108
1109 ff_free_picture_tables(&s->new_picture);
1110 ff_mpeg_unref_picture(avctx, &s->new_picture);
1111
1112 av_freep(&avctx->stats_out);
1113 av_freep(&s->ac_stats);
1114
1115 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
1116 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1117 s->q_chroma_intra_matrix= NULL;
1118 s->q_chroma_intra_matrix16= NULL;
1119 av_freep(&s->q_intra_matrix);
1120 av_freep(&s->q_inter_matrix);
1121 av_freep(&s->q_intra_matrix16);
1122 av_freep(&s->q_inter_matrix16);
1123 av_freep(&s->input_picture);
1124 av_freep(&s->reordered_input_picture);
1125 av_freep(&s->dct_offset);
1126
1127 return 0;
1128 }
1129
get_sae(uint8_t * src,int ref,int stride)1130 static int get_sae(uint8_t *src, int ref, int stride)
1131 {
1132 int x,y;
1133 int acc = 0;
1134
1135 for (y = 0; y < 16; y++) {
1136 for (x = 0; x < 16; x++) {
1137 acc += FFABS(src[x + y * stride] - ref);
1138 }
1139 }
1140
1141 return acc;
1142 }
1143
get_intra_count(MpegEncContext * s,uint8_t * src,uint8_t * ref,int stride)1144 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1145 uint8_t *ref, int stride)
1146 {
1147 int x, y, w, h;
1148 int acc = 0;
1149
1150 w = s->width & ~15;
1151 h = s->height & ~15;
1152
1153 for (y = 0; y < h; y += 16) {
1154 for (x = 0; x < w; x += 16) {
1155 int offset = x + y * stride;
1156 int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1157 stride, 16);
1158 int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1159 int sae = get_sae(src + offset, mean, stride);
1160
1161 acc += sae + 500 < sad;
1162 }
1163 }
1164 return acc;
1165 }
1166
alloc_picture(MpegEncContext * s,Picture * pic,int shared)1167 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1168 {
1169 return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1170 s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1171 s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1172 &s->linesize, &s->uvlinesize);
1173 }
1174
load_input_picture(MpegEncContext * s,const AVFrame * pic_arg)1175 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1176 {
1177 Picture *pic = NULL;
1178 int64_t pts;
1179 int i, display_picture_number = 0, ret;
1180 int encoding_delay = s->max_b_frames ? s->max_b_frames
1181 : (s->low_delay ? 0 : 1);
1182 int flush_offset = 1;
1183 int direct = 1;
1184
1185 if (pic_arg) {
1186 pts = pic_arg->pts;
1187 display_picture_number = s->input_picture_number++;
1188
1189 if (pts != AV_NOPTS_VALUE) {
1190 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1191 int64_t last = s->user_specified_pts;
1192
1193 if (pts <= last) {
1194 av_log(s->avctx, AV_LOG_ERROR,
1195 "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1196 pts, last);
1197 return AVERROR(EINVAL);
1198 }
1199
1200 if (!s->low_delay && display_picture_number == 1)
1201 s->dts_delta = pts - last;
1202 }
1203 s->user_specified_pts = pts;
1204 } else {
1205 if (s->user_specified_pts != AV_NOPTS_VALUE) {
1206 s->user_specified_pts =
1207 pts = s->user_specified_pts + 1;
1208 av_log(s->avctx, AV_LOG_INFO,
1209 "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1210 pts);
1211 } else {
1212 pts = display_picture_number;
1213 }
1214 }
1215
1216 if (!pic_arg->buf[0] ||
1217 pic_arg->linesize[0] != s->linesize ||
1218 pic_arg->linesize[1] != s->uvlinesize ||
1219 pic_arg->linesize[2] != s->uvlinesize)
1220 direct = 0;
1221 if ((s->width & 15) || (s->height & 15))
1222 direct = 0;
1223 if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1224 direct = 0;
1225 if (s->linesize & (STRIDE_ALIGN-1))
1226 direct = 0;
1227
1228 ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1229 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1230
1231 i = ff_find_unused_picture(s->avctx, s->picture, direct);
1232 if (i < 0)
1233 return i;
1234
1235 pic = &s->picture[i];
1236 pic->reference = 3;
1237
1238 if (direct) {
1239 if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1240 return ret;
1241 }
1242 ret = alloc_picture(s, pic, direct);
1243 if (ret < 0)
1244 return ret;
1245
1246 if (!direct) {
1247 if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1248 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1249 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1250 // empty
1251 } else {
1252 int h_chroma_shift, v_chroma_shift;
1253 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1254 &h_chroma_shift,
1255 &v_chroma_shift);
1256
1257 for (i = 0; i < 3; i++) {
1258 int src_stride = pic_arg->linesize[i];
1259 int dst_stride = i ? s->uvlinesize : s->linesize;
1260 int h_shift = i ? h_chroma_shift : 0;
1261 int v_shift = i ? v_chroma_shift : 0;
1262 int w = s->width >> h_shift;
1263 int h = s->height >> v_shift;
1264 uint8_t *src = pic_arg->data[i];
1265 uint8_t *dst = pic->f->data[i];
1266 int vpad = 16;
1267
1268 if ( s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1269 && !s->progressive_sequence
1270 && FFALIGN(s->height, 32) - s->height > 16)
1271 vpad = 32;
1272
1273 if (!s->avctx->rc_buffer_size)
1274 dst += INPLACE_OFFSET;
1275
1276 if (src_stride == dst_stride)
1277 memcpy(dst, src, src_stride * h);
1278 else {
1279 int h2 = h;
1280 uint8_t *dst2 = dst;
1281 while (h2--) {
1282 memcpy(dst2, src, w);
1283 dst2 += dst_stride;
1284 src += src_stride;
1285 }
1286 }
1287 if ((s->width & 15) || (s->height & (vpad-1))) {
1288 s->mpvencdsp.draw_edges(dst, dst_stride,
1289 w, h,
1290 16 >> h_shift,
1291 vpad >> v_shift,
1292 EDGE_BOTTOM);
1293 }
1294 }
1295 emms_c();
1296 }
1297 }
1298 ret = av_frame_copy_props(pic->f, pic_arg);
1299 if (ret < 0)
1300 return ret;
1301
1302 pic->f->display_picture_number = display_picture_number;
1303 pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1304 } else {
1305 /* Flushing: When we have not received enough input frames,
1306 * ensure s->input_picture[0] contains the first picture */
1307 for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1308 if (s->input_picture[flush_offset])
1309 break;
1310
1311 if (flush_offset <= 1)
1312 flush_offset = 1;
1313 else
1314 encoding_delay = encoding_delay - flush_offset + 1;
1315 }
1316
1317 /* shift buffer entries */
1318 for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1319 s->input_picture[i - flush_offset] = s->input_picture[i];
1320
1321 s->input_picture[encoding_delay] = (Picture*) pic;
1322
1323 return 0;
1324 }
1325
skip_check(MpegEncContext * s,Picture * p,Picture * ref)1326 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1327 {
1328 int x, y, plane;
1329 int score = 0;
1330 int64_t score64 = 0;
1331
1332 for (plane = 0; plane < 3; plane++) {
1333 const int stride = p->f->linesize[plane];
1334 const int bw = plane ? 1 : 2;
1335 for (y = 0; y < s->mb_height * bw; y++) {
1336 for (x = 0; x < s->mb_width * bw; x++) {
1337 int off = p->shared ? 0 : 16;
1338 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1339 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1340 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1341
1342 switch (FFABS(s->frame_skip_exp)) {
1343 case 0: score = FFMAX(score, v); break;
1344 case 1: score += FFABS(v); break;
1345 case 2: score64 += v * (int64_t)v; break;
1346 case 3: score64 += FFABS(v * (int64_t)v * v); break;
1347 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1348 }
1349 }
1350 }
1351 }
1352 emms_c();
1353
1354 if (score)
1355 score64 = score;
1356 if (s->frame_skip_exp < 0)
1357 score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1358 -1.0/s->frame_skip_exp);
1359
1360 if (score64 < s->frame_skip_threshold)
1361 return 1;
1362 if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1363 return 1;
1364 return 0;
1365 }
1366
encode_frame(AVCodecContext * c,AVFrame * frame,AVPacket * pkt)1367 static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
1368 {
1369 int ret;
1370 int size = 0;
1371
1372 ret = avcodec_send_frame(c, frame);
1373 if (ret < 0)
1374 return ret;
1375
1376 do {
1377 ret = avcodec_receive_packet(c, pkt);
1378 if (ret >= 0) {
1379 size += pkt->size;
1380 av_packet_unref(pkt);
1381 } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1382 return ret;
1383 } while (ret >= 0);
1384
1385 return size;
1386 }
1387
estimate_best_b_count(MpegEncContext * s)1388 static int estimate_best_b_count(MpegEncContext *s)
1389 {
1390 const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1391 AVPacket *pkt;
1392 const int scale = s->brd_scale;
1393 int width = s->width >> scale;
1394 int height = s->height >> scale;
1395 int i, j, out_size, p_lambda, b_lambda, lambda2;
1396 int64_t best_rd = INT64_MAX;
1397 int best_b_count = -1;
1398 int ret = 0;
1399
1400 av_assert0(scale >= 0 && scale <= 3);
1401
1402 pkt = av_packet_alloc();
1403 if (!pkt)
1404 return AVERROR(ENOMEM);
1405
1406 //emms_c();
1407 //s->next_picture_ptr->quality;
1408 p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1409 //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1410 b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1411 if (!b_lambda) // FIXME we should do this somewhere else
1412 b_lambda = p_lambda;
1413 lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1414 FF_LAMBDA_SHIFT;
1415
1416 for (i = 0; i < s->max_b_frames + 2; i++) {
1417 Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1418 s->next_picture_ptr;
1419 uint8_t *data[4];
1420
1421 if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1422 pre_input = *pre_input_ptr;
1423 memcpy(data, pre_input_ptr->f->data, sizeof(data));
1424
1425 if (!pre_input.shared && i) {
1426 data[0] += INPLACE_OFFSET;
1427 data[1] += INPLACE_OFFSET;
1428 data[2] += INPLACE_OFFSET;
1429 }
1430
1431 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1432 s->tmp_frames[i]->linesize[0],
1433 data[0],
1434 pre_input.f->linesize[0],
1435 width, height);
1436 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1437 s->tmp_frames[i]->linesize[1],
1438 data[1],
1439 pre_input.f->linesize[1],
1440 width >> 1, height >> 1);
1441 s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1442 s->tmp_frames[i]->linesize[2],
1443 data[2],
1444 pre_input.f->linesize[2],
1445 width >> 1, height >> 1);
1446 }
1447 }
1448
1449 for (j = 0; j < s->max_b_frames + 1; j++) {
1450 AVCodecContext *c;
1451 int64_t rd = 0;
1452
1453 if (!s->input_picture[j])
1454 break;
1455
1456 c = avcodec_alloc_context3(NULL);
1457 if (!c) {
1458 ret = AVERROR(ENOMEM);
1459 goto fail;
1460 }
1461
1462 c->width = width;
1463 c->height = height;
1464 c->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1465 c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1466 c->mb_decision = s->avctx->mb_decision;
1467 c->me_cmp = s->avctx->me_cmp;
1468 c->mb_cmp = s->avctx->mb_cmp;
1469 c->me_sub_cmp = s->avctx->me_sub_cmp;
1470 c->pix_fmt = AV_PIX_FMT_YUV420P;
1471 c->time_base = s->avctx->time_base;
1472 c->max_b_frames = s->max_b_frames;
1473
1474 ret = avcodec_open2(c, codec, NULL);
1475 if (ret < 0)
1476 goto fail;
1477
1478
1479 s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1480 s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1481
1482 out_size = encode_frame(c, s->tmp_frames[0], pkt);
1483 if (out_size < 0) {
1484 ret = out_size;
1485 goto fail;
1486 }
1487
1488 //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1489
1490 for (i = 0; i < s->max_b_frames + 1; i++) {
1491 int is_p = i % (j + 1) == j || i == s->max_b_frames;
1492
1493 s->tmp_frames[i + 1]->pict_type = is_p ?
1494 AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1495 s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1496
1497 out_size = encode_frame(c, s->tmp_frames[i + 1], pkt);
1498 if (out_size < 0) {
1499 ret = out_size;
1500 goto fail;
1501 }
1502
1503 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1504 }
1505
1506 /* get the delayed frames */
1507 out_size = encode_frame(c, NULL, pkt);
1508 if (out_size < 0) {
1509 ret = out_size;
1510 goto fail;
1511 }
1512 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1513
1514 rd += c->error[0] + c->error[1] + c->error[2];
1515
1516 if (rd < best_rd) {
1517 best_rd = rd;
1518 best_b_count = j;
1519 }
1520
1521 fail:
1522 avcodec_free_context(&c);
1523 av_packet_unref(pkt);
1524 if (ret < 0) {
1525 best_b_count = ret;
1526 break;
1527 }
1528 }
1529
1530 av_packet_free(&pkt);
1531
1532 return best_b_count;
1533 }
1534
select_input_picture(MpegEncContext * s)1535 static int select_input_picture(MpegEncContext *s)
1536 {
1537 int i, ret;
1538
1539 for (i = 1; i < MAX_PICTURE_COUNT; i++)
1540 s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1541 s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1542
1543 /* set next picture type & ordering */
1544 if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1545 if (s->frame_skip_threshold || s->frame_skip_factor) {
1546 if (s->picture_in_gop_number < s->gop_size &&
1547 s->next_picture_ptr &&
1548 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1549 // FIXME check that the gop check above is +-1 correct
1550 av_frame_unref(s->input_picture[0]->f);
1551
1552 ff_vbv_update(s, 0);
1553
1554 goto no_output_pic;
1555 }
1556 }
1557
1558 if (/*s->picture_in_gop_number >= s->gop_size ||*/
1559 !s->next_picture_ptr || s->intra_only) {
1560 s->reordered_input_picture[0] = s->input_picture[0];
1561 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1562 s->reordered_input_picture[0]->f->coded_picture_number =
1563 s->coded_picture_number++;
1564 } else {
1565 int b_frames = 0;
1566
1567 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1568 for (i = 0; i < s->max_b_frames + 1; i++) {
1569 int pict_num = s->input_picture[0]->f->display_picture_number + i;
1570
1571 if (pict_num >= s->rc_context.num_entries)
1572 break;
1573 if (!s->input_picture[i]) {
1574 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1575 break;
1576 }
1577
1578 s->input_picture[i]->f->pict_type =
1579 s->rc_context.entry[pict_num].new_pict_type;
1580 }
1581 }
1582
1583 if (s->b_frame_strategy == 0) {
1584 b_frames = s->max_b_frames;
1585 while (b_frames && !s->input_picture[b_frames])
1586 b_frames--;
1587 } else if (s->b_frame_strategy == 1) {
1588 for (i = 1; i < s->max_b_frames + 1; i++) {
1589 if (s->input_picture[i] &&
1590 s->input_picture[i]->b_frame_score == 0) {
1591 s->input_picture[i]->b_frame_score =
1592 get_intra_count(s,
1593 s->input_picture[i ]->f->data[0],
1594 s->input_picture[i - 1]->f->data[0],
1595 s->linesize) + 1;
1596 }
1597 }
1598 for (i = 0; i < s->max_b_frames + 1; i++) {
1599 if (!s->input_picture[i] ||
1600 s->input_picture[i]->b_frame_score - 1 >
1601 s->mb_num / s->b_sensitivity)
1602 break;
1603 }
1604
1605 b_frames = FFMAX(0, i - 1);
1606
1607 /* reset scores */
1608 for (i = 0; i < b_frames + 1; i++) {
1609 s->input_picture[i]->b_frame_score = 0;
1610 }
1611 } else if (s->b_frame_strategy == 2) {
1612 b_frames = estimate_best_b_count(s);
1613 if (b_frames < 0)
1614 return b_frames;
1615 }
1616
1617 emms_c();
1618
1619 for (i = b_frames - 1; i >= 0; i--) {
1620 int type = s->input_picture[i]->f->pict_type;
1621 if (type && type != AV_PICTURE_TYPE_B)
1622 b_frames = i;
1623 }
1624 if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1625 b_frames == s->max_b_frames) {
1626 av_log(s->avctx, AV_LOG_ERROR,
1627 "warning, too many B-frames in a row\n");
1628 }
1629
1630 if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1631 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1632 s->gop_size > s->picture_in_gop_number) {
1633 b_frames = s->gop_size - s->picture_in_gop_number - 1;
1634 } else {
1635 if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1636 b_frames = 0;
1637 s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1638 }
1639 }
1640
1641 if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1642 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1643 b_frames--;
1644
1645 s->reordered_input_picture[0] = s->input_picture[b_frames];
1646 if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1647 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1648 s->reordered_input_picture[0]->f->coded_picture_number =
1649 s->coded_picture_number++;
1650 for (i = 0; i < b_frames; i++) {
1651 s->reordered_input_picture[i + 1] = s->input_picture[i];
1652 s->reordered_input_picture[i + 1]->f->pict_type =
1653 AV_PICTURE_TYPE_B;
1654 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1655 s->coded_picture_number++;
1656 }
1657 }
1658 }
1659 no_output_pic:
1660 ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1661
1662 if (s->reordered_input_picture[0]) {
1663 s->reordered_input_picture[0]->reference =
1664 s->reordered_input_picture[0]->f->pict_type !=
1665 AV_PICTURE_TYPE_B ? 3 : 0;
1666
1667 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1668 return ret;
1669
1670 if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1671 // input is a shared pix, so we can't modify it -> allocate a new
1672 // one & ensure that the shared one is reuseable
1673
1674 Picture *pic;
1675 int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1676 if (i < 0)
1677 return i;
1678 pic = &s->picture[i];
1679
1680 pic->reference = s->reordered_input_picture[0]->reference;
1681 if (alloc_picture(s, pic, 0) < 0) {
1682 return -1;
1683 }
1684
1685 ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1686 if (ret < 0)
1687 return ret;
1688
1689 /* mark us unused / free shared pic */
1690 av_frame_unref(s->reordered_input_picture[0]->f);
1691 s->reordered_input_picture[0]->shared = 0;
1692
1693 s->current_picture_ptr = pic;
1694 } else {
1695 // input is not a shared pix -> reuse buffer for current_pix
1696 s->current_picture_ptr = s->reordered_input_picture[0];
1697 for (i = 0; i < 4; i++) {
1698 if (s->new_picture.f->data[i])
1699 s->new_picture.f->data[i] += INPLACE_OFFSET;
1700 }
1701 }
1702 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1703 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1704 s->current_picture_ptr)) < 0)
1705 return ret;
1706
1707 s->picture_number = s->new_picture.f->display_picture_number;
1708 }
1709 return 0;
1710 }
1711
frame_end(MpegEncContext * s)1712 static void frame_end(MpegEncContext *s)
1713 {
1714 if (s->unrestricted_mv &&
1715 s->current_picture.reference &&
1716 !s->intra_only) {
1717 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1718 int hshift = desc->log2_chroma_w;
1719 int vshift = desc->log2_chroma_h;
1720 s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
1721 s->current_picture.f->linesize[0],
1722 s->h_edge_pos, s->v_edge_pos,
1723 EDGE_WIDTH, EDGE_WIDTH,
1724 EDGE_TOP | EDGE_BOTTOM);
1725 s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
1726 s->current_picture.f->linesize[1],
1727 s->h_edge_pos >> hshift,
1728 s->v_edge_pos >> vshift,
1729 EDGE_WIDTH >> hshift,
1730 EDGE_WIDTH >> vshift,
1731 EDGE_TOP | EDGE_BOTTOM);
1732 s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
1733 s->current_picture.f->linesize[2],
1734 s->h_edge_pos >> hshift,
1735 s->v_edge_pos >> vshift,
1736 EDGE_WIDTH >> hshift,
1737 EDGE_WIDTH >> vshift,
1738 EDGE_TOP | EDGE_BOTTOM);
1739 }
1740
1741 emms_c();
1742
1743 s->last_pict_type = s->pict_type;
1744 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1745 if (s->pict_type!= AV_PICTURE_TYPE_B)
1746 s->last_non_b_pict_type = s->pict_type;
1747
1748 #if FF_API_CODED_FRAME
1749 FF_DISABLE_DEPRECATION_WARNINGS
1750 av_frame_unref(s->avctx->coded_frame);
1751 av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1752 FF_ENABLE_DEPRECATION_WARNINGS
1753 #endif
1754 #if FF_API_ERROR_FRAME
1755 FF_DISABLE_DEPRECATION_WARNINGS
1756 memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1757 sizeof(s->current_picture.encoding_error));
1758 FF_ENABLE_DEPRECATION_WARNINGS
1759 #endif
1760 }
1761
update_noise_reduction(MpegEncContext * s)1762 static void update_noise_reduction(MpegEncContext *s)
1763 {
1764 int intra, i;
1765
1766 for (intra = 0; intra < 2; intra++) {
1767 if (s->dct_count[intra] > (1 << 16)) {
1768 for (i = 0; i < 64; i++) {
1769 s->dct_error_sum[intra][i] >>= 1;
1770 }
1771 s->dct_count[intra] >>= 1;
1772 }
1773
1774 for (i = 0; i < 64; i++) {
1775 s->dct_offset[intra][i] = (s->noise_reduction *
1776 s->dct_count[intra] +
1777 s->dct_error_sum[intra][i] / 2) /
1778 (s->dct_error_sum[intra][i] + 1);
1779 }
1780 }
1781 }
1782
frame_start(MpegEncContext * s)1783 static int frame_start(MpegEncContext *s)
1784 {
1785 int ret;
1786
1787 /* mark & release old frames */
1788 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1789 s->last_picture_ptr != s->next_picture_ptr &&
1790 s->last_picture_ptr->f->buf[0]) {
1791 ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1792 }
1793
1794 s->current_picture_ptr->f->pict_type = s->pict_type;
1795 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1796
1797 ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1798 if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1799 s->current_picture_ptr)) < 0)
1800 return ret;
1801
1802 if (s->pict_type != AV_PICTURE_TYPE_B) {
1803 s->last_picture_ptr = s->next_picture_ptr;
1804 if (!s->droppable)
1805 s->next_picture_ptr = s->current_picture_ptr;
1806 }
1807
1808 if (s->last_picture_ptr) {
1809 ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1810 if (s->last_picture_ptr->f->buf[0] &&
1811 (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1812 s->last_picture_ptr)) < 0)
1813 return ret;
1814 }
1815 if (s->next_picture_ptr) {
1816 ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1817 if (s->next_picture_ptr->f->buf[0] &&
1818 (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1819 s->next_picture_ptr)) < 0)
1820 return ret;
1821 }
1822
1823 if (s->picture_structure!= PICT_FRAME) {
1824 int i;
1825 for (i = 0; i < 4; i++) {
1826 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1827 s->current_picture.f->data[i] +=
1828 s->current_picture.f->linesize[i];
1829 }
1830 s->current_picture.f->linesize[i] *= 2;
1831 s->last_picture.f->linesize[i] *= 2;
1832 s->next_picture.f->linesize[i] *= 2;
1833 }
1834 }
1835
1836 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1837 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1838 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1839 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1840 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1841 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1842 } else {
1843 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1844 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1845 }
1846
1847 if (s->dct_error_sum) {
1848 av_assert2(s->noise_reduction && s->encoding);
1849 update_noise_reduction(s);
1850 }
1851
1852 return 0;
1853 }
1854
ff_mpv_encode_picture(AVCodecContext * avctx,AVPacket * pkt,const AVFrame * pic_arg,int * got_packet)1855 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1856 const AVFrame *pic_arg, int *got_packet)
1857 {
1858 MpegEncContext *s = avctx->priv_data;
1859 int i, stuffing_count, ret;
1860 int context_count = s->slice_context_count;
1861
1862 s->vbv_ignore_qmax = 0;
1863
1864 s->picture_in_gop_number++;
1865
1866 if (load_input_picture(s, pic_arg) < 0)
1867 return -1;
1868
1869 if (select_input_picture(s) < 0) {
1870 return -1;
1871 }
1872
1873 /* output? */
1874 if (s->new_picture.f->data[0]) {
1875 int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1876 int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1877 :
1878 s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1879 if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1880 return ret;
1881 if (s->mb_info) {
1882 s->mb_info_ptr = av_packet_new_side_data(pkt,
1883 AV_PKT_DATA_H263_MB_INFO,
1884 s->mb_width*s->mb_height*12);
1885 s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1886 }
1887
1888 for (i = 0; i < context_count; i++) {
1889 int start_y = s->thread_context[i]->start_mb_y;
1890 int end_y = s->thread_context[i]-> end_mb_y;
1891 int h = s->mb_height;
1892 uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1893 uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1894
1895 init_put_bits(&s->thread_context[i]->pb, start, end - start);
1896 }
1897
1898 s->pict_type = s->new_picture.f->pict_type;
1899 //emms_c();
1900 ret = frame_start(s);
1901 if (ret < 0)
1902 return ret;
1903 vbv_retry:
1904 ret = encode_picture(s, s->picture_number);
1905 if (growing_buffer) {
1906 av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1907 pkt->data = s->pb.buf;
1908 pkt->size = avctx->internal->byte_buffer_size;
1909 }
1910 if (ret < 0)
1911 return -1;
1912
1913 #if FF_API_STAT_BITS
1914 FF_DISABLE_DEPRECATION_WARNINGS
1915 avctx->header_bits = s->header_bits;
1916 avctx->mv_bits = s->mv_bits;
1917 avctx->misc_bits = s->misc_bits;
1918 avctx->i_tex_bits = s->i_tex_bits;
1919 avctx->p_tex_bits = s->p_tex_bits;
1920 avctx->i_count = s->i_count;
1921 // FIXME f/b_count in avctx
1922 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1923 avctx->skip_count = s->skip_count;
1924 FF_ENABLE_DEPRECATION_WARNINGS
1925 #endif
1926
1927 frame_end(s);
1928
1929 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1930 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1931
1932 if (avctx->rc_buffer_size) {
1933 RateControlContext *rcc = &s->rc_context;
1934 int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1935 int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);
1936 int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1937
1938 if (put_bits_count(&s->pb) > max_size &&
1939 s->lambda < s->lmax) {
1940 s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1941 (s->qscale + 1) / s->qscale);
1942 if (s->adaptive_quant) {
1943 int i;
1944 for (i = 0; i < s->mb_height * s->mb_stride; i++)
1945 s->lambda_table[i] =
1946 FFMAX(s->lambda_table[i] + min_step,
1947 s->lambda_table[i] * (s->qscale + 1) /
1948 s->qscale);
1949 }
1950 s->mb_skipped = 0; // done in frame_start()
1951 // done in encode_picture() so we must undo it
1952 if (s->pict_type == AV_PICTURE_TYPE_P) {
1953 if (s->flipflop_rounding ||
1954 s->codec_id == AV_CODEC_ID_H263P ||
1955 s->codec_id == AV_CODEC_ID_MPEG4)
1956 s->no_rounding ^= 1;
1957 }
1958 if (s->pict_type != AV_PICTURE_TYPE_B) {
1959 s->time_base = s->last_time_base;
1960 s->last_non_b_time = s->time - s->pp_time;
1961 }
1962 for (i = 0; i < context_count; i++) {
1963 PutBitContext *pb = &s->thread_context[i]->pb;
1964 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1965 }
1966 s->vbv_ignore_qmax = 1;
1967 av_log(avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1968 goto vbv_retry;
1969 }
1970
1971 av_assert0(avctx->rc_max_rate);
1972 }
1973
1974 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1975 ff_write_pass1_stats(s);
1976
1977 for (i = 0; i < 4; i++) {
1978 s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1979 avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1980 }
1981 ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
1982 s->current_picture_ptr->encoding_error,
1983 (avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1984 s->pict_type);
1985
1986 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1987 assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1988 s->misc_bits + s->i_tex_bits +
1989 s->p_tex_bits);
1990 flush_put_bits(&s->pb);
1991 s->frame_bits = put_bits_count(&s->pb);
1992
1993 stuffing_count = ff_vbv_update(s, s->frame_bits);
1994 s->stuffing_bits = 8*stuffing_count;
1995 if (stuffing_count) {
1996 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1997 stuffing_count + 50) {
1998 av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
1999 return -1;
2000 }
2001
2002 switch (s->codec_id) {
2003 case AV_CODEC_ID_MPEG1VIDEO:
2004 case AV_CODEC_ID_MPEG2VIDEO:
2005 while (stuffing_count--) {
2006 put_bits(&s->pb, 8, 0);
2007 }
2008 break;
2009 case AV_CODEC_ID_MPEG4:
2010 put_bits(&s->pb, 16, 0);
2011 put_bits(&s->pb, 16, 0x1C3);
2012 stuffing_count -= 4;
2013 while (stuffing_count--) {
2014 put_bits(&s->pb, 8, 0xFF);
2015 }
2016 break;
2017 default:
2018 av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2019 }
2020 flush_put_bits(&s->pb);
2021 s->frame_bits = put_bits_count(&s->pb);
2022 }
2023
2024 /* update MPEG-1/2 vbv_delay for CBR */
2025 if (avctx->rc_max_rate &&
2026 avctx->rc_min_rate == avctx->rc_max_rate &&
2027 s->out_format == FMT_MPEG1 &&
2028 90000LL * (avctx->rc_buffer_size - 1) <=
2029 avctx->rc_max_rate * 0xFFFFLL) {
2030 AVCPBProperties *props;
2031 size_t props_size;
2032
2033 int vbv_delay, min_delay;
2034 double inbits = avctx->rc_max_rate *
2035 av_q2d(avctx->time_base);
2036 int minbits = s->frame_bits - 8 *
2037 (s->vbv_delay_ptr - s->pb.buf - 1);
2038 double bits = s->rc_context.buffer_index + minbits - inbits;
2039
2040 if (bits < 0)
2041 av_log(avctx, AV_LOG_ERROR,
2042 "Internal error, negative bits\n");
2043
2044 av_assert1(s->repeat_first_field == 0);
2045
2046 vbv_delay = bits * 90000 / avctx->rc_max_rate;
2047 min_delay = (minbits * 90000LL + avctx->rc_max_rate - 1) /
2048 avctx->rc_max_rate;
2049
2050 vbv_delay = FFMAX(vbv_delay, min_delay);
2051
2052 av_assert0(vbv_delay < 0xFFFF);
2053
2054 s->vbv_delay_ptr[0] &= 0xF8;
2055 s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2056 s->vbv_delay_ptr[1] = vbv_delay >> 5;
2057 s->vbv_delay_ptr[2] &= 0x07;
2058 s->vbv_delay_ptr[2] |= vbv_delay << 3;
2059
2060 props = av_cpb_properties_alloc(&props_size);
2061 if (!props)
2062 return AVERROR(ENOMEM);
2063 props->vbv_delay = vbv_delay * 300;
2064
2065 ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2066 (uint8_t*)props, props_size);
2067 if (ret < 0) {
2068 av_freep(&props);
2069 return ret;
2070 }
2071
2072 #if FF_API_VBV_DELAY
2073 FF_DISABLE_DEPRECATION_WARNINGS
2074 avctx->vbv_delay = vbv_delay * 300;
2075 FF_ENABLE_DEPRECATION_WARNINGS
2076 #endif
2077 }
2078 s->total_bits += s->frame_bits;
2079 #if FF_API_STAT_BITS
2080 FF_DISABLE_DEPRECATION_WARNINGS
2081 avctx->frame_bits = s->frame_bits;
2082 FF_ENABLE_DEPRECATION_WARNINGS
2083 #endif
2084
2085
2086 pkt->pts = s->current_picture.f->pts;
2087 if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2088 if (!s->current_picture.f->coded_picture_number)
2089 pkt->dts = pkt->pts - s->dts_delta;
2090 else
2091 pkt->dts = s->reordered_pts;
2092 s->reordered_pts = pkt->pts;
2093 } else
2094 pkt->dts = pkt->pts;
2095 if (s->current_picture.f->key_frame)
2096 pkt->flags |= AV_PKT_FLAG_KEY;
2097 if (s->mb_info)
2098 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2099 } else {
2100 s->frame_bits = 0;
2101 }
2102
2103 /* release non-reference frames */
2104 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2105 if (!s->picture[i].reference)
2106 ff_mpeg_unref_picture(avctx, &s->picture[i]);
2107 }
2108
2109 av_assert1((s->frame_bits & 7) == 0);
2110
2111 pkt->size = s->frame_bits / 8;
2112 *got_packet = !!pkt->size;
2113 return 0;
2114 }
2115
dct_single_coeff_elimination(MpegEncContext * s,int n,int threshold)2116 static inline void dct_single_coeff_elimination(MpegEncContext *s,
2117 int n, int threshold)
2118 {
2119 static const char tab[64] = {
2120 3, 2, 2, 1, 1, 1, 1, 1,
2121 1, 1, 1, 1, 1, 1, 1, 1,
2122 1, 1, 1, 1, 1, 1, 1, 1,
2123 0, 0, 0, 0, 0, 0, 0, 0,
2124 0, 0, 0, 0, 0, 0, 0, 0,
2125 0, 0, 0, 0, 0, 0, 0, 0,
2126 0, 0, 0, 0, 0, 0, 0, 0,
2127 0, 0, 0, 0, 0, 0, 0, 0
2128 };
2129 int score = 0;
2130 int run = 0;
2131 int i;
2132 int16_t *block = s->block[n];
2133 const int last_index = s->block_last_index[n];
2134 int skip_dc;
2135
2136 if (threshold < 0) {
2137 skip_dc = 0;
2138 threshold = -threshold;
2139 } else
2140 skip_dc = 1;
2141
2142 /* Are all we could set to zero already zero? */
2143 if (last_index <= skip_dc - 1)
2144 return;
2145
2146 for (i = 0; i <= last_index; i++) {
2147 const int j = s->intra_scantable.permutated[i];
2148 const int level = FFABS(block[j]);
2149 if (level == 1) {
2150 if (skip_dc && i == 0)
2151 continue;
2152 score += tab[run];
2153 run = 0;
2154 } else if (level > 1) {
2155 return;
2156 } else {
2157 run++;
2158 }
2159 }
2160 if (score >= threshold)
2161 return;
2162 for (i = skip_dc; i <= last_index; i++) {
2163 const int j = s->intra_scantable.permutated[i];
2164 block[j] = 0;
2165 }
2166 if (block[0])
2167 s->block_last_index[n] = 0;
2168 else
2169 s->block_last_index[n] = -1;
2170 }
2171
clip_coeffs(MpegEncContext * s,int16_t * block,int last_index)2172 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2173 int last_index)
2174 {
2175 int i;
2176 const int maxlevel = s->max_qcoeff;
2177 const int minlevel = s->min_qcoeff;
2178 int overflow = 0;
2179
2180 if (s->mb_intra) {
2181 i = 1; // skip clipping of intra dc
2182 } else
2183 i = 0;
2184
2185 for (; i <= last_index; i++) {
2186 const int j = s->intra_scantable.permutated[i];
2187 int level = block[j];
2188
2189 if (level > maxlevel) {
2190 level = maxlevel;
2191 overflow++;
2192 } else if (level < minlevel) {
2193 level = minlevel;
2194 overflow++;
2195 }
2196
2197 block[j] = level;
2198 }
2199
2200 if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2201 av_log(s->avctx, AV_LOG_INFO,
2202 "warning, clipping %d dct coefficients to %d..%d\n",
2203 overflow, minlevel, maxlevel);
2204 }
2205
get_visual_weight(int16_t * weight,uint8_t * ptr,int stride)2206 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2207 {
2208 int x, y;
2209 // FIXME optimize
2210 for (y = 0; y < 8; y++) {
2211 for (x = 0; x < 8; x++) {
2212 int x2, y2;
2213 int sum = 0;
2214 int sqr = 0;
2215 int count = 0;
2216
2217 for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2218 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2219 int v = ptr[x2 + y2 * stride];
2220 sum += v;
2221 sqr += v * v;
2222 count++;
2223 }
2224 }
2225 weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2226 }
2227 }
2228 }
2229
encode_mb_internal(MpegEncContext * s,int motion_x,int motion_y,int mb_block_height,int mb_block_width,int mb_block_count)2230 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2231 int motion_x, int motion_y,
2232 int mb_block_height,
2233 int mb_block_width,
2234 int mb_block_count)
2235 {
2236 int16_t weight[12][64];
2237 int16_t orig[12][64];
2238 const int mb_x = s->mb_x;
2239 const int mb_y = s->mb_y;
2240 int i;
2241 int skip_dct[12];
2242 int dct_offset = s->linesize * 8; // default for progressive frames
2243 int uv_dct_offset = s->uvlinesize * 8;
2244 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2245 ptrdiff_t wrap_y, wrap_c;
2246
2247 for (i = 0; i < mb_block_count; i++)
2248 skip_dct[i] = s->skipdct;
2249
2250 if (s->adaptive_quant) {
2251 const int last_qp = s->qscale;
2252 const int mb_xy = mb_x + mb_y * s->mb_stride;
2253
2254 s->lambda = s->lambda_table[mb_xy];
2255 update_qscale(s);
2256
2257 if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2258 s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2259 s->dquant = s->qscale - last_qp;
2260
2261 if (s->out_format == FMT_H263) {
2262 s->dquant = av_clip(s->dquant, -2, 2);
2263
2264 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2265 if (!s->mb_intra) {
2266 if (s->pict_type == AV_PICTURE_TYPE_B) {
2267 if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2268 s->dquant = 0;
2269 }
2270 if (s->mv_type == MV_TYPE_8X8)
2271 s->dquant = 0;
2272 }
2273 }
2274 }
2275 }
2276 ff_set_qscale(s, last_qp + s->dquant);
2277 } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2278 ff_set_qscale(s, s->qscale + s->dquant);
2279
2280 wrap_y = s->linesize;
2281 wrap_c = s->uvlinesize;
2282 ptr_y = s->new_picture.f->data[0] +
2283 (mb_y * 16 * wrap_y) + mb_x * 16;
2284 ptr_cb = s->new_picture.f->data[1] +
2285 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2286 ptr_cr = s->new_picture.f->data[2] +
2287 (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2288
2289 if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2290 uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2291 int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2292 int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2293 s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2294 wrap_y, wrap_y,
2295 16, 16, mb_x * 16, mb_y * 16,
2296 s->width, s->height);
2297 ptr_y = ebuf;
2298 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2299 wrap_c, wrap_c,
2300 mb_block_width, mb_block_height,
2301 mb_x * mb_block_width, mb_y * mb_block_height,
2302 cw, ch);
2303 ptr_cb = ebuf + 16 * wrap_y;
2304 s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2305 wrap_c, wrap_c,
2306 mb_block_width, mb_block_height,
2307 mb_x * mb_block_width, mb_y * mb_block_height,
2308 cw, ch);
2309 ptr_cr = ebuf + 16 * wrap_y + 16;
2310 }
2311
2312 if (s->mb_intra) {
2313 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2314 int progressive_score, interlaced_score;
2315
2316 s->interlaced_dct = 0;
2317 progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2318 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2319 NULL, wrap_y, 8) - 400;
2320
2321 if (progressive_score > 0) {
2322 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2323 NULL, wrap_y * 2, 8) +
2324 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2325 NULL, wrap_y * 2, 8);
2326 if (progressive_score > interlaced_score) {
2327 s->interlaced_dct = 1;
2328
2329 dct_offset = wrap_y;
2330 uv_dct_offset = wrap_c;
2331 wrap_y <<= 1;
2332 if (s->chroma_format == CHROMA_422 ||
2333 s->chroma_format == CHROMA_444)
2334 wrap_c <<= 1;
2335 }
2336 }
2337 }
2338
2339 s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2340 s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2341 s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2342 s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2343
2344 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2345 skip_dct[4] = 1;
2346 skip_dct[5] = 1;
2347 } else {
2348 s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2349 s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2350 if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2351 s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2352 s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2353 } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2354 s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2355 s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2356 s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2357 s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2358 s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2359 s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2360 }
2361 }
2362 } else {
2363 op_pixels_func (*op_pix)[4];
2364 qpel_mc_func (*op_qpix)[16];
2365 uint8_t *dest_y, *dest_cb, *dest_cr;
2366
2367 dest_y = s->dest[0];
2368 dest_cb = s->dest[1];
2369 dest_cr = s->dest[2];
2370
2371 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2372 op_pix = s->hdsp.put_pixels_tab;
2373 op_qpix = s->qdsp.put_qpel_pixels_tab;
2374 } else {
2375 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2376 op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2377 }
2378
2379 if (s->mv_dir & MV_DIR_FORWARD) {
2380 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2381 s->last_picture.f->data,
2382 op_pix, op_qpix);
2383 op_pix = s->hdsp.avg_pixels_tab;
2384 op_qpix = s->qdsp.avg_qpel_pixels_tab;
2385 }
2386 if (s->mv_dir & MV_DIR_BACKWARD) {
2387 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2388 s->next_picture.f->data,
2389 op_pix, op_qpix);
2390 }
2391
2392 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2393 int progressive_score, interlaced_score;
2394
2395 s->interlaced_dct = 0;
2396 progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2397 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2398 ptr_y + wrap_y * 8,
2399 wrap_y, 8) - 400;
2400
2401 if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2402 progressive_score -= 400;
2403
2404 if (progressive_score > 0) {
2405 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2406 wrap_y * 2, 8) +
2407 s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2408 ptr_y + wrap_y,
2409 wrap_y * 2, 8);
2410
2411 if (progressive_score > interlaced_score) {
2412 s->interlaced_dct = 1;
2413
2414 dct_offset = wrap_y;
2415 uv_dct_offset = wrap_c;
2416 wrap_y <<= 1;
2417 if (s->chroma_format == CHROMA_422)
2418 wrap_c <<= 1;
2419 }
2420 }
2421 }
2422
2423 s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2424 s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2425 s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2426 dest_y + dct_offset, wrap_y);
2427 s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2428 dest_y + dct_offset + 8, wrap_y);
2429
2430 if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2431 skip_dct[4] = 1;
2432 skip_dct[5] = 1;
2433 } else {
2434 s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2435 s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2436 if (!s->chroma_y_shift) { /* 422 */
2437 s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2438 dest_cb + uv_dct_offset, wrap_c);
2439 s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2440 dest_cr + uv_dct_offset, wrap_c);
2441 }
2442 }
2443 /* pre quantization */
2444 if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2445 2 * s->qscale * s->qscale) {
2446 // FIXME optimize
2447 if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2448 skip_dct[0] = 1;
2449 if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2450 skip_dct[1] = 1;
2451 if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2452 wrap_y, 8) < 20 * s->qscale)
2453 skip_dct[2] = 1;
2454 if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2455 wrap_y, 8) < 20 * s->qscale)
2456 skip_dct[3] = 1;
2457 if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2458 skip_dct[4] = 1;
2459 if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2460 skip_dct[5] = 1;
2461 if (!s->chroma_y_shift) { /* 422 */
2462 if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2463 dest_cb + uv_dct_offset,
2464 wrap_c, 8) < 20 * s->qscale)
2465 skip_dct[6] = 1;
2466 if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2467 dest_cr + uv_dct_offset,
2468 wrap_c, 8) < 20 * s->qscale)
2469 skip_dct[7] = 1;
2470 }
2471 }
2472 }
2473
2474 if (s->quantizer_noise_shaping) {
2475 if (!skip_dct[0])
2476 get_visual_weight(weight[0], ptr_y , wrap_y);
2477 if (!skip_dct[1])
2478 get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2479 if (!skip_dct[2])
2480 get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2481 if (!skip_dct[3])
2482 get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2483 if (!skip_dct[4])
2484 get_visual_weight(weight[4], ptr_cb , wrap_c);
2485 if (!skip_dct[5])
2486 get_visual_weight(weight[5], ptr_cr , wrap_c);
2487 if (!s->chroma_y_shift) { /* 422 */
2488 if (!skip_dct[6])
2489 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2490 wrap_c);
2491 if (!skip_dct[7])
2492 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2493 wrap_c);
2494 }
2495 memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2496 }
2497
2498 /* DCT & quantize */
2499 av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2500 {
2501 for (i = 0; i < mb_block_count; i++) {
2502 if (!skip_dct[i]) {
2503 int overflow;
2504 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2505 // FIXME we could decide to change to quantizer instead of
2506 // clipping
2507 // JS: I don't think that would be a good idea it could lower
2508 // quality instead of improve it. Just INTRADC clipping
2509 // deserves changes in quantizer
2510 if (overflow)
2511 clip_coeffs(s, s->block[i], s->block_last_index[i]);
2512 } else
2513 s->block_last_index[i] = -1;
2514 }
2515 if (s->quantizer_noise_shaping) {
2516 for (i = 0; i < mb_block_count; i++) {
2517 if (!skip_dct[i]) {
2518 s->block_last_index[i] =
2519 dct_quantize_refine(s, s->block[i], weight[i],
2520 orig[i], i, s->qscale);
2521 }
2522 }
2523 }
2524
2525 if (s->luma_elim_threshold && !s->mb_intra)
2526 for (i = 0; i < 4; i++)
2527 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2528 if (s->chroma_elim_threshold && !s->mb_intra)
2529 for (i = 4; i < mb_block_count; i++)
2530 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2531
2532 if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2533 for (i = 0; i < mb_block_count; i++) {
2534 if (s->block_last_index[i] == -1)
2535 s->coded_score[i] = INT_MAX / 256;
2536 }
2537 }
2538 }
2539
2540 if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2541 s->block_last_index[4] =
2542 s->block_last_index[5] = 0;
2543 s->block[4][0] =
2544 s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2545 if (!s->chroma_y_shift) { /* 422 / 444 */
2546 for (i=6; i<12; i++) {
2547 s->block_last_index[i] = 0;
2548 s->block[i][0] = s->block[4][0];
2549 }
2550 }
2551 }
2552
2553 // non c quantize code returns incorrect block_last_index FIXME
2554 if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2555 for (i = 0; i < mb_block_count; i++) {
2556 int j;
2557 if (s->block_last_index[i] > 0) {
2558 for (j = 63; j > 0; j--) {
2559 if (s->block[i][s->intra_scantable.permutated[j]])
2560 break;
2561 }
2562 s->block_last_index[i] = j;
2563 }
2564 }
2565 }
2566
2567 /* huffman encode */
2568 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2569 case AV_CODEC_ID_MPEG1VIDEO:
2570 case AV_CODEC_ID_MPEG2VIDEO:
2571 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2572 ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2573 break;
2574 case AV_CODEC_ID_MPEG4:
2575 if (CONFIG_MPEG4_ENCODER)
2576 ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2577 break;
2578 case AV_CODEC_ID_MSMPEG4V2:
2579 case AV_CODEC_ID_MSMPEG4V3:
2580 case AV_CODEC_ID_WMV1:
2581 if (CONFIG_MSMPEG4_ENCODER)
2582 ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2583 break;
2584 case AV_CODEC_ID_WMV2:
2585 if (CONFIG_WMV2_ENCODER)
2586 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2587 break;
2588 case AV_CODEC_ID_H261:
2589 if (CONFIG_H261_ENCODER)
2590 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2591 break;
2592 case AV_CODEC_ID_H263:
2593 case AV_CODEC_ID_H263P:
2594 case AV_CODEC_ID_FLV1:
2595 case AV_CODEC_ID_RV10:
2596 case AV_CODEC_ID_RV20:
2597 if (CONFIG_H263_ENCODER)
2598 ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2599 break;
2600 case AV_CODEC_ID_MJPEG:
2601 case AV_CODEC_ID_AMV:
2602 if (CONFIG_MJPEG_ENCODER)
2603 ff_mjpeg_encode_mb(s, s->block);
2604 break;
2605 case AV_CODEC_ID_SPEEDHQ:
2606 if (CONFIG_SPEEDHQ_ENCODER)
2607 ff_speedhq_encode_mb(s, s->block);
2608 break;
2609 default:
2610 av_assert1(0);
2611 }
2612 }
2613
encode_mb(MpegEncContext * s,int motion_x,int motion_y)2614 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2615 {
2616 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2617 else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2618 else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2619 }
2620
copy_context_before_encode(MpegEncContext * d,MpegEncContext * s,int type)2621 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2622 int i;
2623
2624 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2625
2626 /* MPEG-1 */
2627 d->mb_skip_run= s->mb_skip_run;
2628 for(i=0; i<3; i++)
2629 d->last_dc[i] = s->last_dc[i];
2630
2631 /* statistics */
2632 d->mv_bits= s->mv_bits;
2633 d->i_tex_bits= s->i_tex_bits;
2634 d->p_tex_bits= s->p_tex_bits;
2635 d->i_count= s->i_count;
2636 d->f_count= s->f_count;
2637 d->b_count= s->b_count;
2638 d->skip_count= s->skip_count;
2639 d->misc_bits= s->misc_bits;
2640 d->last_bits= 0;
2641
2642 d->mb_skipped= 0;
2643 d->qscale= s->qscale;
2644 d->dquant= s->dquant;
2645
2646 d->esc3_level_length= s->esc3_level_length;
2647 }
2648
copy_context_after_encode(MpegEncContext * d,MpegEncContext * s,int type)2649 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2650 int i;
2651
2652 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2653 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2654
2655 /* MPEG-1 */
2656 d->mb_skip_run= s->mb_skip_run;
2657 for(i=0; i<3; i++)
2658 d->last_dc[i] = s->last_dc[i];
2659
2660 /* statistics */
2661 d->mv_bits= s->mv_bits;
2662 d->i_tex_bits= s->i_tex_bits;
2663 d->p_tex_bits= s->p_tex_bits;
2664 d->i_count= s->i_count;
2665 d->f_count= s->f_count;
2666 d->b_count= s->b_count;
2667 d->skip_count= s->skip_count;
2668 d->misc_bits= s->misc_bits;
2669
2670 d->mb_intra= s->mb_intra;
2671 d->mb_skipped= s->mb_skipped;
2672 d->mv_type= s->mv_type;
2673 d->mv_dir= s->mv_dir;
2674 d->pb= s->pb;
2675 if(s->data_partitioning){
2676 d->pb2= s->pb2;
2677 d->tex_pb= s->tex_pb;
2678 }
2679 d->block= s->block;
2680 for(i=0; i<8; i++)
2681 d->block_last_index[i]= s->block_last_index[i];
2682 d->interlaced_dct= s->interlaced_dct;
2683 d->qscale= s->qscale;
2684
2685 d->esc3_level_length= s->esc3_level_length;
2686 }
2687
encode_mb_hq(MpegEncContext * s,MpegEncContext * backup,MpegEncContext * best,int type,PutBitContext pb[2],PutBitContext pb2[2],PutBitContext tex_pb[2],int * dmin,int * next_block,int motion_x,int motion_y)2688 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2689 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2690 int *dmin, int *next_block, int motion_x, int motion_y)
2691 {
2692 int score;
2693 uint8_t *dest_backup[3];
2694
2695 copy_context_before_encode(s, backup, type);
2696
2697 s->block= s->blocks[*next_block];
2698 s->pb= pb[*next_block];
2699 if(s->data_partitioning){
2700 s->pb2 = pb2 [*next_block];
2701 s->tex_pb= tex_pb[*next_block];
2702 }
2703
2704 if(*next_block){
2705 memcpy(dest_backup, s->dest, sizeof(s->dest));
2706 s->dest[0] = s->sc.rd_scratchpad;
2707 s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2708 s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2709 av_assert0(s->linesize >= 32); //FIXME
2710 }
2711
2712 encode_mb(s, motion_x, motion_y);
2713
2714 score= put_bits_count(&s->pb);
2715 if(s->data_partitioning){
2716 score+= put_bits_count(&s->pb2);
2717 score+= put_bits_count(&s->tex_pb);
2718 }
2719
2720 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2721 ff_mpv_reconstruct_mb(s, s->block);
2722
2723 score *= s->lambda2;
2724 score += sse_mb(s) << FF_LAMBDA_SHIFT;
2725 }
2726
2727 if(*next_block){
2728 memcpy(s->dest, dest_backup, sizeof(s->dest));
2729 }
2730
2731 if(score<*dmin){
2732 *dmin= score;
2733 *next_block^=1;
2734
2735 copy_context_after_encode(best, s, type);
2736 }
2737 }
2738
sse(MpegEncContext * s,uint8_t * src1,uint8_t * src2,int w,int h,int stride)2739 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2740 const uint32_t *sq = ff_square_tab + 256;
2741 int acc=0;
2742 int x,y;
2743
2744 if(w==16 && h==16)
2745 return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2746 else if(w==8 && h==8)
2747 return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2748
2749 for(y=0; y<h; y++){
2750 for(x=0; x<w; x++){
2751 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2752 }
2753 }
2754
2755 av_assert2(acc>=0);
2756
2757 return acc;
2758 }
2759
sse_mb(MpegEncContext * s)2760 static int sse_mb(MpegEncContext *s){
2761 int w= 16;
2762 int h= 16;
2763
2764 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2765 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2766
2767 if(w==16 && h==16)
2768 if(s->avctx->mb_cmp == FF_CMP_NSSE){
2769 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) +
2770 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) +
2771 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);
2772 }else{
2773 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) +
2774 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) +
2775 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);
2776 }
2777 else
2778 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)
2779 +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)
2780 +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);
2781 }
2782
pre_estimate_motion_thread(AVCodecContext * c,void * arg)2783 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2784 MpegEncContext *s= *(void**)arg;
2785
2786
2787 s->me.pre_pass=1;
2788 s->me.dia_size= s->avctx->pre_dia_size;
2789 s->first_slice_line=1;
2790 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2791 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2792 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2793 }
2794 s->first_slice_line=0;
2795 }
2796
2797 s->me.pre_pass=0;
2798
2799 return 0;
2800 }
2801
estimate_motion_thread(AVCodecContext * c,void * arg)2802 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2803 MpegEncContext *s= *(void**)arg;
2804
2805 s->me.dia_size= s->avctx->dia_size;
2806 s->first_slice_line=1;
2807 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2808 s->mb_x=0; //for block init below
2809 ff_init_block_index(s);
2810 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2811 s->block_index[0]+=2;
2812 s->block_index[1]+=2;
2813 s->block_index[2]+=2;
2814 s->block_index[3]+=2;
2815
2816 /* compute motion vector & mb_type and store in context */
2817 if(s->pict_type==AV_PICTURE_TYPE_B)
2818 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2819 else
2820 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2821 }
2822 s->first_slice_line=0;
2823 }
2824 return 0;
2825 }
2826
mb_var_thread(AVCodecContext * c,void * arg)2827 static int mb_var_thread(AVCodecContext *c, void *arg){
2828 MpegEncContext *s= *(void**)arg;
2829 int mb_x, mb_y;
2830
2831 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2832 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2833 int xx = mb_x * 16;
2834 int yy = mb_y * 16;
2835 uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2836 int varc;
2837 int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2838
2839 varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2840 (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2841
2842 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2843 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2844 s->me.mb_var_sum_temp += varc;
2845 }
2846 }
2847 return 0;
2848 }
2849
write_slice_end(MpegEncContext * s)2850 static void write_slice_end(MpegEncContext *s){
2851 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2852 if(s->partitioned_frame){
2853 ff_mpeg4_merge_partitions(s);
2854 }
2855
2856 ff_mpeg4_stuffing(&s->pb);
2857 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2858 ff_mjpeg_encode_stuffing(s);
2859 } else if (CONFIG_SPEEDHQ_ENCODER && s->out_format == FMT_SPEEDHQ) {
2860 ff_speedhq_end_slice(s);
2861 }
2862
2863 flush_put_bits(&s->pb);
2864
2865 if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2866 s->misc_bits+= get_bits_diff(s);
2867 }
2868
write_mb_info(MpegEncContext * s)2869 static void write_mb_info(MpegEncContext *s)
2870 {
2871 uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2872 int offset = put_bits_count(&s->pb);
2873 int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2874 int gobn = s->mb_y / s->gob_index;
2875 int pred_x, pred_y;
2876 if (CONFIG_H263_ENCODER)
2877 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2878 bytestream_put_le32(&ptr, offset);
2879 bytestream_put_byte(&ptr, s->qscale);
2880 bytestream_put_byte(&ptr, gobn);
2881 bytestream_put_le16(&ptr, mba);
2882 bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2883 bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2884 /* 4MV not implemented */
2885 bytestream_put_byte(&ptr, 0); /* hmv2 */
2886 bytestream_put_byte(&ptr, 0); /* vmv2 */
2887 }
2888
update_mb_info(MpegEncContext * s,int startcode)2889 static void update_mb_info(MpegEncContext *s, int startcode)
2890 {
2891 if (!s->mb_info)
2892 return;
2893 if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2894 s->mb_info_size += 12;
2895 s->prev_mb_info = s->last_mb_info;
2896 }
2897 if (startcode) {
2898 s->prev_mb_info = put_bits_count(&s->pb)/8;
2899 /* This might have incremented mb_info_size above, and we return without
2900 * actually writing any info into that slot yet. But in that case,
2901 * this will be called again at the start of the after writing the
2902 * start code, actually writing the mb info. */
2903 return;
2904 }
2905
2906 s->last_mb_info = put_bits_count(&s->pb)/8;
2907 if (!s->mb_info_size)
2908 s->mb_info_size += 12;
2909 write_mb_info(s);
2910 }
2911
ff_mpv_reallocate_putbitbuffer(MpegEncContext * s,size_t threshold,size_t size_increase)2912 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2913 {
2914 if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2915 && s->slice_context_count == 1
2916 && s->pb.buf == s->avctx->internal->byte_buffer) {
2917 int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2918 int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2919
2920 uint8_t *new_buffer = NULL;
2921 int new_buffer_size = 0;
2922
2923 if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2924 av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2925 return AVERROR(ENOMEM);
2926 }
2927
2928 emms_c();
2929
2930 av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2931 s->avctx->internal->byte_buffer_size + size_increase);
2932 if (!new_buffer)
2933 return AVERROR(ENOMEM);
2934
2935 memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2936 av_free(s->avctx->internal->byte_buffer);
2937 s->avctx->internal->byte_buffer = new_buffer;
2938 s->avctx->internal->byte_buffer_size = new_buffer_size;
2939 rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2940 s->ptr_lastgob = s->pb.buf + lastgob_pos;
2941 s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2942 }
2943 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2944 return AVERROR(EINVAL);
2945 return 0;
2946 }
2947
encode_thread(AVCodecContext * c,void * arg)2948 static int encode_thread(AVCodecContext *c, void *arg){
2949 MpegEncContext *s= *(void**)arg;
2950 int mb_x, mb_y, mb_y_order;
2951 int chr_h= 16>>s->chroma_y_shift;
2952 int i, j;
2953 MpegEncContext best_s = { 0 }, backup_s;
2954 uint8_t bit_buf[2][MAX_MB_BYTES];
2955 uint8_t bit_buf2[2][MAX_MB_BYTES];
2956 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2957 PutBitContext pb[2], pb2[2], tex_pb[2];
2958
2959 for(i=0; i<2; i++){
2960 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2961 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2962 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2963 }
2964
2965 s->last_bits= put_bits_count(&s->pb);
2966 s->mv_bits=0;
2967 s->misc_bits=0;
2968 s->i_tex_bits=0;
2969 s->p_tex_bits=0;
2970 s->i_count=0;
2971 s->f_count=0;
2972 s->b_count=0;
2973 s->skip_count=0;
2974
2975 for(i=0; i<3; i++){
2976 /* init last dc values */
2977 /* note: quant matrix value (8) is implied here */
2978 s->last_dc[i] = 128 << s->intra_dc_precision;
2979
2980 s->current_picture.encoding_error[i] = 0;
2981 }
2982 if(s->codec_id==AV_CODEC_ID_AMV){
2983 s->last_dc[0] = 128*8/13;
2984 s->last_dc[1] = 128*8/14;
2985 s->last_dc[2] = 128*8/14;
2986 }
2987 s->mb_skip_run = 0;
2988 memset(s->last_mv, 0, sizeof(s->last_mv));
2989
2990 s->last_mv_dir = 0;
2991
2992 switch(s->codec_id){
2993 case AV_CODEC_ID_H263:
2994 case AV_CODEC_ID_H263P:
2995 case AV_CODEC_ID_FLV1:
2996 if (CONFIG_H263_ENCODER)
2997 s->gob_index = H263_GOB_HEIGHT(s->height);
2998 break;
2999 case AV_CODEC_ID_MPEG4:
3000 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3001 ff_mpeg4_init_partitions(s);
3002 break;
3003 }
3004
3005 s->resync_mb_x=0;
3006 s->resync_mb_y=0;
3007 s->first_slice_line = 1;
3008 s->ptr_lastgob = s->pb.buf;
3009 for (mb_y_order = s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3010 if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
3011 int first_in_slice;
3012 mb_y = ff_speedhq_mb_y_order_to_mb(mb_y_order, s->mb_height, &first_in_slice);
3013 if (first_in_slice && mb_y_order != s->start_mb_y)
3014 ff_speedhq_end_slice(s);
3015 s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 1024 << s->intra_dc_precision;
3016 } else {
3017 mb_y = mb_y_order;
3018 }
3019 s->mb_x=0;
3020 s->mb_y= mb_y;
3021
3022 ff_set_qscale(s, s->qscale);
3023 ff_init_block_index(s);
3024
3025 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3026 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3027 int mb_type= s->mb_type[xy];
3028 // int d;
3029 int dmin= INT_MAX;
3030 int dir;
3031 int size_increase = s->avctx->internal->byte_buffer_size/4
3032 + s->mb_width*MAX_MB_BYTES;
3033
3034 ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3035 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3036 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3037 return -1;
3038 }
3039 if(s->data_partitioning){
3040 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
3041 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3042 av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3043 return -1;
3044 }
3045 }
3046
3047 s->mb_x = mb_x;
3048 s->mb_y = mb_y; // moved into loop, can get changed by H.261
3049 ff_update_block_index(s);
3050
3051 if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3052 ff_h261_reorder_mb_index(s);
3053 xy= s->mb_y*s->mb_stride + s->mb_x;
3054 mb_type= s->mb_type[xy];
3055 }
3056
3057 /* write gob / video packet header */
3058 if(s->rtp_mode){
3059 int current_packet_size, is_gob_start;
3060
3061 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3062
3063 is_gob_start = s->rtp_payload_size &&
3064 current_packet_size >= s->rtp_payload_size &&
3065 mb_y + mb_x > 0;
3066
3067 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3068
3069 switch(s->codec_id){
3070 case AV_CODEC_ID_H263:
3071 case AV_CODEC_ID_H263P:
3072 if(!s->h263_slice_structured)
3073 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3074 break;
3075 case AV_CODEC_ID_MPEG2VIDEO:
3076 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3077 case AV_CODEC_ID_MPEG1VIDEO:
3078 if(s->mb_skip_run) is_gob_start=0;
3079 break;
3080 case AV_CODEC_ID_MJPEG:
3081 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3082 break;
3083 }
3084
3085 if(is_gob_start){
3086 if(s->start_mb_y != mb_y || mb_x!=0){
3087 write_slice_end(s);
3088
3089 if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3090 ff_mpeg4_init_partitions(s);
3091 }
3092 }
3093
3094 av_assert2((put_bits_count(&s->pb)&7) == 0);
3095 current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3096
3097 if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3098 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3099 int d = 100 / s->error_rate;
3100 if(r % d == 0){
3101 current_packet_size=0;
3102 s->pb.buf_ptr= s->ptr_lastgob;
3103 av_assert1(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3104 }
3105 }
3106
3107 #if FF_API_RTP_CALLBACK
3108 FF_DISABLE_DEPRECATION_WARNINGS
3109 if (s->avctx->rtp_callback){
3110 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3111 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3112 }
3113 FF_ENABLE_DEPRECATION_WARNINGS
3114 #endif
3115 update_mb_info(s, 1);
3116
3117 switch(s->codec_id){
3118 case AV_CODEC_ID_MPEG4:
3119 if (CONFIG_MPEG4_ENCODER) {
3120 ff_mpeg4_encode_video_packet_header(s);
3121 ff_mpeg4_clean_buffers(s);
3122 }
3123 break;
3124 case AV_CODEC_ID_MPEG1VIDEO:
3125 case AV_CODEC_ID_MPEG2VIDEO:
3126 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3127 ff_mpeg1_encode_slice_header(s);
3128 ff_mpeg1_clean_buffers(s);
3129 }
3130 break;
3131 case AV_CODEC_ID_H263:
3132 case AV_CODEC_ID_H263P:
3133 if (CONFIG_H263_ENCODER)
3134 ff_h263_encode_gob_header(s, mb_y);
3135 break;
3136 }
3137
3138 if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3139 int bits= put_bits_count(&s->pb);
3140 s->misc_bits+= bits - s->last_bits;
3141 s->last_bits= bits;
3142 }
3143
3144 s->ptr_lastgob += current_packet_size;
3145 s->first_slice_line=1;
3146 s->resync_mb_x=mb_x;
3147 s->resync_mb_y=mb_y;
3148 }
3149 }
3150
3151 if( (s->resync_mb_x == s->mb_x)
3152 && s->resync_mb_y+1 == s->mb_y){
3153 s->first_slice_line=0;
3154 }
3155
3156 s->mb_skipped=0;
3157 s->dquant=0; //only for QP_RD
3158
3159 update_mb_info(s, 0);
3160
3161 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
3162 int next_block=0;
3163 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3164
3165 copy_context_before_encode(&backup_s, s, -1);
3166 backup_s.pb= s->pb;
3167 best_s.data_partitioning= s->data_partitioning;
3168 best_s.partitioned_frame= s->partitioned_frame;
3169 if(s->data_partitioning){
3170 backup_s.pb2= s->pb2;
3171 backup_s.tex_pb= s->tex_pb;
3172 }
3173
3174 if(mb_type&CANDIDATE_MB_TYPE_INTER){
3175 s->mv_dir = MV_DIR_FORWARD;
3176 s->mv_type = MV_TYPE_16X16;
3177 s->mb_intra= 0;
3178 s->mv[0][0][0] = s->p_mv_table[xy][0];
3179 s->mv[0][0][1] = s->p_mv_table[xy][1];
3180 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3181 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3182 }
3183 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3184 s->mv_dir = MV_DIR_FORWARD;
3185 s->mv_type = MV_TYPE_FIELD;
3186 s->mb_intra= 0;
3187 for(i=0; i<2; i++){
3188 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3189 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3190 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3191 }
3192 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3193 &dmin, &next_block, 0, 0);
3194 }
3195 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3196 s->mv_dir = MV_DIR_FORWARD;
3197 s->mv_type = MV_TYPE_16X16;
3198 s->mb_intra= 0;
3199 s->mv[0][0][0] = 0;
3200 s->mv[0][0][1] = 0;
3201 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3202 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3203 }
3204 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3205 s->mv_dir = MV_DIR_FORWARD;
3206 s->mv_type = MV_TYPE_8X8;
3207 s->mb_intra= 0;
3208 for(i=0; i<4; i++){
3209 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3210 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3211 }
3212 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3213 &dmin, &next_block, 0, 0);
3214 }
3215 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3216 s->mv_dir = MV_DIR_FORWARD;
3217 s->mv_type = MV_TYPE_16X16;
3218 s->mb_intra= 0;
3219 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3220 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3221 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3222 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3223 }
3224 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3225 s->mv_dir = MV_DIR_BACKWARD;
3226 s->mv_type = MV_TYPE_16X16;
3227 s->mb_intra= 0;
3228 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3229 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3230 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3231 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3232 }
3233 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3234 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3235 s->mv_type = MV_TYPE_16X16;
3236 s->mb_intra= 0;
3237 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3238 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3239 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3240 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3241 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3242 &dmin, &next_block, 0, 0);
3243 }
3244 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3245 s->mv_dir = MV_DIR_FORWARD;
3246 s->mv_type = MV_TYPE_FIELD;
3247 s->mb_intra= 0;
3248 for(i=0; i<2; i++){
3249 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3250 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3251 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3252 }
3253 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3254 &dmin, &next_block, 0, 0);
3255 }
3256 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3257 s->mv_dir = MV_DIR_BACKWARD;
3258 s->mv_type = MV_TYPE_FIELD;
3259 s->mb_intra= 0;
3260 for(i=0; i<2; i++){
3261 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3262 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3263 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3264 }
3265 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3266 &dmin, &next_block, 0, 0);
3267 }
3268 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3269 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3270 s->mv_type = MV_TYPE_FIELD;
3271 s->mb_intra= 0;
3272 for(dir=0; dir<2; dir++){
3273 for(i=0; i<2; i++){
3274 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3275 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3276 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3277 }
3278 }
3279 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3280 &dmin, &next_block, 0, 0);
3281 }
3282 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3283 s->mv_dir = 0;
3284 s->mv_type = MV_TYPE_16X16;
3285 s->mb_intra= 1;
3286 s->mv[0][0][0] = 0;
3287 s->mv[0][0][1] = 0;
3288 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3289 &dmin, &next_block, 0, 0);
3290 if(s->h263_pred || s->h263_aic){
3291 if(best_s.mb_intra)
3292 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3293 else
3294 ff_clean_intra_table_entries(s); //old mode?
3295 }
3296 }
3297
3298 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3299 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3300 const int last_qp= backup_s.qscale;
3301 int qpi, qp, dc[6];
3302 int16_t ac[6][16];
3303 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3304 static const int dquant_tab[4]={-1,1,-2,2};
3305 int storecoefs = s->mb_intra && s->dc_val[0];
3306
3307 av_assert2(backup_s.dquant == 0);
3308
3309 //FIXME intra
3310 s->mv_dir= best_s.mv_dir;
3311 s->mv_type = MV_TYPE_16X16;
3312 s->mb_intra= best_s.mb_intra;
3313 s->mv[0][0][0] = best_s.mv[0][0][0];
3314 s->mv[0][0][1] = best_s.mv[0][0][1];
3315 s->mv[1][0][0] = best_s.mv[1][0][0];
3316 s->mv[1][0][1] = best_s.mv[1][0][1];
3317
3318 qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3319 for(; qpi<4; qpi++){
3320 int dquant= dquant_tab[qpi];
3321 qp= last_qp + dquant;
3322 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3323 continue;
3324 backup_s.dquant= dquant;
3325 if(storecoefs){
3326 for(i=0; i<6; i++){
3327 dc[i]= s->dc_val[0][ s->block_index[i] ];
3328 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3329 }
3330 }
3331
3332 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3333 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3334 if(best_s.qscale != qp){
3335 if(storecoefs){
3336 for(i=0; i<6; i++){
3337 s->dc_val[0][ s->block_index[i] ]= dc[i];
3338 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3339 }
3340 }
3341 }
3342 }
3343 }
3344 }
3345 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3346 int mx= s->b_direct_mv_table[xy][0];
3347 int my= s->b_direct_mv_table[xy][1];
3348
3349 backup_s.dquant = 0;
3350 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3351 s->mb_intra= 0;
3352 ff_mpeg4_set_direct_mv(s, mx, my);
3353 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3354 &dmin, &next_block, mx, my);
3355 }
3356 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3357 backup_s.dquant = 0;
3358 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3359 s->mb_intra= 0;
3360 ff_mpeg4_set_direct_mv(s, 0, 0);
3361 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3362 &dmin, &next_block, 0, 0);
3363 }
3364 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3365 int coded=0;
3366 for(i=0; i<6; i++)
3367 coded |= s->block_last_index[i];
3368 if(coded){
3369 int mx,my;
3370 memcpy(s->mv, best_s.mv, sizeof(s->mv));
3371 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3372 mx=my=0; //FIXME find the one we actually used
3373 ff_mpeg4_set_direct_mv(s, mx, my);
3374 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3375 mx= s->mv[1][0][0];
3376 my= s->mv[1][0][1];
3377 }else{
3378 mx= s->mv[0][0][0];
3379 my= s->mv[0][0][1];
3380 }
3381
3382 s->mv_dir= best_s.mv_dir;
3383 s->mv_type = best_s.mv_type;
3384 s->mb_intra= 0;
3385 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3386 s->mv[0][0][1] = best_s.mv[0][0][1];
3387 s->mv[1][0][0] = best_s.mv[1][0][0];
3388 s->mv[1][0][1] = best_s.mv[1][0][1];*/
3389 backup_s.dquant= 0;
3390 s->skipdct=1;
3391 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3392 &dmin, &next_block, mx, my);
3393 s->skipdct=0;
3394 }
3395 }
3396
3397 s->current_picture.qscale_table[xy] = best_s.qscale;
3398
3399 copy_context_after_encode(s, &best_s, -1);
3400
3401 pb_bits_count= put_bits_count(&s->pb);
3402 flush_put_bits(&s->pb);
3403 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3404 s->pb= backup_s.pb;
3405
3406 if(s->data_partitioning){
3407 pb2_bits_count= put_bits_count(&s->pb2);
3408 flush_put_bits(&s->pb2);
3409 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3410 s->pb2= backup_s.pb2;
3411
3412 tex_pb_bits_count= put_bits_count(&s->tex_pb);
3413 flush_put_bits(&s->tex_pb);
3414 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3415 s->tex_pb= backup_s.tex_pb;
3416 }
3417 s->last_bits= put_bits_count(&s->pb);
3418
3419 if (CONFIG_H263_ENCODER &&
3420 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3421 ff_h263_update_motion_val(s);
3422
3423 if(next_block==0){ //FIXME 16 vs linesize16
3424 s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3425 s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3426 s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3427 }
3428
3429 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3430 ff_mpv_reconstruct_mb(s, s->block);
3431 } else {
3432 int motion_x = 0, motion_y = 0;
3433 s->mv_type=MV_TYPE_16X16;
3434 // only one MB-Type possible
3435
3436 switch(mb_type){
3437 case CANDIDATE_MB_TYPE_INTRA:
3438 s->mv_dir = 0;
3439 s->mb_intra= 1;
3440 motion_x= s->mv[0][0][0] = 0;
3441 motion_y= s->mv[0][0][1] = 0;
3442 break;
3443 case CANDIDATE_MB_TYPE_INTER:
3444 s->mv_dir = MV_DIR_FORWARD;
3445 s->mb_intra= 0;
3446 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3447 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3448 break;
3449 case CANDIDATE_MB_TYPE_INTER_I:
3450 s->mv_dir = MV_DIR_FORWARD;
3451 s->mv_type = MV_TYPE_FIELD;
3452 s->mb_intra= 0;
3453 for(i=0; i<2; i++){
3454 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3455 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3456 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3457 }
3458 break;
3459 case CANDIDATE_MB_TYPE_INTER4V:
3460 s->mv_dir = MV_DIR_FORWARD;
3461 s->mv_type = MV_TYPE_8X8;
3462 s->mb_intra= 0;
3463 for(i=0; i<4; i++){
3464 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3465 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3466 }
3467 break;
3468 case CANDIDATE_MB_TYPE_DIRECT:
3469 if (CONFIG_MPEG4_ENCODER) {
3470 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3471 s->mb_intra= 0;
3472 motion_x=s->b_direct_mv_table[xy][0];
3473 motion_y=s->b_direct_mv_table[xy][1];
3474 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3475 }
3476 break;
3477 case CANDIDATE_MB_TYPE_DIRECT0:
3478 if (CONFIG_MPEG4_ENCODER) {
3479 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3480 s->mb_intra= 0;
3481 ff_mpeg4_set_direct_mv(s, 0, 0);
3482 }
3483 break;
3484 case CANDIDATE_MB_TYPE_BIDIR:
3485 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3486 s->mb_intra= 0;
3487 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3488 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3489 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3490 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3491 break;
3492 case CANDIDATE_MB_TYPE_BACKWARD:
3493 s->mv_dir = MV_DIR_BACKWARD;
3494 s->mb_intra= 0;
3495 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3496 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3497 break;
3498 case CANDIDATE_MB_TYPE_FORWARD:
3499 s->mv_dir = MV_DIR_FORWARD;
3500 s->mb_intra= 0;
3501 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3502 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3503 break;
3504 case CANDIDATE_MB_TYPE_FORWARD_I:
3505 s->mv_dir = MV_DIR_FORWARD;
3506 s->mv_type = MV_TYPE_FIELD;
3507 s->mb_intra= 0;
3508 for(i=0; i<2; i++){
3509 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3510 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3511 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3512 }
3513 break;
3514 case CANDIDATE_MB_TYPE_BACKWARD_I:
3515 s->mv_dir = MV_DIR_BACKWARD;
3516 s->mv_type = MV_TYPE_FIELD;
3517 s->mb_intra= 0;
3518 for(i=0; i<2; i++){
3519 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3520 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3521 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3522 }
3523 break;
3524 case CANDIDATE_MB_TYPE_BIDIR_I:
3525 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3526 s->mv_type = MV_TYPE_FIELD;
3527 s->mb_intra= 0;
3528 for(dir=0; dir<2; dir++){
3529 for(i=0; i<2; i++){
3530 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3531 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3532 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3533 }
3534 }
3535 break;
3536 default:
3537 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3538 }
3539
3540 encode_mb(s, motion_x, motion_y);
3541
3542 // RAL: Update last macroblock type
3543 s->last_mv_dir = s->mv_dir;
3544
3545 if (CONFIG_H263_ENCODER &&
3546 s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3547 ff_h263_update_motion_val(s);
3548
3549 ff_mpv_reconstruct_mb(s, s->block);
3550 }
3551
3552 /* clean the MV table in IPS frames for direct mode in B-frames */
3553 if(s->mb_intra /* && I,P,S_TYPE */){
3554 s->p_mv_table[xy][0]=0;
3555 s->p_mv_table[xy][1]=0;
3556 }
3557
3558 if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3559 int w= 16;
3560 int h= 16;
3561
3562 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3563 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3564
3565 s->current_picture.encoding_error[0] += sse(
3566 s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3567 s->dest[0], w, h, s->linesize);
3568 s->current_picture.encoding_error[1] += sse(
3569 s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3570 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3571 s->current_picture.encoding_error[2] += sse(
3572 s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3573 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3574 }
3575 if(s->loop_filter){
3576 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3577 ff_h263_loop_filter(s);
3578 }
3579 ff_dlog(s->avctx, "MB %d %d bits\n",
3580 s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3581 }
3582 }
3583
3584 //not beautiful here but we must write it before flushing so it has to be here
3585 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3586 ff_msmpeg4_encode_ext_header(s);
3587
3588 write_slice_end(s);
3589
3590 #if FF_API_RTP_CALLBACK
3591 FF_DISABLE_DEPRECATION_WARNINGS
3592 /* Send the last GOB if RTP */
3593 if (s->avctx->rtp_callback) {
3594 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3595 int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3596 /* Call the RTP callback to send the last GOB */
3597 emms_c();
3598 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3599 }
3600 FF_ENABLE_DEPRECATION_WARNINGS
3601 #endif
3602
3603 return 0;
3604 }
3605
3606 #define MERGE(field) dst->field += src->field; src->field=0
merge_context_after_me(MpegEncContext * dst,MpegEncContext * src)3607 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3608 MERGE(me.scene_change_score);
3609 MERGE(me.mc_mb_var_sum_temp);
3610 MERGE(me.mb_var_sum_temp);
3611 }
3612
merge_context_after_encode(MpegEncContext * dst,MpegEncContext * src)3613 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3614 int i;
3615
3616 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3617 MERGE(dct_count[1]);
3618 MERGE(mv_bits);
3619 MERGE(i_tex_bits);
3620 MERGE(p_tex_bits);
3621 MERGE(i_count);
3622 MERGE(f_count);
3623 MERGE(b_count);
3624 MERGE(skip_count);
3625 MERGE(misc_bits);
3626 MERGE(er.error_count);
3627 MERGE(padding_bug_score);
3628 MERGE(current_picture.encoding_error[0]);
3629 MERGE(current_picture.encoding_error[1]);
3630 MERGE(current_picture.encoding_error[2]);
3631
3632 if (dst->noise_reduction){
3633 for(i=0; i<64; i++){
3634 MERGE(dct_error_sum[0][i]);
3635 MERGE(dct_error_sum[1][i]);
3636 }
3637 }
3638
3639 av_assert1(put_bits_count(&src->pb) % 8 ==0);
3640 av_assert1(put_bits_count(&dst->pb) % 8 ==0);
3641 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3642 flush_put_bits(&dst->pb);
3643 }
3644
estimate_qp(MpegEncContext * s,int dry_run)3645 static int estimate_qp(MpegEncContext *s, int dry_run){
3646 if (s->next_lambda){
3647 s->current_picture_ptr->f->quality =
3648 s->current_picture.f->quality = s->next_lambda;
3649 if(!dry_run) s->next_lambda= 0;
3650 } else if (!s->fixed_qscale) {
3651 int quality = ff_rate_estimate_qscale(s, dry_run);
3652 s->current_picture_ptr->f->quality =
3653 s->current_picture.f->quality = quality;
3654 if (s->current_picture.f->quality < 0)
3655 return -1;
3656 }
3657
3658 if(s->adaptive_quant){
3659 switch(s->codec_id){
3660 case AV_CODEC_ID_MPEG4:
3661 if (CONFIG_MPEG4_ENCODER)
3662 ff_clean_mpeg4_qscales(s);
3663 break;
3664 case AV_CODEC_ID_H263:
3665 case AV_CODEC_ID_H263P:
3666 case AV_CODEC_ID_FLV1:
3667 if (CONFIG_H263_ENCODER)
3668 ff_clean_h263_qscales(s);
3669 break;
3670 default:
3671 ff_init_qscale_tab(s);
3672 }
3673
3674 s->lambda= s->lambda_table[0];
3675 //FIXME broken
3676 }else
3677 s->lambda = s->current_picture.f->quality;
3678 update_qscale(s);
3679 return 0;
3680 }
3681
3682 /* must be called before writing the header */
set_frame_distances(MpegEncContext * s)3683 static void set_frame_distances(MpegEncContext * s){
3684 av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3685 s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3686
3687 if(s->pict_type==AV_PICTURE_TYPE_B){
3688 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3689 av_assert1(s->pb_time > 0 && s->pb_time < s->pp_time);
3690 }else{
3691 s->pp_time= s->time - s->last_non_b_time;
3692 s->last_non_b_time= s->time;
3693 av_assert1(s->picture_number==0 || s->pp_time > 0);
3694 }
3695 }
3696
encode_picture(MpegEncContext * s,int picture_number)3697 static int encode_picture(MpegEncContext *s, int picture_number)
3698 {
3699 int i, ret;
3700 int bits;
3701 int context_count = s->slice_context_count;
3702
3703 s->picture_number = picture_number;
3704
3705 /* Reset the average MB variance */
3706 s->me.mb_var_sum_temp =
3707 s->me.mc_mb_var_sum_temp = 0;
3708
3709 /* we need to initialize some time vars before we can encode B-frames */
3710 // RAL: Condition added for MPEG1VIDEO
3711 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3712 set_frame_distances(s);
3713 if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3714 ff_set_mpeg4_time(s);
3715
3716 s->me.scene_change_score=0;
3717
3718 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3719
3720 if(s->pict_type==AV_PICTURE_TYPE_I){
3721 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3722 else s->no_rounding=0;
3723 }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3724 if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3725 s->no_rounding ^= 1;
3726 }
3727
3728 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3729 if (estimate_qp(s,1) < 0)
3730 return -1;
3731 ff_get_2pass_fcode(s);
3732 } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3733 if(s->pict_type==AV_PICTURE_TYPE_B)
3734 s->lambda= s->last_lambda_for[s->pict_type];
3735 else
3736 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3737 update_qscale(s);
3738 }
3739
3740 if(s->codec_id != AV_CODEC_ID_AMV && s->codec_id != AV_CODEC_ID_MJPEG){
3741 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3742 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3743 s->q_chroma_intra_matrix = s->q_intra_matrix;
3744 s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3745 }
3746
3747 s->mb_intra=0; //for the rate distortion & bit compare functions
3748 for(i=1; i<context_count; i++){
3749 ret = ff_update_duplicate_context(s->thread_context[i], s);
3750 if (ret < 0)
3751 return ret;
3752 }
3753
3754 if(ff_init_me(s)<0)
3755 return -1;
3756
3757 /* Estimate motion for every MB */
3758 if(s->pict_type != AV_PICTURE_TYPE_I){
3759 s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3760 s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3761 if (s->pict_type != AV_PICTURE_TYPE_B) {
3762 if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3763 s->me_pre == 2) {
3764 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3765 }
3766 }
3767
3768 s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3769 }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3770 /* I-Frame */
3771 for(i=0; i<s->mb_stride*s->mb_height; i++)
3772 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3773
3774 if(!s->fixed_qscale){
3775 /* finding spatial complexity for I-frame rate control */
3776 s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3777 }
3778 }
3779 for(i=1; i<context_count; i++){
3780 merge_context_after_me(s, s->thread_context[i]);
3781 }
3782 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3783 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3784 emms_c();
3785
3786 if (s->me.scene_change_score > s->scenechange_threshold &&
3787 s->pict_type == AV_PICTURE_TYPE_P) {
3788 s->pict_type= AV_PICTURE_TYPE_I;
3789 for(i=0; i<s->mb_stride*s->mb_height; i++)
3790 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3791 if(s->msmpeg4_version >= 3)
3792 s->no_rounding=1;
3793 ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3794 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3795 }
3796
3797 if(!s->umvplus){
3798 if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3799 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3800
3801 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3802 int a,b;
3803 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3804 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3805 s->f_code= FFMAX3(s->f_code, a, b);
3806 }
3807
3808 ff_fix_long_p_mvs(s, s->intra_penalty ? CANDIDATE_MB_TYPE_INTER : CANDIDATE_MB_TYPE_INTRA);
3809 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, !!s->intra_penalty);
3810 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3811 int j;
3812 for(i=0; i<2; i++){
3813 for(j=0; j<2; j++)
3814 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3815 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, !!s->intra_penalty);
3816 }
3817 }
3818 }
3819
3820 if(s->pict_type==AV_PICTURE_TYPE_B){
3821 int a, b;
3822
3823 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3824 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3825 s->f_code = FFMAX(a, b);
3826
3827 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3828 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3829 s->b_code = FFMAX(a, b);
3830
3831 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3832 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3833 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3834 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3835 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3836 int dir, j;
3837 for(dir=0; dir<2; dir++){
3838 for(i=0; i<2; i++){
3839 for(j=0; j<2; j++){
3840 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3841 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3842 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3843 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3844 }
3845 }
3846 }
3847 }
3848 }
3849 }
3850
3851 if (estimate_qp(s, 0) < 0)
3852 return -1;
3853
3854 if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3855 s->pict_type == AV_PICTURE_TYPE_I &&
3856 !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3857 s->qscale= 3; //reduce clipping problems
3858
3859 if (s->out_format == FMT_MJPEG) {
3860 const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3861 const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3862
3863 if (s->avctx->intra_matrix) {
3864 chroma_matrix =
3865 luma_matrix = s->avctx->intra_matrix;
3866 }
3867 if (s->avctx->chroma_intra_matrix)
3868 chroma_matrix = s->avctx->chroma_intra_matrix;
3869
3870 /* for mjpeg, we do include qscale in the matrix */
3871 for(i=1;i<64;i++){
3872 int j = s->idsp.idct_permutation[i];
3873
3874 s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3875 s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3876 }
3877 s->y_dc_scale_table=
3878 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3879 s->chroma_intra_matrix[0] =
3880 s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3881 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3882 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3883 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3884 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3885 s->qscale= 8;
3886 }
3887 if(s->codec_id == AV_CODEC_ID_AMV){
3888 static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
3889 static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
3890 for(i=1;i<64;i++){
3891 int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3892
3893 s->intra_matrix[j] = sp5x_qscale_five_quant_table[0][i];
3894 s->chroma_intra_matrix[j] = sp5x_qscale_five_quant_table[1][i];
3895 }
3896 s->y_dc_scale_table= y;
3897 s->c_dc_scale_table= c;
3898 s->intra_matrix[0] = 13;
3899 s->chroma_intra_matrix[0] = 14;
3900 ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3901 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3902 ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3903 s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3904 s->qscale= 8;
3905 }
3906
3907 if (s->out_format == FMT_SPEEDHQ) {
3908 s->y_dc_scale_table=
3909 s->c_dc_scale_table= ff_mpeg2_dc_scale_table[3];
3910 }
3911
3912 //FIXME var duplication
3913 s->current_picture_ptr->f->key_frame =
3914 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3915 s->current_picture_ptr->f->pict_type =
3916 s->current_picture.f->pict_type = s->pict_type;
3917
3918 if (s->current_picture.f->key_frame)
3919 s->picture_in_gop_number=0;
3920
3921 s->mb_x = s->mb_y = 0;
3922 s->last_bits= put_bits_count(&s->pb);
3923 switch(s->out_format) {
3924 case FMT_MJPEG:
3925 if (CONFIG_MJPEG_ENCODER && s->huffman != HUFFMAN_TABLE_OPTIMAL)
3926 ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3927 s->pred, s->intra_matrix, s->chroma_intra_matrix);
3928 break;
3929 case FMT_SPEEDHQ:
3930 if (CONFIG_SPEEDHQ_ENCODER)
3931 ff_speedhq_encode_picture_header(s);
3932 break;
3933 case FMT_H261:
3934 if (CONFIG_H261_ENCODER)
3935 ff_h261_encode_picture_header(s, picture_number);
3936 break;
3937 case FMT_H263:
3938 if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3939 ff_wmv2_encode_picture_header(s, picture_number);
3940 else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3941 ff_msmpeg4_encode_picture_header(s, picture_number);
3942 else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3943 ret = ff_mpeg4_encode_picture_header(s, picture_number);
3944 if (ret < 0)
3945 return ret;
3946 } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3947 ret = ff_rv10_encode_picture_header(s, picture_number);
3948 if (ret < 0)
3949 return ret;
3950 }
3951 else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3952 ff_rv20_encode_picture_header(s, picture_number);
3953 else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3954 ff_flv_encode_picture_header(s, picture_number);
3955 else if (CONFIG_H263_ENCODER)
3956 ff_h263_encode_picture_header(s, picture_number);
3957 break;
3958 case FMT_MPEG1:
3959 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3960 ff_mpeg1_encode_picture_header(s, picture_number);
3961 break;
3962 default:
3963 av_assert0(0);
3964 }
3965 bits= put_bits_count(&s->pb);
3966 s->header_bits= bits - s->last_bits;
3967
3968 for(i=1; i<context_count; i++){
3969 update_duplicate_context_after_me(s->thread_context[i], s);
3970 }
3971 s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3972 for(i=1; i<context_count; i++){
3973 if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3974 set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-BUF_BITS));
3975 merge_context_after_encode(s, s->thread_context[i]);
3976 }
3977 emms_c();
3978 return 0;
3979 }
3980
denoise_dct_c(MpegEncContext * s,int16_t * block)3981 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3982 const int intra= s->mb_intra;
3983 int i;
3984
3985 s->dct_count[intra]++;
3986
3987 for(i=0; i<64; i++){
3988 int level= block[i];
3989
3990 if(level){
3991 if(level>0){
3992 s->dct_error_sum[intra][i] += level;
3993 level -= s->dct_offset[intra][i];
3994 if(level<0) level=0;
3995 }else{
3996 s->dct_error_sum[intra][i] -= level;
3997 level += s->dct_offset[intra][i];
3998 if(level>0) level=0;
3999 }
4000 block[i]= level;
4001 }
4002 }
4003 }
4004
dct_quantize_trellis_c(MpegEncContext * s,int16_t * block,int n,int qscale,int * overflow)4005 static int dct_quantize_trellis_c(MpegEncContext *s,
4006 int16_t *block, int n,
4007 int qscale, int *overflow){
4008 const int *qmat;
4009 const uint16_t *matrix;
4010 const uint8_t *scantable;
4011 const uint8_t *perm_scantable;
4012 int max=0;
4013 unsigned int threshold1, threshold2;
4014 int bias=0;
4015 int run_tab[65];
4016 int level_tab[65];
4017 int score_tab[65];
4018 int survivor[65];
4019 int survivor_count;
4020 int last_run=0;
4021 int last_level=0;
4022 int last_score= 0;
4023 int last_i;
4024 int coeff[2][64];
4025 int coeff_count[64];
4026 int qmul, qadd, start_i, last_non_zero, i, dc;
4027 const int esc_length= s->ac_esc_length;
4028 uint8_t * length;
4029 uint8_t * last_length;
4030 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4031 int mpeg2_qscale;
4032
4033 s->fdsp.fdct(block);
4034
4035 if(s->dct_error_sum)
4036 s->denoise_dct(s, block);
4037 qmul= qscale*16;
4038 qadd= ((qscale-1)|1)*8;
4039
4040 if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
4041 else mpeg2_qscale = qscale << 1;
4042
4043 if (s->mb_intra) {
4044 int q;
4045 scantable= s->intra_scantable.scantable;
4046 perm_scantable= s->intra_scantable.permutated;
4047 if (!s->h263_aic) {
4048 if (n < 4)
4049 q = s->y_dc_scale;
4050 else
4051 q = s->c_dc_scale;
4052 q = q << 3;
4053 } else{
4054 /* For AIC we skip quant/dequant of INTRADC */
4055 q = 1 << 3;
4056 qadd=0;
4057 }
4058
4059 /* note: block[0] is assumed to be positive */
4060 block[0] = (block[0] + (q >> 1)) / q;
4061 start_i = 1;
4062 last_non_zero = 0;
4063 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4064 matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4065 if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4066 bias= 1<<(QMAT_SHIFT-1);
4067
4068 if (n > 3 && s->intra_chroma_ac_vlc_length) {
4069 length = s->intra_chroma_ac_vlc_length;
4070 last_length= s->intra_chroma_ac_vlc_last_length;
4071 } else {
4072 length = s->intra_ac_vlc_length;
4073 last_length= s->intra_ac_vlc_last_length;
4074 }
4075 } else {
4076 scantable= s->inter_scantable.scantable;
4077 perm_scantable= s->inter_scantable.permutated;
4078 start_i = 0;
4079 last_non_zero = -1;
4080 qmat = s->q_inter_matrix[qscale];
4081 matrix = s->inter_matrix;
4082 length = s->inter_ac_vlc_length;
4083 last_length= s->inter_ac_vlc_last_length;
4084 }
4085 last_i= start_i;
4086
4087 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4088 threshold2= (threshold1<<1);
4089
4090 for(i=63; i>=start_i; i--) {
4091 const int j = scantable[i];
4092 int level = block[j] * qmat[j];
4093
4094 if(((unsigned)(level+threshold1))>threshold2){
4095 last_non_zero = i;
4096 break;
4097 }
4098 }
4099
4100 for(i=start_i; i<=last_non_zero; i++) {
4101 const int j = scantable[i];
4102 int level = block[j] * qmat[j];
4103
4104 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4105 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4106 if(((unsigned)(level+threshold1))>threshold2){
4107 if(level>0){
4108 level= (bias + level)>>QMAT_SHIFT;
4109 coeff[0][i]= level;
4110 coeff[1][i]= level-1;
4111 // coeff[2][k]= level-2;
4112 }else{
4113 level= (bias - level)>>QMAT_SHIFT;
4114 coeff[0][i]= -level;
4115 coeff[1][i]= -level+1;
4116 // coeff[2][k]= -level+2;
4117 }
4118 coeff_count[i]= FFMIN(level, 2);
4119 av_assert2(coeff_count[i]);
4120 max |=level;
4121 }else{
4122 coeff[0][i]= (level>>31)|1;
4123 coeff_count[i]= 1;
4124 }
4125 }
4126
4127 *overflow= s->max_qcoeff < max; //overflow might have happened
4128
4129 if(last_non_zero < start_i){
4130 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4131 return last_non_zero;
4132 }
4133
4134 score_tab[start_i]= 0;
4135 survivor[0]= start_i;
4136 survivor_count= 1;
4137
4138 for(i=start_i; i<=last_non_zero; i++){
4139 int level_index, j, zero_distortion;
4140 int dct_coeff= FFABS(block[ scantable[i] ]);
4141 int best_score=256*256*256*120;
4142
4143 if (s->fdsp.fdct == ff_fdct_ifast)
4144 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4145 zero_distortion= dct_coeff*dct_coeff;
4146
4147 for(level_index=0; level_index < coeff_count[i]; level_index++){
4148 int distortion;
4149 int level= coeff[level_index][i];
4150 const int alevel= FFABS(level);
4151 int unquant_coeff;
4152
4153 av_assert2(level);
4154
4155 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4156 unquant_coeff= alevel*qmul + qadd;
4157 } else if(s->out_format == FMT_MJPEG) {
4158 j = s->idsp.idct_permutation[scantable[i]];
4159 unquant_coeff = alevel * matrix[j] * 8;
4160 }else{ // MPEG-1
4161 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4162 if(s->mb_intra){
4163 unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4164 unquant_coeff = (unquant_coeff - 1) | 1;
4165 }else{
4166 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4167 unquant_coeff = (unquant_coeff - 1) | 1;
4168 }
4169 unquant_coeff<<= 3;
4170 }
4171
4172 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4173 level+=64;
4174 if((level&(~127)) == 0){
4175 for(j=survivor_count-1; j>=0; j--){
4176 int run= i - survivor[j];
4177 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4178 score += score_tab[i-run];
4179
4180 if(score < best_score){
4181 best_score= score;
4182 run_tab[i+1]= run;
4183 level_tab[i+1]= level-64;
4184 }
4185 }
4186
4187 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4188 for(j=survivor_count-1; j>=0; j--){
4189 int run= i - survivor[j];
4190 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4191 score += score_tab[i-run];
4192 if(score < last_score){
4193 last_score= score;
4194 last_run= run;
4195 last_level= level-64;
4196 last_i= i+1;
4197 }
4198 }
4199 }
4200 }else{
4201 distortion += esc_length*lambda;
4202 for(j=survivor_count-1; j>=0; j--){
4203 int run= i - survivor[j];
4204 int score= distortion + score_tab[i-run];
4205
4206 if(score < best_score){
4207 best_score= score;
4208 run_tab[i+1]= run;
4209 level_tab[i+1]= level-64;
4210 }
4211 }
4212
4213 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4214 for(j=survivor_count-1; j>=0; j--){
4215 int run= i - survivor[j];
4216 int score= distortion + score_tab[i-run];
4217 if(score < last_score){
4218 last_score= score;
4219 last_run= run;
4220 last_level= level-64;
4221 last_i= i+1;
4222 }
4223 }
4224 }
4225 }
4226 }
4227
4228 score_tab[i+1]= best_score;
4229
4230 // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
4231 if(last_non_zero <= 27){
4232 for(; survivor_count; survivor_count--){
4233 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4234 break;
4235 }
4236 }else{
4237 for(; survivor_count; survivor_count--){
4238 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4239 break;
4240 }
4241 }
4242
4243 survivor[ survivor_count++ ]= i+1;
4244 }
4245
4246 if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4247 last_score= 256*256*256*120;
4248 for(i= survivor[0]; i<=last_non_zero + 1; i++){
4249 int score= score_tab[i];
4250 if (i)
4251 score += lambda * 2; // FIXME more exact?
4252
4253 if(score < last_score){
4254 last_score= score;
4255 last_i= i;
4256 last_level= level_tab[i];
4257 last_run= run_tab[i];
4258 }
4259 }
4260 }
4261
4262 s->coded_score[n] = last_score;
4263
4264 dc= FFABS(block[0]);
4265 last_non_zero= last_i - 1;
4266 memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4267
4268 if(last_non_zero < start_i)
4269 return last_non_zero;
4270
4271 if(last_non_zero == 0 && start_i == 0){
4272 int best_level= 0;
4273 int best_score= dc * dc;
4274
4275 for(i=0; i<coeff_count[0]; i++){
4276 int level= coeff[i][0];
4277 int alevel= FFABS(level);
4278 int unquant_coeff, score, distortion;
4279
4280 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4281 unquant_coeff= (alevel*qmul + qadd)>>3;
4282 } else{ // MPEG-1
4283 unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4284 unquant_coeff = (unquant_coeff - 1) | 1;
4285 }
4286 unquant_coeff = (unquant_coeff + 4) >> 3;
4287 unquant_coeff<<= 3 + 3;
4288
4289 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4290 level+=64;
4291 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4292 else score= distortion + esc_length*lambda;
4293
4294 if(score < best_score){
4295 best_score= score;
4296 best_level= level - 64;
4297 }
4298 }
4299 block[0]= best_level;
4300 s->coded_score[n] = best_score - dc*dc;
4301 if(best_level == 0) return -1;
4302 else return last_non_zero;
4303 }
4304
4305 i= last_i;
4306 av_assert2(last_level);
4307
4308 block[ perm_scantable[last_non_zero] ]= last_level;
4309 i -= last_run + 1;
4310
4311 for(; i>start_i; i -= run_tab[i] + 1){
4312 block[ perm_scantable[i-1] ]= level_tab[i];
4313 }
4314
4315 return last_non_zero;
4316 }
4317
4318 static int16_t basis[64][64];
4319
build_basis(uint8_t * perm)4320 static void build_basis(uint8_t *perm){
4321 int i, j, x, y;
4322 emms_c();
4323 for(i=0; i<8; i++){
4324 for(j=0; j<8; j++){
4325 for(y=0; y<8; y++){
4326 for(x=0; x<8; x++){
4327 double s= 0.25*(1<<BASIS_SHIFT);
4328 int index= 8*i + j;
4329 int perm_index= perm[index];
4330 if(i==0) s*= sqrt(0.5);
4331 if(j==0) s*= sqrt(0.5);
4332 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
4333 }
4334 }
4335 }
4336 }
4337 }
4338
dct_quantize_refine(MpegEncContext * s,int16_t * block,int16_t * weight,int16_t * orig,int n,int qscale)4339 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4340 int16_t *block, int16_t *weight, int16_t *orig,
4341 int n, int qscale){
4342 int16_t rem[64];
4343 LOCAL_ALIGNED_16(int16_t, d1, [64]);
4344 const uint8_t *scantable;
4345 const uint8_t *perm_scantable;
4346 // unsigned int threshold1, threshold2;
4347 // int bias=0;
4348 int run_tab[65];
4349 int prev_run=0;
4350 int prev_level=0;
4351 int qmul, qadd, start_i, last_non_zero, i, dc;
4352 uint8_t * length;
4353 uint8_t * last_length;
4354 int lambda;
4355 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4356
4357 if(basis[0][0] == 0)
4358 build_basis(s->idsp.idct_permutation);
4359
4360 qmul= qscale*2;
4361 qadd= (qscale-1)|1;
4362 if (s->mb_intra) {
4363 scantable= s->intra_scantable.scantable;
4364 perm_scantable= s->intra_scantable.permutated;
4365 if (!s->h263_aic) {
4366 if (n < 4)
4367 q = s->y_dc_scale;
4368 else
4369 q = s->c_dc_scale;
4370 } else{
4371 /* For AIC we skip quant/dequant of INTRADC */
4372 q = 1;
4373 qadd=0;
4374 }
4375 q <<= RECON_SHIFT-3;
4376 /* note: block[0] is assumed to be positive */
4377 dc= block[0]*q;
4378 // block[0] = (block[0] + (q >> 1)) / q;
4379 start_i = 1;
4380 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4381 // bias= 1<<(QMAT_SHIFT-1);
4382 if (n > 3 && s->intra_chroma_ac_vlc_length) {
4383 length = s->intra_chroma_ac_vlc_length;
4384 last_length= s->intra_chroma_ac_vlc_last_length;
4385 } else {
4386 length = s->intra_ac_vlc_length;
4387 last_length= s->intra_ac_vlc_last_length;
4388 }
4389 } else {
4390 scantable= s->inter_scantable.scantable;
4391 perm_scantable= s->inter_scantable.permutated;
4392 dc= 0;
4393 start_i = 0;
4394 length = s->inter_ac_vlc_length;
4395 last_length= s->inter_ac_vlc_last_length;
4396 }
4397 last_non_zero = s->block_last_index[n];
4398
4399 dc += (1<<(RECON_SHIFT-1));
4400 for(i=0; i<64; i++){
4401 rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4402 }
4403
4404 sum=0;
4405 for(i=0; i<64; i++){
4406 int one= 36;
4407 int qns=4;
4408 int w;
4409
4410 w= FFABS(weight[i]) + qns*one;
4411 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4412
4413 weight[i] = w;
4414 // w=weight[i] = (63*qns + (w/2)) / w;
4415
4416 av_assert2(w>0);
4417 av_assert2(w<(1<<6));
4418 sum += w*w;
4419 }
4420 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4421
4422 run=0;
4423 rle_index=0;
4424 for(i=start_i; i<=last_non_zero; i++){
4425 int j= perm_scantable[i];
4426 const int level= block[j];
4427 int coeff;
4428
4429 if(level){
4430 if(level<0) coeff= qmul*level - qadd;
4431 else coeff= qmul*level + qadd;
4432 run_tab[rle_index++]=run;
4433 run=0;
4434
4435 s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4436 }else{
4437 run++;
4438 }
4439 }
4440
4441 for(;;){
4442 int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4443 int best_coeff=0;
4444 int best_change=0;
4445 int run2, best_unquant_change=0, analyze_gradient;
4446 analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4447
4448 if(analyze_gradient){
4449 for(i=0; i<64; i++){
4450 int w= weight[i];
4451
4452 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4453 }
4454 s->fdsp.fdct(d1);
4455 }
4456
4457 if(start_i){
4458 const int level= block[0];
4459 int change, old_coeff;
4460
4461 av_assert2(s->mb_intra);
4462
4463 old_coeff= q*level;
4464
4465 for(change=-1; change<=1; change+=2){
4466 int new_level= level + change;
4467 int score, new_coeff;
4468
4469 new_coeff= q*new_level;
4470 if(new_coeff >= 2048 || new_coeff < 0)
4471 continue;
4472
4473 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4474 new_coeff - old_coeff);
4475 if(score<best_score){
4476 best_score= score;
4477 best_coeff= 0;
4478 best_change= change;
4479 best_unquant_change= new_coeff - old_coeff;
4480 }
4481 }
4482 }
4483
4484 run=0;
4485 rle_index=0;
4486 run2= run_tab[rle_index++];
4487 prev_level=0;
4488 prev_run=0;
4489
4490 for(i=start_i; i<64; i++){
4491 int j= perm_scantable[i];
4492 const int level= block[j];
4493 int change, old_coeff;
4494
4495 if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4496 break;
4497
4498 if(level){
4499 if(level<0) old_coeff= qmul*level - qadd;
4500 else old_coeff= qmul*level + qadd;
4501 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4502 }else{
4503 old_coeff=0;
4504 run2--;
4505 av_assert2(run2>=0 || i >= last_non_zero );
4506 }
4507
4508 for(change=-1; change<=1; change+=2){
4509 int new_level= level + change;
4510 int score, new_coeff, unquant_change;
4511
4512 score=0;
4513 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4514 continue;
4515
4516 if(new_level){
4517 if(new_level<0) new_coeff= qmul*new_level - qadd;
4518 else new_coeff= qmul*new_level + qadd;
4519 if(new_coeff >= 2048 || new_coeff <= -2048)
4520 continue;
4521 //FIXME check for overflow
4522
4523 if(level){
4524 if(level < 63 && level > -63){
4525 if(i < last_non_zero)
4526 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4527 - length[UNI_AC_ENC_INDEX(run, level+64)];
4528 else
4529 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4530 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4531 }
4532 }else{
4533 av_assert2(FFABS(new_level)==1);
4534
4535 if(analyze_gradient){
4536 int g= d1[ scantable[i] ];
4537 if(g && (g^new_level) >= 0)
4538 continue;
4539 }
4540
4541 if(i < last_non_zero){
4542 int next_i= i + run2 + 1;
4543 int next_level= block[ perm_scantable[next_i] ] + 64;
4544
4545 if(next_level&(~127))
4546 next_level= 0;
4547
4548 if(next_i < last_non_zero)
4549 score += length[UNI_AC_ENC_INDEX(run, 65)]
4550 + length[UNI_AC_ENC_INDEX(run2, next_level)]
4551 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4552 else
4553 score += length[UNI_AC_ENC_INDEX(run, 65)]
4554 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4555 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4556 }else{
4557 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4558 if(prev_level){
4559 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4560 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4561 }
4562 }
4563 }
4564 }else{
4565 new_coeff=0;
4566 av_assert2(FFABS(level)==1);
4567
4568 if(i < last_non_zero){
4569 int next_i= i + run2 + 1;
4570 int next_level= block[ perm_scantable[next_i] ] + 64;
4571
4572 if(next_level&(~127))
4573 next_level= 0;
4574
4575 if(next_i < last_non_zero)
4576 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4577 - length[UNI_AC_ENC_INDEX(run2, next_level)]
4578 - length[UNI_AC_ENC_INDEX(run, 65)];
4579 else
4580 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4581 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4582 - length[UNI_AC_ENC_INDEX(run, 65)];
4583 }else{
4584 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4585 if(prev_level){
4586 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4587 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4588 }
4589 }
4590 }
4591
4592 score *= lambda;
4593
4594 unquant_change= new_coeff - old_coeff;
4595 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4596
4597 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4598 unquant_change);
4599 if(score<best_score){
4600 best_score= score;
4601 best_coeff= i;
4602 best_change= change;
4603 best_unquant_change= unquant_change;
4604 }
4605 }
4606 if(level){
4607 prev_level= level + 64;
4608 if(prev_level&(~127))
4609 prev_level= 0;
4610 prev_run= run;
4611 run=0;
4612 }else{
4613 run++;
4614 }
4615 }
4616
4617 if(best_change){
4618 int j= perm_scantable[ best_coeff ];
4619
4620 block[j] += best_change;
4621
4622 if(best_coeff > last_non_zero){
4623 last_non_zero= best_coeff;
4624 av_assert2(block[j]);
4625 }else{
4626 for(; last_non_zero>=start_i; last_non_zero--){
4627 if(block[perm_scantable[last_non_zero]])
4628 break;
4629 }
4630 }
4631
4632 run=0;
4633 rle_index=0;
4634 for(i=start_i; i<=last_non_zero; i++){
4635 int j= perm_scantable[i];
4636 const int level= block[j];
4637
4638 if(level){
4639 run_tab[rle_index++]=run;
4640 run=0;
4641 }else{
4642 run++;
4643 }
4644 }
4645
4646 s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4647 }else{
4648 break;
4649 }
4650 }
4651
4652 return last_non_zero;
4653 }
4654
4655 /**
4656 * Permute an 8x8 block according to permutation.
4657 * @param block the block which will be permuted according to
4658 * the given permutation vector
4659 * @param permutation the permutation vector
4660 * @param last the last non zero coefficient in scantable order, used to
4661 * speed the permutation up
4662 * @param scantable the used scantable, this is only used to speed the
4663 * permutation up, the block is not (inverse) permutated
4664 * to scantable order!
4665 */
ff_block_permute(int16_t * block,uint8_t * permutation,const uint8_t * scantable,int last)4666 void ff_block_permute(int16_t *block, uint8_t *permutation,
4667 const uint8_t *scantable, int last)
4668 {
4669 int i;
4670 int16_t temp[64];
4671
4672 if (last <= 0)
4673 return;
4674 //FIXME it is ok but not clean and might fail for some permutations
4675 // if (permutation[1] == 1)
4676 // return;
4677
4678 for (i = 0; i <= last; i++) {
4679 const int j = scantable[i];
4680 temp[j] = block[j];
4681 block[j] = 0;
4682 }
4683
4684 for (i = 0; i <= last; i++) {
4685 const int j = scantable[i];
4686 const int perm_j = permutation[j];
4687 block[perm_j] = temp[j];
4688 }
4689 }
4690
ff_dct_quantize_c(MpegEncContext * s,int16_t * block,int n,int qscale,int * overflow)4691 int ff_dct_quantize_c(MpegEncContext *s,
4692 int16_t *block, int n,
4693 int qscale, int *overflow)
4694 {
4695 int i, j, level, last_non_zero, q, start_i;
4696 const int *qmat;
4697 const uint8_t *scantable;
4698 int bias;
4699 int max=0;
4700 unsigned int threshold1, threshold2;
4701
4702 s->fdsp.fdct(block);
4703
4704 if(s->dct_error_sum)
4705 s->denoise_dct(s, block);
4706
4707 if (s->mb_intra) {
4708 scantable= s->intra_scantable.scantable;
4709 if (!s->h263_aic) {
4710 if (n < 4)
4711 q = s->y_dc_scale;
4712 else
4713 q = s->c_dc_scale;
4714 q = q << 3;
4715 } else
4716 /* For AIC we skip quant/dequant of INTRADC */
4717 q = 1 << 3;
4718
4719 /* note: block[0] is assumed to be positive */
4720 block[0] = (block[0] + (q >> 1)) / q;
4721 start_i = 1;
4722 last_non_zero = 0;
4723 qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4724 bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4725 } else {
4726 scantable= s->inter_scantable.scantable;
4727 start_i = 0;
4728 last_non_zero = -1;
4729 qmat = s->q_inter_matrix[qscale];
4730 bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4731 }
4732 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4733 threshold2= (threshold1<<1);
4734 for(i=63;i>=start_i;i--) {
4735 j = scantable[i];
4736 level = block[j] * qmat[j];
4737
4738 if(((unsigned)(level+threshold1))>threshold2){
4739 last_non_zero = i;
4740 break;
4741 }else{
4742 block[j]=0;
4743 }
4744 }
4745 for(i=start_i; i<=last_non_zero; i++) {
4746 j = scantable[i];
4747 level = block[j] * qmat[j];
4748
4749 // if( bias+level >= (1<<QMAT_SHIFT)
4750 // || bias-level >= (1<<QMAT_SHIFT)){
4751 if(((unsigned)(level+threshold1))>threshold2){
4752 if(level>0){
4753 level= (bias + level)>>QMAT_SHIFT;
4754 block[j]= level;
4755 }else{
4756 level= (bias - level)>>QMAT_SHIFT;
4757 block[j]= -level;
4758 }
4759 max |=level;
4760 }else{
4761 block[j]=0;
4762 }
4763 }
4764 *overflow= s->max_qcoeff < max; //overflow might have happened
4765
4766 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4767 if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4768 ff_block_permute(block, s->idsp.idct_permutation,
4769 scantable, last_non_zero);
4770
4771 return last_non_zero;
4772 }
4773
4774 #define OFFSET(x) offsetof(MpegEncContext, x)
4775 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4776 static const AVOption h263_options[] = {
4777 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4778 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4779 FF_MPV_COMMON_OPTS
4780 { NULL },
4781 };
4782
4783 static const AVClass h263_class = {
4784 .class_name = "H.263 encoder",
4785 .item_name = av_default_item_name,
4786 .option = h263_options,
4787 .version = LIBAVUTIL_VERSION_INT,
4788 };
4789
4790 AVCodec ff_h263_encoder = {
4791 .name = "h263",
4792 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4793 .type = AVMEDIA_TYPE_VIDEO,
4794 .id = AV_CODEC_ID_H263,
4795 .priv_data_size = sizeof(MpegEncContext),
4796 .init = ff_mpv_encode_init,
4797 .encode2 = ff_mpv_encode_picture,
4798 .close = ff_mpv_encode_end,
4799 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
4800 .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4801 .priv_class = &h263_class,
4802 };
4803
4804 static const AVOption h263p_options[] = {
4805 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4806 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4807 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4808 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
4809 FF_MPV_COMMON_OPTS
4810 { NULL },
4811 };
4812 static const AVClass h263p_class = {
4813 .class_name = "H.263p encoder",
4814 .item_name = av_default_item_name,
4815 .option = h263p_options,
4816 .version = LIBAVUTIL_VERSION_INT,
4817 };
4818
4819 AVCodec ff_h263p_encoder = {
4820 .name = "h263p",
4821 .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4822 .type = AVMEDIA_TYPE_VIDEO,
4823 .id = AV_CODEC_ID_H263P,
4824 .priv_data_size = sizeof(MpegEncContext),
4825 .init = ff_mpv_encode_init,
4826 .encode2 = ff_mpv_encode_picture,
4827 .close = ff_mpv_encode_end,
4828 .capabilities = AV_CODEC_CAP_SLICE_THREADS,
4829 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
4830 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4831 .priv_class = &h263p_class,
4832 };
4833
4834 static const AVClass msmpeg4v2_class = {
4835 .class_name = "msmpeg4v2 encoder",
4836 .item_name = av_default_item_name,
4837 .option = ff_mpv_generic_options,
4838 .version = LIBAVUTIL_VERSION_INT,
4839 };
4840
4841 AVCodec ff_msmpeg4v2_encoder = {
4842 .name = "msmpeg4v2",
4843 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4844 .type = AVMEDIA_TYPE_VIDEO,
4845 .id = AV_CODEC_ID_MSMPEG4V2,
4846 .priv_data_size = sizeof(MpegEncContext),
4847 .init = ff_mpv_encode_init,
4848 .encode2 = ff_mpv_encode_picture,
4849 .close = ff_mpv_encode_end,
4850 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
4851 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4852 .priv_class = &msmpeg4v2_class,
4853 };
4854
4855 static const AVClass msmpeg4v3_class = {
4856 .class_name = "msmpeg4v3 encoder",
4857 .item_name = av_default_item_name,
4858 .option = ff_mpv_generic_options,
4859 .version = LIBAVUTIL_VERSION_INT,
4860 };
4861
4862 AVCodec ff_msmpeg4v3_encoder = {
4863 .name = "msmpeg4",
4864 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4865 .type = AVMEDIA_TYPE_VIDEO,
4866 .id = AV_CODEC_ID_MSMPEG4V3,
4867 .priv_data_size = sizeof(MpegEncContext),
4868 .init = ff_mpv_encode_init,
4869 .encode2 = ff_mpv_encode_picture,
4870 .close = ff_mpv_encode_end,
4871 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
4872 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4873 .priv_class = &msmpeg4v3_class,
4874 };
4875
4876 static const AVClass wmv1_class = {
4877 .class_name = "wmv1 encoder",
4878 .item_name = av_default_item_name,
4879 .option = ff_mpv_generic_options,
4880 .version = LIBAVUTIL_VERSION_INT,
4881 };
4882
4883 AVCodec ff_wmv1_encoder = {
4884 .name = "wmv1",
4885 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4886 .type = AVMEDIA_TYPE_VIDEO,
4887 .id = AV_CODEC_ID_WMV1,
4888 .priv_data_size = sizeof(MpegEncContext),
4889 .init = ff_mpv_encode_init,
4890 .encode2 = ff_mpv_encode_picture,
4891 .close = ff_mpv_encode_end,
4892 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
4893 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4894 .priv_class = &wmv1_class,
4895 };
4896