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