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