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