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  /* MPEG-1/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  emms_c();
1324  }
1325  }
1326  ret = av_frame_copy_props(pic->f, pic_arg);
1327  if (ret < 0)
1328  return ret;
1329 
1330  pic->f->display_picture_number = display_picture_number;
1331  pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1332  } else {
1333  /* Flushing: When we have not received enough input frames,
1334  * ensure s->input_picture[0] contains the first picture */
1335  for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1336  if (s->input_picture[flush_offset])
1337  break;
1338 
1339  if (flush_offset <= 1)
1340  flush_offset = 1;
1341  else
1342  encoding_delay = encoding_delay - flush_offset + 1;
1343  }
1344 
1345  /* shift buffer entries */
1346  for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1347  s->input_picture[i - flush_offset] = s->input_picture[i];
1348 
1349  s->input_picture[encoding_delay] = (Picture*) pic;
1350 
1351  return 0;
1352 }
1353 
1355 {
1356  int x, y, plane;
1357  int score = 0;
1358  int64_t score64 = 0;
1359 
1360  for (plane = 0; plane < 3; plane++) {
1361  const int stride = p->f->linesize[plane];
1362  const int bw = plane ? 1 : 2;
1363  for (y = 0; y < s->mb_height * bw; y++) {
1364  for (x = 0; x < s->mb_width * bw; x++) {
1365  int off = p->shared ? 0 : 16;
1366  uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1367  uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1368  int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1369 
1370  switch (FFABS(s->frame_skip_exp)) {
1371  case 0: score = FFMAX(score, v); break;
1372  case 1: score += FFABS(v); break;
1373  case 2: score64 += v * (int64_t)v; break;
1374  case 3: score64 += FFABS(v * (int64_t)v * v); break;
1375  case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1376  }
1377  }
1378  }
1379  }
1380  emms_c();
1381 
1382  if (score)
1383  score64 = score;
1384  if (s->frame_skip_exp < 0)
1385  score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1386  -1.0/s->frame_skip_exp);
1387 
1388  if (score64 < s->frame_skip_threshold)
1389  return 1;
1390  if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1391  return 1;
1392  return 0;
1393 }
1394 
1396 {
1397  AVPacket pkt = { 0 };
1398  int ret, got_output;
1399 
1400  av_init_packet(&pkt);
1401  ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1402  if (ret < 0)
1403  return ret;
1404 
1405  ret = pkt.size;
1406  av_packet_unref(&pkt);
1407  return ret;
1408 }
1409 
1411 {
1414  const int scale = s->brd_scale;
1415  int i, j, out_size, p_lambda, b_lambda, lambda2;
1416  int64_t best_rd = INT64_MAX;
1417  int best_b_count = -1;
1418 
1419  if (!c)
1420  return AVERROR(ENOMEM);
1421  av_assert0(scale >= 0 && scale <= 3);
1422 
1423  //emms_c();
1424  //s->next_picture_ptr->quality;
1425  p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1426  //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1427  b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1428  if (!b_lambda) // FIXME we should do this somewhere else
1429  b_lambda = p_lambda;
1430  lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1432 
1433  c->width = s->width >> scale;
1434  c->height = s->height >> scale;
1436  c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1437  c->mb_decision = s->avctx->mb_decision;
1438  c->me_cmp = s->avctx->me_cmp;
1439  c->mb_cmp = s->avctx->mb_cmp;
1440  c->me_sub_cmp = s->avctx->me_sub_cmp;
1442  c->time_base = s->avctx->time_base;
1443  c->max_b_frames = s->max_b_frames;
1444 
1445  if (avcodec_open2(c, codec, NULL) < 0)
1446  return -1;
1447 
1448  for (i = 0; i < s->max_b_frames + 2; i++) {
1449  Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1450  s->next_picture_ptr;
1451  uint8_t *data[4];
1452 
1453  if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1454  pre_input = *pre_input_ptr;
1455  memcpy(data, pre_input_ptr->f->data, sizeof(data));
1456 
1457  if (!pre_input.shared && i) {
1458  data[0] += INPLACE_OFFSET;
1459  data[1] += INPLACE_OFFSET;
1460  data[2] += INPLACE_OFFSET;
1461  }
1462 
1463  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1464  s->tmp_frames[i]->linesize[0],
1465  data[0],
1466  pre_input.f->linesize[0],
1467  c->width, c->height);
1468  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1469  s->tmp_frames[i]->linesize[1],
1470  data[1],
1471  pre_input.f->linesize[1],
1472  c->width >> 1, c->height >> 1);
1473  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1474  s->tmp_frames[i]->linesize[2],
1475  data[2],
1476  pre_input.f->linesize[2],
1477  c->width >> 1, c->height >> 1);
1478  }
1479  }
1480 
1481  for (j = 0; j < s->max_b_frames + 1; j++) {
1482  int64_t rd = 0;
1483 
1484  if (!s->input_picture[j])
1485  break;
1486 
1487  c->error[0] = c->error[1] = c->error[2] = 0;
1488 
1490  s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1491 
1492  out_size = encode_frame(c, s->tmp_frames[0]);
1493 
1494  //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1495 
1496  for (i = 0; i < s->max_b_frames + 1; i++) {
1497  int is_p = i % (j + 1) == j || i == s->max_b_frames;
1498 
1499  s->tmp_frames[i + 1]->pict_type = is_p ?
1501  s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1502 
1503  out_size = encode_frame(c, s->tmp_frames[i + 1]);
1504 
1505  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1506  }
1507 
1508  /* get the delayed frames */
1509  while (out_size) {
1510  out_size = encode_frame(c, NULL);
1511  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1512  }
1513 
1514  rd += c->error[0] + c->error[1] + c->error[2];
1515 
1516  if (rd < best_rd) {
1517  best_rd = rd;
1518  best_b_count = j;
1519  }
1520  }
1521 
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 the 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 modify it -> allocate 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
1742 #endif
1743 #if FF_API_ERROR_FRAME
1746  sizeof(s->current_picture.encoding_error));
1748 #endif
1749 }
1750 
1752 {
1753  int intra, i;
1754 
1755  for (intra = 0; intra < 2; intra++) {
1756  if (s->dct_count[intra] > (1 << 16)) {
1757  for (i = 0; i < 64; i++) {
1758  s->dct_error_sum[intra][i] >>= 1;
1759  }
1760  s->dct_count[intra] >>= 1;
1761  }
1762 
1763  for (i = 0; i < 64; i++) {
1764  s->dct_offset[intra][i] = (s->noise_reduction *
1765  s->dct_count[intra] +
1766  s->dct_error_sum[intra][i] / 2) /
1767  (s->dct_error_sum[intra][i] + 1);
1768  }
1769  }
1770 }
1771 
1773 {
1774  int ret;
1775 
1776  /* mark & release old frames */
1777  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1779  s->last_picture_ptr->f->buf[0]) {
1781  }
1782 
1785 
1787  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1788  s->current_picture_ptr)) < 0)
1789  return ret;
1790 
1791  if (s->pict_type != AV_PICTURE_TYPE_B) {
1793  if (!s->droppable)
1795  }
1796 
1797  if (s->last_picture_ptr) {
1799  if (s->last_picture_ptr->f->buf[0] &&
1800  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1801  s->last_picture_ptr)) < 0)
1802  return ret;
1803  }
1804  if (s->next_picture_ptr) {
1806  if (s->next_picture_ptr->f->buf[0] &&
1807  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1808  s->next_picture_ptr)) < 0)
1809  return ret;
1810  }
1811 
1812  if (s->picture_structure!= PICT_FRAME) {
1813  int i;
1814  for (i = 0; i < 4; i++) {
1816  s->current_picture.f->data[i] +=
1817  s->current_picture.f->linesize[i];
1818  }
1819  s->current_picture.f->linesize[i] *= 2;
1820  s->last_picture.f->linesize[i] *= 2;
1821  s->next_picture.f->linesize[i] *= 2;
1822  }
1823  }
1824 
1825  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1828  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1831  } else {
1834  }
1835 
1836  if (s->dct_error_sum) {
1839  }
1840 
1841  return 0;
1842 }
1843 
1845  const AVFrame *pic_arg, int *got_packet)
1846 {
1847  MpegEncContext *s = avctx->priv_data;
1848  int i, stuffing_count, ret;
1849  int context_count = s->slice_context_count;
1850 
1851  s->vbv_ignore_qmax = 0;
1852 
1853  s->picture_in_gop_number++;
1854 
1855  if (load_input_picture(s, pic_arg) < 0)
1856  return -1;
1857 
1858  if (select_input_picture(s) < 0) {
1859  return -1;
1860  }
1861 
1862  /* output? */
1863  if (s->new_picture.f->data[0]) {
1864  int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1865  int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1866  :
1867  s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1868  if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1869  return ret;
1870  if (s->mb_info) {
1873  s->mb_width*s->mb_height*12);
1874  s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1875  }
1876 
1877  for (i = 0; i < context_count; i++) {
1878  int start_y = s->thread_context[i]->start_mb_y;
1879  int end_y = s->thread_context[i]-> end_mb_y;
1880  int h = s->mb_height;
1881  uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1882  uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1883 
1884  init_put_bits(&s->thread_context[i]->pb, start, end - start);
1885  }
1886 
1887  s->pict_type = s->new_picture.f->pict_type;
1888  //emms_c();
1889  ret = frame_start(s);
1890  if (ret < 0)
1891  return ret;
1892 vbv_retry:
1893  ret = encode_picture(s, s->picture_number);
1894  if (growing_buffer) {
1895  av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1896  pkt->data = s->pb.buf;
1897  pkt->size = avctx->internal->byte_buffer_size;
1898  }
1899  if (ret < 0)
1900  return -1;
1901 
1902 #if FF_API_STAT_BITS
1904  avctx->header_bits = s->header_bits;
1905  avctx->mv_bits = s->mv_bits;
1906  avctx->misc_bits = s->misc_bits;
1907  avctx->i_tex_bits = s->i_tex_bits;
1908  avctx->p_tex_bits = s->p_tex_bits;
1909  avctx->i_count = s->i_count;
1910  // FIXME f/b_count in avctx
1911  avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1912  avctx->skip_count = s->skip_count;
1914 #endif
1915 
1916  frame_end(s);
1917 
1918  if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1920 
1921  if (avctx->rc_buffer_size) {
1922  RateControlContext *rcc = &s->rc_context;
1923  int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1924  int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1925  int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1926 
1927  if (put_bits_count(&s->pb) > max_size &&
1928  s->lambda < s->lmax) {
1929  s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1930  (s->qscale + 1) / s->qscale);
1931  if (s->adaptive_quant) {
1932  int i;
1933  for (i = 0; i < s->mb_height * s->mb_stride; i++)
1934  s->lambda_table[i] =
1935  FFMAX(s->lambda_table[i] + min_step,
1936  s->lambda_table[i] * (s->qscale + 1) /
1937  s->qscale);
1938  }
1939  s->mb_skipped = 0; // done in frame_start()
1940  // done in encode_picture() so we must undo it
1941  if (s->pict_type == AV_PICTURE_TYPE_P) {
1942  if (s->flipflop_rounding ||
1943  s->codec_id == AV_CODEC_ID_H263P ||
1945  s->no_rounding ^= 1;
1946  }
1947  if (s->pict_type != AV_PICTURE_TYPE_B) {
1948  s->time_base = s->last_time_base;
1949  s->last_non_b_time = s->time - s->pp_time;
1950  }
1951  for (i = 0; i < context_count; i++) {
1952  PutBitContext *pb = &s->thread_context[i]->pb;
1953  init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1954  }
1955  s->vbv_ignore_qmax = 1;
1956  av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1957  goto vbv_retry;
1958  }
1959 
1961  }
1962 
1963  if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1965 
1966  for (i = 0; i < 4; i++) {
1968  avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1969  }
1972  (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1973  s->pict_type);
1974 
1975  if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1976  assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1977  s->misc_bits + s->i_tex_bits +
1978  s->p_tex_bits);
1979  flush_put_bits(&s->pb);
1980  s->frame_bits = put_bits_count(&s->pb);
1981 
1982  stuffing_count = ff_vbv_update(s, s->frame_bits);
1983  s->stuffing_bits = 8*stuffing_count;
1984  if (stuffing_count) {
1985  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1986  stuffing_count + 50) {
1987  av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1988  return -1;
1989  }
1990 
1991  switch (s->codec_id) {
1994  while (stuffing_count--) {
1995  put_bits(&s->pb, 8, 0);
1996  }
1997  break;
1998  case AV_CODEC_ID_MPEG4:
1999  put_bits(&s->pb, 16, 0);
2000  put_bits(&s->pb, 16, 0x1C3);
2001  stuffing_count -= 4;
2002  while (stuffing_count--) {
2003  put_bits(&s->pb, 8, 0xFF);
2004  }
2005  break;
2006  default:
2007  av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2008  }
2009  flush_put_bits(&s->pb);
2010  s->frame_bits = put_bits_count(&s->pb);
2011  }
2012 
2013  /* update MPEG-1/2 vbv_delay for CBR */
2014  if (s->avctx->rc_max_rate &&
2015  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
2016  s->out_format == FMT_MPEG1 &&
2017  90000LL * (avctx->rc_buffer_size - 1) <=
2018  s->avctx->rc_max_rate * 0xFFFFLL) {
2019  AVCPBProperties *props;
2020  size_t props_size;
2021 
2022  int vbv_delay, min_delay;
2023  double inbits = s->avctx->rc_max_rate *
2024  av_q2d(s->avctx->time_base);
2025  int minbits = s->frame_bits - 8 *
2026  (s->vbv_delay_ptr - s->pb.buf - 1);
2027  double bits = s->rc_context.buffer_index + minbits - inbits;
2028 
2029  if (bits < 0)
2031  "Internal error, negative bits\n");
2032 
2033  assert(s->repeat_first_field == 0);
2034 
2035  vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
2036  min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
2037  s->avctx->rc_max_rate;
2038 
2039  vbv_delay = FFMAX(vbv_delay, min_delay);
2040 
2041  av_assert0(vbv_delay < 0xFFFF);
2042 
2043  s->vbv_delay_ptr[0] &= 0xF8;
2044  s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2045  s->vbv_delay_ptr[1] = vbv_delay >> 5;
2046  s->vbv_delay_ptr[2] &= 0x07;
2047  s->vbv_delay_ptr[2] |= vbv_delay << 3;
2048 
2049  props = av_cpb_properties_alloc(&props_size);
2050  if (!props)
2051  return AVERROR(ENOMEM);
2052  props->vbv_delay = vbv_delay * 300;
2053 
2055  (uint8_t*)props, props_size);
2056  if (ret < 0) {
2057  av_freep(&props);
2058  return ret;
2059  }
2060 
2061 #if FF_API_VBV_DELAY
2063  avctx->vbv_delay = vbv_delay * 300;
2065 #endif
2066  }
2067  s->total_bits += s->frame_bits;
2068 #if FF_API_STAT_BITS
2070  avctx->frame_bits = s->frame_bits;
2072 #endif
2073 
2074 
2075  pkt->pts = s->current_picture.f->pts;
2076  if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2078  pkt->dts = pkt->pts - s->dts_delta;
2079  else
2080  pkt->dts = s->reordered_pts;
2081  s->reordered_pts = pkt->pts;
2082  } else
2083  pkt->dts = pkt->pts;
2084  if (s->current_picture.f->key_frame)
2085  pkt->flags |= AV_PKT_FLAG_KEY;
2086  if (s->mb_info)
2088  } else {
2089  s->frame_bits = 0;
2090  }
2091 
2092  /* release non-reference frames */
2093  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2094  if (!s->picture[i].reference)
2095  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2096  }
2097 
2098  av_assert1((s->frame_bits & 7) == 0);
2099 
2100  pkt->size = s->frame_bits / 8;
2101  *got_packet = !!pkt->size;
2102  return 0;
2103 }
2104 
2106  int n, int threshold)
2107 {
2108  static const char tab[64] = {
2109  3, 2, 2, 1, 1, 1, 1, 1,
2110  1, 1, 1, 1, 1, 1, 1, 1,
2111  1, 1, 1, 1, 1, 1, 1, 1,
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  0, 0, 0, 0, 0, 0, 0, 0
2117  };
2118  int score = 0;
2119  int run = 0;
2120  int i;
2121  int16_t *block = s->block[n];
2122  const int last_index = s->block_last_index[n];
2123  int skip_dc;
2124 
2125  if (threshold < 0) {
2126  skip_dc = 0;
2127  threshold = -threshold;
2128  } else
2129  skip_dc = 1;
2130 
2131  /* Are all we could set to zero already zero? */
2132  if (last_index <= skip_dc - 1)
2133  return;
2134 
2135  for (i = 0; i <= last_index; i++) {
2136  const int j = s->intra_scantable.permutated[i];
2137  const int level = FFABS(block[j]);
2138  if (level == 1) {
2139  if (skip_dc && i == 0)
2140  continue;
2141  score += tab[run];
2142  run = 0;
2143  } else if (level > 1) {
2144  return;
2145  } else {
2146  run++;
2147  }
2148  }
2149  if (score >= threshold)
2150  return;
2151  for (i = skip_dc; i <= last_index; i++) {
2152  const int j = s->intra_scantable.permutated[i];
2153  block[j] = 0;
2154  }
2155  if (block[0])
2156  s->block_last_index[n] = 0;
2157  else
2158  s->block_last_index[n] = -1;
2159 }
2160 
2161 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2162  int last_index)
2163 {
2164  int i;
2165  const int maxlevel = s->max_qcoeff;
2166  const int minlevel = s->min_qcoeff;
2167  int overflow = 0;
2168 
2169  if (s->mb_intra) {
2170  i = 1; // skip clipping of intra dc
2171  } else
2172  i = 0;
2173 
2174  for (; i <= last_index; i++) {
2175  const int j = s->intra_scantable.permutated[i];
2176  int level = block[j];
2177 
2178  if (level > maxlevel) {
2179  level = maxlevel;
2180  overflow++;
2181  } else if (level < minlevel) {
2182  level = minlevel;
2183  overflow++;
2184  }
2185 
2186  block[j] = level;
2187  }
2188 
2189  if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2190  av_log(s->avctx, AV_LOG_INFO,
2191  "warning, clipping %d dct coefficients to %d..%d\n",
2192  overflow, minlevel, maxlevel);
2193 }
2194 
2195 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2196 {
2197  int x, y;
2198  // FIXME optimize
2199  for (y = 0; y < 8; y++) {
2200  for (x = 0; x < 8; x++) {
2201  int x2, y2;
2202  int sum = 0;
2203  int sqr = 0;
2204  int count = 0;
2205 
2206  for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2207  for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2208  int v = ptr[x2 + y2 * stride];
2209  sum += v;
2210  sqr += v * v;
2211  count++;
2212  }
2213  }
2214  weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2215  }
2216  }
2217 }
2218 
2220  int motion_x, int motion_y,
2221  int mb_block_height,
2222  int mb_block_width,
2223  int mb_block_count)
2224 {
2225  int16_t weight[12][64];
2226  int16_t orig[12][64];
2227  const int mb_x = s->mb_x;
2228  const int mb_y = s->mb_y;
2229  int i;
2230  int skip_dct[12];
2231  int dct_offset = s->linesize * 8; // default for progressive frames
2232  int uv_dct_offset = s->uvlinesize * 8;
2233  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2234  ptrdiff_t wrap_y, wrap_c;
2235 
2236  for (i = 0; i < mb_block_count; i++)
2237  skip_dct[i] = s->skipdct;
2238 
2239  if (s->adaptive_quant) {
2240  const int last_qp = s->qscale;
2241  const int mb_xy = mb_x + mb_y * s->mb_stride;
2242 
2243  s->lambda = s->lambda_table[mb_xy];
2244  update_qscale(s);
2245 
2246  if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2247  s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2248  s->dquant = s->qscale - last_qp;
2249 
2250  if (s->out_format == FMT_H263) {
2251  s->dquant = av_clip(s->dquant, -2, 2);
2252 
2253  if (s->codec_id == AV_CODEC_ID_MPEG4) {
2254  if (!s->mb_intra) {
2255  if (s->pict_type == AV_PICTURE_TYPE_B) {
2256  if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2257  s->dquant = 0;
2258  }
2259  if (s->mv_type == MV_TYPE_8X8)
2260  s->dquant = 0;
2261  }
2262  }
2263  }
2264  }
2265  ff_set_qscale(s, last_qp + s->dquant);
2266  } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2267  ff_set_qscale(s, s->qscale + s->dquant);
2268 
2269  wrap_y = s->linesize;
2270  wrap_c = s->uvlinesize;
2271  ptr_y = s->new_picture.f->data[0] +
2272  (mb_y * 16 * wrap_y) + mb_x * 16;
2273  ptr_cb = s->new_picture.f->data[1] +
2274  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2275  ptr_cr = s->new_picture.f->data[2] +
2276  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2277 
2278  if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2279  uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2280  int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2281  int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2282  s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2283  wrap_y, wrap_y,
2284  16, 16, mb_x * 16, mb_y * 16,
2285  s->width, s->height);
2286  ptr_y = ebuf;
2287  s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2288  wrap_c, wrap_c,
2289  mb_block_width, mb_block_height,
2290  mb_x * mb_block_width, mb_y * mb_block_height,
2291  cw, ch);
2292  ptr_cb = ebuf + 16 * wrap_y;
2293  s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2294  wrap_c, wrap_c,
2295  mb_block_width, mb_block_height,
2296  mb_x * mb_block_width, mb_y * mb_block_height,
2297  cw, ch);
2298  ptr_cr = ebuf + 16 * wrap_y + 16;
2299  }
2300 
2301  if (s->mb_intra) {
2303  int progressive_score, interlaced_score;
2304 
2305  s->interlaced_dct = 0;
2306  progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2307  s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2308  NULL, wrap_y, 8) - 400;
2309 
2310  if (progressive_score > 0) {
2311  interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2312  NULL, wrap_y * 2, 8) +
2313  s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2314  NULL, wrap_y * 2, 8);
2315  if (progressive_score > interlaced_score) {
2316  s->interlaced_dct = 1;
2317 
2318  dct_offset = wrap_y;
2319  uv_dct_offset = wrap_c;
2320  wrap_y <<= 1;
2321  if (s->chroma_format == CHROMA_422 ||
2322  s->chroma_format == CHROMA_444)
2323  wrap_c <<= 1;
2324  }
2325  }
2326  }
2327 
2328  s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2329  s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2330  s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2331  s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2332 
2333  if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2334  skip_dct[4] = 1;
2335  skip_dct[5] = 1;
2336  } else {
2337  s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2338  s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2339  if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2340  s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2341  s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2342  } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2343  s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2344  s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2345  s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2346  s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2347  s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2348  s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2349  }
2350  }
2351  } else {
2352  op_pixels_func (*op_pix)[4];
2353  qpel_mc_func (*op_qpix)[16];
2354  uint8_t *dest_y, *dest_cb, *dest_cr;
2355 
2356  dest_y = s->dest[0];
2357  dest_cb = s->dest[1];
2358  dest_cr = s->dest[2];
2359 
2360  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2361  op_pix = s->hdsp.put_pixels_tab;
2362  op_qpix = s->qdsp.put_qpel_pixels_tab;
2363  } else {
2364  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2365  op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2366  }
2367 
2368  if (s->mv_dir & MV_DIR_FORWARD) {
2369  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2370  s->last_picture.f->data,
2371  op_pix, op_qpix);
2372  op_pix = s->hdsp.avg_pixels_tab;
2373  op_qpix = s->qdsp.avg_qpel_pixels_tab;
2374  }
2375  if (s->mv_dir & MV_DIR_BACKWARD) {
2376  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2377  s->next_picture.f->data,
2378  op_pix, op_qpix);
2379  }
2380 
2382  int progressive_score, interlaced_score;
2383 
2384  s->interlaced_dct = 0;
2385  progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2386  s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2387  ptr_y + wrap_y * 8,
2388  wrap_y, 8) - 400;
2389 
2390  if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2391  progressive_score -= 400;
2392 
2393  if (progressive_score > 0) {
2394  interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2395  wrap_y * 2, 8) +
2396  s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2397  ptr_y + wrap_y,
2398  wrap_y * 2, 8);
2399 
2400  if (progressive_score > interlaced_score) {
2401  s->interlaced_dct = 1;
2402 
2403  dct_offset = wrap_y;
2404  uv_dct_offset = wrap_c;
2405  wrap_y <<= 1;
2406  if (s->chroma_format == CHROMA_422)
2407  wrap_c <<= 1;
2408  }
2409  }
2410  }
2411 
2412  s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2413  s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2414  s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2415  dest_y + dct_offset, wrap_y);
2416  s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2417  dest_y + dct_offset + 8, wrap_y);
2418 
2419  if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2420  skip_dct[4] = 1;
2421  skip_dct[5] = 1;
2422  } else {
2423  s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2424  s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2425  if (!s->chroma_y_shift) { /* 422 */
2426  s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2427  dest_cb + uv_dct_offset, wrap_c);
2428  s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2429  dest_cr + uv_dct_offset, wrap_c);
2430  }
2431  }
2432  /* pre quantization */
2433  if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2434  2 * s->qscale * s->qscale) {
2435  // FIXME optimize
2436  if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2437  skip_dct[0] = 1;
2438  if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2439  skip_dct[1] = 1;
2440  if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2441  wrap_y, 8) < 20 * s->qscale)
2442  skip_dct[2] = 1;
2443  if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2444  wrap_y, 8) < 20 * s->qscale)
2445  skip_dct[3] = 1;
2446  if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2447  skip_dct[4] = 1;
2448  if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2449  skip_dct[5] = 1;
2450  if (!s->chroma_y_shift) { /* 422 */
2451  if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2452  dest_cb + uv_dct_offset,
2453  wrap_c, 8) < 20 * s->qscale)
2454  skip_dct[6] = 1;
2455  if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2456  dest_cr + uv_dct_offset,
2457  wrap_c, 8) < 20 * s->qscale)
2458  skip_dct[7] = 1;
2459  }
2460  }
2461  }
2462 
2463  if (s->quantizer_noise_shaping) {
2464  if (!skip_dct[0])
2465  get_visual_weight(weight[0], ptr_y , wrap_y);
2466  if (!skip_dct[1])
2467  get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2468  if (!skip_dct[2])
2469  get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2470  if (!skip_dct[3])
2471  get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2472  if (!skip_dct[4])
2473  get_visual_weight(weight[4], ptr_cb , wrap_c);
2474  if (!skip_dct[5])
2475  get_visual_weight(weight[5], ptr_cr , wrap_c);
2476  if (!s->chroma_y_shift) { /* 422 */
2477  if (!skip_dct[6])
2478  get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2479  wrap_c);
2480  if (!skip_dct[7])
2481  get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2482  wrap_c);
2483  }
2484  memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2485  }
2486 
2487  /* DCT & quantize */
2488  av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2489  {
2490  for (i = 0; i < mb_block_count; i++) {
2491  if (!skip_dct[i]) {
2492  int overflow;
2493  s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2494  // FIXME we could decide to change to quantizer instead of
2495  // clipping
2496  // JS: I don't think that would be a good idea it could lower
2497  // quality instead of improve it. Just INTRADC clipping
2498  // deserves changes in quantizer
2499  if (overflow)
2500  clip_coeffs(s, s->block[i], s->block_last_index[i]);
2501  } else
2502  s->block_last_index[i] = -1;
2503  }
2504  if (s->quantizer_noise_shaping) {
2505  for (i = 0; i < mb_block_count; i++) {
2506  if (!skip_dct[i]) {
2507  s->block_last_index[i] =
2508  dct_quantize_refine(s, s->block[i], weight[i],
2509  orig[i], i, s->qscale);
2510  }
2511  }
2512  }
2513 
2514  if (s->luma_elim_threshold && !s->mb_intra)
2515  for (i = 0; i < 4; i++)
2517  if (s->chroma_elim_threshold && !s->mb_intra)
2518  for (i = 4; i < mb_block_count; i++)
2520 
2521  if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2522  for (i = 0; i < mb_block_count; i++) {
2523  if (s->block_last_index[i] == -1)
2524  s->coded_score[i] = INT_MAX / 256;
2525  }
2526  }
2527  }
2528 
2529  if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2530  s->block_last_index[4] =
2531  s->block_last_index[5] = 0;
2532  s->block[4][0] =
2533  s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2534  if (!s->chroma_y_shift) { /* 422 / 444 */
2535  for (i=6; i<12; i++) {
2536  s->block_last_index[i] = 0;
2537  s->block[i][0] = s->block[4][0];
2538  }
2539  }
2540  }
2541 
2542  // non c quantize code returns incorrect block_last_index FIXME
2543  if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2544  for (i = 0; i < mb_block_count; i++) {
2545  int j;
2546  if (s->block_last_index[i] > 0) {
2547  for (j = 63; j > 0; j--) {
2548  if (s->block[i][s->intra_scantable.permutated[j]])
2549  break;
2550  }
2551  s->block_last_index[i] = j;
2552  }
2553  }
2554  }
2555 
2556  /* huffman encode */
2557  switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2560  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2561  ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2562  break;
2563  case AV_CODEC_ID_MPEG4:
2564  if (CONFIG_MPEG4_ENCODER)
2565  ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2566  break;
2567  case AV_CODEC_ID_MSMPEG4V2:
2568  case AV_CODEC_ID_MSMPEG4V3:
2569  case AV_CODEC_ID_WMV1:
2571  ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2572  break;
2573  case AV_CODEC_ID_WMV2:
2574  if (CONFIG_WMV2_ENCODER)
2575  ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2576  break;
2577  case AV_CODEC_ID_H261:
2578  if (CONFIG_H261_ENCODER)
2579  ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2580  break;
2581  case AV_CODEC_ID_H263:
2582  case AV_CODEC_ID_H263P:
2583  case AV_CODEC_ID_FLV1:
2584  case AV_CODEC_ID_RV10:
2585  case AV_CODEC_ID_RV20:
2586  if (CONFIG_H263_ENCODER)
2587  ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2588  break;
2589  case AV_CODEC_ID_MJPEG:
2590  case AV_CODEC_ID_AMV:
2591  if (CONFIG_MJPEG_ENCODER)
2592  ff_mjpeg_encode_mb(s, s->block);
2593  break;
2594  default:
2595  av_assert1(0);
2596  }
2597 }
2598 
2599 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2600 {
2601  if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2602  else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2603  else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2604 }
2605 
2607  int i;
2608 
2609  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2610 
2611  /* MPEG-1 */
2612  d->mb_skip_run= s->mb_skip_run;
2613  for(i=0; i<3; i++)
2614  d->last_dc[i] = s->last_dc[i];
2615 
2616  /* statistics */
2617  d->mv_bits= s->mv_bits;
2618  d->i_tex_bits= s->i_tex_bits;
2619  d->p_tex_bits= s->p_tex_bits;
2620  d->i_count= s->i_count;
2621  d->f_count= s->f_count;
2622  d->b_count= s->b_count;
2623  d->skip_count= s->skip_count;
2624  d->misc_bits= s->misc_bits;
2625  d->last_bits= 0;
2626 
2627  d->mb_skipped= 0;
2628  d->qscale= s->qscale;
2629  d->dquant= s->dquant;
2630 
2632 }
2633 
2635  int i;
2636 
2637  memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2638  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2639 
2640  /* MPEG-1 */
2641  d->mb_skip_run= s->mb_skip_run;
2642  for(i=0; i<3; i++)
2643  d->last_dc[i] = s->last_dc[i];
2644 
2645  /* statistics */
2646  d->mv_bits= s->mv_bits;
2647  d->i_tex_bits= s->i_tex_bits;
2648  d->p_tex_bits= s->p_tex_bits;
2649  d->i_count= s->i_count;
2650  d->f_count= s->f_count;
2651  d->b_count= s->b_count;
2652  d->skip_count= s->skip_count;
2653  d->misc_bits= s->misc_bits;
2654 
2655  d->mb_intra= s->mb_intra;
2656  d->mb_skipped= s->mb_skipped;
2657  d->mv_type= s->mv_type;
2658  d->mv_dir= s->mv_dir;
2659  d->pb= s->pb;
2660  if(s->data_partitioning){
2661  d->pb2= s->pb2;
2662  d->tex_pb= s->tex_pb;
2663  }
2664  d->block= s->block;
2665  for(i=0; i<8; i++)
2666  d->block_last_index[i]= s->block_last_index[i];
2668  d->qscale= s->qscale;
2669 
2671 }
2672 
2673 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2675  int *dmin, int *next_block, int motion_x, int motion_y)
2676 {
2677  int score;
2678  uint8_t *dest_backup[3];
2679 
2680  copy_context_before_encode(s, backup, type);
2681 
2682  s->block= s->blocks[*next_block];
2683  s->pb= pb[*next_block];
2684  if(s->data_partitioning){
2685  s->pb2 = pb2 [*next_block];
2686  s->tex_pb= tex_pb[*next_block];
2687  }
2688 
2689  if(*next_block){
2690  memcpy(dest_backup, s->dest, sizeof(s->dest));
2691  s->dest[0] = s->sc.rd_scratchpad;
2692  s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2693  s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2694  av_assert0(s->linesize >= 32); //FIXME
2695  }
2696 
2697  encode_mb(s, motion_x, motion_y);
2698 
2699  score= put_bits_count(&s->pb);
2700  if(s->data_partitioning){
2701  score+= put_bits_count(&s->pb2);
2702  score+= put_bits_count(&s->tex_pb);
2703  }
2704 
2705  if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2706  ff_mpv_decode_mb(s, s->block);
2707 
2708  score *= s->lambda2;
2709  score += sse_mb(s) << FF_LAMBDA_SHIFT;
2710  }
2711 
2712  if(*next_block){
2713  memcpy(s->dest, dest_backup, sizeof(s->dest));
2714  }
2715 
2716  if(score<*dmin){
2717  *dmin= score;
2718  *next_block^=1;
2719 
2720  copy_context_after_encode(best, s, type);
2721  }
2722 }
2723 
2724 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2725  uint32_t *sq = ff_square_tab + 256;
2726  int acc=0;
2727  int x,y;
2728 
2729  if(w==16 && h==16)
2730  return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2731  else if(w==8 && h==8)
2732  return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2733 
2734  for(y=0; y<h; y++){
2735  for(x=0; x<w; x++){
2736  acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2737  }
2738  }
2739 
2740  av_assert2(acc>=0);
2741 
2742  return acc;
2743 }
2744 
2745 static int sse_mb(MpegEncContext *s){
2746  int w= 16;
2747  int h= 16;
2748 
2749  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2750  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2751 
2752  if(w==16 && h==16)
2753  if(s->avctx->mb_cmp == FF_CMP_NSSE){
2754  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) +
2755  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) +
2756  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);
2757  }else{
2758  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) +
2759  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) +
2760  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);
2761  }
2762  else
2763  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)
2764  +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)
2765  +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);
2766 }
2767 
2769  MpegEncContext *s= *(void**)arg;
2770 
2771 
2772  s->me.pre_pass=1;
2773  s->me.dia_size= s->avctx->pre_dia_size;
2774  s->first_slice_line=1;
2775  for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2776  for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2778  }
2779  s->first_slice_line=0;
2780  }
2781 
2782  s->me.pre_pass=0;
2783 
2784  return 0;
2785 }
2786 
2788  MpegEncContext *s= *(void**)arg;
2789 
2791 
2792  s->me.dia_size= s->avctx->dia_size;
2793  s->first_slice_line=1;
2794  for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2795  s->mb_x=0; //for block init below
2797  for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2798  s->block_index[0]+=2;
2799  s->block_index[1]+=2;
2800  s->block_index[2]+=2;
2801  s->block_index[3]+=2;
2802 
2803  /* compute motion vector & mb_type and store in context */
2806  else
2808  }
2809  s->first_slice_line=0;
2810  }
2811  return 0;
2812 }
2813 
2814 static int mb_var_thread(AVCodecContext *c, void *arg){
2815  MpegEncContext *s= *(void**)arg;
2816  int mb_x, mb_y;
2817 
2819 
2820  for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2821  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2822  int xx = mb_x * 16;
2823  int yy = mb_y * 16;
2824  uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2825  int varc;
2826  int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2827 
2828  varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2829  (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2830 
2831  s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2832  s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2833  s->me.mb_var_sum_temp += varc;
2834  }
2835  }
2836  return 0;
2837 }
2838 
2840  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2841  if(s->partitioned_frame){
2843  }
2844 
2845  ff_mpeg4_stuffing(&s->pb);
2846  }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2848  }
2849 
2851  flush_put_bits(&s->pb);
2852 
2853  if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2854  s->misc_bits+= get_bits_diff(s);
2855 }
2856 
2858 {
2859  uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2860  int offset = put_bits_count(&s->pb);
2861  int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2862  int gobn = s->mb_y / s->gob_index;
2863  int pred_x, pred_y;
2864  if (CONFIG_H263_ENCODER)
2865  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2866  bytestream_put_le32(&ptr, offset);
2867  bytestream_put_byte(&ptr, s->qscale);
2868  bytestream_put_byte(&ptr, gobn);
2869  bytestream_put_le16(&ptr, mba);
2870  bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2871  bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2872  /* 4MV not implemented */
2873  bytestream_put_byte(&ptr, 0); /* hmv2 */
2874  bytestream_put_byte(&ptr, 0); /* vmv2 */
2875 }
2876 
2877 static void update_mb_info(MpegEncContext *s, int startcode)
2878 {
2879  if (!s->mb_info)
2880  return;
2881  if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2882  s->mb_info_size += 12;
2883  s->prev_mb_info = s->last_mb_info;
2884  }
2885  if (startcode) {
2886  s->prev_mb_info = put_bits_count(&s->pb)/8;
2887  /* This might have incremented mb_info_size above, and we return without
2888  * actually writing any info into that slot yet. But in that case,
2889  * this will be called again at the start of the after writing the
2890  * start code, actually writing the mb info. */
2891  return;
2892  }
2893 
2894  s->last_mb_info = put_bits_count(&s->pb)/8;
2895  if (!s->mb_info_size)
2896  s->mb_info_size += 12;
2897  write_mb_info(s);
2898 }
2899 
2900 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2901 {
2902  if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2903  && s->slice_context_count == 1
2904  && s->pb.buf == s->avctx->internal->byte_buffer) {
2905  int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2906  int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2907 
2908  uint8_t *new_buffer = NULL;
2909  int new_buffer_size = 0;
2910 
2911  if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2912  av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2913  return AVERROR(ENOMEM);
2914  }
2915 
2916  emms_c();
2917 
2918  av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2919  s->avctx->internal->byte_buffer_size + size_increase);
2920  if (!new_buffer)
2921  return AVERROR(ENOMEM);
2922 
2923  memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2925  s->avctx->internal->byte_buffer = new_buffer;
2926  s->avctx->internal->byte_buffer_size = new_buffer_size;
2927  rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2928  s->ptr_lastgob = s->pb.buf + lastgob_pos;
2929  s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2930  }
2931  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2932  return AVERROR(EINVAL);
2933  return 0;
2934 }
2935 
2936 static int encode_thread(AVCodecContext *c, void *arg){
2937  MpegEncContext *s= *(void**)arg;
2938  int mb_x, mb_y;
2939  int chr_h= 16>>s->chroma_y_shift;
2940  int i, j;
2941  MpegEncContext best_s = { 0 }, backup_s;
2942  uint8_t bit_buf[2][MAX_MB_BYTES];
2943  uint8_t bit_buf2[2][MAX_MB_BYTES];
2944  uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2945  PutBitContext pb[2], pb2[2], tex_pb[2];
2946 
2948 
2949  for(i=0; i<2; i++){
2950  init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2951  init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2952  init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2953  }
2954 
2955  s->last_bits= put_bits_count(&s->pb);
2956  s->mv_bits=0;
2957  s->misc_bits=0;
2958  s->i_tex_bits=0;
2959  s->p_tex_bits=0;
2960  s->i_count=0;
2961  s->f_count=0;
2962  s->b_count=0;
2963  s->skip_count=0;
2964 
2965  for(i=0; i<3; i++){
2966  /* init last dc values */
2967  /* note: quant matrix value (8) is implied here */
2968  s->last_dc[i] = 128 << s->intra_dc_precision;
2969 
2970  s->current_picture.encoding_error[i] = 0;
2971  }
2972  if(s->codec_id==AV_CODEC_ID_AMV){
2973  s->last_dc[0] = 128*8/13;
2974  s->last_dc[1] = 128*8/14;
2975  s->last_dc[2] = 128*8/14;
2976  }
2977  s->mb_skip_run = 0;
2978  memset(s->last_mv, 0, sizeof(s->last_mv));
2979 
2980  s->last_mv_dir = 0;
2981 
2982  switch(s->codec_id){
2983  case AV_CODEC_ID_H263:
2984  case AV_CODEC_ID_H263P:
2985  case AV_CODEC_ID_FLV1:
2986  if (CONFIG_H263_ENCODER)
2987  s->gob_index = H263_GOB_HEIGHT(s->height);
2988  break;
2989  case AV_CODEC_ID_MPEG4:
2990  if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2992  break;
2993  }
2994 
2995  s->resync_mb_x=0;
2996  s->resync_mb_y=0;
2997  s->first_slice_line = 1;
2998  s->ptr_lastgob = s->pb.buf;
2999  for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
3000  s->mb_x=0;
3001  s->mb_y= mb_y;
3002 
3003  ff_set_qscale(s, s->qscale);
3005 
3006  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3007  int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3008  int mb_type= s->mb_type[xy];
3009 // int d;
3010  int dmin= INT_MAX;
3011  int dir;
3012  int size_increase = s->avctx->internal->byte_buffer_size/4
3013  + s->mb_width*MAX_MB_BYTES;
3014 
3015  ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3016  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3017  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3018  return -1;
3019  }
3020  if(s->data_partitioning){
3021  if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
3022  || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3023  av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3024  return -1;
3025  }
3026  }
3027 
3028  s->mb_x = mb_x;
3029  s->mb_y = mb_y; // moved into loop, can get changed by H.261
3031 
3032  if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3034  xy= s->mb_y*s->mb_stride + s->mb_x;
3035  mb_type= s->mb_type[xy];
3036  }
3037 
3038  /* write gob / video packet header */
3039  if(s->rtp_mode){
3040  int current_packet_size, is_gob_start;
3041 
3042  current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3043 
3044  is_gob_start = s->rtp_payload_size &&
3045  current_packet_size >= s->rtp_payload_size &&
3046  mb_y + mb_x > 0;
3047 
3048  if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3049 
3050  switch(s->codec_id){
3051  case AV_CODEC_ID_H263:
3052  case AV_CODEC_ID_H263P:
3053  if(!s->h263_slice_structured)
3054  if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3055  break;
3057  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3059  if(s->mb_skip_run) is_gob_start=0;
3060  break;
3061  case AV_CODEC_ID_MJPEG:
3062  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3063  break;
3064  }
3065 
3066  if(is_gob_start){
3067  if(s->start_mb_y != mb_y || mb_x!=0){
3068  write_slice_end(s);
3069 
3070  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3072  }
3073  }
3074 
3075  av_assert2((put_bits_count(&s->pb)&7) == 0);
3076  current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3077 
3078  if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3079  int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3080  int d = 100 / s->error_rate;
3081  if(r % d == 0){
3082  current_packet_size=0;
3083  s->pb.buf_ptr= s->ptr_lastgob;
3084  assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3085  }
3086  }
3087 
3088 #if FF_API_RTP_CALLBACK
3090  if (s->avctx->rtp_callback){
3091  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3092  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3093  }
3095 #endif
3096  update_mb_info(s, 1);
3097 
3098  switch(s->codec_id){
3099  case AV_CODEC_ID_MPEG4:
3100  if (CONFIG_MPEG4_ENCODER) {
3103  }
3104  break;
3107  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3110  }
3111  break;
3112  case AV_CODEC_ID_H263:
3113  case AV_CODEC_ID_H263P:
3114  if (CONFIG_H263_ENCODER)
3115  ff_h263_encode_gob_header(s, mb_y);
3116  break;
3117  }
3118 
3119  if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3120  int bits= put_bits_count(&s->pb);
3121  s->misc_bits+= bits - s->last_bits;
3122  s->last_bits= bits;
3123  }
3124 
3125  s->ptr_lastgob += current_packet_size;
3126  s->first_slice_line=1;
3127  s->resync_mb_x=mb_x;
3128  s->resync_mb_y=mb_y;
3129  }
3130  }
3131 
3132  if( (s->resync_mb_x == s->mb_x)
3133  && s->resync_mb_y+1 == s->mb_y){
3134  s->first_slice_line=0;
3135  }
3136 
3137  s->mb_skipped=0;
3138  s->dquant=0; //only for QP_RD
3139 
3140  update_mb_info(s, 0);
3141 
3142  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
3143  int next_block=0;
3144  int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3145 
3146  copy_context_before_encode(&backup_s, s, -1);
3147  backup_s.pb= s->pb;
3150  if(s->data_partitioning){
3151  backup_s.pb2= s->pb2;
3152  backup_s.tex_pb= s->tex_pb;
3153  }
3154 
3155  if(mb_type&CANDIDATE_MB_TYPE_INTER){
3156  s->mv_dir = MV_DIR_FORWARD;
3157  s->mv_type = MV_TYPE_16X16;
3158  s->mb_intra= 0;
3159  s->mv[0][0][0] = s->p_mv_table[xy][0];
3160  s->mv[0][0][1] = s->p_mv_table[xy][1];
3161  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3162  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3163  }
3164  if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3165  s->mv_dir = MV_DIR_FORWARD;
3166  s->mv_type = MV_TYPE_FIELD;
3167  s->mb_intra= 0;
3168  for(i=0; i<2; i++){
3169  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3170  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3171  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3172  }
3173  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3174  &dmin, &next_block, 0, 0);
3175  }
3176  if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3177  s->mv_dir = MV_DIR_FORWARD;
3178  s->mv_type = MV_TYPE_16X16;
3179  s->mb_intra= 0;
3180  s->mv[0][0][0] = 0;
3181  s->mv[0][0][1] = 0;
3182  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3183  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3184  }
3185  if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3186  s->mv_dir = MV_DIR_FORWARD;
3187  s->mv_type = MV_TYPE_8X8;
3188  s->mb_intra= 0;
3189  for(i=0; i<4; i++){
3190  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3191  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3192  }
3193  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3194  &dmin, &next_block, 0, 0);
3195  }
3196  if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3197  s->mv_dir = MV_DIR_FORWARD;
3198  s->mv_type = MV_TYPE_16X16;
3199  s->mb_intra= 0;
3200  s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3201  s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3202  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3203  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3204  }
3205  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3206  s->mv_dir = MV_DIR_BACKWARD;
3207  s->mv_type = MV_TYPE_16X16;
3208  s->mb_intra= 0;
3209  s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3210  s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3211  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3212  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3213  }
3214  if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3216  s->mv_type = MV_TYPE_16X16;
3217  s->mb_intra= 0;
3218  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3219  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3220  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3221  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3222  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3223  &dmin, &next_block, 0, 0);
3224  }
3225  if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3226  s->mv_dir = MV_DIR_FORWARD;
3227  s->mv_type = MV_TYPE_FIELD;
3228  s->mb_intra= 0;
3229  for(i=0; i<2; i++){
3230  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3231  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3232  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3233  }
3234  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3235  &dmin, &next_block, 0, 0);
3236  }
3237  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3238  s->mv_dir = MV_DIR_BACKWARD;
3239  s->mv_type = MV_TYPE_FIELD;
3240  s->mb_intra= 0;
3241  for(i=0; i<2; i++){
3242  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3243  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3244  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3245  }
3246  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3247  &dmin, &next_block, 0, 0);
3248  }
3249  if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3251  s->mv_type = MV_TYPE_FIELD;
3252  s->mb_intra= 0;
3253  for(dir=0; dir<2; dir++){
3254  for(i=0; i<2; i++){
3255  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3256  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3257  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3258  }
3259  }
3260  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3261  &dmin, &next_block, 0, 0);
3262  }
3263  if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3264  s->mv_dir = 0;
3265  s->mv_type = MV_TYPE_16X16;
3266  s->mb_intra= 1;
3267  s->mv[0][0][0] = 0;
3268  s->mv[0][0][1] = 0;
3269  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3270  &dmin, &next_block, 0, 0);
3271  if(s->h263_pred || s->h263_aic){
3272  if(best_s.mb_intra)
3273  s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3274  else
3275  ff_clean_intra_table_entries(s); //old mode?
3276  }
3277  }
3278 
3279  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3280  if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3281  const int last_qp= backup_s.qscale;
3282  int qpi, qp, dc[6];
3283  int16_t ac[6][16];
3284  const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3285  static const int dquant_tab[4]={-1,1,-2,2};
3286  int storecoefs = s->mb_intra && s->dc_val[0];
3287 
3288  av_assert2(backup_s.dquant == 0);
3289 
3290  //FIXME intra
3291  s->mv_dir= best_s.mv_dir;
3292  s->mv_type = MV_TYPE_16X16;
3293  s->mb_intra= best_s.mb_intra;
3294  s->mv[0][0][0] = best_s.mv[0][0][0];
3295  s->mv[0][0][1] = best_s.mv[0][0][1];
3296  s->mv[1][0][0] = best_s.mv[1][0][0];
3297  s->mv[1][0][1] = best_s.mv[1][0][1];
3298 
3299  qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3300  for(; qpi<4; qpi++){
3301  int dquant= dquant_tab[qpi];
3302  qp= last_qp + dquant;
3303  if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3304  continue;
3305  backup_s.dquant= dquant;
3306  if(storecoefs){
3307  for(i=0; i<6; i++){
3308  dc[i]= s->dc_val[0][ s->block_index[i] ];
3309  memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3310  }
3311  }
3312 
3313  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3314  &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3315  if(best_s.qscale != qp){
3316  if(storecoefs){
3317  for(i=0; i<6; i++){
3318  s->dc_val[0][ s->block_index[i] ]= dc[i];
3319  memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3320  }
3321  }
3322  }
3323  }
3324  }
3325  }
3326  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3327  int mx= s->b_direct_mv_table[xy][0];
3328  int my= s->b_direct_mv_table[xy][1];
3329 
3330  backup_s.dquant = 0;
3332  s->mb_intra= 0;
3333  ff_mpeg4_set_direct_mv(s, mx, my);
3334  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3335  &dmin, &next_block, mx, my);
3336  }
3337  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3338  backup_s.dquant = 0;
3340  s->mb_intra= 0;
3341  ff_mpeg4_set_direct_mv(s, 0, 0);
3342  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3343  &dmin, &next_block, 0, 0);
3344  }
3345  if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3346  int coded=0;
3347  for(i=0; i<6; i++)
3348  coded |= s->block_last_index[i];
3349  if(coded){
3350  int mx,my;
3351  memcpy(s->mv, best_s.mv, sizeof(s->mv));
3352  if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3353  mx=my=0; //FIXME find the one we actually used
3354  ff_mpeg4_set_direct_mv(s, mx, my);
3355  }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3356  mx= s->mv[1][0][0];
3357  my= s->mv[1][0][1];
3358  }else{
3359  mx= s->mv[0][0][0];
3360  my= s->mv[0][0][1];
3361  }
3362 
3363  s->mv_dir= best_s.mv_dir;
3364  s->mv_type = best_s.mv_type;
3365  s->mb_intra= 0;
3366 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3367  s->mv[0][0][1] = best_s.mv[0][0][1];
3368  s->mv[1][0][0] = best_s.mv[1][0][0];
3369  s->mv[1][0][1] = best_s.mv[1][0][1];*/
3370  backup_s.dquant= 0;
3371  s->skipdct=1;
3372  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3373  &dmin, &next_block, mx, my);
3374  s->skipdct=0;
3375  }
3376  }
3377 
3378  s->current_picture.qscale_table[xy] = best_s.qscale;
3379 
3380  copy_context_after_encode(s, &best_s, -1);
3381 
3382  pb_bits_count= put_bits_count(&s->pb);
3383  flush_put_bits(&s->pb);
3384  avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3385  s->pb= backup_s.pb;
3386 
3387  if(s->data_partitioning){
3388  pb2_bits_count= put_bits_count(&s->pb2);
3389  flush_put_bits(&s->pb2);
3390  avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3391  s->pb2= backup_s.pb2;
3392 
3393  tex_pb_bits_count= put_bits_count(&s->tex_pb);
3394  flush_put_bits(&s->tex_pb);
3395  avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3396  s->tex_pb= backup_s.tex_pb;
3397  }
3398  s->last_bits= put_bits_count(&s->pb);
3399 
3400  if (CONFIG_H263_ENCODER &&
3403 
3404  if(next_block==0){ //FIXME 16 vs linesize16
3405  s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3406  s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3407  s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3408  }
3409 
3411  ff_mpv_decode_mb(s, s->block);
3412  } else {
3413  int motion_x = 0, motion_y = 0;
3415  // only one MB-Type possible
3416 
3417  switch(mb_type){
3419  s->mv_dir = 0;
3420  s->mb_intra= 1;
3421  motion_x= s->mv[0][0][0] = 0;
3422  motion_y= s->mv[0][0][1] = 0;
3423  break;
3425  s->mv_dir = MV_DIR_FORWARD;
3426  s->mb_intra= 0;
3427  motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3428  motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3429  break;
3431  s->mv_dir = MV_DIR_FORWARD;
3432  s->mv_type = MV_TYPE_FIELD;
3433  s->mb_intra= 0;
3434  for(i=0; i<2; i++){
3435  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3436  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3437  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3438  }
3439  break;
3441  s->mv_dir = MV_DIR_FORWARD;
3442  s->mv_type = MV_TYPE_8X8;
3443  s->mb_intra= 0;
3444  for(i=0; i<4; i++){
3445  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3446  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3447  }
3448  break;
3450  if (CONFIG_MPEG4_ENCODER) {
3452  s->mb_intra= 0;
3453  motion_x=s->b_direct_mv_table[xy][0];
3454  motion_y=s->b_direct_mv_table[xy][1];
3455  ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3456  }
3457  break;
3459  if (CONFIG_MPEG4_ENCODER) {
3461  s->mb_intra= 0;
3462  ff_mpeg4_set_direct_mv(s, 0, 0);
3463  }
3464  break;
3467  s->mb_intra= 0;
3468  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3469  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3470  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3471  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3472  break;
3474  s->mv_dir = MV_DIR_BACKWARD;
3475  s->mb_intra= 0;
3476  motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3477  motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3478  break;
3480  s->mv_dir = MV_DIR_FORWARD;
3481  s->mb_intra= 0;
3482  motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3483  motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3484  break;
3486  s->mv_dir = MV_DIR_FORWARD;
3487  s->mv_type = MV_TYPE_FIELD;
3488  s->mb_intra= 0;
3489  for(i=0; i<2; i++){
3490  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3491  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3492  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3493  }
3494  break;
3496  s->mv_dir = MV_DIR_BACKWARD;
3497  s->mv_type = MV_TYPE_FIELD;
3498  s->mb_intra= 0;
3499  for(i=0; i<2; i++){
3500  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3501  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3502  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3503  }
3504  break;
3507  s->mv_type = MV_TYPE_FIELD;
3508  s->mb_intra= 0;
3509  for(dir=0; dir<2; dir++){
3510  for(i=0; i<2; i++){
3511  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3512  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3513  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3514  }
3515  }
3516  break;
3517  default:
3518  av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3519  }
3520 
3521  encode_mb(s, motion_x, motion_y);
3522 
3523  // RAL: Update last macroblock type
3524  s->last_mv_dir = s->mv_dir;
3525 
3526  if (CONFIG_H263_ENCODER &&
3529 
3530  ff_mpv_decode_mb(s, s->block);
3531  }
3532 
3533  /* clean the MV table in IPS frames for direct mode in B-frames */
3534  if(s->mb_intra /* && I,P,S_TYPE */){
3535  s->p_mv_table[xy][0]=0;
3536  s->p_mv_table[xy][1]=0;
3537  }
3538 
3539  if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3540  int w= 16;
3541  int h= 16;
3542 
3543  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3544  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3545 
3547  s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3548  s->dest[0], w, h, s->linesize);
3550  s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3551  s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3553  s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3554  s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3555  }
3556  if(s->loop_filter){
3557  if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3559  }
3560  ff_dlog(s->avctx, "MB %d %d bits\n",
3561  s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3562  }
3563  }
3564 
3565  //not beautiful here but we must write it before flushing so it has to be here
3568 
3569  write_slice_end(s);
3570 
3571 #if FF_API_RTP_CALLBACK
3573  /* Send the last GOB if RTP */
3574  if (s->avctx->rtp_callback) {
3575  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3576  int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3577  /* Call the RTP callback to send the last GOB */
3578  emms_c();
3579  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3580  }
3582 #endif
3583 
3584  return 0;
3585 }
3586 
3587 #define MERGE(field) dst->field += src->field; src->field=0
3589  MERGE(me.scene_change_score);
3590  MERGE(me.mc_mb_var_sum_temp);
3591  MERGE(me.mb_var_sum_temp);
3592 }
3593 
3595  int i;
3596 
3597  MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3598  MERGE(dct_count[1]);
3599  MERGE(mv_bits);
3600  MERGE(i_tex_bits);
3601  MERGE(p_tex_bits);
3602  MERGE(i_count);
3603  MERGE(f_count);
3604  MERGE(b_count);
3605  MERGE(skip_count);
3606  MERGE(misc_bits);
3607  MERGE(er.error_count);
3612 
3613  if (dst->noise_reduction){
3614  for(i=0; i<64; i++){
3615  MERGE(dct_error_sum[0][i]);
3616  MERGE(dct_error_sum[1][i]);
3617  }
3618  }
3619 
3620  assert(put_bits_count(&src->pb) % 8 ==0);
3621  assert(put_bits_count(&dst->pb) % 8 ==0);
3622  avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3623  flush_put_bits(&dst->pb);
3624 }
3625 
3626 static int estimate_qp(MpegEncContext *s, int dry_run){
3627  if (s->next_lambda){
3630  if(!dry_run) s->next_lambda= 0;
3631  } else if (!s->fixed_qscale) {
3634  if (s->current_picture.f->quality < 0)
3635  return -1;
3636  }
3637 
3638  if(s->adaptive_quant){
3639  switch(s->codec_id){
3640  case AV_CODEC_ID_MPEG4:
3641  if (CONFIG_MPEG4_ENCODER)
3643  break;
3644  case AV_CODEC_ID_H263:
3645  case AV_CODEC_ID_H263P:
3646  case AV_CODEC_ID_FLV1:
3647  if (CONFIG_H263_ENCODER)
3649  break;
3650  default:
3651  ff_init_qscale_tab(s);
3652  }
3653 
3654  s->lambda= s->lambda_table[0];
3655  //FIXME broken
3656  }else
3657  s->lambda = s->current_picture.f->quality;
3658  update_qscale(s);
3659  return 0;
3660 }
3661 
3662 /* must be called before writing the header */
3665  s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3666 
3667  if(s->pict_type==AV_PICTURE_TYPE_B){
3668  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3669  assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3670  }else{
3671  s->pp_time= s->time - s->last_non_b_time;
3672  s->last_non_b_time= s->time;
3673  assert(s->picture_number==0 || s->pp_time > 0);
3674  }
3675 }
3676 
3678 {
3679  int i, ret;
3680  int bits;
3681  int context_count = s->slice_context_count;
3682 
3684 
3685  /* Reset the average MB variance */
3686  s->me.mb_var_sum_temp =
3687  s->me.mc_mb_var_sum_temp = 0;
3688 
3689  /* we need to initialize some time vars before we can encode B-frames */
3690  // RAL: Condition added for MPEG1VIDEO
3693  if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3694  ff_set_mpeg4_time(s);
3695 
3696  s->me.scene_change_score=0;
3697 
3698 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3699 
3700  if(s->pict_type==AV_PICTURE_TYPE_I){
3701  if(s->msmpeg4_version >= 3) s->no_rounding=1;
3702  else s->no_rounding=0;
3703  }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3705  s->no_rounding ^= 1;
3706  }
3707 
3708  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3709  if (estimate_qp(s,1) < 0)
3710  return -1;
3711  ff_get_2pass_fcode(s);
3712  } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3714  s->lambda= s->last_lambda_for[s->pict_type];
3715  else
3717  update_qscale(s);
3718  }
3719 
3725  }
3726 
3727  s->mb_intra=0; //for the rate distortion & bit compare functions
3728  for(i=1; i<context_count; i++){
3730  if (ret < 0)
3731  return ret;
3732  }
3733 
3734  if(ff_init_me(s)<0)
3735  return -1;
3736 
3737  /* Estimate motion for every MB */
3738  if(s->pict_type != AV_PICTURE_TYPE_I){
3739  s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3740  s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3741  if (s->pict_type != AV_PICTURE_TYPE_B) {
3742  if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3743  s->me_pre == 2) {
3744  s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3745  }
3746  }
3747 
3748  s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3749  }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3750  /* I-Frame */
3751  for(i=0; i<s->mb_stride*s->mb_height; i++)
3753 
3754  if(!s->fixed_qscale){
3755  /* finding spatial complexity for I-frame rate control */
3756  s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3757  }
3758  }
3759  for(i=1; i<context_count; i++){
3761  }
3763  s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3764  emms_c();
3765 
3767  s->pict_type == AV_PICTURE_TYPE_P) {
3769  for(i=0; i<s->mb_stride*s->mb_height; i++)
3771  if(s->msmpeg4_version >= 3)
3772  s->no_rounding=1;
3773  ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3775  }
3776 
3777  if(!s->umvplus){
3780 
3782  int a,b;
3783  a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3785  s->f_code= FFMAX3(s->f_code, a, b);
3786  }
3787 
3788  ff_fix_long_p_mvs(s);
3791  int j;
3792  for(i=0; i<2; i++){
3793  for(j=0; j<2; j++)
3796  }
3797  }
3798  }
3799 
3800  if(s->pict_type==AV_PICTURE_TYPE_B){
3801  int a, b;
3802 
3805  s->f_code = FFMAX(a, b);
3806 
3809  s->b_code = FFMAX(a, b);
3810 
3816  int dir, j;
3817  for(dir=0; dir<2; dir++){
3818  for(i=0; i<2; i++){
3819  for(j=0; j<2; j++){
3822  ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3823  s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3824  }
3825  }
3826  }
3827  }
3828  }
3829  }
3830 
3831  if (estimate_qp(s, 0) < 0)
3832  return -1;
3833 
3834  if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3835  s->pict_type == AV_PICTURE_TYPE_I &&
3836  !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3837  s->qscale= 3; //reduce clipping problems
3838 
3839  if (s->out_format == FMT_MJPEG) {
3840  const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3841  const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3842 
3843  if (s->avctx->intra_matrix) {
3844  chroma_matrix =
3845  luma_matrix = s->avctx->intra_matrix;
3846  }
3847  if (s->avctx->chroma_intra_matrix)
3848  chroma_matrix = s->avctx->chroma_intra_matrix;
3849 
3850  /* for mjpeg, we do include qscale in the matrix */
3851  for(i=1;i<64;i++){
3852  int j = s->idsp.idct_permutation[i];
3853 
3854  s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3855  s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3856  }
3857  s->y_dc_scale_table=
3859  s->chroma_intra_matrix[0] =
3862  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3864  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3865  s->qscale= 8;
3866  }
3867  if(s->codec_id == AV_CODEC_ID_AMV){
3868  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};
3869  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};
3870  for(i=1;i<64;i++){
3871  int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3872 
3873  s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3874  s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3875  }
3876  s->y_dc_scale_table= y;
3877  s->c_dc_scale_table= c;
3878  s->intra_matrix[0] = 13;
3879  s->chroma_intra_matrix[0] = 14;
3881  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3883  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3884  s->qscale= 8;
3885  }
3886 
3887  //FIXME var duplication
3889  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3892 
3893  if (s->current_picture.f->key_frame)
3894  s->picture_in_gop_number=0;
3895 
3896  s->mb_x = s->mb_y = 0;
3897  s->last_bits= put_bits_count(&s->pb);
3898  switch(s->out_format) {
3899  case FMT_MJPEG:
3900  if (CONFIG_MJPEG_ENCODER)
3903  break;
3904  case FMT_H261:
3905  if (CONFIG_H261_ENCODER)
3906  ff_h261_encode_picture_header(s, picture_number);
3907  break;
3908  case FMT_H263:
3909  if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3910  ff_wmv2_encode_picture_header(s, picture_number);
3911  else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3912  ff_msmpeg4_encode_picture_header(s, picture_number);
3913  else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3914  ret = ff_mpeg4_encode_picture_header(s, picture_number);
3915  if (ret < 0)
3916  return ret;
3917  } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3918  ret = ff_rv10_encode_picture_header(s, picture_number);
3919  if (ret < 0)
3920  return ret;
3921  }
3922  else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3923  ff_rv20_encode_picture_header(s, picture_number);
3924  else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3925  ff_flv_encode_picture_header(s, picture_number);
3926  else if (CONFIG_H263_ENCODER)
3927  ff_h263_encode_picture_header(s, picture_number);
3928  break;
3929  case FMT_MPEG1:
3930  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3931  ff_mpeg1_encode_picture_header(s, picture_number);
3932  break;
3933  default:
3934  av_assert0(0);
3935  }
3936  bits= put_bits_count(&s->pb);
3937  s->header_bits= bits - s->last_bits;
3938 
3939  for(i=1; i<context_count; i++){
3941  }
3942  s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3943  for(i=1; i<context_count; i++){
3944  if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3945  set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
3947  }
3948  emms_c();
3949  return 0;
3950 }
3951 
3952 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3953  const int intra= s->mb_intra;
3954  int i;
3955 
3956  s->dct_count[intra]++;
3957 
3958  for(i=0; i<64; i++){
3959  int level= block[i];
3960 
3961  if(level){
3962  if(level>0){
3963  s->dct_error_sum[intra][i] += level;
3964  level -= s->dct_offset[intra][i];
3965  if(level<0) level=0;
3966  }else{
3967  s->dct_error_sum[intra][i] -= level;
3968  level += s->dct_offset[intra][i];
3969  if(level>0) level=0;
3970  }
3971  block[i]= level;
3972  }
3973  }
3974 }
3975 
3977  int16_t *block, int n,
3978  int qscale, int *overflow){
3979  const int *qmat;
3980  const uint16_t *matrix;
3981  const uint8_t *scantable= s->intra_scantable.scantable;
3982  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3983  int max=0;
3984  unsigned int threshold1, threshold2;
3985  int bias=0;
3986  int run_tab[65];
3987  int level_tab[65];
3988  int score_tab[65];
3989  int survivor[65];
3990  int survivor_count;
3991  int last_run=0;
3992  int last_level=0;
3993  int last_score= 0;
3994  int last_i;
3995  int coeff[2][64];
3996  int coeff_count[64];
3997  int qmul, qadd, start_i, last_non_zero, i, dc;
3998  const int esc_length= s->ac_esc_length;
3999  uint8_t * length;
4000  uint8_t * last_length;
4001  const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4002  int mpeg2_qscale;
4003 
4004  s->fdsp.fdct(block);
4005 
4006  if(s->dct_error_sum)
4007  s->denoise_dct(s, block);
4008  qmul= qscale*16;
4009  qadd= ((qscale-1)|1)*8;
4010 
4011  if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
4012  else mpeg2_qscale = qscale << 1;
4013 
4014  if (s->mb_intra) {
4015  int q;
4016  if (!s->h263_aic) {
4017  if (n < 4)
4018  q = s->y_dc_scale;
4019  else
4020  q = s->c_dc_scale;
4021  q = q << 3;
4022  } else{
4023  /* For AIC we skip quant/dequant of INTRADC */
4024  q = 1 << 3;
4025  qadd=0;
4026  }
4027 
4028  /* note: block[0] is assumed to be positive */
4029  block[0] = (block[0] + (q >> 1)) / q;
4030  start_i = 1;
4031  last_non_zero = 0;
4032  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4033  matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4034  if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4035  bias= 1<<(QMAT_SHIFT-1);
4036 
4037  if (n > 3 && s->intra_chroma_ac_vlc_length) {
4038  length = s->intra_chroma_ac_vlc_length;
4039  last_length= s->intra_chroma_ac_vlc_last_length;
4040  } else {
4041  length = s->intra_ac_vlc_length;
4042  last_length= s->intra_ac_vlc_last_length;
4043  }
4044  } else {
4045  start_i = 0;
4046  last_non_zero = -1;
4047  qmat = s->q_inter_matrix[qscale];
4048  matrix = s->inter_matrix;
4049  length = s->inter_ac_vlc_length;
4050  last_length= s->inter_ac_vlc_last_length;
4051  }
4052  last_i= start_i;
4053 
4054  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4055  threshold2= (threshold1<<1);
4056 
4057  for(i=63; i>=start_i; i--) {
4058  const int j = scantable[i];
4059  int level = block[j] * qmat[j];
4060 
4061  if(((unsigned)(level+threshold1))>threshold2){
4062  last_non_zero = i;
4063  break;
4064  }
4065  }
4066 
4067  for(i=start_i; i<=last_non_zero; i++) {
4068  const int j = scantable[i];
4069  int level = block[j] * qmat[j];
4070 
4071 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4072 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4073  if(((unsigned)(level+threshold1))>threshold2){
4074  if(level>0){
4075  level= (bias + level)>>QMAT_SHIFT;
4076  coeff[0][i]= level;
4077  coeff[1][i]= level-1;
4078 // coeff[2][k]= level-2;
4079  }else{
4080  level= (bias - level)>>QMAT_SHIFT;
4081  coeff[0][i]= -level;
4082  coeff[1][i]= -level+1;
4083 // coeff[2][k]= -level+2;
4084  }
4085  coeff_count[i]= FFMIN(level, 2);
4086  av_assert2(coeff_count[i]);
4087  max |=level;
4088  }else{
4089  coeff[0][i]= (level>>31)|1;
4090  coeff_count[i]= 1;
4091  }
4092  }
4093 
4094  *overflow= s->max_qcoeff < max; //overflow might have happened
4095 
4096  if(last_non_zero < start_i){
4097  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4098  return last_non_zero;
4099  }
4100 
4101  score_tab[start_i]= 0;
4102  survivor[0]= start_i;
4103  survivor_count= 1;
4104 
4105  for(i=start_i; i<=last_non_zero; i++){
4106  int level_index, j, zero_distortion;
4107  int dct_coeff= FFABS(block[ scantable[i] ]);
4108  int best_score=256*256*256*120;
4109 
4110  if (s->fdsp.fdct == ff_fdct_ifast)
4111  dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4112  zero_distortion= dct_coeff*dct_coeff;
4113 
4114  for(level_index=0; level_index < coeff_count[i]; level_index++){
4115  int distortion;
4116  int level= coeff[level_index][i];
4117  const int alevel= FFABS(level);
4118  int unquant_coeff;
4119 
4120  av_assert2(level);
4121 
4122  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4123  unquant_coeff= alevel*qmul + qadd;
4124  } else if(s->out_format == FMT_MJPEG) {
4125  j = s->idsp.idct_permutation[scantable[i]];
4126  unquant_coeff = alevel * matrix[j] * 8;
4127  }else{ // MPEG-1
4128  j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4129  if(s->mb_intra){
4130  unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4131  unquant_coeff = (unquant_coeff - 1) | 1;
4132  }else{
4133  unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4134  unquant_coeff = (unquant_coeff - 1) | 1;
4135  }
4136  unquant_coeff<<= 3;
4137  }
4138 
4139  distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4140  level+=64;
4141  if((level&(~127)) == 0){
4142  for(j=survivor_count-1; j>=0; j--){
4143  int run= i - survivor[j];
4144  int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4145  score += score_tab[i-run];
4146 
4147  if(score < best_score){
4148  best_score= score;
4149  run_tab[i+1]= run;
4150  level_tab[i+1]= level-64;
4151  }
4152  }
4153 
4154  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4155  for(j=survivor_count-1; j>=0; j--){
4156  int run= i - survivor[j];
4157  int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4158  score += score_tab[i-run];
4159  if(score < last_score){
4160  last_score= score;
4161  last_run= run;
4162  last_level= level-64;
4163  last_i= i+1;
4164  }
4165  }
4166  }
4167  }else{
4168  distortion += esc_length*lambda;
4169  for(j=survivor_count-1; j>=0; j--){
4170  int run= i - survivor[j];
4171  int score= distortion + score_tab[i-run];
4172 
4173  if(score < best_score){
4174  best_score= score;
4175  run_tab[i+1]= run;
4176  level_tab[i+1]= level-64;
4177  }
4178  }
4179 
4180  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4181  for(j=survivor_count-1; j>=0; j--){
4182  int run= i - survivor[j];
4183  int score= distortion + score_tab[i-run];
4184  if(score < last_score){
4185  last_score= score;
4186  last_run= run;
4187  last_level= level-64;
4188  last_i= i+1;
4189  }
4190  }
4191  }
4192  }
4193  }
4194 
4195  score_tab[i+1]= best_score;
4196 
4197  // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
4198  if(last_non_zero <= 27){
4199  for(; survivor_count; survivor_count--){
4200  if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4201  break;
4202  }
4203  }else{
4204  for(; survivor_count; survivor_count--){
4205  if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4206  break;
4207  }
4208  }
4209 
4210  survivor[ survivor_count++ ]= i+1;
4211  }
4212 
4213  if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4214  last_score= 256*256*256*120;
4215  for(i= survivor[0]; i<=last_non_zero + 1; i++){
4216  int score= score_tab[i];
4217  if (i)
4218  score += lambda * 2; // FIXME more exact?
4219 
4220  if(score < last_score){
4221  last_score= score;
4222  last_i= i;
4223  last_level= level_tab[i];
4224  last_run= run_tab[i];
4225  }
4226  }
4227  }
4228 
4229  s->coded_score[n] = last_score;
4230 
4231  dc= FFABS(block[0]);
4232  last_non_zero= last_i - 1;
4233  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4234 
4235  if(last_non_zero < start_i)
4236  return last_non_zero;
4237 
4238  if(last_non_zero == 0 && start_i == 0){
4239  int best_level= 0;
4240  int best_score= dc * dc;
4241 
4242  for(i=0; i<coeff_count[0]; i++){
4243  int level= coeff[i][0];
4244  int alevel= FFABS(level);
4245  int unquant_coeff, score, distortion;
4246 
4247  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4248  unquant_coeff= (alevel*qmul + qadd)>>3;
4249  } else{ // MPEG-1
4250  unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4251  unquant_coeff = (unquant_coeff - 1) | 1;
4252  }
4253  unquant_coeff = (unquant_coeff + 4) >> 3;
4254  unquant_coeff<<= 3 + 3;
4255 
4256  distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4257  level+=64;
4258  if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4259  else score= distortion + esc_length*lambda;
4260 
4261  if(score < best_score){
4262  best_score= score;
4263  best_level= level - 64;
4264  }
4265  }
4266  block[0]= best_level;
4267  s->coded_score[n] = best_score - dc*dc;
4268  if(best_level == 0) return -1;
4269  else return last_non_zero;
4270  }
4271 
4272  i= last_i;
4273  av_assert2(last_level);
4274 
4275  block[ perm_scantable[last_non_zero] ]= last_level;
4276  i -= last_run + 1;
4277 
4278  for(; i>start_i; i -= run_tab[i] + 1){
4279  block[ perm_scantable[i-1] ]= level_tab[i];
4280  }
4281 
4282  return last_non_zero;
4283 }
4284 
4285 //#define REFINE_STATS 1
4286 static int16_t basis[64][64];
4287 
4288 static void build_basis(uint8_t *perm){
4289  int i, j, x, y;
4290  emms_c();
4291  for(i=0; i<8; i++){
4292  for(j=0; j<8; j++){
4293  for(y=0; y<8; y++){
4294  for(x=0; x<8; x++){
4295  double s= 0.25*(1<<BASIS_SHIFT);
4296  int index= 8*i + j;
4297  int perm_index= perm[index];
4298  if(i==0) s*= sqrt(0.5);
4299  if(j==0) s*= sqrt(0.5);
4300  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)));
4301  }
4302  }
4303  }
4304  }
4305 }
4306 
4307 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4308  int16_t *block, int16_t *weight, int16_t *orig,
4309  int n, int qscale){
4310  int16_t rem[64];
4311  LOCAL_ALIGNED_16(int16_t, d1, [64]);
4312  const uint8_t *scantable= s->intra_scantable.scantable;
4313  const uint8_t *perm_scantable= s->intra_scantable.permutated;
4314 // unsigned int threshold1, threshold2;
4315 // int bias=0;
4316  int run_tab[65];
4317  int prev_run=0;
4318  int prev_level=0;
4319  int qmul, qadd, start_i, last_non_zero, i, dc;
4320  uint8_t * length;
4321  uint8_t * last_length;
4322  int lambda;
4323  int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4324 #ifdef REFINE_STATS
4325 static int count=0;
4326 static int after_last=0;
4327 static int to_zero=0;
4328 static int from_zero=0;
4329 static int raise=0;
4330 static int lower=0;
4331 static int messed_sign=0;
4332 #endif
4333 
4334  if(basis[0][0] == 0)
4336 
4337  qmul= qscale*2;
4338  qadd= (qscale-1)|1;
4339  if (s->mb_intra) {
4340  if (!s->h263_aic) {
4341  if (n < 4)
4342  q = s->y_dc_scale;
4343  else
4344  q = s->c_dc_scale;
4345  } else{
4346  /* For AIC we skip quant/dequant of INTRADC */
4347  q = 1;
4348  qadd=0;
4349  }
4350  q <<= RECON_SHIFT-3;
4351  /* note: block[0] is assumed to be positive */
4352  dc= block[0]*q;
4353 // block[0] = (block[0] + (q >> 1)) / q;
4354  start_i = 1;
4355 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4356 // bias= 1<<(QMAT_SHIFT-1);
4357  if (n > 3 && s->intra_chroma_ac_vlc_length) {
4358  length = s->intra_chroma_ac_vlc_length;
4359  last_length= s->intra_chroma_ac_vlc_last_length;
4360  } else {
4361  length = s->intra_ac_vlc_length;
4362  last_length= s->intra_ac_vlc_last_length;
4363  }
4364  } else {
4365  dc= 0;
4366  start_i = 0;
4367  length = s->inter_ac_vlc_length;
4368  last_length= s->inter_ac_vlc_last_length;
4369  }
4370  last_non_zero = s->block_last_index[n];
4371 
4372 #ifdef REFINE_STATS
4373 {START_TIMER
4374 #endif
4375  dc += (1<<(RECON_SHIFT-1));
4376  for(i=0; i<64; i++){
4377  rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4378  }
4379 #ifdef REFINE_STATS
4380 STOP_TIMER("memset rem[]")}
4381 #endif
4382  sum=0;
4383  for(i=0; i<64; i++){
4384  int one= 36;
4385  int qns=4;
4386  int w;
4387 
4388  w= FFABS(weight[i]) + qns*one;
4389  w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4390 
4391  weight[i] = w;
4392 // w=weight[i] = (63*qns + (w/2)) / w;
4393 
4394  av_assert2(w>0);
4395  av_assert2(w<(1<<6));
4396  sum += w*w;
4397  }
4398  lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4399 #ifdef REFINE_STATS
4400 {START_TIMER
4401 #endif
4402  run=0;
4403  rle_index=0;
4404  for(i=start_i; i<=last_non_zero; i++){
4405  int j= perm_scantable[i];
4406  const int level= block[j];
4407  int coeff;
4408 
4409  if(level){
4410  if(level<0) coeff= qmul*level - qadd;
4411  else coeff= qmul*level + qadd;
4412  run_tab[rle_index++]=run;
4413  run=0;
4414 
4415  s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4416  }else{
4417  run++;
4418  }
4419  }
4420 #ifdef REFINE_STATS
4421 if(last_non_zero>0){
4422 STOP_TIMER("init rem[]")
4423 }
4424 }
4425 
4426 {START_TIMER
4427 #endif
4428  for(;;){
4429  int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4430  int best_coeff=0;
4431  int best_change=0;
4432  int run2, best_unquant_change=0, analyze_gradient;
4433 #ifdef REFINE_STATS
4434 {START_TIMER
4435 #endif
4436  analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4437 
4438  if(analyze_gradient){
4439 #ifdef REFINE_STATS
4440 {START_TIMER
4441 #endif
4442  for(i=0; i<64; i++){
4443  int w= weight[i];
4444 
4445  d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4446  }
4447 #ifdef REFINE_STATS
4448 STOP_TIMER("rem*w*w")}
4449 {START_TIMER
4450 #endif
4451  s->fdsp.fdct(d1);
4452 #ifdef REFINE_STATS
4453 STOP_TIMER("dct")}
4454 #endif
4455  }
4456 
4457  if(start_i){
4458  const int level= block[0];
4459  int change, old_coeff;
4460 
4461  av_assert2(s->mb_intra);
4462 
4463  old_coeff= q*level;
4464 
4465  for(change=-1; change<=1; change+=2){
4466  int new_level= level + change;
4467  int score, new_coeff;
4468 
4469  new_coeff= q*new_level;
4470  if(new_coeff >= 2048 || new_coeff < 0)
4471  continue;
4472 
4473  score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4474  new_coeff - old_coeff);
4475  if(score<best_score){
4476  best_score= score;
4477  best_coeff= 0;
4478  best_change= change;
4479  best_unquant_change= new_coeff - old_coeff;
4480  }
4481  }
4482  }
4483 
4484  run=0;
4485  rle_index=0;
4486  run2= run_tab[rle_index++];
4487  prev_level=0;
4488  prev_run=0;
4489 
4490  for(i=start_i; i<64; i++){
4491  int j= perm_scantable[i];
4492  const int level= block[j];
4493  int change, old_coeff;
4494 
4495  if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4496  break;
4497 
4498  if(level){
4499  if(level<0) old_coeff= qmul*level - qadd;
4500  else old_coeff= qmul*level + qadd;
4501  run2= run_tab[rle_index++]; //FIXME ! maybe after last
4502  }else{
4503  old_coeff=0;
4504  run2--;
4505  av_assert2(run2>=0 || i >= last_non_zero );
4506  }
4507 
4508  for(change=-1; change<=1; change+=2){
4509  int new_level= level + change;
4510  int score, new_coeff, unquant_change;
4511 
4512  score=0;
4513  if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4514  continue;
4515 
4516  if(new_level){
4517  if(new_level<0) new_coeff= qmul*new_level - qadd;
4518  else new_coeff= qmul*new_level + qadd;
4519  if(new_coeff >= 2048 || new_coeff <= -2048)
4520  continue;
4521  //FIXME check for overflow
4522 
4523  if(level){
4524  if(level < 63 && level > -63){
4525  if(i < last_non_zero)
4526  score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4527  - length[UNI_AC_ENC_INDEX(run, level+64)];
4528  else
4529  score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4530  - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4531  }
4532  }else{
4533  av_assert2(FFABS(new_level)==1);
4534 
4535  if(analyze_gradient){
4536  int g= d1[ scantable[i] ];
4537  if(g && (g^new_level) >= 0)
4538  continue;
4539  }
4540 
4541  if(i < last_non_zero){
4542  int next_i= i + run2 + 1;
4543  int next_level= block[ perm_scantable[next_i] ] + 64;
4544 
4545  if(next_level&(~127))
4546  next_level= 0;
4547 
4548  if(next_i < last_non_zero)
4549  score += length[UNI_AC_ENC_INDEX(run, 65)]
4550  + length[UNI_AC_ENC_INDEX(run2, next_level)]
4551  - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4552  else
4553  score += length[UNI_AC_ENC_INDEX(run, 65)]