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