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