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