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