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