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