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