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