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