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