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