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  && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
540  av_log(avctx, AV_LOG_ERROR,
541  "mpeg2 style quantization not supported by codec\n");
542  return -1;
543  }
544 
545  if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
546  av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
547  return -1;
548  }
549 
550  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
551  s->avctx->mb_decision != FF_MB_DECISION_RD) {
552  av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
553  return -1;
554  }
555 
556  if (s->avctx->scenechange_threshold < 1000000000 &&
557  (s->flags & CODEC_FLAG_CLOSED_GOP)) {
558  av_log(avctx, AV_LOG_ERROR,
559  "closed gop with scene change detection are not supported yet, "
560  "set threshold to 1000000000\n");
561  return -1;
562  }
563 
564  if (s->flags & CODEC_FLAG_LOW_DELAY) {
565  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
566  av_log(avctx, AV_LOG_ERROR,
567  "low delay forcing is only available for mpeg2\n");
568  return -1;
569  }
570  if (s->max_b_frames != 0) {
571  av_log(avctx, AV_LOG_ERROR,
572  "b frames cannot be used with low delay\n");
573  return -1;
574  }
575  }
576 
577  if (s->q_scale_type == 1) {
578  if (avctx->qmax > 12) {
579  av_log(avctx, AV_LOG_ERROR,
580  "non linear quant only supports qmax <= 12 currently\n");
581  return -1;
582  }
583  }
584 
585  if (s->avctx->thread_count > 1 &&
586  s->codec_id != AV_CODEC_ID_MPEG4 &&
587  s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
588  s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
589  s->codec_id != AV_CODEC_ID_MJPEG &&
590  (s->codec_id != AV_CODEC_ID_H263P)) {
591  av_log(avctx, AV_LOG_ERROR,
592  "multi threaded encoding not supported by codec\n");
593  return -1;
594  }
595 
596  if (s->avctx->thread_count < 1) {
597  av_log(avctx, AV_LOG_ERROR,
598  "automatic thread number detection not supported by codec, "
599  "patch welcome\n");
600  return -1;
601  }
602 
603  if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
604  s->rtp_mode = 1;
605 
606  if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
607  s->h263_slice_structured = 1;
608 
609  if (!avctx->time_base.den || !avctx->time_base.num) {
610  av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
611  return -1;
612  }
613 
614  i = (INT_MAX / 2 + 128) >> 8;
615  if (avctx->mb_threshold >= i) {
616  av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
617  i - 1);
618  return -1;
619  }
620 
621  if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
622  av_log(avctx, AV_LOG_INFO,
623  "notice: b_frame_strategy only affects the first pass\n");
624  avctx->b_frame_strategy = 0;
625  }
626 
627  i = av_gcd(avctx->time_base.den, avctx->time_base.num);
628  if (i > 1) {
629  av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
630  avctx->time_base.den /= i;
631  avctx->time_base.num /= i;
632  //return -1;
633  }
634 
635  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) {
636  // (a + x * 3 / 8) / x
637  s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
638  s->inter_quant_bias = 0;
639  } else {
640  s->intra_quant_bias = 0;
641  // (a - x / 4) / x
642  s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
643  }
644 
645  if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
646  s->intra_quant_bias = avctx->intra_quant_bias;
647  if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
648  s->inter_quant_bias = avctx->inter_quant_bias;
649 
650  av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
651 
652  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
653 
654  if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
655  s->avctx->time_base.den > (1 << 16) - 1) {
656  av_log(avctx, AV_LOG_ERROR,
657  "timebase %d/%d not supported by MPEG 4 standard, "
658  "the maximum admitted value for the timebase denominator "
659  "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
660  (1 << 16) - 1);
661  return -1;
662  }
663  s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
664 
665  switch (avctx->codec->id) {
666  case AV_CODEC_ID_MPEG1VIDEO:
667  s->out_format = FMT_MPEG1;
668  s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
669  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
670  break;
671  case AV_CODEC_ID_MPEG2VIDEO:
672  s->out_format = FMT_MPEG1;
673  s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
674  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
675  s->rtp_mode = 1;
676  break;
677  case AV_CODEC_ID_LJPEG:
678  case AV_CODEC_ID_MJPEG:
679  case AV_CODEC_ID_AMV:
680  s->out_format = FMT_MJPEG;
681  s->intra_only = 1; /* force intra only for jpeg */
682  if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
683  (avctx->pix_fmt == AV_PIX_FMT_BGR0
684  || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
685  || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
686  s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
687  s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
688  s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
689  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
690  s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
691  s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
692  } else {
693  s->mjpeg_vsample[0] = 2;
694  s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
695  s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
696  s->mjpeg_hsample[0] = 2;
697  s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
698  s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
699  }
700  if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
701  ff_mjpeg_encode_init(s) < 0)
702  return -1;
703  avctx->delay = 0;
704  s->low_delay = 1;
705  break;
706  case AV_CODEC_ID_H261:
707  if (!CONFIG_H261_ENCODER)
708  return -1;
709  if (ff_h261_get_picture_format(s->width, s->height) < 0) {
710  av_log(avctx, AV_LOG_ERROR,
711  "The specified picture size of %dx%d is not valid for the "
712  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
713  s->width, s->height);
714  return -1;
715  }
716  s->out_format = FMT_H261;
717  avctx->delay = 0;
718  s->low_delay = 1;
719  break;
720  case AV_CODEC_ID_H263:
721  if (!CONFIG_H263_ENCODER)
722  return -1;
723  if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
724  s->width, s->height) == 8) {
725  av_log(avctx, AV_LOG_ERROR,
726  "The specified picture size of %dx%d is not valid for "
727  "the H.263 codec.\nValid sizes are 128x96, 176x144, "
728  "352x288, 704x576, and 1408x1152. "
729  "Try H.263+.\n", s->width, s->height);
730  return -1;
731  }
732  s->out_format = FMT_H263;
733  avctx->delay = 0;
734  s->low_delay = 1;
735  break;
736  case AV_CODEC_ID_H263P:
737  s->out_format = FMT_H263;
738  s->h263_plus = 1;
739  /* Fx */
740  s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
741  s->modified_quant = s->h263_aic;
742  s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
743  s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
744 
745  /* /Fx */
746  /* These are just to be sure */
747  avctx->delay = 0;
748  s->low_delay = 1;
749  break;
750  case AV_CODEC_ID_FLV1:
751  s->out_format = FMT_H263;
752  s->h263_flv = 2; /* format = 1; 11-bit codes */
753  s->unrestricted_mv = 1;
754  s->rtp_mode = 0; /* don't allow GOB */
755  avctx->delay = 0;
756  s->low_delay = 1;
757  break;
758  case AV_CODEC_ID_RV10:
759  s->out_format = FMT_H263;
760  avctx->delay = 0;
761  s->low_delay = 1;
762  break;
763  case AV_CODEC_ID_RV20:
764  s->out_format = FMT_H263;
765  avctx->delay = 0;
766  s->low_delay = 1;
767  s->modified_quant = 1;
768  s->h263_aic = 1;
769  s->h263_plus = 1;
770  s->loop_filter = 1;
771  s->unrestricted_mv = 0;
772  break;
773  case AV_CODEC_ID_MPEG4:
774  s->out_format = FMT_H263;
775  s->h263_pred = 1;
776  s->unrestricted_mv = 1;
777  s->low_delay = s->max_b_frames ? 0 : 1;
778  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
779  break;
780  case AV_CODEC_ID_MSMPEG4V2:
781  s->out_format = FMT_H263;
782  s->h263_pred = 1;
783  s->unrestricted_mv = 1;
784  s->msmpeg4_version = 2;
785  avctx->delay = 0;
786  s->low_delay = 1;
787  break;
788  case AV_CODEC_ID_MSMPEG4V3:
789  s->out_format = FMT_H263;
790  s->h263_pred = 1;
791  s->unrestricted_mv = 1;
792  s->msmpeg4_version = 3;
793  s->flipflop_rounding = 1;
794  avctx->delay = 0;
795  s->low_delay = 1;
796  break;
797  case AV_CODEC_ID_WMV1:
798  s->out_format = FMT_H263;
799  s->h263_pred = 1;
800  s->unrestricted_mv = 1;
801  s->msmpeg4_version = 4;
802  s->flipflop_rounding = 1;
803  avctx->delay = 0;
804  s->low_delay = 1;
805  break;
806  case AV_CODEC_ID_WMV2:
807  s->out_format = FMT_H263;
808  s->h263_pred = 1;
809  s->unrestricted_mv = 1;
810  s->msmpeg4_version = 5;
811  s->flipflop_rounding = 1;
812  avctx->delay = 0;
813  s->low_delay = 1;
814  break;
815  default:
816  return -1;
817  }
818 
819  avctx->has_b_frames = !s->low_delay;
820 
821  s->encoding = 1;
822 
823  s->progressive_frame =
824  s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
825  CODEC_FLAG_INTERLACED_ME) ||
826  s->alternate_scan);
827 
828  /* init */
829  if (ff_MPV_common_init(s) < 0)
830  return -1;
831 
832  ff_dct_encode_init(s);
833 
834  if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
835  s->chroma_qscale_table = ff_h263_chroma_qscale_table;
836 
837  s->quant_precision = 5;
838 
839  ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
840  ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
841 
842  if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
843  ff_h261_encode_init(s);
844  if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
845  ff_h263_encode_init(s);
846  if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
847  ff_msmpeg4_encode_init(s);
848  if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
849  && s->out_format == FMT_MPEG1)
850  ff_mpeg1_encode_init(s);
851 
852  /* init q matrix */
853  for (i = 0; i < 64; i++) {
854  int j = s->dsp.idct_permutation[i];
855  if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
856  s->mpeg_quant) {
857  s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
858  s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
859  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
860  s->intra_matrix[j] =
861  s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
862  } else {
863  /* mpeg1/2 */
864  s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
865  s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
866  }
867  if (s->avctx->intra_matrix)
868  s->intra_matrix[j] = s->avctx->intra_matrix[i];
869  if (s->avctx->inter_matrix)
870  s->inter_matrix[j] = s->avctx->inter_matrix[i];
871  }
872 
873  /* precompute matrix */
874  /* for mjpeg, we do include qscale in the matrix */
875  if (s->out_format != FMT_MJPEG) {
876  ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
877  s->intra_matrix, s->intra_quant_bias, avctx->qmin,
878  31, 1);
879  ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
880  s->inter_matrix, s->inter_quant_bias, avctx->qmin,
881  31, 0);
882  }
883 
884  if (ff_rate_control_init(s) < 0)
885  return -1;
886 
887  return 0;
888 }
889 
890 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
891 {
892  MpegEncContext *s = avctx->priv_data;
893 
894  ff_rate_control_uninit(s);
895 
896  ff_MPV_common_end(s);
897  if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
898  s->out_format == FMT_MJPEG)
899  ff_mjpeg_encode_close(s);
900 
901  av_freep(&avctx->extradata);
902 
903  return 0;
904 }
905 
906 static int get_sae(uint8_t *src, int ref, int stride)
907 {
908  int x,y;
909  int acc = 0;
910 
911  for (y = 0; y < 16; y++) {
912  for (x = 0; x < 16; x++) {
913  acc += FFABS(src[x + y * stride] - ref);
914  }
915  }
916 
917  return acc;
918 }
919 
920 static int get_intra_count(MpegEncContext *s, uint8_t *src,
921  uint8_t *ref, int stride)
922 {
923  int x, y, w, h;
924  int acc = 0;
925 
926  w = s->width & ~15;
927  h = s->height & ~15;
928 
929  for (y = 0; y < h; y += 16) {
930  for (x = 0; x < w; x += 16) {
931  int offset = x + y * stride;
932  int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
933  16);
934  int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
935  int sae = get_sae(src + offset, mean, stride);
936 
937  acc += sae + 500 < sad;
938  }
939  }
940  return acc;
941 }
942 
943 
944 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
945 {
946  Picture *pic = NULL;
947  int64_t pts;
948  int i, display_picture_number = 0, ret;
949  const int encoding_delay = s->max_b_frames ? s->max_b_frames :
950  (s->low_delay ? 0 : 1);
951  int direct = 1;
952 
953  if (pic_arg) {
954  pts = pic_arg->pts;
955  display_picture_number = s->input_picture_number++;
956 
957  if (pts != AV_NOPTS_VALUE) {
958  if (s->user_specified_pts != AV_NOPTS_VALUE) {
959  int64_t last = s->user_specified_pts;
960 
961  if (pts <= last) {
962  av_log(s->avctx, AV_LOG_ERROR,
963  "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
964  pts, last);
965  return AVERROR(EINVAL);
966  }
967 
968  if (!s->low_delay && display_picture_number == 1)
969  s->dts_delta = pts - 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 
1636  /* release non-reference frames */
1637  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1638  if (!s->picture[i].reference)
1639  ff_mpeg_unref_picture(s, &s->picture[i]);
1640  }
1641 
1642  assert((s->frame_bits & 7) == 0);
1643 
1644  pkt->size = s->frame_bits / 8;
1645  *got_packet = !!pkt->size;
1646  return 0;
1647 }
1648 
1649 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1650  int n, int threshold)
1651 {
1652  static const char tab[64] = {
1653  3, 2, 2, 1, 1, 1, 1, 1,
1654  1, 1, 1, 1, 1, 1, 1, 1,
1655  1, 1, 1, 1, 1, 1, 1, 1,
1656  0, 0, 0, 0, 0, 0, 0, 0,
1657  0, 0, 0, 0, 0, 0, 0, 0,
1658  0, 0, 0, 0, 0, 0, 0, 0,
1659  0, 0, 0, 0, 0, 0, 0, 0,
1660  0, 0, 0, 0, 0, 0, 0, 0
1661  };
1662  int score = 0;
1663  int run = 0;
1664  int i;
1665  int16_t *block = s->block[n];
1666  const int last_index = s->block_last_index[n];
1667  int skip_dc;
1668 
1669  if (threshold < 0) {
1670  skip_dc = 0;
1671  threshold = -threshold;
1672  } else
1673  skip_dc = 1;
1674 
1675  /* Are all we could set to zero already zero? */
1676  if (last_index <= skip_dc - 1)
1677  return;
1678 
1679  for (i = 0; i <= last_index; i++) {
1680  const int j = s->intra_scantable.permutated[i];
1681  const int level = FFABS(block[j]);
1682  if (level == 1) {
1683  if (skip_dc && i == 0)
1684  continue;
1685  score += tab[run];
1686  run = 0;
1687  } else if (level > 1) {
1688  return;
1689  } else {
1690  run++;
1691  }
1692  }
1693  if (score >= threshold)
1694  return;
1695  for (i = skip_dc; i <= last_index; i++) {
1696  const int j = s->intra_scantable.permutated[i];
1697  block[j] = 0;
1698  }
1699  if (block[0])
1700  s->block_last_index[n] = 0;
1701  else
1702  s->block_last_index[n] = -1;
1703 }
1704 
1705 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1706  int last_index)
1707 {
1708  int i;
1709  const int maxlevel = s->max_qcoeff;
1710  const int minlevel = s->min_qcoeff;
1711  int overflow = 0;
1712 
1713  if (s->mb_intra) {
1714  i = 1; // skip clipping of intra dc
1715  } else
1716  i = 0;
1717 
1718  for (; i <= last_index; i++) {
1719  const int j = s->intra_scantable.permutated[i];
1720  int level = block[j];
1721 
1722  if (level > maxlevel) {
1723  level = maxlevel;
1724  overflow++;
1725  } else if (level < minlevel) {
1726  level = minlevel;
1727  overflow++;
1728  }
1729 
1730  block[j] = level;
1731  }
1732 
1733  if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1734  av_log(s->avctx, AV_LOG_INFO,
1735  "warning, clipping %d dct coefficients to %d..%d\n",
1736  overflow, minlevel, maxlevel);
1737 }
1738 
1739 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1740 {
1741  int x, y;
1742  // FIXME optimize
1743  for (y = 0; y < 8; y++) {
1744  for (x = 0; x < 8; x++) {
1745  int x2, y2;
1746  int sum = 0;
1747  int sqr = 0;
1748  int count = 0;
1749 
1750  for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1751  for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1752  int v = ptr[x2 + y2 * stride];
1753  sum += v;
1754  sqr += v * v;
1755  count++;
1756  }
1757  }
1758  weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1759  }
1760  }
1761 }
1762 
1763 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1764  int motion_x, int motion_y,
1765  int mb_block_height,
1766  int mb_block_width,
1767  int mb_block_count)
1768 {
1769  int16_t weight[12][64];
1770  int16_t orig[12][64];
1771  const int mb_x = s->mb_x;
1772  const int mb_y = s->mb_y;
1773  int i;
1774  int skip_dct[12];
1775  int dct_offset = s->linesize * 8; // default for progressive frames
1776  int uv_dct_offset = s->uvlinesize * 8;
1777  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1778  int wrap_y, wrap_c;
1779 
1780  for (i = 0; i < mb_block_count; i++)
1781  skip_dct[i] = s->skipdct;
1782 
1783  if (s->adaptive_quant) {
1784  const int last_qp = s->qscale;
1785  const int mb_xy = mb_x + mb_y * s->mb_stride;
1786 
1787  s->lambda = s->lambda_table[mb_xy];
1788  update_qscale(s);
1789 
1790  if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1791  s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1792  s->dquant = s->qscale - last_qp;
1793 
1794  if (s->out_format == FMT_H263) {
1795  s->dquant = av_clip(s->dquant, -2, 2);
1796 
1797  if (s->codec_id == AV_CODEC_ID_MPEG4) {
1798  if (!s->mb_intra) {
1799  if (s->pict_type == AV_PICTURE_TYPE_B) {
1800  if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1801  s->dquant = 0;
1802  }
1803  if (s->mv_type == MV_TYPE_8X8)
1804  s->dquant = 0;
1805  }
1806  }
1807  }
1808  }
1809  ff_set_qscale(s, last_qp + s->dquant);
1810  } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1811  ff_set_qscale(s, s->qscale + s->dquant);
1812 
1813  wrap_y = s->linesize;
1814  wrap_c = s->uvlinesize;
1815  ptr_y = s->new_picture.f.data[0] +
1816  (mb_y * 16 * wrap_y) + mb_x * 16;
1817  ptr_cb = s->new_picture.f.data[1] +
1818  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1819  ptr_cr = s->new_picture.f.data[2] +
1820  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
1821 
1822  if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1823  uint8_t *ebuf = s->edge_emu_buffer + 32;
1824  int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
1825  int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
1826  s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1827  mb_y * 16, s->width, s->height);
1828  ptr_y = ebuf;
1829  s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, mb_block_width,
1830  mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1831  cw, ch);
1832  ptr_cb = ebuf + 18 * wrap_y;
1833  s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr, wrap_c, mb_block_width,
1834  mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,
1835  cw, ch);
1836  ptr_cr = ebuf + 18 * wrap_y + 16;
1837  }
1838 
1839  if (s->mb_intra) {
1840  if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1841  int progressive_score, interlaced_score;
1842 
1843  s->interlaced_dct = 0;
1844  progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1845  NULL, wrap_y, 8) +
1846  s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1847  NULL, wrap_y, 8) - 400;
1848 
1849  if (progressive_score > 0) {
1850  interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1851  NULL, wrap_y * 2, 8) +
1852  s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1853  NULL, wrap_y * 2, 8);
1854  if (progressive_score > interlaced_score) {
1855  s->interlaced_dct = 1;
1856 
1857  dct_offset = wrap_y;
1858  uv_dct_offset = wrap_c;
1859  wrap_y <<= 1;
1860  if (s->chroma_format == CHROMA_422 ||
1861  s->chroma_format == CHROMA_444)
1862  wrap_c <<= 1;
1863  }
1864  }
1865  }
1866 
1867  s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1868  s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1869  s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1870  s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1871 
1872  if (s->flags & CODEC_FLAG_GRAY) {
1873  skip_dct[4] = 1;
1874  skip_dct[5] = 1;
1875  } else {
1876  s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1877  s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1878  if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
1879  s->dsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
1880  s->dsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
1881  } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
1882  s->dsp.get_pixels(s->block[6], ptr_cb + 8, wrap_c);
1883  s->dsp.get_pixels(s->block[7], ptr_cr + 8, wrap_c);
1884  s->dsp.get_pixels(s->block[8], ptr_cb + uv_dct_offset, wrap_c);
1885  s->dsp.get_pixels(s->block[9], ptr_cr + uv_dct_offset, wrap_c);
1886  s->dsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
1887  s->dsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
1888  }
1889  }
1890  } else {
1891  op_pixels_func (*op_pix)[4];
1892  qpel_mc_func (*op_qpix)[16];
1893  uint8_t *dest_y, *dest_cb, *dest_cr;
1894 
1895  dest_y = s->dest[0];
1896  dest_cb = s->dest[1];
1897  dest_cr = s->dest[2];
1898 
1899  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1900  op_pix = s->hdsp.put_pixels_tab;
1901  op_qpix = s->dsp.put_qpel_pixels_tab;
1902  } else {
1903  op_pix = s->hdsp.put_no_rnd_pixels_tab;
1904  op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1905  }
1906 
1907  if (s->mv_dir & MV_DIR_FORWARD) {
1908  ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1909  s->last_picture.f.data,
1910  op_pix, op_qpix);
1911  op_pix = s->hdsp.avg_pixels_tab;
1912  op_qpix = s->dsp.avg_qpel_pixels_tab;
1913  }
1914  if (s->mv_dir & MV_DIR_BACKWARD) {
1915  ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1916  s->next_picture.f.data,
1917  op_pix, op_qpix);
1918  }
1919 
1920  if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1921  int progressive_score, interlaced_score;
1922 
1923  s->interlaced_dct = 0;
1924  progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1925  ptr_y, wrap_y,
1926  8) +
1927  s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1928  ptr_y + wrap_y * 8, wrap_y,
1929  8) - 400;
1930 
1931  if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1932  progressive_score -= 400;
1933 
1934  if (progressive_score > 0) {
1935  interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1936  ptr_y,
1937  wrap_y * 2, 8) +
1938  s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1939  ptr_y + wrap_y,
1940  wrap_y * 2, 8);
1941 
1942  if (progressive_score > interlaced_score) {
1943  s->interlaced_dct = 1;
1944 
1945  dct_offset = wrap_y;
1946  uv_dct_offset = wrap_c;
1947  wrap_y <<= 1;
1948  if (s->chroma_format == CHROMA_422)
1949  wrap_c <<= 1;
1950  }
1951  }
1952  }
1953 
1954  s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1955  s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1956  s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1957  dest_y + dct_offset, wrap_y);
1958  s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1959  dest_y + dct_offset + 8, wrap_y);
1960 
1961  if (s->flags & CODEC_FLAG_GRAY) {
1962  skip_dct[4] = 1;
1963  skip_dct[5] = 1;
1964  } else {
1965  s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1966  s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1967  if (!s->chroma_y_shift) { /* 422 */
1968  s->dsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
1969  dest_cb + uv_dct_offset, wrap_c);
1970  s->dsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
1971  dest_cr + uv_dct_offset, wrap_c);
1972  }
1973  }
1974  /* pre quantization */
1975  if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1976  2 * s->qscale * s->qscale) {
1977  // FIXME optimize
1978  if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1979  wrap_y, 8) < 20 * s->qscale)
1980  skip_dct[0] = 1;
1981  if (s->dsp.sad[1](NULL, ptr_y + 8,
1982  dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1983  skip_dct[1] = 1;
1984  if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1985  dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1986  skip_dct[2] = 1;
1987  if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1988  dest_y + dct_offset + 8,
1989  wrap_y, 8) < 20 * s->qscale)
1990  skip_dct[3] = 1;
1991  if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1992  wrap_c, 8) < 20 * s->qscale)
1993  skip_dct[4] = 1;
1994  if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1995  wrap_c, 8) < 20 * s->qscale)
1996  skip_dct[5] = 1;
1997  if (!s->chroma_y_shift) { /* 422 */
1998  if (s->dsp.sad[1](NULL, ptr_cb + uv_dct_offset,
1999  dest_cb + uv_dct_offset,
2000  wrap_c, 8) < 20 * s->qscale)
2001  skip_dct[6] = 1;
2002  if (s->dsp.sad[1](NULL, ptr_cr + uv_dct_offset,
2003  dest_cr + uv_dct_offset,
2004  wrap_c, 8) < 20 * s->qscale)
2005  skip_dct[7] = 1;
2006  }
2007  }
2008  }
2009 
2010  if (s->quantizer_noise_shaping) {
2011  if (!skip_dct[0])
2012  get_visual_weight(weight[0], ptr_y , wrap_y);
2013  if (!skip_dct[1])
2014  get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2015  if (!skip_dct[2])
2016  get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2017  if (!skip_dct[3])
2018  get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2019  if (!skip_dct[4])
2020  get_visual_weight(weight[4], ptr_cb , wrap_c);
2021  if (!skip_dct[5])
2022  get_visual_weight(weight[5], ptr_cr , wrap_c);
2023  if (!s->chroma_y_shift) { /* 422 */
2024  if (!skip_dct[6])
2025  get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2026  wrap_c);
2027  if (!skip_dct[7])
2028  get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2029  wrap_c);
2030  }
2031  memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2032  }
2033 
2034  /* DCT & quantize */
2035  av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2036  {
2037  for (i = 0; i < mb_block_count; i++) {
2038  if (!skip_dct[i]) {
2039  int overflow;
2040  s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2041  // FIXME we could decide to change to quantizer instead of
2042  // clipping
2043  // JS: I don't think that would be a good idea it could lower
2044  // quality instead of improve it. Just INTRADC clipping
2045  // deserves changes in quantizer
2046  if (overflow)
2047  clip_coeffs(s, s->block[i], s->block_last_index[i]);
2048  } else
2049  s->block_last_index[i] = -1;
2050  }
2051  if (s->quantizer_noise_shaping) {
2052  for (i = 0; i < mb_block_count; i++) {
2053  if (!skip_dct[i]) {
2054  s->block_last_index[i] =
2055  dct_quantize_refine(s, s->block[i], weight[i],
2056  orig[i], i, s->qscale);
2057  }
2058  }
2059  }
2060 
2061  if (s->luma_elim_threshold && !s->mb_intra)
2062  for (i = 0; i < 4; i++)
2063  dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2064  if (s->chroma_elim_threshold && !s->mb_intra)
2065  for (i = 4; i < mb_block_count; i++)
2066  dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2067 
2068  if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2069  for (i = 0; i < mb_block_count; i++) {
2070  if (s->block_last_index[i] == -1)
2071  s->coded_score[i] = INT_MAX / 256;
2072  }
2073  }
2074  }
2075 
2076  if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2077  s->block_last_index[4] =
2078  s->block_last_index[5] = 0;
2079  s->block[4][0] =
2080  s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2081  if (!s->chroma_y_shift) { /* 422 / 444 */
2082  for (i=6; i<12; i++) {
2083  s->block_last_index[i] = 0;
2084  s->block[i][0] = s->block[4][0];
2085  }
2086  }
2087  }
2088 
2089  // non c quantize code returns incorrect block_last_index FIXME
2090  if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2091  for (i = 0; i < mb_block_count; i++) {
2092  int j;
2093  if (s->block_last_index[i] > 0) {
2094  for (j = 63; j > 0; j--) {
2095  if (s->block[i][s->intra_scantable.permutated[j]])
2096  break;
2097  }
2098  s->block_last_index[i] = j;
2099  }
2100  }
2101  }
2102 
2103  /* huffman encode */
2104  switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2105  case AV_CODEC_ID_MPEG1VIDEO:
2106  case AV_CODEC_ID_MPEG2VIDEO:
2107  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2108  ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2109  break;
2110  case AV_CODEC_ID_MPEG4:
2111  if (CONFIG_MPEG4_ENCODER)
2112  ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2113  break;
2114  case AV_CODEC_ID_MSMPEG4V2:
2115  case AV_CODEC_ID_MSMPEG4V3:
2116  case AV_CODEC_ID_WMV1:
2117  if (CONFIG_MSMPEG4_ENCODER)
2118  ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2119  break;
2120  case AV_CODEC_ID_WMV2:
2121  if (CONFIG_WMV2_ENCODER)
2122  ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2123  break;
2124  case AV_CODEC_ID_H261:
2125  if (CONFIG_H261_ENCODER)
2126  ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2127  break;
2128  case AV_CODEC_ID_H263:
2129  case AV_CODEC_ID_H263P:
2130  case AV_CODEC_ID_FLV1:
2131  case AV_CODEC_ID_RV10:
2132  case AV_CODEC_ID_RV20:
2133  if (CONFIG_H263_ENCODER)
2134  ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2135  break;
2136  case AV_CODEC_ID_MJPEG:
2137  case AV_CODEC_ID_AMV:
2138  if (CONFIG_MJPEG_ENCODER)
2139  ff_mjpeg_encode_mb(s, s->block);
2140  break;
2141  default:
2142  av_assert1(0);
2143  }
2144 }
2145 
2146 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2147 {
2148  if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2149  else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2150  else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2151 }
2152 
2153 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2154  int i;
2155 
2156  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2157 
2158  /* mpeg1 */
2159  d->mb_skip_run= s->mb_skip_run;
2160  for(i=0; i<3; i++)
2161  d->last_dc[i] = s->last_dc[i];
2162 
2163  /* statistics */
2164  d->mv_bits= s->mv_bits;
2165  d->i_tex_bits= s->i_tex_bits;
2166  d->p_tex_bits= s->p_tex_bits;
2167  d->i_count= s->i_count;
2168  d->f_count= s->f_count;
2169  d->b_count= s->b_count;
2170  d->skip_count= s->skip_count;
2171  d->misc_bits= s->misc_bits;
2172  d->last_bits= 0;
2173 
2174  d->mb_skipped= 0;
2175  d->qscale= s->qscale;
2176  d->dquant= s->dquant;
2177 
2178  d->esc3_level_length= s->esc3_level_length;
2179 }
2180 
2181 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2182  int i;
2183 
2184  memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2185  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2186 
2187  /* mpeg1 */
2188  d->mb_skip_run= s->mb_skip_run;
2189  for(i=0; i<3; i++)
2190  d->last_dc[i] = s->last_dc[i];
2191 
2192  /* statistics */
2193  d->mv_bits= s->mv_bits;
2194  d->i_tex_bits= s->i_tex_bits;
2195  d->p_tex_bits= s->p_tex_bits;
2196  d->i_count= s->i_count;
2197  d->f_count= s->f_count;
2198  d->b_count= s->b_count;
2199  d->skip_count= s->skip_count;
2200  d->misc_bits= s->misc_bits;
2201 
2202  d->mb_intra= s->mb_intra;
2203  d->mb_skipped= s->mb_skipped;
2204  d->mv_type= s->mv_type;
2205  d->mv_dir= s->mv_dir;
2206  d->pb= s->pb;
2207  if(s->data_partitioning){
2208  d->pb2= s->pb2;
2209  d->tex_pb= s->tex_pb;
2210  }
2211  d->block= s->block;
2212  for(i=0; i<8; i++)
2213  d->block_last_index[i]= s->block_last_index[i];
2214  d->interlaced_dct= s->interlaced_dct;
2215  d->qscale= s->qscale;
2216 
2217  d->esc3_level_length= s->esc3_level_length;
2218 }
2219 
2220 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2221  PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2222  int *dmin, int *next_block, int motion_x, int motion_y)
2223 {
2224  int score;
2225  uint8_t *dest_backup[3];
2226 
2227  copy_context_before_encode(s, backup, type);
2228 
2229  s->block= s->blocks[*next_block];
2230  s->pb= pb[*next_block];
2231  if(s->data_partitioning){
2232  s->pb2 = pb2 [*next_block];
2233  s->tex_pb= tex_pb[*next_block];
2234  }
2235 
2236  if(*next_block){
2237  memcpy(dest_backup, s->dest, sizeof(s->dest));
2238  s->dest[0] = s->rd_scratchpad;
2239  s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2240  s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2241  assert(s->linesize >= 32); //FIXME
2242  }
2243 
2244  encode_mb(s, motion_x, motion_y);
2245 
2246  score= put_bits_count(&s->pb);
2247  if(s->data_partitioning){
2248  score+= put_bits_count(&s->pb2);
2249  score+= put_bits_count(&s->tex_pb);
2250  }
2251 
2252  if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2253  ff_MPV_decode_mb(s, s->block);
2254 
2255  score *= s->lambda2;
2256  score += sse_mb(s) << FF_LAMBDA_SHIFT;
2257  }
2258 
2259  if(*next_block){
2260  memcpy(s->dest, dest_backup, sizeof(s->dest));
2261  }
2262 
2263  if(score<*dmin){
2264  *dmin= score;
2265  *next_block^=1;
2266 
2267  copy_context_after_encode(best, s, type);
2268  }
2269 }
2270 
2271 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2272  uint32_t *sq = ff_squareTbl + 256;
2273  int acc=0;
2274  int x,y;
2275 
2276  if(w==16 && h==16)
2277  return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2278  else if(w==8 && h==8)
2279  return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2280 
2281  for(y=0; y<h; y++){
2282  for(x=0; x<w; x++){
2283  acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2284  }
2285  }
2286 
2287  av_assert2(acc>=0);
2288 
2289  return acc;
2290 }
2291 
2292 static int sse_mb(MpegEncContext *s){
2293  int w= 16;
2294  int h= 16;
2295 
2296  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2297  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2298 
2299  if(w==16 && h==16)
2300  if(s->avctx->mb_cmp == FF_CMP_NSSE){
2301  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)
2302  +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)
2303  +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);
2304  }else{
2305  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)
2306  +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)
2307  +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);
2308  }
2309  else
2310  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)
2311  +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)
2312  +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);
2313 }
2314 
2315 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2316  MpegEncContext *s= *(void**)arg;
2317 
2318 
2319  s->me.pre_pass=1;
2320  s->me.dia_size= s->avctx->pre_dia_size;
2321  s->first_slice_line=1;
2322  for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2323  for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2324  ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2325  }
2326  s->first_slice_line=0;
2327  }
2328 
2329  s->me.pre_pass=0;
2330 
2331  return 0;
2332 }
2333 
2334 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2335  MpegEncContext *s= *(void**)arg;
2336 
2337  ff_check_alignment();
2338 
2339  s->me.dia_size= s->avctx->dia_size;
2340  s->first_slice_line=1;
2341  for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2342  s->mb_x=0; //for block init below
2343  ff_init_block_index(s);
2344  for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2345  s->block_index[0]+=2;
2346  s->block_index[1]+=2;
2347  s->block_index[2]+=2;
2348  s->block_index[3]+=2;
2349 
2350  /* compute motion vector & mb_type and store in context */
2351  if(s->pict_type==AV_PICTURE_TYPE_B)
2352  ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2353  else
2354  ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2355  }
2356  s->first_slice_line=0;
2357  }
2358  return 0;
2359 }
2360 
2361 static int mb_var_thread(AVCodecContext *c, void *arg){
2362  MpegEncContext *s= *(void**)arg;
2363  int mb_x, mb_y;
2364 
2365  ff_check_alignment();
2366 
2367  for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2368  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2369  int xx = mb_x * 16;
2370  int yy = mb_y * 16;
2371  uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2372  int varc;
2373  int sum = s->dsp.pix_sum(pix, s->linesize);
2374 
2375  varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2376 
2377  s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2378  s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2379  s->me.mb_var_sum_temp += varc;
2380  }
2381  }
2382  return 0;
2383 }
2384 
2385 static void write_slice_end(MpegEncContext *s){
2386  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2387  if(s->partitioned_frame){
2388  ff_mpeg4_merge_partitions(s);
2389  }
2390 
2391  ff_mpeg4_stuffing(&s->pb);
2392  }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2393  ff_mjpeg_encode_stuffing(s);
2394  }
2395 
2396  avpriv_align_put_bits(&s->pb);
2397  flush_put_bits(&s->pb);
2398 
2399  if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2400  s->misc_bits+= get_bits_diff(s);
2401 }
2402 
2403 static void write_mb_info(MpegEncContext *s)
2404 {
2405  uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2406  int offset = put_bits_count(&s->pb);
2407  int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2408  int gobn = s->mb_y / s->gob_index;
2409  int pred_x, pred_y;
2410  if (CONFIG_H263_ENCODER)
2411  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2412  bytestream_put_le32(&ptr, offset);
2413  bytestream_put_byte(&ptr, s->qscale);
2414  bytestream_put_byte(&ptr, gobn);
2415  bytestream_put_le16(&ptr, mba);
2416  bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2417  bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2418  /* 4MV not implemented */
2419  bytestream_put_byte(&ptr, 0); /* hmv2 */
2420  bytestream_put_byte(&ptr, 0); /* vmv2 */
2421 }
2422 
2423 static void update_mb_info(MpegEncContext *s, int startcode)
2424 {
2425  if (!s->mb_info)
2426  return;
2427  if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2428  s->mb_info_size += 12;
2429  s->prev_mb_info = s->last_mb_info;
2430  }
2431  if (startcode) {
2432  s->prev_mb_info = put_bits_count(&s->pb)/8;
2433  /* This might have incremented mb_info_size above, and we return without
2434  * actually writing any info into that slot yet. But in that case,
2435  * this will be called again at the start of the after writing the
2436  * start code, actually writing the mb info. */
2437  return;
2438  }
2439 
2440  s->last_mb_info = put_bits_count(&s->pb)/8;
2441  if (!s->mb_info_size)
2442  s->mb_info_size += 12;
2443  write_mb_info(s);
2444 }
2445 
2446 static int encode_thread(AVCodecContext *c, void *arg){
2447  MpegEncContext *s= *(void**)arg;
2448  int mb_x, mb_y, pdif = 0;
2449  int chr_h= 16>>s->chroma_y_shift;
2450  int i, j;
2451  MpegEncContext best_s, backup_s;
2452  uint8_t bit_buf[2][MAX_MB_BYTES];
2453  uint8_t bit_buf2[2][MAX_MB_BYTES];
2454  uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2455  PutBitContext pb[2], pb2[2], tex_pb[2];
2456 
2457  ff_check_alignment();
2458 
2459  for(i=0; i<2; i++){
2460  init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2461  init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2462  init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2463  }
2464 
2465  s->last_bits= put_bits_count(&s->pb);
2466  s->mv_bits=0;
2467  s->misc_bits=0;
2468  s->i_tex_bits=0;
2469  s->p_tex_bits=0;
2470  s->i_count=0;
2471  s->f_count=0;
2472  s->b_count=0;
2473  s->skip_count=0;
2474 
2475  for(i=0; i<3; i++){
2476  /* init last dc values */
2477  /* note: quant matrix value (8) is implied here */
2478  s->last_dc[i] = 128 << s->intra_dc_precision;
2479 
2480  s->current_picture.f.error[i] = 0;
2481  }
2482  if(s->codec_id==AV_CODEC_ID_AMV){
2483  s->last_dc[0] = 128*8/13;
2484  s->last_dc[1] = 128*8/14;
2485  s->last_dc[2] = 128*8/14;
2486  }
2487  s->mb_skip_run = 0;
2488  memset(s->last_mv, 0, sizeof(s->last_mv));
2489 
2490  s->last_mv_dir = 0;
2491 
2492  switch(s->codec_id){
2493  case AV_CODEC_ID_H263:
2494  case AV_CODEC_ID_H263P:
2495  case AV_CODEC_ID_FLV1:
2496  if (CONFIG_H263_ENCODER)
2497  s->gob_index = ff_h263_get_gob_height(s);
2498  break;
2499  case AV_CODEC_ID_MPEG4:
2500  if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2501  ff_mpeg4_init_partitions(s);
2502  break;
2503  }
2504 
2505  s->resync_mb_x=0;
2506  s->resync_mb_y=0;
2507  s->first_slice_line = 1;
2508  s->ptr_lastgob = s->pb.buf;
2509  for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2510  s->mb_x=0;
2511  s->mb_y= mb_y;
2512 
2513  ff_set_qscale(s, s->qscale);
2514  ff_init_block_index(s);
2515 
2516  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2517  int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2518  int mb_type= s->mb_type[xy];
2519 // int d;
2520  int dmin= INT_MAX;
2521  int dir;
2522 
2523  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2524  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2525  return -1;
2526  }
2527  if(s->data_partitioning){
2528  if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2529  || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2530  av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2531  return -1;
2532  }
2533  }
2534 
2535  s->mb_x = mb_x;
2536  s->mb_y = mb_y; // moved into loop, can get changed by H.261
2537  ff_update_block_index(s);
2538 
2539  if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2540  ff_h261_reorder_mb_index(s);
2541  xy= s->mb_y*s->mb_stride + s->mb_x;
2542  mb_type= s->mb_type[xy];
2543  }
2544 
2545  /* write gob / video packet header */
2546  if(s->rtp_mode){
2547  int current_packet_size, is_gob_start;
2548 
2549  current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2550 
2551  is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2552 
2553  if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2554 
2555  switch(s->codec_id){
2556  case AV_CODEC_ID_H263:
2557  case AV_CODEC_ID_H263P:
2558  if(!s->h263_slice_structured)
2559  if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2560  break;
2561  case AV_CODEC_ID_MPEG2VIDEO:
2562  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2563  case AV_CODEC_ID_MPEG1VIDEO:
2564  if(s->mb_skip_run) is_gob_start=0;
2565  break;
2566  case AV_CODEC_ID_MJPEG:
2567  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2568  break;
2569  }
2570 
2571  if(is_gob_start){
2572  if(s->start_mb_y != mb_y || mb_x!=0){
2573  write_slice_end(s);
2574  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2575  ff_mpeg4_init_partitions(s);
2576  }
2577  }
2578 
2579  av_assert2((put_bits_count(&s->pb)&7) == 0);
2580  current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2581 
2582  if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2583  int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2584  int d= 100 / s->avctx->error_rate;
2585  if(r % d == 0){
2586  current_packet_size=0;
2587  s->pb.buf_ptr= s->ptr_lastgob;
2588  assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2589  }
2590  }
2591 
2592  if (s->avctx->rtp_callback){
2593  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2594  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2595  }
2596  update_mb_info(s, 1);
2597 
2598  switch(s->codec_id){
2599  case AV_CODEC_ID_MPEG4:
2600  if (CONFIG_MPEG4_ENCODER) {
2601  ff_mpeg4_encode_video_packet_header(s);
2602  ff_mpeg4_clean_buffers(s);
2603  }
2604  break;
2605  case AV_CODEC_ID_MPEG1VIDEO:
2606  case AV_CODEC_ID_MPEG2VIDEO:
2607  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2608  ff_mpeg1_encode_slice_header(s);
2609  ff_mpeg1_clean_buffers(s);
2610  }
2611  break;
2612  case AV_CODEC_ID_H263:
2613  case AV_CODEC_ID_H263P:
2614  if (CONFIG_H263_ENCODER)
2615  ff_h263_encode_gob_header(s, mb_y);
2616  break;
2617  }
2618 
2619  if(s->flags&CODEC_FLAG_PASS1){
2620  int bits= put_bits_count(&s->pb);
2621  s->misc_bits+= bits - s->last_bits;
2622  s->last_bits= bits;
2623  }
2624 
2625  s->ptr_lastgob += current_packet_size;
2626  s->first_slice_line=1;
2627  s->resync_mb_x=mb_x;
2628  s->resync_mb_y=mb_y;
2629  }
2630  }
2631 
2632  if( (s->resync_mb_x == s->mb_x)
2633  && s->resync_mb_y+1 == s->mb_y){
2634  s->first_slice_line=0;
2635  }
2636 
2637  s->mb_skipped=0;
2638  s->dquant=0; //only for QP_RD
2639 
2640  update_mb_info(s, 0);
2641 
2642  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
2643  int next_block=0;
2644  int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2645 
2646  copy_context_before_encode(&backup_s, s, -1);
2647  backup_s.pb= s->pb;
2648  best_s.data_partitioning= s->data_partitioning;
2649  best_s.partitioned_frame= s->partitioned_frame;
2650  if(s->data_partitioning){
2651  backup_s.pb2= s->pb2;
2652  backup_s.tex_pb= s->tex_pb;
2653  }
2654 
2655  if(mb_type&CANDIDATE_MB_TYPE_INTER){
2656  s->mv_dir = MV_DIR_FORWARD;
2657  s->mv_type = MV_TYPE_16X16;
2658  s->mb_intra= 0;
2659  s->mv[0][0][0] = s->p_mv_table[xy][0];
2660  s->mv[0][0][1] = s->p_mv_table[xy][1];
2661  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2662  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2663  }
2664  if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2665  s->mv_dir = MV_DIR_FORWARD;
2666  s->mv_type = MV_TYPE_FIELD;
2667  s->mb_intra= 0;
2668  for(i=0; i<2; i++){
2669  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2670  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2671  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2672  }
2673  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2674  &dmin, &next_block, 0, 0);
2675  }
2676  if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2677  s->mv_dir = MV_DIR_FORWARD;
2678  s->mv_type = MV_TYPE_16X16;
2679  s->mb_intra= 0;
2680  s->mv[0][0][0] = 0;
2681  s->mv[0][0][1] = 0;
2682  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2683  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2684  }
2685  if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2686  s->mv_dir = MV_DIR_FORWARD;
2687  s->mv_type = MV_TYPE_8X8;
2688  s->mb_intra= 0;
2689  for(i=0; i<4; i++){
2690  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2691  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2692  }
2693  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2694  &dmin, &next_block, 0, 0);
2695  }
2696  if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2697  s->mv_dir = MV_DIR_FORWARD;
2698  s->mv_type = MV_TYPE_16X16;
2699  s->mb_intra= 0;
2700  s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2701  s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2702  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2703  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2704  }
2705  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2706  s->mv_dir = MV_DIR_BACKWARD;
2707  s->mv_type = MV_TYPE_16X16;
2708  s->mb_intra= 0;
2709  s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2710  s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2711  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2712  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2713  }
2714  if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2715  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2716  s->mv_type = MV_TYPE_16X16;
2717  s->mb_intra= 0;
2718  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2719  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2720  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2721  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2722  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2723  &dmin, &next_block, 0, 0);
2724  }
2725  if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2726  s->mv_dir = MV_DIR_FORWARD;
2727  s->mv_type = MV_TYPE_FIELD;
2728  s->mb_intra= 0;
2729  for(i=0; i<2; i++){
2730  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2731  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2732  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2733  }
2734  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2735  &dmin, &next_block, 0, 0);
2736  }
2737  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2738  s->mv_dir = MV_DIR_BACKWARD;
2739  s->mv_type = MV_TYPE_FIELD;
2740  s->mb_intra= 0;
2741  for(i=0; i<2; i++){
2742  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2743  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2744  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2745  }
2746  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2747  &dmin, &next_block, 0, 0);
2748  }
2749  if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2750  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2751  s->mv_type = MV_TYPE_FIELD;
2752  s->mb_intra= 0;
2753  for(dir=0; dir<2; dir++){
2754  for(i=0; i<2; i++){
2755  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2756  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2757  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2758  }
2759  }
2760  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2761  &dmin, &next_block, 0, 0);
2762  }
2763  if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2764  s->mv_dir = 0;
2765  s->mv_type = MV_TYPE_16X16;
2766  s->mb_intra= 1;
2767  s->mv[0][0][0] = 0;
2768  s->mv[0][0][1] = 0;
2769  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2770  &dmin, &next_block, 0, 0);
2771  if(s->h263_pred || s->h263_aic){
2772  if(best_s.mb_intra)
2773  s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2774  else
2775  ff_clean_intra_table_entries(s); //old mode?
2776  }
2777  }
2778 
2779  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2780  if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2781  const int last_qp= backup_s.qscale;
2782  int qpi, qp, dc[6];
2783  int16_t ac[6][16];
2784  const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2785  static const int dquant_tab[4]={-1,1,-2,2};
2786  int storecoefs = s->mb_intra && s->dc_val[0];
2787 
2788  av_assert2(backup_s.dquant == 0);
2789 
2790  //FIXME intra
2791  s->mv_dir= best_s.mv_dir;
2792  s->mv_type = MV_TYPE_16X16;
2793  s->mb_intra= best_s.mb_intra;
2794  s->mv[0][0][0] = best_s.mv[0][0][0];
2795  s->mv[0][0][1] = best_s.mv[0][0][1];
2796  s->mv[1][0][0] = best_s.mv[1][0][0];
2797  s->mv[1][0][1] = best_s.mv[1][0][1];
2798 
2799  qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2800  for(; qpi<4; qpi++){
2801  int dquant= dquant_tab[qpi];
2802  qp= last_qp + dquant;
2803  if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2804  continue;
2805  backup_s.dquant= dquant;
2806  if(storecoefs){
2807  for(i=0; i<6; i++){
2808  dc[i]= s->dc_val[0][ s->block_index[i] ];
2809  memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2810  }
2811  }
2812 
2813  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2814  &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2815  if(best_s.qscale != qp){
2816  if(storecoefs){
2817  for(i=0; i<6; i++){
2818  s->dc_val[0][ s->block_index[i] ]= dc[i];
2819  memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2820  }
2821  }
2822  }
2823  }
2824  }
2825  }
2826  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2827  int mx= s->b_direct_mv_table[xy][0];
2828  int my= s->b_direct_mv_table[xy][1];
2829 
2830  backup_s.dquant = 0;
2831  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2832  s->mb_intra= 0;
2833  ff_mpeg4_set_direct_mv(s, mx, my);
2834  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2835  &dmin, &next_block, mx, my);
2836  }
2837  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2838  backup_s.dquant = 0;
2839  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2840  s->mb_intra= 0;
2841  ff_mpeg4_set_direct_mv(s, 0, 0);
2842  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2843  &dmin, &next_block, 0, 0);
2844  }
2845  if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2846  int coded=0;
2847  for(i=0; i<6; i++)
2848  coded |= s->block_last_index[i];
2849  if(coded){
2850  int mx,my;
2851  memcpy(s->mv, best_s.mv, sizeof(s->mv));
2852  if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2853  mx=my=0; //FIXME find the one we actually used
2854  ff_mpeg4_set_direct_mv(s, mx, my);
2855  }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2856  mx= s->mv[1][0][0];
2857  my= s->mv[1][0][1];
2858  }else{
2859  mx= s->mv[0][0][0];
2860  my= s->mv[0][0][1];
2861  }
2862 
2863  s->mv_dir= best_s.mv_dir;
2864  s->mv_type = best_s.mv_type;
2865  s->mb_intra= 0;
2866 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2867  s->mv[0][0][1] = best_s.mv[0][0][1];
2868  s->mv[1][0][0] = best_s.mv[1][0][0];
2869  s->mv[1][0][1] = best_s.mv[1][0][1];*/
2870  backup_s.dquant= 0;
2871  s->skipdct=1;
2872  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2873  &dmin, &next_block, mx, my);
2874  s->skipdct=0;
2875  }
2876  }
2877 
2878  s->current_picture.qscale_table[xy] = best_s.qscale;
2879 
2880  copy_context_after_encode(s, &best_s, -1);
2881 
2882  pb_bits_count= put_bits_count(&s->pb);
2883  flush_put_bits(&s->pb);
2884  avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2885  s->pb= backup_s.pb;
2886 
2887  if(s->data_partitioning){
2888  pb2_bits_count= put_bits_count(&s->pb2);
2889  flush_put_bits(&s->pb2);
2890  avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2891  s->pb2= backup_s.pb2;
2892 
2893  tex_pb_bits_count= put_bits_count(&s->tex_pb);
2894  flush_put_bits(&s->tex_pb);
2895  avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2896  s->tex_pb= backup_s.tex_pb;
2897  }
2898  s->last_bits= put_bits_count(&s->pb);
2899 
2900  if (CONFIG_H263_ENCODER &&
2901  s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2902  ff_h263_update_motion_val(s);
2903 
2904  if(next_block==0){ //FIXME 16 vs linesize16
2905  s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2906  s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2907  s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2908  }
2909 
2910  if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2911  ff_MPV_decode_mb(s, s->block);
2912  } else {
2913  int motion_x = 0, motion_y = 0;
2914  s->mv_type=MV_TYPE_16X16;
2915  // only one MB-Type possible
2916 
2917  switch(mb_type){
2918  case CANDIDATE_MB_TYPE_INTRA:
2919  s->mv_dir = 0;
2920  s->mb_intra= 1;
2921  motion_x= s->mv[0][0][0] = 0;
2922  motion_y= s->mv[0][0][1] = 0;
2923  break;
2924  case CANDIDATE_MB_TYPE_INTER:
2925  s->mv_dir = MV_DIR_FORWARD;
2926  s->mb_intra= 0;
2927  motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2928  motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2929  break;
2930  case CANDIDATE_MB_TYPE_INTER_I:
2931  s->mv_dir = MV_DIR_FORWARD;
2932  s->mv_type = MV_TYPE_FIELD;
2933  s->mb_intra= 0;
2934  for(i=0; i<2; i++){
2935  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2936  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2937  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2938  }
2939  break;
2940  case CANDIDATE_MB_TYPE_INTER4V:
2941  s->mv_dir = MV_DIR_FORWARD;
2942  s->mv_type = MV_TYPE_8X8;
2943  s->mb_intra= 0;
2944  for(i=0; i<4; i++){
2945  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2946  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2947  }
2948  break;
2949  case CANDIDATE_MB_TYPE_DIRECT:
2950  if (CONFIG_MPEG4_ENCODER) {
2951  s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2952  s->mb_intra= 0;
2953  motion_x=s->b_direct_mv_table[xy][0];
2954  motion_y=s->b_direct_mv_table[xy][1];
2955  ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2956  }
2957  break;
2958  case CANDIDATE_MB_TYPE_DIRECT0:
2959  if (CONFIG_MPEG4_ENCODER) {
2960  s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2961  s->mb_intra= 0;
2962  ff_mpeg4_set_direct_mv(s, 0, 0);
2963  }
2964  break;
2965  case CANDIDATE_MB_TYPE_BIDIR:
2966  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2967  s->mb_intra= 0;
2968  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2969  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2970  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2971  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2972  break;
2973  case CANDIDATE_MB_TYPE_BACKWARD:
2974  s->mv_dir = MV_DIR_BACKWARD;
2975  s->mb_intra= 0;
2976  motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2977  motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2978  break;
2979  case CANDIDATE_MB_TYPE_FORWARD:
2980  s->mv_dir = MV_DIR_FORWARD;
2981  s->mb_intra= 0;
2982  motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2983  motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2984  break;
2985  case CANDIDATE_MB_TYPE_FORWARD_I:
2986  s->mv_dir = MV_DIR_FORWARD;
2987  s->mv_type = MV_TYPE_FIELD;
2988  s->mb_intra= 0;
2989  for(i=0; i<2; i++){
2990  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2991  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2992  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2993  }
2994  break;
2995  case CANDIDATE_MB_TYPE_BACKWARD_I:
2996  s->mv_dir = MV_DIR_BACKWARD;
2997  s->mv_type = MV_TYPE_FIELD;
2998  s->mb_intra= 0;
2999  for(i=0; i<2; i++){
3000  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3001  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3002  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3003  }
3004  break;
3005  case CANDIDATE_MB_TYPE_BIDIR_I:
3006  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3007  s->mv_type = MV_TYPE_FIELD;
3008  s->mb_intra= 0;
3009  for(dir=0; dir<2; dir++){
3010  for(i=0; i<2; i++){
3011  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3012  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3013  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3014  }
3015  }
3016  break;
3017  default:
3018  av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3019  }
3020 
3021  encode_mb(s, motion_x, motion_y);
3022 
3023  // RAL: Update last macroblock type
3024  s->last_mv_dir = s->mv_dir;
3025 
3026  if (CONFIG_H263_ENCODER &&
3027  s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3028  ff_h263_update_motion_val(s);
3029 
3030  ff_MPV_decode_mb(s, s->block);
3031  }
3032 
3033  /* clean the MV table in IPS frames for direct mode in B frames */
3034  if(s->mb_intra /* && I,P,S_TYPE */){
3035  s->p_mv_table[xy][0]=0;
3036  s->p_mv_table[xy][1]=0;
3037  }
3038 
3039  if(s->flags&CODEC_FLAG_PSNR){
3040  int w= 16;
3041  int h= 16;
3042 
3043  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3044  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3045 
3046  s->current_picture.f.error[0] += sse(
3047  s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3048  s->dest[0], w, h, s->linesize);
3049  s->current_picture.f.error[1] += sse(
3050  s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3051  s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3052  s->current_picture.f.error[2] += sse(
3053  s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3054  s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3055  }
3056  if(s->loop_filter){
3057  if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3058  ff_h263_loop_filter(s);
3059  }
3060  av_dlog(s->avctx, "MB %d %d bits\n",
3061  s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3062  }
3063  }
3064 
3065  //not beautiful here but we must write it before flushing so it has to be here
3066  if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3067  ff_msmpeg4_encode_ext_header(s);
3068 
3069  write_slice_end(s);
3070 
3071  /* Send the last GOB if RTP */
3072  if (s->avctx->rtp_callback) {
3073  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3074  pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3075  /* Call the RTP callback to send the last GOB */
3076  emms_c();
3077  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3078  }
3079 
3080  return 0;
3081 }
3082 
3083 #define MERGE(field) dst->field += src->field; src->field=0
3084 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3085  MERGE(me.scene_change_score);
3086  MERGE(me.mc_mb_var_sum_temp);
3087  MERGE(me.mb_var_sum_temp);
3088 }
3089 
3090 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3091  int i;
3092 
3093  MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3094  MERGE(dct_count[1]);
3095  MERGE(mv_bits);
3096  MERGE(i_tex_bits);
3097  MERGE(p_tex_bits);
3098  MERGE(i_count);
3099  MERGE(f_count);
3100  MERGE(b_count);
3101  MERGE(skip_count);
3102  MERGE(misc_bits);
3103  MERGE(er.error_count);
3104  MERGE(padding_bug_score);
3105  MERGE(current_picture.f.error[0]);
3106  MERGE(current_picture.f.error[1]);
3107  MERGE(current_picture.f.error[2]);
3108 
3109  if(dst->avctx->noise_reduction){
3110  for(i=0; i<64; i++){
3111  MERGE(dct_error_sum[0][i]);
3112  MERGE(dct_error_sum[1][i]);
3113  }
3114  }
3115 
3116  assert(put_bits_count(&src->pb) % 8 ==0);
3117  assert(put_bits_count(&dst->pb) % 8 ==0);
3118  avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3119  flush_put_bits(&dst->pb);
3120 }
3121 
3122 static int estimate_qp(MpegEncContext *s, int dry_run){
3123  if (s->next_lambda){
3124  s->current_picture_ptr->f.quality =
3125  s->current_picture.f.quality = s->next_lambda;
3126  if(!dry_run) s->next_lambda= 0;
3127  } else if (!s->fixed_qscale) {
3128  s->current_picture_ptr->f.quality =
3129  s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3130  if (s->current_picture.f.quality < 0)
3131  return -1;
3132  }
3133 
3134  if(s->adaptive_quant){
3135  switch(s->codec_id){
3136  case AV_CODEC_ID_MPEG4:
3137  if (CONFIG_MPEG4_ENCODER)
3138  ff_clean_mpeg4_qscales(s);
3139  break;
3140  case AV_CODEC_ID_H263:
3141  case AV_CODEC_ID_H263P:
3142  case AV_CODEC_ID_FLV1:
3143  if (CONFIG_H263_ENCODER)
3144  ff_clean_h263_qscales(s);
3145  break;
3146  default:
3147  ff_init_qscale_tab(s);
3148  }
3149 
3150  s->lambda= s->lambda_table[0];
3151  //FIXME broken
3152  }else
3153  s->lambda = s->current_picture.f.quality;
3154  update_qscale(s);
3155  return 0;
3156 }
3157 
3158 /* must be called before writing the header */
3159 static void set_frame_distances(MpegEncContext * s){
3160  assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3161  s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3162 
3163  if(s->pict_type==AV_PICTURE_TYPE_B){
3164  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3165  assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3166  }else{
3167  s->pp_time= s->time - s->last_non_b_time;
3168  s->last_non_b_time= s->time;
3169  assert(s->picture_number==0 || s->pp_time > 0);
3170  }
3171 }
3172 
3173 static int encode_picture(MpegEncContext *s, int picture_number)
3174 {
3175  int i, ret;
3176  int bits;
3177  int context_count = s->slice_context_count;
3178 
3179  s->picture_number = picture_number;
3180 
3181  /* Reset the average MB variance */
3182  s->me.mb_var_sum_temp =
3183  s->me.mc_mb_var_sum_temp = 0;
3184 
3185  /* we need to initialize some time vars before we can encode b-frames */
3186  // RAL: Condition added for MPEG1VIDEO
3187  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3188  set_frame_distances(s);
3189  if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3190  ff_set_mpeg4_time(s);
3191 
3192  s->me.scene_change_score=0;
3193 
3194 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3195 
3196  if(s->pict_type==AV_PICTURE_TYPE_I){
3197  if(s->msmpeg4_version >= 3) s->no_rounding=1;
3198  else s->no_rounding=0;
3199  }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3200  if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3201  s->no_rounding ^= 1;
3202  }
3203 
3204  if(s->flags & CODEC_FLAG_PASS2){
3205  if (estimate_qp(s,1) < 0)
3206  return -1;
3207  ff_get_2pass_fcode(s);
3208  }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3209  if(s->pict_type==AV_PICTURE_TYPE_B)
3210  s->lambda= s->last_lambda_for[s->pict_type];
3211  else
3212  s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3213  update_qscale(s);
3214  }
3215 
3216  if(s->codec_id != AV_CODEC_ID_AMV){
3217  if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
3218  if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3219  s->q_chroma_intra_matrix = s->q_intra_matrix;
3220  s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3221  }
3222 
3223  s->mb_intra=0; //for the rate distortion & bit compare functions
3224  for(i=1; i<context_count; i++){
3225  ret = ff_update_duplicate_context(s->thread_context[i], s);
3226  if (ret < 0)
3227  return ret;
3228  }
3229 
3230  if(ff_init_me(s)<0)
3231  return -1;
3232 
3233  /* Estimate motion for every MB */
3234  if(s->pict_type != AV_PICTURE_TYPE_I){
3235  s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3236  s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3237  if (s->pict_type != AV_PICTURE_TYPE_B) {
3238  if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3239  s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3240  }
3241  }
3242 
3243  s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3244  }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3245  /* I-Frame */
3246  for(i=0; i<s->mb_stride*s->mb_height; i++)
3247  s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3248 
3249  if(!s->fixed_qscale){
3250  /* finding spatial complexity for I-frame rate control */
3251  s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3252  }
3253  }
3254  for(i=1; i<context_count; i++){
3255  merge_context_after_me(s, s->thread_context[i]);
3256  }
3257  s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3258  s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3259  emms_c();
3260 
3261  if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3262  s->pict_type= AV_PICTURE_TYPE_I;
3263  for(i=0; i<s->mb_stride*s->mb_height; i++)
3264  s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3265  if(s->msmpeg4_version >= 3)
3266  s->no_rounding=1;
3267  av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3268  s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3269  }
3270 
3271  if(!s->umvplus){
3272  if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3273  s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3274 
3275  if(s->flags & CODEC_FLAG_INTERLACED_ME){
3276  int a,b;
3277  a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3278  b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3279  s->f_code= FFMAX3(s->f_code, a, b);
3280  }
3281 
3282  ff_fix_long_p_mvs(s);
3283  ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3284  if(s->flags & CODEC_FLAG_INTERLACED_ME){
3285  int j;
3286  for(i=0; i<2; i++){
3287  for(j=0; j<2; j++)
3288  ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3289  s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3290  }
3291  }
3292  }
3293 
3294  if(s->pict_type==AV_PICTURE_TYPE_B){
3295  int a, b;
3296 
3297  a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3298  b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3299  s->f_code = FFMAX(a, b);
3300 
3301  a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3302  b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3303  s->b_code = FFMAX(a, b);
3304 
3305  ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3306  ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3307  ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3308  ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3309  if(s->flags & CODEC_FLAG_INTERLACED_ME){
3310  int dir, j;
3311  for(dir=0; dir<2; dir++){
3312  for(i=0; i<2; i++){
3313  for(j=0; j<2; j++){
3314  int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3315  : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3316  ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3317  s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3318  }
3319  }
3320  }
3321  }
3322  }
3323  }
3324 
3325  if (estimate_qp(s, 0) < 0)
3326  return -1;
3327 
3328  if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3329  s->qscale= 3; //reduce clipping problems
3330 
3331  if (s->out_format == FMT_MJPEG) {
3332  /* for mjpeg, we do include qscale in the matrix */
3333  for(i=1;i<64;i++){
3334  int j= s->dsp.idct_permutation[i];
3335 
3336  s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3337  }
3338  s->y_dc_scale_table=
3339  s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3340  s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3341  ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3342  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3343  s->qscale= 8;
3344  }
3345  if(s->codec_id == AV_CODEC_ID_AMV){
3346  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};
3347  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};
3348  for(i=1;i<64;i++){
3349  int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3350 
3351  s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3352  s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3353  }
3354  s->y_dc_scale_table= y;
3355  s->c_dc_scale_table= c;
3356  s->intra_matrix[0] = 13;
3357  s->chroma_intra_matrix[0] = 14;
3358  ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3359  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3360  ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3361  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3362  s->qscale= 8;
3363  }
3364 
3365  //FIXME var duplication
3366  s->current_picture_ptr->f.key_frame =
3367  s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3368  s->current_picture_ptr->f.pict_type =
3369  s->current_picture.f.pict_type = s->pict_type;
3370 
3371  if (s->current_picture.f.key_frame)
3372  s->picture_in_gop_number=0;
3373 
3374  s->mb_x = s->mb_y = 0;
3375  s->last_bits= put_bits_count(&s->pb);
3376  switch(s->out_format) {
3377  case FMT_MJPEG:
3378  if (CONFIG_MJPEG_ENCODER)
3379  ff_mjpeg_encode_picture_header(s);
3380  break;
3381  case FMT_H261:
3382  if (CONFIG_H261_ENCODER)
3383  ff_h261_encode_picture_header(s, picture_number);
3384  break;
3385  case FMT_H263:
3386  if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3387  ff_wmv2_encode_picture_header(s, picture_number);
3388  else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3389  ff_msmpeg4_encode_picture_header(s, picture_number);
3390  else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3391  ff_mpeg4_encode_picture_header(s, picture_number);
3392  else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3393  ff_rv10_encode_picture_header(s, picture_number);
3394  else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3395  ff_rv20_encode_picture_header(s, picture_number);
3396  else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3397  ff_flv_encode_picture_header(s, picture_number);
3398  else if (CONFIG_H263_ENCODER)
3399  ff_h263_encode_picture_header(s, picture_number);
3400  break;
3401  case FMT_MPEG1:
3402  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3403  ff_mpeg1_encode_picture_header(s, picture_number);
3404  break;
3405  default:
3406  av_assert0(0);
3407  }
3408  bits= put_bits_count(&s->pb);
3409  s->header_bits= bits - s->last_bits;
3410 
3411  for(i=1; i<context_count; i++){
3412  update_duplicate_context_after_me(s->thread_context[i], s);
3413  }
3414  s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3415  for(i=1; i<context_count; i++){
3416  merge_context_after_encode(s, s->thread_context[i]);
3417  }
3418  emms_c();
3419  return 0;
3420 }
3421 
3422 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3423  const int intra= s->mb_intra;
3424  int i;
3425 
3426  s->dct_count[intra]++;
3427 
3428  for(i=0; i<64; i++){
3429  int level= block[i];
3430 
3431  if(level){
3432  if(level>0){
3433  s->dct_error_sum[intra][i] += level;
3434  level -= s->dct_offset[intra][i];
3435  if(level<0) level=0;
3436  }else{
3437  s->dct_error_sum[intra][i] -= level;
3438  level += s->dct_offset[intra][i];
3439  if(level>0) level=0;
3440  }
3441  block[i]= level;
3442  }
3443  }
3444 }
3445 
3446 static int dct_quantize_trellis_c(MpegEncContext *s,
3447  int16_t *block, int n,
3448  int qscale, int *overflow){
3449  const int *qmat;
3450  const uint8_t *scantable= s->intra_scantable.scantable;
3451  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3452  int max=0;
3453  unsigned int threshold1, threshold2;
3454  int bias=0;
3455  int run_tab[65];
3456  int level_tab[65];
3457  int score_tab[65];
3458  int survivor[65];
3459  int survivor_count;
3460  int last_run=0;
3461  int last_level=0;
3462  int last_score= 0;
3463  int last_i;
3464  int coeff[2][64];
3465  int coeff_count[64];
3466  int qmul, qadd, start_i, last_non_zero, i, dc;
3467  const int esc_length= s->ac_esc_length;
3468  uint8_t * length;
3469  uint8_t * last_length;
3470  const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3471 
3472  s->dsp.fdct (block);
3473 
3474  if(s->dct_error_sum)
3475  s->denoise_dct(s, block);
3476  qmul= qscale*16;
3477  qadd= ((qscale-1)|1)*8;
3478 
3479  if (s->mb_intra) {
3480  int q;
3481  if (!s->h263_aic) {
3482  if (n < 4)
3483  q = s->y_dc_scale;
3484  else
3485  q = s->c_dc_scale;
3486  q = q << 3;
3487  } else{
3488  /* For AIC we skip quant/dequant of INTRADC */
3489  q = 1 << 3;
3490  qadd=0;
3491  }
3492 
3493  /* note: block[0] is assumed to be positive */
3494  block[0] = (block[0] + (q >> 1)) / q;
3495  start_i = 1;
3496  last_non_zero = 0;
3497  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3498  if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3499  bias= 1<<(QMAT_SHIFT-1);
3500  length = s->intra_ac_vlc_length;
3501  last_length= s->intra_ac_vlc_last_length;
3502  } else {
3503  start_i = 0;
3504  last_non_zero = -1;
3505  qmat = s->q_inter_matrix[qscale];
3506  length = s->inter_ac_vlc_length;
3507  last_length= s->inter_ac_vlc_last_length;
3508  }
3509  last_i= start_i;
3510 
3511  threshold1= (1<<QMAT_SHIFT) - bias - 1;
3512  threshold2= (threshold1<<1);
3513 
3514  for(i=63; i>=start_i; i--) {
3515  const int j = scantable[i];
3516  int level = block[j] * qmat[j];
3517 
3518  if(((unsigned)(level+threshold1))>threshold2){
3519  last_non_zero = i;
3520  break;
3521  }
3522  }
3523 
3524  for(i=start_i; i<=last_non_zero; i++) {
3525  const int j = scantable[i];
3526  int level = block[j] * qmat[j];
3527 
3528 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3529 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3530  if(((unsigned)(level+threshold1))>threshold2){
3531  if(level>0){
3532  level= (bias + level)>>QMAT_SHIFT;
3533  coeff[0][i]= level;
3534  coeff[1][i]= level-1;
3535 // coeff[2][k]= level-2;
3536  }else{
3537  level= (bias - level)>>QMAT_SHIFT;
3538  coeff[0][i]= -level;
3539  coeff[1][i]= -level+1;
3540 // coeff[2][k]= -level+2;
3541  }
3542  coeff_count[i]= FFMIN(level, 2);
3543  av_assert2(coeff_count[i]);
3544  max |=level;
3545  }else{
3546  coeff[0][i]= (level>>31)|1;
3547  coeff_count[i]= 1;
3548  }
3549  }
3550 
3551  *overflow= s->max_qcoeff < max; //overflow might have happened
3552 
3553  if(last_non_zero < start_i){
3554  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3555  return last_non_zero;
3556  }
3557 
3558  score_tab[start_i]= 0;
3559  survivor[0]= start_i;
3560  survivor_count= 1;
3561 
3562  for(i=start_i; i<=last_non_zero; i++){
3563  int level_index, j, zero_distortion;
3564  int dct_coeff= FFABS(block[ scantable[i] ]);
3565  int best_score=256*256*256*120;
3566 
3567  if (s->dsp.fdct == ff_fdct_ifast)
3568  dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3569  zero_distortion= dct_coeff*dct_coeff;
3570 
3571  for(level_index=0; level_index < coeff_count[i]; level_index++){
3572  int distortion;
3573  int level= coeff[level_index][i];
3574  const int alevel= FFABS(level);
3575  int unquant_coeff;
3576 
3577  av_assert2(level);
3578 
3579  if(s->out_format == FMT_H263){
3580  unquant_coeff= alevel*qmul + qadd;
3581  }else{ //MPEG1
3582  j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3583  if(s->mb_intra){
3584  unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3585  unquant_coeff = (unquant_coeff - 1) | 1;
3586  }else{
3587  unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3588  unquant_coeff = (unquant_coeff - 1) | 1;
3589  }
3590  unquant_coeff<<= 3;
3591  }
3592 
3593  distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3594  level+=64;
3595  if((level&(~127)) == 0){
3596  for(j=survivor_count-1; j>=0; j--){
3597  int run= i - survivor[j];
3598  int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3599  score += score_tab[i-run];
3600 
3601  if(score < best_score){
3602  best_score= score;
3603  run_tab[i+1]= run;
3604  level_tab[i+1]= level-64;
3605  }
3606  }
3607 
3608  if(s->out_format == FMT_H263){
3609  for(j=survivor_count-1; j>=0; j--){
3610  int run= i - survivor[j];
3611  int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3612  score += score_tab[i-run];
3613  if(score < last_score){
3614  last_score= score;
3615  last_run= run;
3616  last_level= level-64;
3617  last_i= i+1;
3618  }
3619  }
3620  }
3621  }else{
3622  distortion += esc_length*lambda;
3623  for(j=survivor_count-1; j>=0; j--){
3624  int run= i - survivor[j];
3625  int score= distortion + score_tab[i-run];
3626 
3627  if(score < best_score){
3628  best_score= score;
3629  run_tab[i+1]= run;
3630  level_tab[i+1]= level-64;
3631  }
3632  }
3633 
3634  if(s->out_format == FMT_H263){
3635  for(j=survivor_count-1; j>=0; j--){
3636  int run= i - survivor[j];
3637  int score= distortion + score_tab[i-run];
3638  if(score < last_score){
3639  last_score= score;
3640  last_run= run;
3641  last_level= level-64;
3642  last_i= i+1;
3643  }
3644  }
3645  }
3646  }
3647  }
3648 
3649  score_tab[i+1]= best_score;
3650 
3651  //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3652  if(last_non_zero <= 27){
3653  for(; survivor_count; survivor_count--){
3654  if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3655  break;
3656  }
3657  }else{
3658  for(; survivor_count; survivor_count--){
3659  if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3660  break;
3661  }
3662  }
3663 
3664  survivor[ survivor_count++ ]= i+1;
3665  }
3666 
3667  if(s->out_format != FMT_H263){
3668  last_score= 256*256*256*120;
3669  for(i= survivor[0]; i<=last_non_zero + 1; i++){
3670  int score= score_tab[i];
3671  if(i) score += lambda*2; //FIXME exacter?
3672 
3673  if(score < last_score){
3674  last_score= score;
3675  last_i= i;
3676  last_level= level_tab[i];
3677  last_run= run_tab[i];
3678  }
3679  }
3680  }
3681 
3682  s->coded_score[n] = last_score;
3683 
3684  dc= FFABS(block[0]);
3685  last_non_zero= last_i - 1;
3686  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3687 
3688  if(last_non_zero < start_i)
3689  return last_non_zero;
3690 
3691  if(last_non_zero == 0 && start_i == 0){
3692  int best_level= 0;
3693  int best_score= dc * dc;
3694 
3695  for(i=0; i<coeff_count[0]; i++){
3696  int level= coeff[i][0];
3697  int alevel= FFABS(level);
3698  int unquant_coeff, score, distortion;
3699 
3700  if(s->out_format == FMT_H263){
3701  unquant_coeff= (alevel*qmul + qadd)>>3;
3702  }else{ //MPEG1
3703  unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3704  unquant_coeff = (unquant_coeff - 1) | 1;
3705  }
3706  unquant_coeff = (unquant_coeff + 4) >> 3;
3707  unquant_coeff<<= 3 + 3;
3708 
3709  distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3710  level+=64;
3711  if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3712  else score= distortion + esc_length*lambda;
3713 
3714  if(score < best_score){
3715  best_score= score;
3716  best_level= level - 64;
3717  }
3718  }
3719  block[0]= best_level;
3720  s->coded_score[n] = best_score - dc*dc;
3721  if(best_level == 0) return -1;
3722  else return last_non_zero;
3723  }
3724 
3725  i= last_i;
3726  av_assert2(last_level);
3727 
3728  block[ perm_scantable[last_non_zero] ]= last_level;
3729  i -= last_run + 1;
3730 
3731  for(; i>start_i; i -= run_tab[i] + 1){
3732  block[ perm_scantable[i-1] ]= level_tab[i];
3733  }
3734 
3735  return last_non_zero;
3736 }
3737 
3738 //#define REFINE_STATS 1
3739 static int16_t basis[64][64];
3740 
3741 static void build_basis(uint8_t *perm){
3742  int i, j, x, y;
3743  emms_c();
3744  for(i=0; i<8; i++){
3745  for(j=0; j<8; j++){
3746  for(y=0; y<8; y++){
3747  for(x=0; x<8; x++){
3748  double s= 0.25*(1<<BASIS_SHIFT);
3749  int index= 8*i + j;
3750  int perm_index= perm[index];
3751  if(i==0) s*= sqrt(0.5);
3752  if(j==0) s*= sqrt(0.5);
3753  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)));
3754  }
3755  }
3756  }
3757  }
3758 }
3759 
3760 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3761  int16_t *block, int16_t *weight, int16_t *orig,
3762  int n, int qscale){
3763  int16_t rem[64];
3764  LOCAL_ALIGNED_16(int16_t, d1, [64]);
3765  const uint8_t *scantable= s->intra_scantable.scantable;
3766  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3767 // unsigned int threshold1, threshold2;
3768 // int bias=0;
3769  int run_tab[65];
3770  int prev_run=0;
3771  int prev_level=0;
3772  int qmul, qadd, start_i, last_non_zero, i, dc;
3773  uint8_t * length;
3774  uint8_t * last_length;
3775  int lambda;
3776  int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3777 #ifdef REFINE_STATS
3778 static int count=0;
3779 static int after_last=0;
3780 static int to_zero=0;
3781 static int from_zero=0;
3782 static int raise=0;
3783 static int lower=0;
3784 static int messed_sign=0;
3785 #endif
3786 
3787  if(basis[0][0] == 0)
3788  build_basis(s->dsp.idct_permutation);
3789 
3790  qmul= qscale*2;
3791  qadd= (qscale-1)|1;
3792  if (s->mb_intra) {
3793  if (!s->h263_aic) {
3794  if (n < 4)
3795  q = s->y_dc_scale;
3796  else
3797  q = s->c_dc_scale;
3798  } else{
3799  /* For AIC we skip quant/dequant of INTRADC */
3800  q = 1;
3801  qadd=0;
3802  }
3803  q <<= RECON_SHIFT-3;
3804  /* note: block[0] is assumed to be positive */
3805  dc= block[0]*q;
3806 // block[0] = (block[0] + (q >> 1)) / q;
3807  start_i = 1;
3808 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3809 // bias= 1<<(QMAT_SHIFT-1);
3810  length = s->intra_ac_vlc_length;
3811  last_length= s->intra_ac_vlc_last_length;
3812  } else {
3813  dc= 0;
3814  start_i = 0;
3815  length = s->inter_ac_vlc_length;
3816  last_length= s->inter_ac_vlc_last_length;
3817  }
3818  last_non_zero = s->block_last_index[n];
3819 
3820 #ifdef REFINE_STATS
3821 {START_TIMER
3822 #endif
3823  dc += (1<<(RECON_SHIFT-1));
3824  for(i=0; i<64; i++){
3825  rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3826  }
3827 #ifdef REFINE_STATS
3828 STOP_TIMER("memset rem[]")}
3829 #endif
3830  sum=0;
3831  for(i=0; i<64; i++){
3832  int one= 36;
3833  int qns=4;
3834  int w;
3835 
3836  w= FFABS(weight[i]) + qns*one;
3837  w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3838 
3839  weight[i] = w;
3840 // w=weight[i] = (63*qns + (w/2)) / w;
3841 
3842  av_assert2(w>0);
3843  av_assert2(w<(1<<6));
3844  sum += w*w;
3845  }
3846  lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3847 #ifdef REFINE_STATS
3848 {START_TIMER
3849 #endif
3850  run=0;
3851  rle_index=0;
3852  for(i=start_i; i<=last_non_zero; i++){
3853  int j= perm_scantable[i];
3854  const int level= block[j];
3855  int coeff;
3856 
3857  if(level){
3858  if(level<0) coeff= qmul*level - qadd;
3859  else coeff= qmul*level + qadd;
3860  run_tab[rle_index++]=run;
3861  run=0;
3862 
3863  s->dsp.add_8x8basis(rem, basis[j], coeff);
3864  }else{
3865  run++;
3866  }
3867  }
3868 #ifdef REFINE_STATS
3869 if(last_non_zero>0){
3870 STOP_TIMER("init rem[]")
3871 }
3872 }
3873 
3874 {START_TIMER
3875 #endif
3876  for(;;){
3877  int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3878  int best_coeff=0;
3879  int best_change=0;
3880  int run2, best_unquant_change=0, analyze_gradient;
3881 #ifdef REFINE_STATS
3882 {START_TIMER
3883 #endif
3884  analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3885 
3886  if(analyze_gradient){
3887 #ifdef REFINE_STATS
3888 {START_TIMER
3889 #endif
3890  for(i=0; i<64; i++){
3891  int w= weight[i];
3892 
3893  d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3894  }
3895 #ifdef REFINE_STATS
3896 STOP_TIMER("rem*w*w")}
3897 {START_TIMER
3898 #endif
3899  s->dsp.fdct(d1);
3900 #ifdef REFINE_STATS
3901 STOP_TIMER("dct")}
3902 #endif
3903  }
3904 
3905  if(start_i){
3906  const int level= block[0];
3907  int change, old_coeff;
3908 
3909  av_assert2(s->mb_intra);
3910 
3911  old_coeff= q*level;
3912 
3913  for(change=-1; change<=1; change+=2){
3914  int new_level= level + change;
3915  int score, new_coeff;
3916 
3917  new_coeff= q*new_level;
3918  if(new_coeff >= 2048 || new_coeff < 0)
3919  continue;
3920 
3921  score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3922  if(score<best_score){
3923  best_score= score;
3924  best_coeff= 0;
3925  best_change= change;
3926  best_unquant_change= new_coeff - old_coeff;
3927  }
3928  }
3929  }
3930 
3931  run=0;
3932  rle_index=0;
3933  run2= run_tab[rle_index++];
3934  prev_level=0;
3935  prev_run=0;
3936 
3937  for(i=start_i; i<64; i++){
3938  int j= perm_scantable[i];
3939  const int level= block[j];
3940  int change, old_coeff;
3941 
3942  if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3943  break;
3944 
3945  if(level){
3946  if(level<0) old_coeff= qmul*level - qadd;
3947  else old_coeff= qmul*level + qadd;
3948  run2= run_tab[rle_index++]; //FIXME ! maybe after last
3949  }else{
3950  old_coeff=0;
3951  run2--;
3952  av_assert2(run2>=0 || i >= last_non_zero );
3953  }
3954 
3955  for(change=-1; change<=1; change+=2){
3956  int new_level= level + change;
3957  int score, new_coeff, unquant_change;
3958 
3959  score=0;
3960  if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3961  continue;
3962 
3963  if(new_level){
3964  if(new_level<0) new_coeff= qmul*new_level - qadd;
3965  else new_coeff= qmul*new_level + qadd;
3966  if(new_coeff >= 2048 || new_coeff <= -2048)
3967  continue;
3968  //FIXME check for overflow
3969 
3970  if(level){
3971  if(level < 63 && level > -63){
3972  if(i < last_non_zero)
3973  score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3974  - length[UNI_AC_ENC_INDEX(run, level+64)];
3975  else
3976  score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3977  - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3978  }
3979  }else{
3980  av_assert2(FFABS(new_level)==1);
3981 
3982  if(analyze_gradient){
3983  int g= d1[ scantable[i] ];
3984  if(g && (g^new_level) >= 0)
3985  continue;
3986  }
3987 
3988  if(i < last_non_zero){
3989  int next_i= i + run2 + 1;
3990  int next_level= block[ perm_scantable[next_i] ] + 64;
3991 
3992  if(next_level&(~127))
3993  next_level= 0;
3994 
3995  if(next_i < last_non_zero)
3996  score += length[UNI_AC_ENC_INDEX(run, 65)]
3997  + length[UNI_AC_ENC_INDEX(run2, next_level)]
3998  - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3999  else
4000  score += length[UNI_AC_ENC_INDEX(run, 65)]
4001  + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4002  - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4003  }else{
4004  score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4005  if(prev_level){
4006  score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4007  - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4008  }
4009  }
4010  }
4011  }else{
4012  new_coeff=0;
4013  av_assert2(FFABS(level)==1);
4014 
4015  if(i < last_non_zero){
4016  int next_i= i + run2 + 1;
4017  int next_level= block[ perm_scantable[next_i] ] + 64;
4018 
4019  if(next_level&(~127))
4020  next_level= 0;
4021 
4022  if(next_i < last_non_zero)
4023  score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4024  - length[UNI_AC_ENC_INDEX(run2, next_level)]
4025  - length[UNI_AC_ENC_INDEX(run, 65)];
4026  else
4027  score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4028  - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4029  - length[UNI_AC_ENC_INDEX(run, 65)];
4030  }else{
4031  score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4032  if(prev_level){
4033  score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4034  - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4035  }
4036  }
4037  }
4038 
4039  score *= lambda;
4040 
4041  unquant_change= new_coeff - old_coeff;
4042  av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4043 
4044  score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4045  if(score<best_score){
4046  best_score= score;
4047  best_coeff= i;
4048  best_change= change;
4049  best_unquant_change= unquant_change;
4050  }
4051  }
4052  if(level){
4053  prev_level= level + 64;
4054  if(prev_level&(~127))
4055  prev_level= 0;
4056  prev_run= run;
4057  run=0;
4058  }else{
4059  run++;
4060  }
4061  }
4062 #ifdef REFINE_STATS
4063 STOP_TIMER("iterative step")}
4064 #endif
4065 
4066  if(best_change){
4067  int j= perm_scantable[ best_coeff ];
4068 
4069  block[j] += best_change;
4070 
4071  if(best_coeff > last_non_zero){
4072  last_non_zero= best_coeff;
4073  av_assert2(block[j]);
4074 #ifdef REFINE_STATS
4075 after_last++;
4076 #endif
4077  }else{
4078 #ifdef REFINE_STATS
4079 if(block[j]){
4080  if(block[j] - best_change){
4081  if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4082  raise++;
4083  }else{
4084  lower++;
4085  }
4086  }else{
4087  from_zero++;
4088  }
4089 }else{
4090  to_zero++;
4091 }
4092 #endif
4093  for(; last_non_zero>=start_i; last_non_zero--){
4094  if(block[perm_scantable[last_non_zero]])
4095  break;
4096  }
4097  }
4098 #ifdef REFINE_STATS
4099 count++;
4100 if(256*256*256*64 % count == 0){
4101  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);
4102 }
4103 #endif
4104  run=0;
4105  rle_index=0;
4106  for(i=start_i; i<=last_non_zero; i++){
4107  int j= perm_scantable[i];
4108  const int level= block[j];
4109 
4110  if(level){
4111  run_tab[rle_index++]=run;
4112  run=0;
4113  }else{
4114  run++;
4115  }
4116  }
4117 
4118  s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4119  }else{
4120  break;
4121  }
4122  }
4123 #ifdef REFINE_STATS
4124 if(last_non_zero>0){
4125 STOP_TIMER("iterative search")
4126 }
4127 }
4128 #endif
4129 
4130  return last_non_zero;
4131 }
4132 
4133 int ff_dct_quantize_c(MpegEncContext *s,
4134  int16_t *block, int n,
4135  int qscale, int *overflow)
4136 {
4137  int i, j, level, last_non_zero, q, start_i;
4138  const int *qmat;
4139  const uint8_t *scantable= s->intra_scantable.scantable;
4140  int bias;
4141  int max=0;
4142  unsigned int threshold1, threshold2;
4143 
4144  s->dsp.fdct (block);
4145 
4146  if(s->dct_error_sum)
4147  s->denoise_dct(s, block);
4148 
4149  if (s->mb_intra) {
4150  if (!s->h263_aic) {
4151  if (n < 4)
4152  q = s->y_dc_scale;
4153  else
4154  q = s->c_dc_scale;
4155  q = q << 3;
4156  } else
4157  /* For AIC we skip quant/dequant of INTRADC */
4158  q = 1 << 3;
4159 
4160  /* note: block[0] is assumed to be positive */
4161  block[0] = (block[0] + (q >> 1)) / q;
4162  start_i = 1;
4163  last_non_zero = 0;
4164  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4165  bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4166  } else {
4167  start_i = 0;
4168  last_non_zero = -1;
4169  qmat = s->q_inter_matrix[qscale];
4170  bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4171  }
4172  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4173  threshold2= (threshold1<<1);
4174  for(i=63;i>=start_i;i--) {
4175  j = scantable[i];
4176  level = block[j] * qmat[j];
4177 
4178  if(((unsigned)(level+threshold1))>threshold2){
4179  last_non_zero = i;
4180  break;
4181  }else{
4182  block[j]=0;
4183  }
4184  }
4185  for(i=start_i; i<=last_non_zero; i++) {
4186  j = scantable[i];
4187  level = block[j] * qmat[j];
4188 
4189 // if( bias+level >= (1<<QMAT_SHIFT)
4190 // || bias-level >= (1<<QMAT_SHIFT)){
4191  if(((unsigned)(level+threshold1))>threshold2){
4192  if(level>0){
4193  level= (bias + level)>>QMAT_SHIFT;
4194  block[j]= level;
4195  }else{
4196  level= (bias - level)>>QMAT_SHIFT;
4197  block[j]= -level;
4198  }
4199  max |=level;
4200  }else{
4201  block[j]=0;
4202  }
4203  }
4204  *overflow= s->max_qcoeff < max; //overflow might have happened
4205 
4206  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4207  if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4208  ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4209 
4210  return last_non_zero;
4211 }
4212 
4213 #define OFFSET(x) offsetof(MpegEncContext, x)
4214 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4215 static const AVOption h263_options[] = {
4216  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4217  { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4218  { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4219  FF_MPV_COMMON_OPTS
4220  { NULL },
4221 };
4222 
4223 static const AVClass h263_class = {
4224  .class_name = "H.263 encoder",
4225  .item_name = av_default_item_name,
4226  .option = h263_options,
4227  .version = LIBAVUTIL_VERSION_INT,
4228 };
4229 
4230 AVCodec ff_h263_encoder = {
4231  .name = "h263",
4232  .type = AVMEDIA_TYPE_VIDEO,
4233  .id = AV_CODEC_ID_H263,
4234  .priv_data_size = sizeof(MpegEncContext),
4235  .init = ff_MPV_encode_init,
4236  .encode2 = ff_MPV_encode_picture,
4237  .close = ff_MPV_encode_end,
4238  .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4239  .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4240  .priv_class = &h263_class,
4241 };
4242 
4243 static const AVOption h263p_options[] = {
4244  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4245  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4246  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4247  { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4248  FF_MPV_COMMON_OPTS
4249  { NULL },
4250 };
4251 static const AVClass h263p_class = {
4252  .class_name = "H.263p encoder",
4253  .item_name = av_default_item_name,
4254  .option = h263p_options,
4255  .version = LIBAVUTIL_VERSION_INT,
4256 };
4257 
4258 AVCodec ff_h263p_encoder = {
4259  .name = "h263p",
4260  .type = AVMEDIA_TYPE_VIDEO,
4261  .id = AV_CODEC_ID_H263P,
4262  .priv_data_size = sizeof(MpegEncContext),
4263  .init = ff_MPV_encode_init,
4264  .encode2 = ff_MPV_encode_picture,
4265  .close = ff_MPV_encode_end,
4266  .capabilities = CODEC_CAP_SLICE_THREADS,
4267  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4268  .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4269  .priv_class = &h263p_class,
4270 };
4271 
4272 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4273 
4274 AVCodec ff_msmpeg4v2_encoder = {
4275  .name = "msmpeg4v2",
4276  .type = AVMEDIA_TYPE_VIDEO,
4277  .id = AV_CODEC_ID_MSMPEG4V2,
4278  .priv_data_size = sizeof(MpegEncContext),
4279  .init = ff_MPV_encode_init,
4280  .encode2 = ff_MPV_encode_picture,
4281  .close = ff_MPV_encode_end,
4282  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4283  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4284  .priv_class = &msmpeg4v2_class,
4285 };
4286 
4287 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4288 
4289 AVCodec ff_msmpeg4v3_encoder = {
4290  .name = "msmpeg4",
4291  .type = AVMEDIA_TYPE_VIDEO,
4292  .id = AV_CODEC_ID_MSMPEG4V3,
4293  .priv_data_size = sizeof(MpegEncContext),
4294  .init = ff_MPV_encode_init,
4295  .encode2 = ff_MPV_encode_picture,
4296  .close = ff_MPV_encode_end,
4297  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4298  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4299  .priv_class = &msmpeg4v3_class,
4300 };
4301 
4302 FF_MPV_GENERIC_CLASS(wmv1)
4303 
4304 AVCodec ff_wmv1_encoder = {
4305  .name = "wmv1",
4306  .type = AVMEDIA_TYPE_VIDEO,
4307  .id = AV_CODEC_ID_WMV1,
4308  .priv_data_size = sizeof(MpegEncContext),
4309  .init = ff_MPV_encode_init,
4310  .encode2 = ff_MPV_encode_picture,
4311  .close = ff_MPV_encode_end,
4312  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4313  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4314  .priv_class = &wmv1_class,
4315 };
Generated on Wed Jul 10 2013 23:48:02 for FFmpeg by   doxygen 1.8.2