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