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