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