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