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  * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
27  */
28 
29 /**
30  * @file
31  * The simplest mpeg encoder (well, it was the simplest!).
32  */
33 
34 #include <stdint.h>
35 
36 #include "libavutil/internal.h"
37 #include "libavutil/intmath.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/timer.h"
42 #include "avcodec.h"
43 #include "dct.h"
44 #include "idctdsp.h"
45 #include "mpeg12.h"
46 #include "mpegvideo.h"
47 #include "mpegvideodata.h"
48 #include "h261.h"
49 #include "h263.h"
50 #include "h263data.h"
51 #include "mjpegenc_common.h"
52 #include "mathops.h"
53 #include "mpegutils.h"
54 #include "mjpegenc.h"
55 #include "msmpeg4.h"
56 #include "pixblockdsp.h"
57 #include "qpeldsp.h"
58 #include "faandct.h"
59 #include "thread.h"
60 #include "aandcttab.h"
61 #include "flv.h"
62 #include "mpeg4video.h"
63 #include "internal.h"
64 #include "bytestream.h"
65 #include "wmv2.h"
66 #include "rv10.h"
67 #include <limits.h>
68 #include "sp5x.h"
69 
70 #define QUANT_BIAS_SHIFT 8
71 
72 #define QMAT_SHIFT_MMX 16
73 #define QMAT_SHIFT 21
74 
76 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
77 static int sse_mb(MpegEncContext *s);
78 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
79 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
80 
83 
86  { NULL },
87 };
88 
89 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
90  uint16_t (*qmat16)[2][64],
91  const uint16_t *quant_matrix,
92  int bias, int qmin, int qmax, int intra)
93 {
94  FDCTDSPContext *fdsp = &s->fdsp;
95  int qscale;
96  int shift = 0;
97 
98  for (qscale = qmin; qscale <= qmax; qscale++) {
99  int i;
100  int qscale2;
101 
103  else qscale2 = qscale << 1;
104 
105  if (fdsp->fdct == ff_jpeg_fdct_islow_8 ||
106 #if CONFIG_FAANDCT
107  fdsp->fdct == ff_faandct ||
108 #endif /* CONFIG_FAANDCT */
109  fdsp->fdct == ff_jpeg_fdct_islow_10) {
110  for (i = 0; i < 64; i++) {
111  const int j = s->idsp.idct_permutation[i];
112  int64_t den = (int64_t) qscale2 * quant_matrix[j];
113  /* 16 <= qscale * quant_matrix[i] <= 7905
114  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
115  * 19952 <= x <= 249205026
116  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
117  * 3444240 >= (1 << 36) / (x) >= 275 */
118 
119  qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
120  }
121  } else if (fdsp->fdct == ff_fdct_ifast) {
122  for (i = 0; i < 64; i++) {
123  const int j = s->idsp.idct_permutation[i];
124  int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
125  /* 16 <= qscale * quant_matrix[i] <= 7905
126  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
127  * 19952 <= x <= 249205026
128  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
129  * 3444240 >= (1 << 36) / (x) >= 275 */
130 
131  qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
132  }
133  } else {
134  for (i = 0; i < 64; i++) {
135  const int j = s->idsp.idct_permutation[i];
136  int64_t den = (int64_t) qscale2 * quant_matrix[j];
137  /* We can safely suppose that 16 <= quant_matrix[i] <= 255
138  * Assume x = qscale * quant_matrix[i]
139  * So 16 <= x <= 7905
140  * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
141  * so 32768 >= (1 << 19) / (x) >= 67 */
142  qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
143  //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
144  // (qscale * quant_matrix[i]);
145  qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
146 
147  if (qmat16[qscale][0][i] == 0 ||
148  qmat16[qscale][0][i] == 128 * 256)
149  qmat16[qscale][0][i] = 128 * 256 - 1;
150  qmat16[qscale][1][i] =
151  ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
152  qmat16[qscale][0][i]);
153  }
154  }
155 
156  for (i = intra; i < 64; i++) {
157  int64_t max = 8191;
158  if (fdsp->fdct == ff_fdct_ifast) {
159  max = (8191LL * ff_aanscales[i]) >> 14;
160  }
161  while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
162  shift++;
163  }
164  }
165  }
166  if (shift) {
168  "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
169  QMAT_SHIFT - shift);
170  }
171 }
172 
173 static inline void update_qscale(MpegEncContext *s)
174 {
175  if (s->q_scale_type == 1 && 0) {
176  int i;
177  int bestdiff=INT_MAX;
178  int best = 1;
179 
180  for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
181  int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
182  if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
184  continue;
185  if (diff < bestdiff) {
186  bestdiff = diff;
187  best = i;
188  }
189  }
190  s->qscale = best;
191  } else {
192  s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
193  (FF_LAMBDA_SHIFT + 7);
194  s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
195  }
196 
197  s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
199 }
200 
201 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
202 {
203  int i;
204 
205  if (matrix) {
206  put_bits(pb, 1, 1);
207  for (i = 0; i < 64; i++) {
208  put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
209  }
210  } else
211  put_bits(pb, 1, 0);
212 }
213 
214 /**
215  * init s->current_picture.qscale_table from s->lambda_table
216  */
218 {
219  int8_t * const qscale_table = s->current_picture.qscale_table;
220  int i;
221 
222  for (i = 0; i < s->mb_num; i++) {
223  unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
224  int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
225  qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
226  s->avctx->qmax);
227  }
228 }
229 
232 {
233 #define COPY(a) dst->a= src->a
234  COPY(pict_type);
236  COPY(f_code);
237  COPY(b_code);
238  COPY(qscale);
239  COPY(lambda);
240  COPY(lambda2);
243  COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
244  COPY(progressive_frame); // FIXME don't set in encode_header
245  COPY(partitioned_frame); // FIXME don't set in encode_header
246 #undef COPY
247 }
248 
249 /**
250  * Set the given MpegEncContext to defaults for encoding.
251  * the changed fields will not depend upon the prior state of the MpegEncContext.
252  */
254 {
255  int i;
257 
258  for (i = -16; i < 16; i++) {
259  default_fcode_tab[i + MAX_MV] = 1;
260  }
263 
264  s->input_picture_number = 0;
265  s->picture_in_gop_number = 0;
266 }
267 
269  if (ARCH_X86)
271 
272  if (CONFIG_H263_ENCODER)
274  if (!s->dct_quantize)
276  if (!s->denoise_dct)
279  if (s->avctx->trellis)
281 
282  return 0;
283 }
284 
285 /* init video encoder */
287 {
288  MpegEncContext *s = avctx->priv_data;
289  AVCPBProperties *cpb_props;
290  int i, ret, format_supported;
291 
293 
294  switch (avctx->codec_id) {
296  if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
297  avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
298  av_log(avctx, AV_LOG_ERROR,
299  "only YUV420 and YUV422 are supported\n");
300  return -1;
301  }
302  break;
303  case AV_CODEC_ID_MJPEG:
304  case AV_CODEC_ID_AMV:
305  format_supported = 0;
306  /* JPEG color space */
307  if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
308  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
309  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
310  (avctx->color_range == AVCOL_RANGE_JPEG &&
311  (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
312  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
313  avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
314  format_supported = 1;
315  /* MPEG color space */
316  else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
317  (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
318  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
319  avctx->pix_fmt == AV_PIX_FMT_YUV444P))
320  format_supported = 1;
321 
322  if (!format_supported) {
323  av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
324  return -1;
325  }
326  break;
327  default:
328  if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
329  av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
330  return -1;
331  }
332  }
333 
334  switch (avctx->pix_fmt) {
335  case AV_PIX_FMT_YUVJ444P:
336  case AV_PIX_FMT_YUV444P:
338  break;
339  case AV_PIX_FMT_YUVJ422P:
340  case AV_PIX_FMT_YUV422P:
342  break;
343  case AV_PIX_FMT_YUVJ420P:
344  case AV_PIX_FMT_YUV420P:
345  default:
347  break;
348  }
349 
350  avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
351 
352 #if FF_API_PRIVATE_OPT
354  if (avctx->rtp_payload_size)
356  if (avctx->me_penalty_compensation)
358  if (avctx->pre_me)
359  s->me_pre = avctx->pre_me;
361 #endif
362 
363  s->bit_rate = avctx->bit_rate;
364  s->width = avctx->width;
365  s->height = avctx->height;
366  if (avctx->gop_size > 600 &&
368  av_log(avctx, AV_LOG_WARNING,
369  "keyframe interval too large!, reducing it from %d to %d\n",
370  avctx->gop_size, 600);
371  avctx->gop_size = 600;
372  }
373  s->gop_size = avctx->gop_size;
374  s->avctx = avctx;
375  if (avctx->max_b_frames > MAX_B_FRAMES) {
376  av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
377  "is %d.\n", MAX_B_FRAMES);
378  avctx->max_b_frames = MAX_B_FRAMES;
379  }
380  s->max_b_frames = avctx->max_b_frames;
381  s->codec_id = avctx->codec->id;
383  s->quarter_sample = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
384  s->rtp_mode = !!s->rtp_payload_size;
386 
387  // workaround some differences between how applications specify dc precision
388  if (s->intra_dc_precision < 0) {
389  s->intra_dc_precision += 8;
390  } else if (s->intra_dc_precision >= 8)
391  s->intra_dc_precision -= 8;
392 
393  if (s->intra_dc_precision < 0) {
394  av_log(avctx, AV_LOG_ERROR,
395  "intra dc precision must be positive, note some applications use"
396  " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
397  return AVERROR(EINVAL);
398  }
399 
400  if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
401  av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
402  return AVERROR(EINVAL);
403  }
405 
406  if (s->gop_size <= 1) {
407  s->intra_only = 1;
408  s->gop_size = 12;
409  } else {
410  s->intra_only = 0;
411  }
412 
413 #if FF_API_MOTION_EST
415  s->me_method = avctx->me_method;
417 #endif
418 
419  /* Fixed QSCALE */
420  s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
421 
422 #if FF_API_MPV_OPT
424  if (avctx->border_masking != 0.0)
425  s->border_masking = avctx->border_masking;
427 #endif
428 
429  s->adaptive_quant = (s->avctx->lumi_masking ||
430  s->avctx->dark_masking ||
433  s->avctx->p_masking ||
434  s->border_masking ||
435  (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
436  !s->fixed_qscale;
437 
439 
440  if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
441  switch(avctx->codec_id) {
444  avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
445  break;
446  case AV_CODEC_ID_MPEG4:
450  if (avctx->rc_max_rate >= 15000000) {
451  avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
452  } else if(avctx->rc_max_rate >= 2000000) {
453  avctx->rc_buffer_size = 80 + (avctx->rc_max_rate - 2000000LL) * (320- 80) / (15000000 - 2000000);
454  } else if(avctx->rc_max_rate >= 384000) {
455  avctx->rc_buffer_size = 40 + (avctx->rc_max_rate - 384000LL) * ( 80- 40) / ( 2000000 - 384000);
456  } else
457  avctx->rc_buffer_size = 40;
458  avctx->rc_buffer_size *= 16384;
459  break;
460  }
461  if (avctx->rc_buffer_size) {
462  av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
463  }
464  }
465 
466  if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
467  av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
468  return -1;
469  }
470 
471  if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
472  av_log(avctx, AV_LOG_INFO,
473  "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
474  }
475 
476  if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
477  av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
478  return -1;
479  }
480 
481  if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
482  av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
483  return -1;
484  }
485 
486  if (avctx->rc_max_rate &&
487  avctx->rc_max_rate == avctx->bit_rate &&
488  avctx->rc_max_rate != avctx->rc_min_rate) {
489  av_log(avctx, AV_LOG_INFO,
490  "impossible bitrate constraints, this will fail\n");
491  }
492 
493  if (avctx->rc_buffer_size &&
494  avctx->bit_rate * (int64_t)avctx->time_base.num >
495  avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
496  av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
497  return -1;
498  }
499 
500  if (!s->fixed_qscale &&
501  avctx->bit_rate * av_q2d(avctx->time_base) >
502  avctx->bit_rate_tolerance) {
503  av_log(avctx, AV_LOG_WARNING,
504  "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, (int64_t)avctx->bit_rate);
505  avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
506  }
507 
508  if (s->avctx->rc_max_rate &&
509  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
512  90000LL * (avctx->rc_buffer_size - 1) >
513  s->avctx->rc_max_rate * 0xFFFFLL) {
514  av_log(avctx, AV_LOG_INFO,
515  "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
516  "specified vbv buffer is too large for the given bitrate!\n");
517  }
518 
519  if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
521  s->codec_id != AV_CODEC_ID_FLV1) {
522  av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
523  return -1;
524  }
525 
526  if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
527  av_log(avctx, AV_LOG_ERROR,
528  "OBMC is only supported with simple mb decision\n");
529  return -1;
530  }
531 
532  if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
533  av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
534  return -1;
535  }
536 
537  if (s->max_b_frames &&
538  s->codec_id != AV_CODEC_ID_MPEG4 &&
541  av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
542  return -1;
543  }
544  if (s->max_b_frames < 0) {
545  av_log(avctx, AV_LOG_ERROR,
546  "max b frames must be 0 or positive for mpegvideo based encoders\n");
547  return -1;
548  }
549 
550  if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
551  s->codec_id == AV_CODEC_ID_H263 ||
552  s->codec_id == AV_CODEC_ID_H263P) &&
553  (avctx->sample_aspect_ratio.num > 255 ||
554  avctx->sample_aspect_ratio.den > 255)) {
555  av_log(avctx, AV_LOG_WARNING,
556  "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
559  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
560  }
561 
562  if ((s->codec_id == AV_CODEC_ID_H263 ||
563  s->codec_id == AV_CODEC_ID_H263P) &&
564  (avctx->width > 2048 ||
565  avctx->height > 1152 )) {
566  av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
567  return -1;
568  }
569  if ((s->codec_id == AV_CODEC_ID_H263 ||
570  s->codec_id == AV_CODEC_ID_H263P) &&
571  ((avctx->width &3) ||
572  (avctx->height&3) )) {
573  av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
574  return -1;
575  }
576 
577  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
578  (avctx->width > 4095 ||
579  avctx->height > 4095 )) {
580  av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
581  return -1;
582  }
583 
584  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
585  (avctx->width > 16383 ||
586  avctx->height > 16383 )) {
587  av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
588  return -1;
589  }
590 
591  if (s->codec_id == AV_CODEC_ID_RV10 &&
592  (avctx->width &15 ||
593  avctx->height&15 )) {
594  av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
595  return AVERROR(EINVAL);
596  }
597 
598  if (s->codec_id == AV_CODEC_ID_RV20 &&
599  (avctx->width &3 ||
600  avctx->height&3 )) {
601  av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
602  return AVERROR(EINVAL);
603  }
604 
605  if ((s->codec_id == AV_CODEC_ID_WMV1 ||
606  s->codec_id == AV_CODEC_ID_WMV2) &&
607  avctx->width & 1) {
608  av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
609  return -1;
610  }
611 
614  av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
615  return -1;
616  }
617 
618 #if FF_API_PRIVATE_OPT
620  if (avctx->mpeg_quant)
621  s->mpeg_quant = avctx->mpeg_quant;
623 #endif
624 
625  // FIXME mpeg2 uses that too
626  if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
627  && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
628  av_log(avctx, AV_LOG_ERROR,
629  "mpeg2 style quantization not supported by codec\n");
630  return -1;
631  }
632 
633  if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
634  av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
635  return -1;
636  }
637 
638  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
640  av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
641  return -1;
642  }
643 
644 #if FF_API_PRIVATE_OPT
646  if (avctx->scenechange_threshold)
649 #endif
650 
651  if (s->scenechange_threshold < 1000000000 &&
653  av_log(avctx, AV_LOG_ERROR,
654  "closed gop with scene change detection are not supported yet, "
655  "set threshold to 1000000000\n");
656  return -1;
657  }
658 
659  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
660  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
661  av_log(avctx, AV_LOG_ERROR,
662  "low delay forcing is only available for mpeg2\n");
663  return -1;
664  }
665  if (s->max_b_frames != 0) {
666  av_log(avctx, AV_LOG_ERROR,
667  "b frames cannot be used with low delay\n");
668  return -1;
669  }
670  }
671 
672  if (s->q_scale_type == 1) {
673  if (avctx->qmax > 28) {
674  av_log(avctx, AV_LOG_ERROR,
675  "non linear quant only supports qmax <= 28 currently\n");
676  return -1;
677  }
678  }
679 
680  if (avctx->slices > 1 &&
681  (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
682  av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
683  return AVERROR(EINVAL);
684  }
685 
686  if (s->avctx->thread_count > 1 &&
687  s->codec_id != AV_CODEC_ID_MPEG4 &&
690  s->codec_id != AV_CODEC_ID_MJPEG &&
691  (s->codec_id != AV_CODEC_ID_H263P)) {
692  av_log(avctx, AV_LOG_ERROR,
693  "multi threaded encoding not supported by codec\n");
694  return -1;
695  }
696 
697  if (s->avctx->thread_count < 1) {
698  av_log(avctx, AV_LOG_ERROR,
699  "automatic thread number detection not supported by codec, "
700  "patch welcome\n");
701  return -1;
702  }
703 
704  if (!avctx->time_base.den || !avctx->time_base.num) {
705  av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
706  return -1;
707  }
708 
709 #if FF_API_PRIVATE_OPT
711  if (avctx->b_frame_strategy)
713  if (avctx->b_sensitivity != 40)
714  s->b_sensitivity = avctx->b_sensitivity;
716 #endif
717 
718  if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
719  av_log(avctx, AV_LOG_INFO,
720  "notice: b_frame_strategy only affects the first pass\n");
721  s->b_frame_strategy = 0;
722  }
723 
724  i = av_gcd(avctx->time_base.den, avctx->time_base.num);
725  if (i > 1) {
726  av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
727  avctx->time_base.den /= i;
728  avctx->time_base.num /= i;
729  //return -1;
730  }
731 
733  // (a + x * 3 / 8) / x
734  s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
735  s->inter_quant_bias = 0;
736  } else {
737  s->intra_quant_bias = 0;
738  // (a - x / 4) / x
739  s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
740  }
741 
742  if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
743  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
744  return AVERROR(EINVAL);
745  }
746 
747 #if FF_API_QUANT_BIAS
754 #endif
755 
756  av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
757 
758  if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
759  s->avctx->time_base.den > (1 << 16) - 1) {
760  av_log(avctx, AV_LOG_ERROR,
761  "timebase %d/%d not supported by MPEG 4 standard, "
762  "the maximum admitted value for the timebase denominator "
763  "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
764  (1 << 16) - 1);
765  return -1;
766  }
767  s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
768 
769  switch (avctx->codec->id) {
771  s->out_format = FMT_MPEG1;
773  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
774  break;
776  s->out_format = FMT_MPEG1;
778  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
779  s->rtp_mode = 1;
780  break;
781  case AV_CODEC_ID_MJPEG:
782  case AV_CODEC_ID_AMV:
783  s->out_format = FMT_MJPEG;
784  s->intra_only = 1; /* force intra only for jpeg */
785  if (!CONFIG_MJPEG_ENCODER ||
786  ff_mjpeg_encode_init(s) < 0)
787  return -1;
788  avctx->delay = 0;
789  s->low_delay = 1;
790  break;
791  case AV_CODEC_ID_H261:
792  if (!CONFIG_H261_ENCODER)
793  return -1;
794  if (ff_h261_get_picture_format(s->width, s->height) < 0) {
795  av_log(avctx, AV_LOG_ERROR,
796  "The specified picture size of %dx%d is not valid for the "
797  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
798  s->width, s->height);
799  return -1;
800  }
801  s->out_format = FMT_H261;
802  avctx->delay = 0;
803  s->low_delay = 1;
804  s->rtp_mode = 0; /* Sliced encoding not supported */
805  break;
806  case AV_CODEC_ID_H263:
807  if (!CONFIG_H263_ENCODER)
808  return -1;
810  s->width, s->height) == 8) {
811  av_log(avctx, AV_LOG_ERROR,
812  "The specified picture size of %dx%d is not valid for "
813  "the H.263 codec.\nValid sizes are 128x96, 176x144, "
814  "352x288, 704x576, and 1408x1152. "
815  "Try H.263+.\n", s->width, s->height);
816  return -1;
817  }
818  s->out_format = FMT_H263;
819  avctx->delay = 0;
820  s->low_delay = 1;
821  break;
822  case AV_CODEC_ID_H263P:
823  s->out_format = FMT_H263;
824  s->h263_plus = 1;
825  /* Fx */
826  s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
827  s->modified_quant = s->h263_aic;
828  s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
829  s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
830 
831  /* /Fx */
832  /* These are just to be sure */
833  avctx->delay = 0;
834  s->low_delay = 1;
835  break;
836  case AV_CODEC_ID_FLV1:
837  s->out_format = FMT_H263;
838  s->h263_flv = 2; /* format = 1; 11-bit codes */
839  s->unrestricted_mv = 1;
840  s->rtp_mode = 0; /* don't allow GOB */
841  avctx->delay = 0;
842  s->low_delay = 1;
843  break;
844  case AV_CODEC_ID_RV10:
845  s->out_format = FMT_H263;
846  avctx->delay = 0;
847  s->low_delay = 1;
848  break;
849  case AV_CODEC_ID_RV20:
850  s->out_format = FMT_H263;
851  avctx->delay = 0;
852  s->low_delay = 1;
853  s->modified_quant = 1;
854  s->h263_aic = 1;
855  s->h263_plus = 1;
856  s->loop_filter = 1;
857  s->unrestricted_mv = 0;
858  break;
859  case AV_CODEC_ID_MPEG4:
860  s->out_format = FMT_H263;
861  s->h263_pred = 1;
862  s->unrestricted_mv = 1;
863  s->low_delay = s->max_b_frames ? 0 : 1;
864  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
865  break;
867  s->out_format = FMT_H263;
868  s->h263_pred = 1;
869  s->unrestricted_mv = 1;
870  s->msmpeg4_version = 2;
871  avctx->delay = 0;
872  s->low_delay = 1;
873  break;
875  s->out_format = FMT_H263;
876  s->h263_pred = 1;
877  s->unrestricted_mv = 1;
878  s->msmpeg4_version = 3;
879  s->flipflop_rounding = 1;
880  avctx->delay = 0;
881  s->low_delay = 1;
882  break;
883  case AV_CODEC_ID_WMV1:
884  s->out_format = FMT_H263;
885  s->h263_pred = 1;
886  s->unrestricted_mv = 1;
887  s->msmpeg4_version = 4;
888  s->flipflop_rounding = 1;
889  avctx->delay = 0;
890  s->low_delay = 1;
891  break;
892  case AV_CODEC_ID_WMV2:
893  s->out_format = FMT_H263;
894  s->h263_pred = 1;
895  s->unrestricted_mv = 1;
896  s->msmpeg4_version = 5;
897  s->flipflop_rounding = 1;
898  avctx->delay = 0;
899  s->low_delay = 1;
900  break;
901  default:
902  return -1;
903  }
904 
905 #if FF_API_PRIVATE_OPT
907  if (avctx->noise_reduction)
908  s->noise_reduction = avctx->noise_reduction;
910 #endif
911 
912  avctx->has_b_frames = !s->low_delay;
913 
914  s->encoding = 1;
915 
916  s->progressive_frame =
919  s->alternate_scan);
920 
921  /* init */
922  ff_mpv_idct_init(s);
923  if (ff_mpv_common_init(s) < 0)
924  return -1;
925 
926  ff_fdctdsp_init(&s->fdsp, avctx);
927  ff_me_cmp_init(&s->mecc, avctx);
929  ff_pixblockdsp_init(&s->pdsp, avctx);
930  ff_qpeldsp_init(&s->qdsp);
931 
932  if (s->msmpeg4_version) {
934  2 * 2 * (MAX_LEVEL + 1) *
935  (MAX_RUN + 1) * 2 * sizeof(int), fail);
936  }
937  FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
938 
939  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
940  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
941  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
942  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
943  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
944  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
946  MAX_PICTURE_COUNT * sizeof(Picture *), fail);
948  MAX_PICTURE_COUNT * sizeof(Picture *), fail);
949 
950 
951  if (s->noise_reduction) {
953  2 * 64 * sizeof(uint16_t), fail);
954  }
955 
957 
958  if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
960 
961  if (s->slice_context_count > 1) {
962  s->rtp_mode = 1;
963 
964  if (avctx->codec_id == AV_CODEC_ID_H263P)
965  s->h263_slice_structured = 1;
966  }
967 
968  s->quant_precision = 5;
969 
970 #if FF_API_PRIVATE_OPT
972  if (avctx->frame_skip_threshold)
974  if (avctx->frame_skip_factor)
976  if (avctx->frame_skip_exp)
977  s->frame_skip_exp = avctx->frame_skip_exp;
978  if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
979  s->frame_skip_cmp = avctx->frame_skip_cmp;
981 #endif
982 
985 
986  if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
988  if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
991  if ((ret = ff_msmpeg4_encode_init(s)) < 0)
992  return ret;
993  if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
994  && s->out_format == FMT_MPEG1)
996 
997  /* init q matrix */
998  for (i = 0; i < 64; i++) {
999  int j = s->idsp.idct_permutation[i];
1000  if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
1001  s->mpeg_quant) {
1004  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1005  s->intra_matrix[j] =
1007  } else {
1008  /* mpeg1/2 */
1009  s->chroma_intra_matrix[j] =
1012  }
1013  if (s->avctx->intra_matrix)
1014  s->intra_matrix[j] = s->avctx->intra_matrix[i];
1015  if (s->avctx->inter_matrix)
1016  s->inter_matrix[j] = s->avctx->inter_matrix[i];
1017  }
1018 
1019  /* precompute matrix */
1020  /* for mjpeg, we do include qscale in the matrix */
1021  if (s->out_format != FMT_MJPEG) {
1023  s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1024  31, 1);
1026  s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1027  31, 0);
1028  }
1029 
1030  if (ff_rate_control_init(s) < 0)
1031  return -1;
1032 
1033 #if FF_API_ERROR_RATE
1035  if (avctx->error_rate)
1036  s->error_rate = avctx->error_rate;
1038 #endif
1039 
1040 #if FF_API_NORMALIZE_AQP
1042  if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
1043  s->mpv_flags |= FF_MPV_FLAG_NAQ;
1045 #endif
1046 
1047 #if FF_API_MV0
1049  if (avctx->flags & CODEC_FLAG_MV0)
1050  s->mpv_flags |= FF_MPV_FLAG_MV0;
1052 #endif
1053 
1054 #if FF_API_MPV_OPT
1056  if (avctx->rc_qsquish != 0.0)
1057  s->rc_qsquish = avctx->rc_qsquish;
1058  if (avctx->rc_qmod_amp != 0.0)
1059  s->rc_qmod_amp = avctx->rc_qmod_amp;
1060  if (avctx->rc_qmod_freq)
1061  s->rc_qmod_freq = avctx->rc_qmod_freq;
1062  if (avctx->rc_buffer_aggressivity != 1.0)
1064  if (avctx->rc_initial_cplx != 0.0)
1065  s->rc_initial_cplx = avctx->rc_initial_cplx;
1066  if (avctx->lmin)
1067  s->lmin = avctx->lmin;
1068  if (avctx->lmax)
1069  s->lmax = avctx->lmax;
1070 
1071  if (avctx->rc_eq) {
1072  av_freep(&s->rc_eq);
1073  s->rc_eq = av_strdup(avctx->rc_eq);
1074  if (!s->rc_eq)
1075  return AVERROR(ENOMEM);
1076  }
1078 #endif
1079 
1080 #if FF_API_PRIVATE_OPT
1082  if (avctx->brd_scale)
1083  s->brd_scale = avctx->brd_scale;
1084 
1085  if (avctx->prediction_method)
1086  s->pred = avctx->prediction_method + 1;
1088 #endif
1089 
1090  if (s->b_frame_strategy == 2) {
1091  for (i = 0; i < s->max_b_frames + 2; i++) {
1092  s->tmp_frames[i] = av_frame_alloc();
1093  if (!s->tmp_frames[i])
1094  return AVERROR(ENOMEM);
1095 
1097  s->tmp_frames[i]->width = s->width >> s->brd_scale;
1098  s->tmp_frames[i]->height = s->height >> s->brd_scale;
1099 
1100  ret = av_frame_get_buffer(s->tmp_frames[i], 32);
1101  if (ret < 0)
1102  return ret;
1103  }
1104  }
1105 
1106  cpb_props = ff_add_cpb_side_data(avctx);
1107  if (!cpb_props)
1108  return AVERROR(ENOMEM);
1109  cpb_props->max_bitrate = avctx->rc_max_rate;
1110  cpb_props->min_bitrate = avctx->rc_min_rate;
1111  cpb_props->avg_bitrate = avctx->bit_rate;
1112  cpb_props->buffer_size = avctx->rc_buffer_size;
1113 
1114  return 0;
1115 fail:
1116  ff_mpv_encode_end(avctx);
1117  return AVERROR_UNKNOWN;
1118 }
1119 
1121 {
1122  MpegEncContext *s = avctx->priv_data;
1123  int i;
1124 
1126 
1127  ff_mpv_common_end(s);
1128  if (CONFIG_MJPEG_ENCODER &&
1129  s->out_format == FMT_MJPEG)
1131 
1132  av_freep(&avctx->extradata);
1133 
1134  for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1135  av_frame_free(&s->tmp_frames[i]);
1136 
1139 
1140  av_freep(&s->avctx->stats_out);
1141  av_freep(&s->ac_stats);
1142 
1147  av_freep(&s->q_intra_matrix);
1148  av_freep(&s->q_inter_matrix);
1151  av_freep(&s->input_picture);
1153  av_freep(&s->dct_offset);
1154 
1155  return 0;
1156 }
1157 
1158 static int get_sae(uint8_t *src, int ref, int stride)
1159 {
1160  int x,y;
1161  int acc = 0;
1162 
1163  for (y = 0; y < 16; y++) {
1164  for (x = 0; x < 16; x++) {
1165  acc += FFABS(src[x + y * stride] - ref);
1166  }
1167  }
1168 
1169  return acc;
1170 }
1171 
1173  uint8_t *ref, int stride)
1174 {
1175  int x, y, w, h;
1176  int acc = 0;
1177 
1178  w = s->width & ~15;
1179  h = s->height & ~15;
1180 
1181  for (y = 0; y < h; y += 16) {
1182  for (x = 0; x < w; x += 16) {
1183  int offset = x + y * stride;
1184  int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1185  stride, 16);
1186  int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1187  int sae = get_sae(src + offset, mean, stride);
1188 
1189  acc += sae + 500 < sad;
1190  }
1191  }
1192  return acc;
1193 }
1194 
1195 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1196 {
1197  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1199  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1200  &s->linesize, &s->uvlinesize);
1201 }
1202 
1203 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1204 {
1205  Picture *pic = NULL;
1206  int64_t pts;
1207  int i, display_picture_number = 0, ret;
1208  int encoding_delay = s->max_b_frames ? s->max_b_frames
1209  : (s->low_delay ? 0 : 1);
1210  int flush_offset = 1;
1211  int direct = 1;
1212 
1213  if (pic_arg) {
1214  pts = pic_arg->pts;
1215  display_picture_number = s->input_picture_number++;
1216 
1217  if (pts != AV_NOPTS_VALUE) {
1218  if (s->user_specified_pts != AV_NOPTS_VALUE) {
1219  int64_t last = s->user_specified_pts;
1220 
1221  if (pts <= last) {
1223  "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1224  pts, last);
1225  return AVERROR(EINVAL);
1226  }
1227 
1228  if (!s->low_delay && display_picture_number == 1)
1229  s->dts_delta = pts - last;
1230  }
1231  s->user_specified_pts = pts;
1232  } else {
1233  if (s->user_specified_pts != AV_NOPTS_VALUE) {
1234  s->user_specified_pts =
1235  pts = s->user_specified_pts + 1;
1236  av_log(s->avctx, AV_LOG_INFO,
1237  "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1238  pts);
1239  } else {
1240  pts = display_picture_number;
1241  }
1242  }
1243 
1244  if (!pic_arg->buf[0] ||
1245  pic_arg->linesize[0] != s->linesize ||
1246  pic_arg->linesize[1] != s->uvlinesize ||
1247  pic_arg->linesize[2] != s->uvlinesize)
1248  direct = 0;
1249  if ((s->width & 15) || (s->height & 15))
1250  direct = 0;
1251  if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1252  direct = 0;
1253  if (s->linesize & (STRIDE_ALIGN-1))
1254  direct = 0;
1255 
1256  ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1257  pic_arg->linesize[1], s->linesize, s->uvlinesize);
1258 
1259  i = ff_find_unused_picture(s->avctx, s->picture, direct);
1260  if (i < 0)
1261  return i;
1262 
1263  pic = &s->picture[i];
1264  pic->reference = 3;
1265 
1266  if (direct) {
1267  if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1268  return ret;
1269  }
1270  ret = alloc_picture(s, pic, direct);
1271  if (ret < 0)
1272  return ret;
1273 
1274  if (!direct) {
1275  if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1276  pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1277  pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1278  // empty
1279  } else {
1280  int h_chroma_shift, v_chroma_shift;
1282  &h_chroma_shift,
1283  &v_chroma_shift);
1284 
1285  for (i = 0; i < 3; i++) {
1286  int src_stride = pic_arg->linesize[i];
1287  int dst_stride = i ? s->uvlinesize : s->linesize;
1288  int h_shift = i ? h_chroma_shift : 0;
1289  int v_shift = i ? v_chroma_shift : 0;
1290  int w = s->width >> h_shift;
1291  int h = s->height >> v_shift;
1292  uint8_t *src = pic_arg->data[i];
1293  uint8_t *dst = pic->f->data[i];
1294  int vpad = 16;
1295 
1296  if ( s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1297  && !s->progressive_sequence
1298  && FFALIGN(s->height, 32) - s->height > 16)
1299  vpad = 32;
1300 
1301  if (!s->avctx->rc_buffer_size)
1302  dst += INPLACE_OFFSET;
1303 
1304  if (src_stride == dst_stride)
1305  memcpy(dst, src, src_stride * h);
1306  else {
1307  int h2 = h;
1308  uint8_t *dst2 = dst;
1309  while (h2--) {
1310  memcpy(dst2, src, w);
1311  dst2 += dst_stride;
1312  src += src_stride;
1313  }
1314  }
1315  if ((s->width & 15) || (s->height & (vpad-1))) {
1316  s->mpvencdsp.draw_edges(dst, dst_stride,
1317  w, h,
1318  16 >> h_shift,
1319  vpad >> v_shift,
1320  EDGE_BOTTOM);
1321  }
1322  }
1323  }
1324  }
1325  ret = av_frame_copy_props(pic->f, pic_arg);
1326  if (ret < 0)
1327  return ret;
1328 
1329  pic->f->display_picture_number = display_picture_number;
1330  pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1331  } else {
1332  /* Flushing: When we have not received enough input frames,
1333  * ensure s->input_picture[0] contains the first picture */
1334  for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1335  if (s->input_picture[flush_offset])
1336  break;
1337 
1338  if (flush_offset <= 1)
1339  flush_offset = 1;
1340  else
1341  encoding_delay = encoding_delay - flush_offset + 1;
1342  }
1343 
1344  /* shift buffer entries */
1345  for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1346  s->input_picture[i - flush_offset] = s->input_picture[i];
1347 
1348  s->input_picture[encoding_delay] = (Picture*) pic;
1349 
1350  return 0;
1351 }
1352 
1353 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1354 {
1355  int x, y, plane;
1356  int score = 0;
1357  int64_t score64 = 0;
1358 
1359  for (plane = 0; plane < 3; plane++) {
1360  const int stride = p->f->linesize[plane];
1361  const int bw = plane ? 1 : 2;
1362  for (y = 0; y < s->mb_height * bw; y++) {
1363  for (x = 0; x < s->mb_width * bw; x++) {
1364  int off = p->shared ? 0 : 16;
1365  uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1366  uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1367  int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1368 
1369  switch (FFABS(s->frame_skip_exp)) {
1370  case 0: score = FFMAX(score, v); break;
1371  case 1: score += FFABS(v); break;
1372  case 2: score64 += v * (int64_t)v; break;
1373  case 3: score64 += FFABS(v * (int64_t)v * v); break;
1374  case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1375  }
1376  }
1377  }
1378  }
1379  emms_c();
1380 
1381  if (score)
1382  score64 = score;
1383  if (s->frame_skip_exp < 0)
1384  score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1385  -1.0/s->frame_skip_exp);
1386 
1387  if (score64 < s->frame_skip_threshold)
1388  return 1;
1389  if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1390  return 1;
1391  return 0;
1392 }
1393 
1395 {
1396  AVPacket pkt = { 0 };
1397  int ret, got_output;
1398 
1399  av_init_packet(&pkt);
1400  ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1401  if (ret < 0)
1402  return ret;
1403 
1404  ret = pkt.size;
1405  av_packet_unref(&pkt);
1406  return ret;
1407 }
1408 
1410 {
1413  const int scale = s->brd_scale;
1414  int i, j, out_size, p_lambda, b_lambda, lambda2;
1415  int64_t best_rd = INT64_MAX;
1416  int best_b_count = -1;
1417 
1418  if (!c)
1419  return AVERROR(ENOMEM);
1420  av_assert0(scale >= 0 && scale <= 3);
1421 
1422  //emms_c();
1423  //s->next_picture_ptr->quality;
1424  p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1425  //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1426  b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1427  if (!b_lambda) // FIXME we should do this somewhere else
1428  b_lambda = p_lambda;
1429  lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1431 
1432  c->width = s->width >> scale;
1433  c->height = s->height >> scale;
1435  c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1436  c->mb_decision = s->avctx->mb_decision;
1437  c->me_cmp = s->avctx->me_cmp;
1438  c->mb_cmp = s->avctx->mb_cmp;
1439  c->me_sub_cmp = s->avctx->me_sub_cmp;
1441  c->time_base = s->avctx->time_base;
1442  c->max_b_frames = s->max_b_frames;
1443 
1444  if (avcodec_open2(c, codec, NULL) < 0)
1445  return -1;
1446 
1447  for (i = 0; i < s->max_b_frames + 2; i++) {
1448  Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1449  s->next_picture_ptr;
1450  uint8_t *data[4];
1451 
1452  if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1453  pre_input = *pre_input_ptr;
1454  memcpy(data, pre_input_ptr->f->data, sizeof(data));
1455 
1456  if (!pre_input.shared && i) {
1457  data[0] += INPLACE_OFFSET;
1458  data[1] += INPLACE_OFFSET;
1459  data[2] += INPLACE_OFFSET;
1460  }
1461 
1462  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1463  s->tmp_frames[i]->linesize[0],
1464  data[0],
1465  pre_input.f->linesize[0],
1466  c->width, c->height);
1467  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1468  s->tmp_frames[i]->linesize[1],
1469  data[1],
1470  pre_input.f->linesize[1],
1471  c->width >> 1, c->height >> 1);
1472  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1473  s->tmp_frames[i]->linesize[2],
1474  data[2],
1475  pre_input.f->linesize[2],
1476  c->width >> 1, c->height >> 1);
1477  }
1478  }
1479 
1480  for (j = 0; j < s->max_b_frames + 1; j++) {
1481  int64_t rd = 0;
1482 
1483  if (!s->input_picture[j])
1484  break;
1485 
1486  c->error[0] = c->error[1] = c->error[2] = 0;
1487 
1489  s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1490 
1491  out_size = encode_frame(c, s->tmp_frames[0]);
1492 
1493  //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1494 
1495  for (i = 0; i < s->max_b_frames + 1; i++) {
1496  int is_p = i % (j + 1) == j || i == s->max_b_frames;
1497 
1498  s->tmp_frames[i + 1]->pict_type = is_p ?
1500  s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1501 
1502  out_size = encode_frame(c, s->tmp_frames[i + 1]);
1503 
1504  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1505  }
1506 
1507  /* get the delayed frames */
1508  while (out_size) {
1509  out_size = encode_frame(c, NULL);
1510  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1511  }
1512 
1513  rd += c->error[0] + c->error[1] + c->error[2];
1514 
1515  if (rd < best_rd) {
1516  best_rd = rd;
1517  best_b_count = j;
1518  }
1519  }
1520 
1521  avcodec_close(c);
1522  av_freep(&c);
1523 
1524  return best_b_count;
1525 }
1526 
1528 {
1529  int i, ret;
1530 
1531  for (i = 1; i < MAX_PICTURE_COUNT; i++)
1533  s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1534 
1535  /* set next picture type & ordering */
1536  if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1537  if (s->frame_skip_threshold || s->frame_skip_factor) {
1538  if (s->picture_in_gop_number < s->gop_size &&
1539  s->next_picture_ptr &&
1540  skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1541  // FIXME check that te gop check above is +-1 correct
1542  av_frame_unref(s->input_picture[0]->f);
1543 
1544  ff_vbv_update(s, 0);
1545 
1546  goto no_output_pic;
1547  }
1548  }
1549 
1550  if (/*s->picture_in_gop_number >= s->gop_size ||*/
1551  !s->next_picture_ptr || s->intra_only) {
1552  s->reordered_input_picture[0] = s->input_picture[0];
1555  s->coded_picture_number++;
1556  } else {
1557  int b_frames = 0;
1558 
1559  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1560  for (i = 0; i < s->max_b_frames + 1; i++) {
1561  int pict_num = s->input_picture[0]->f->display_picture_number + i;
1562 
1563  if (pict_num >= s->rc_context.num_entries)
1564  break;
1565  if (!s->input_picture[i]) {
1566  s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1567  break;
1568  }
1569 
1570  s->input_picture[i]->f->pict_type =
1571  s->rc_context.entry[pict_num].new_pict_type;
1572  }
1573  }
1574 
1575  if (s->b_frame_strategy == 0) {
1576  b_frames = s->max_b_frames;
1577  while (b_frames && !s->input_picture[b_frames])
1578  b_frames--;
1579  } else if (s->b_frame_strategy == 1) {
1580  for (i = 1; i < s->max_b_frames + 1; i++) {
1581  if (s->input_picture[i] &&
1582  s->input_picture[i]->b_frame_score == 0) {
1583  s->input_picture[i]->b_frame_score =
1584  get_intra_count(s,
1585  s->input_picture[i ]->f->data[0],
1586  s->input_picture[i - 1]->f->data[0],
1587  s->linesize) + 1;
1588  }
1589  }
1590  for (i = 0; i < s->max_b_frames + 1; i++) {
1591  if (!s->input_picture[i] ||
1592  s->input_picture[i]->b_frame_score - 1 >
1593  s->mb_num / s->b_sensitivity)
1594  break;
1595  }
1596 
1597  b_frames = FFMAX(0, i - 1);
1598 
1599  /* reset scores */
1600  for (i = 0; i < b_frames + 1; i++) {
1601  s->input_picture[i]->b_frame_score = 0;
1602  }
1603  } else if (s->b_frame_strategy == 2) {
1604  b_frames = estimate_best_b_count(s);
1605  }
1606 
1607  emms_c();
1608 
1609  for (i = b_frames - 1; i >= 0; i--) {
1610  int type = s->input_picture[i]->f->pict_type;
1611  if (type && type != AV_PICTURE_TYPE_B)
1612  b_frames = i;
1613  }
1614  if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1615  b_frames == s->max_b_frames) {
1617  "warning, too many b frames in a row\n");
1618  }
1619 
1620  if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1621  if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1622  s->gop_size > s->picture_in_gop_number) {
1623  b_frames = s->gop_size - s->picture_in_gop_number - 1;
1624  } else {
1626  b_frames = 0;
1627  s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1628  }
1629  }
1630 
1631  if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1632  s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1633  b_frames--;
1634 
1635  s->reordered_input_picture[0] = s->input_picture[b_frames];
1639  s->coded_picture_number++;
1640  for (i = 0; i < b_frames; i++) {
1641  s->reordered_input_picture[i + 1] = s->input_picture[i];
1642  s->reordered_input_picture[i + 1]->f->pict_type =
1645  s->coded_picture_number++;
1646  }
1647  }
1648  }
1649 no_output_pic:
1651 
1652  if (s->reordered_input_picture[0]) {
1655  AV_PICTURE_TYPE_B ? 3 : 0;
1656 
1657  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1658  return ret;
1659 
1660  if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1661  // input is a shared pix, so we can't modifiy it -> alloc a new
1662  // one & ensure that the shared one is reuseable
1663 
1664  Picture *pic;
1665  int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1666  if (i < 0)
1667  return i;
1668  pic = &s->picture[i];
1669 
1671  if (alloc_picture(s, pic, 0) < 0) {
1672  return -1;
1673  }
1674 
1675  ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1676  if (ret < 0)
1677  return ret;
1678 
1679  /* mark us unused / free shared pic */
1681  s->reordered_input_picture[0]->shared = 0;
1682 
1683  s->current_picture_ptr = pic;
1684  } else {
1685  // input is not a shared pix -> reuse buffer for current_pix
1687  for (i = 0; i < 4; i++) {
1688  s->new_picture.f->data[i] += INPLACE_OFFSET;
1689  }
1690  }
1692  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1693  s->current_picture_ptr)) < 0)
1694  return ret;
1695 
1697  }
1698  return 0;
1699 }
1700 
1701 static void frame_end(MpegEncContext *s)
1702 {
1703  if (s->unrestricted_mv &&
1705  !s->intra_only) {
1707  int hshift = desc->log2_chroma_w;
1708  int vshift = desc->log2_chroma_h;
1710  s->current_picture.f->linesize[0],
1711  s->h_edge_pos, s->v_edge_pos,
1713  EDGE_TOP | EDGE_BOTTOM);
1715  s->current_picture.f->linesize[1],
1716  s->h_edge_pos >> hshift,
1717  s->v_edge_pos >> vshift,
1718  EDGE_WIDTH >> hshift,
1719  EDGE_WIDTH >> vshift,
1720  EDGE_TOP | EDGE_BOTTOM);
1722  s->current_picture.f->linesize[2],
1723  s->h_edge_pos >> hshift,
1724  s->v_edge_pos >> vshift,
1725  EDGE_WIDTH >> hshift,
1726  EDGE_WIDTH >> vshift,
1727  EDGE_TOP | EDGE_BOTTOM);
1728  }
1729 
1730  emms_c();
1731 
1732  s->last_pict_type = s->pict_type;
1734  if (s->pict_type!= AV_PICTURE_TYPE_B)
1736 
1737 #if FF_API_CODED_FRAME
1741 #endif
1742 #if FF_API_ERROR_FRAME
1745  sizeof(s->current_picture.encoding_error));
1747 #endif
1748 }
1749 
1751 {
1752  int intra, i;
1753 
1754  for (intra = 0; intra < 2; intra++) {
1755  if (s->dct_count[intra] > (1 << 16)) {
1756  for (i = 0; i < 64; i++) {
1757  s->dct_error_sum[intra][i] >>= 1;
1758  }
1759  s->dct_count[intra] >>= 1;
1760  }
1761 
1762  for (i = 0; i < 64; i++) {
1763  s->dct_offset[intra][i] = (s->noise_reduction *
1764  s->dct_count[intra] +
1765  s->dct_error_sum[intra][i] / 2) /
1766  (s->dct_error_sum[intra][i] + 1);
1767  }
1768  }
1769 }
1770 
1772 {
1773  int ret;
1774 
1775  /* mark & release old frames */
1776  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1778  s->last_picture_ptr->f->buf[0]) {
1780  }
1781 
1784 
1786  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1787  s->current_picture_ptr)) < 0)
1788  return ret;
1789 
1790  if (s->pict_type != AV_PICTURE_TYPE_B) {
1792  if (!s->droppable)
1794  }
1795 
1796  if (s->last_picture_ptr) {
1798  if (s->last_picture_ptr->f->buf[0] &&
1799  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1800  s->last_picture_ptr)) < 0)
1801  return ret;
1802  }
1803  if (s->next_picture_ptr) {
1805  if (s->next_picture_ptr->f->buf[0] &&
1806  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1807  s->next_picture_ptr)) < 0)
1808  return ret;
1809  }
1810 
1811  if (s->picture_structure!= PICT_FRAME) {
1812  int i;
1813  for (i = 0; i < 4; i++) {
1815  s->current_picture.f->data[i] +=
1816  s->current_picture.f->linesize[i];
1817  }
1818  s->current_picture.f->linesize[i] *= 2;
1819  s->last_picture.f->linesize[i] *= 2;
1820  s->next_picture.f->linesize[i] *= 2;
1821  }
1822  }
1823 
1824  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1827  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1830  } else {
1833  }
1834 
1835  if (s->dct_error_sum) {
1838  }
1839 
1840  return 0;
1841 }
1842 
1844  const AVFrame *pic_arg, int *got_packet)
1845 {
1846  MpegEncContext *s = avctx->priv_data;
1847  int i, stuffing_count, ret;
1848  int context_count = s->slice_context_count;
1849 
1850  s->vbv_ignore_qmax = 0;
1851 
1852  s->picture_in_gop_number++;
1853 
1854  if (load_input_picture(s, pic_arg) < 0)
1855  return -1;
1856 
1857  if (select_input_picture(s) < 0) {
1858  return -1;
1859  }
1860 
1861  /* output? */
1862  if (s->new_picture.f->data[0]) {
1863  int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1864  int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1865  :
1866  s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1867  if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1868  return ret;
1869  if (s->mb_info) {
1872  s->mb_width*s->mb_height*12);
1873  s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1874  }
1875 
1876  for (i = 0; i < context_count; i++) {
1877  int start_y = s->thread_context[i]->start_mb_y;
1878  int end_y = s->thread_context[i]-> end_mb_y;
1879  int h = s->mb_height;
1880  uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1881  uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1882 
1883  init_put_bits(&s->thread_context[i]->pb, start, end - start);
1884  }
1885 
1886  s->pict_type = s->new_picture.f->pict_type;
1887  //emms_c();
1888  ret = frame_start(s);
1889  if (ret < 0)
1890  return ret;
1891 vbv_retry:
1892  ret = encode_picture(s, s->picture_number);
1893  if (growing_buffer) {
1894  av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1895  pkt->data = s->pb.buf;
1896  pkt->size = avctx->internal->byte_buffer_size;
1897  }
1898  if (ret < 0)
1899  return -1;
1900 
1901 #if FF_API_STAT_BITS
1903  avctx->header_bits = s->header_bits;
1904  avctx->mv_bits = s->mv_bits;
1905  avctx->misc_bits = s->misc_bits;
1906  avctx->i_tex_bits = s->i_tex_bits;
1907  avctx->p_tex_bits = s->p_tex_bits;
1908  avctx->i_count = s->i_count;
1909  // FIXME f/b_count in avctx
1910  avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1911  avctx->skip_count = s->skip_count;
1913 #endif
1914 
1915  frame_end(s);
1916 
1917  if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1919 
1920  if (avctx->rc_buffer_size) {
1921  RateControlContext *rcc = &s->rc_context;
1922  int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1923  int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1924  int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1925 
1926  if (put_bits_count(&s->pb) > max_size &&
1927  s->lambda < s->lmax) {
1928  s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1929  (s->qscale + 1) / s->qscale);
1930  if (s->adaptive_quant) {
1931  int i;
1932  for (i = 0; i < s->mb_height * s->mb_stride; i++)
1933  s->lambda_table[i] =
1934  FFMAX(s->lambda_table[i] + min_step,
1935  s->lambda_table[i] * (s->qscale + 1) /
1936  s->qscale);
1937  }
1938  s->mb_skipped = 0; // done in frame_start()
1939  // done in encode_picture() so we must undo it
1940  if (s->pict_type == AV_PICTURE_TYPE_P) {
1941  if (s->flipflop_rounding ||
1942  s->codec_id == AV_CODEC_ID_H263P ||
1944  s->no_rounding ^= 1;
1945  }
1946  if (s->pict_type != AV_PICTURE_TYPE_B) {
1947  s->time_base = s->last_time_base;
1948  s->last_non_b_time = s->time - s->pp_time;
1949  }
1950  for (i = 0; i < context_count; i++) {
1951  PutBitContext *pb = &s->thread_context[i]->pb;
1952  init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1953  }
1954  s->vbv_ignore_qmax = 1;
1955  av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1956  goto vbv_retry;
1957  }
1958 
1960  }
1961 
1962  if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1964 
1965  for (i = 0; i < 4; i++) {
1967  avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1968  }
1971  (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1972  s->pict_type);
1973 
1974  if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1975  assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1976  s->misc_bits + s->i_tex_bits +
1977  s->p_tex_bits);
1978  flush_put_bits(&s->pb);
1979  s->frame_bits = put_bits_count(&s->pb);
1980 
1981  stuffing_count = ff_vbv_update(s, s->frame_bits);
1982  s->stuffing_bits = 8*stuffing_count;
1983  if (stuffing_count) {
1984  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1985  stuffing_count + 50) {
1986  av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1987  return -1;
1988  }
1989 
1990  switch (s->codec_id) {
1993  while (stuffing_count--) {
1994  put_bits(&s->pb, 8, 0);
1995  }
1996  break;
1997  case AV_CODEC_ID_MPEG4:
1998  put_bits(&s->pb, 16, 0);
1999  put_bits(&s->pb, 16, 0x1C3);
2000  stuffing_count -= 4;
2001  while (stuffing_count--) {
2002  put_bits(&s->pb, 8, 0xFF);
2003  }
2004  break;
2005  default:
2006  av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2007  }
2008  flush_put_bits(&s->pb);
2009  s->frame_bits = put_bits_count(&s->pb);
2010  }
2011 
2012  /* update mpeg1/2 vbv_delay for CBR */
2013  if (s->avctx->rc_max_rate &&
2014  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
2015  s->out_format == FMT_MPEG1 &&
2016  90000LL * (avctx->rc_buffer_size - 1) <=
2017  s->avctx->rc_max_rate * 0xFFFFLL) {
2018  AVCPBProperties *props;
2019  size_t props_size;
2020 
2021  int vbv_delay, min_delay;
2022  double inbits = s->avctx->rc_max_rate *
2023  av_q2d(s->avctx->time_base);
2024  int minbits = s->frame_bits - 8 *
2025  (s->vbv_delay_ptr - s->pb.buf - 1);
2026  double bits = s->rc_context.buffer_index + minbits - inbits;
2027 
2028  if (bits < 0)
2030  "Internal error, negative bits\n");
2031 
2032  assert(s->repeat_first_field == 0);
2033 
2034  vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
2035  min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
2036  s->avctx->rc_max_rate;
2037 
2038  vbv_delay = FFMAX(vbv_delay, min_delay);
2039 
2040  av_assert0(vbv_delay < 0xFFFF);
2041 
2042  s->vbv_delay_ptr[0] &= 0xF8;
2043  s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2044  s->vbv_delay_ptr[1] = vbv_delay >> 5;
2045  s->vbv_delay_ptr[2] &= 0x07;
2046  s->vbv_delay_ptr[2] |= vbv_delay << 3;
2047 
2048  props = av_cpb_properties_alloc(&props_size);
2049  if (!props)
2050  return AVERROR(ENOMEM);
2051  props->vbv_delay = vbv_delay * 300;
2052 
2054  (uint8_t*)props, props_size);
2055  if (ret < 0) {
2056  av_freep(&props);
2057  return ret;
2058  }
2059 
2060 #if FF_API_VBV_DELAY
2062  avctx->vbv_delay = vbv_delay * 300;
2064 #endif
2065  }
2066  s->total_bits += s->frame_bits;
2067 #if FF_API_STAT_BITS
2069  avctx->frame_bits = s->frame_bits;
2071 #endif
2072 
2073 
2074  pkt->pts = s->current_picture.f->pts;
2075  if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2077  pkt->dts = pkt->pts - s->dts_delta;
2078  else
2079  pkt->dts = s->reordered_pts;
2080  s->reordered_pts = pkt->pts;
2081  } else
2082  pkt->dts = pkt->pts;
2083  if (s->current_picture.f->key_frame)
2084  pkt->flags |= AV_PKT_FLAG_KEY;
2085  if (s->mb_info)
2087  } else {
2088  s->frame_bits = 0;
2089  }
2090 
2091  /* release non-reference frames */
2092  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2093  if (!s->picture[i].reference)
2094  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2095  }
2096 
2097  av_assert1((s->frame_bits & 7) == 0);
2098 
2099  pkt->size = s->frame_bits / 8;
2100  *got_packet = !!pkt->size;
2101  return 0;
2102 }
2103 
2105  int n, int threshold)
2106 {
2107  static const char tab[64] = {
2108  3, 2, 2, 1, 1, 1, 1, 1,
2109  1, 1, 1, 1, 1, 1, 1, 1,
2110  1, 1, 1, 1, 1, 1, 1, 1,
2111  0, 0, 0, 0, 0, 0, 0, 0,
2112  0, 0, 0, 0, 0, 0, 0, 0,
2113  0, 0, 0, 0, 0, 0, 0, 0,
2114  0, 0, 0, 0, 0, 0, 0, 0,
2115  0, 0, 0, 0, 0, 0, 0, 0
2116  };
2117  int score = 0;
2118  int run = 0;
2119  int i;
2120  int16_t *block = s->block[n];
2121  const int last_index = s->block_last_index[n];
2122  int skip_dc;
2123 
2124  if (threshold < 0) {
2125  skip_dc = 0;
2126  threshold = -threshold;
2127  } else
2128  skip_dc = 1;
2129 
2130  /* Are all we could set to zero already zero? */
2131  if (last_index <= skip_dc - 1)
2132  return;
2133 
2134  for (i = 0; i <= last_index; i++) {
2135  const int j = s->intra_scantable.permutated[i];
2136  const int level = FFABS(block[j]);
2137  if (level == 1) {
2138  if (skip_dc && i == 0)
2139  continue;
2140  score += tab[run];
2141  run = 0;
2142  } else if (level > 1) {
2143  return;
2144  } else {
2145  run++;
2146  }
2147  }
2148  if (score >= threshold)
2149  return;
2150  for (i = skip_dc; i <= last_index; i++) {
2151  const int j = s->intra_scantable.permutated[i];
2152  block[j] = 0;
2153  }
2154  if (block[0])
2155  s->block_last_index[n] = 0;
2156  else
2157  s->block_last_index[n] = -1;
2158 }
2159 
2160 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2161  int last_index)
2162 {
2163  int i;
2164  const int maxlevel = s->max_qcoeff;
2165  const int minlevel = s->min_qcoeff;
2166  int overflow = 0;
2167 
2168  if (s->mb_intra) {
2169  i = 1; // skip clipping of intra dc
2170  } else
2171  i = 0;
2172 
2173  for (; i <= last_index; i++) {
2174  const int j = s->intra_scantable.permutated[i];
2175  int level = block[j];
2176 
2177  if (level > maxlevel) {
2178  level = maxlevel;
2179  overflow++;
2180  } else if (level < minlevel) {
2181  level = minlevel;
2182  overflow++;
2183  }
2184 
2185  block[j] = level;
2186  }
2187 
2188  if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2189  av_log(s->avctx, AV_LOG_INFO,
2190  "warning, clipping %d dct coefficients to %d..%d\n",
2191  overflow, minlevel, maxlevel);
2192 }
2193 
2194 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2195 {
2196  int x, y;
2197  // FIXME optimize
2198  for (y = 0; y < 8; y++) {
2199  for (x = 0; x < 8; x++) {
2200  int x2, y2;
2201  int sum = 0;
2202  int sqr = 0;
2203  int count = 0;
2204 
2205  for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2206  for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2207  int v = ptr[x2 + y2 * stride];
2208  sum += v;
2209  sqr += v * v;
2210  count++;
2211  }
2212  }
2213  weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2214  }
2215  }
2216 }
2217 
2219  int motion_x, int motion_y,
2220  int mb_block_height,
2221  int mb_block_width,
2222  int mb_block_count)
2223 {
2224  int16_t weight[12][64];
2225  int16_t orig[12][64];
2226  const int mb_x = s->mb_x;
2227  const int mb_y = s->mb_y;
2228  int i;
2229  int skip_dct[12];
2230  int dct_offset = s->linesize * 8; // default for progressive frames
2231  int uv_dct_offset = s->uvlinesize * 8;
2232  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2233  ptrdiff_t wrap_y, wrap_c;
2234 
2235  for (i = 0; i < mb_block_count; i++)
2236  skip_dct[i] = s->skipdct;
2237 
2238  if (s->adaptive_quant) {
2239  const int last_qp = s->qscale;
2240  const int mb_xy = mb_x + mb_y * s->mb_stride;
2241 
2242  s->lambda = s->lambda_table[mb_xy];
2243  update_qscale(s);
2244 
2245  if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2246  s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2247  s->dquant = s->qscale - last_qp;
2248 
2249  if (s->out_format == FMT_H263) {
2250  s->dquant = av_clip(s->dquant, -2, 2);
2251 
2252  if (s->codec_id == AV_CODEC_ID_MPEG4) {
2253  if (!s->mb_intra) {
2254  if (s->pict_type == AV_PICTURE_TYPE_B) {
2255  if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2256  s->dquant = 0;
2257  }
2258  if (s->mv_type == MV_TYPE_8X8)
2259  s->dquant = 0;
2260  }
2261  }
2262  }
2263  }
2264  ff_set_qscale(s, last_qp + s->dquant);
2265  } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2266  ff_set_qscale(s, s->qscale + s->dquant);
2267 
2268  wrap_y = s->linesize;
2269  wrap_c = s->uvlinesize;
2270  ptr_y = s->new_picture.f->data[0] +
2271  (mb_y * 16 * wrap_y) + mb_x * 16;
2272  ptr_cb = s->new_picture.f->data[1] +
2273  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2274  ptr_cr = s->new_picture.f->data[2] +
2275  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2276 
2277  if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2278  uint8_t *ebuf = s->sc.edge_emu_buffer + 36 * wrap_y;
2279  int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2280  int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2281  s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2282  wrap_y, wrap_y,
2283  16, 16, mb_x * 16, mb_y * 16,
2284  s->width, s->height);
2285  ptr_y = ebuf;
2286  s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2287  wrap_c, wrap_c,
2288  mb_block_width, mb_block_height,
2289  mb_x * mb_block_width, mb_y * mb_block_height,
2290  cw, ch);
2291  ptr_cb = ebuf + 16 * wrap_y;
2292  s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2293  wrap_c, wrap_c,
2294  mb_block_width, mb_block_height,
2295  mb_x * mb_block_width, mb_y * mb_block_height,
2296  cw, ch);
2297  ptr_cr = ebuf + 16 * wrap_y + 16;
2298  }
2299 
2300  if (s->mb_intra) {
2302  int progressive_score, interlaced_score;
2303 
2304  s->interlaced_dct = 0;
2305  progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2306  s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2307  NULL, wrap_y, 8) - 400;
2308 
2309  if (progressive_score > 0) {
2310  interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2311  NULL, wrap_y * 2, 8) +
2312  s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2313  NULL, wrap_y * 2, 8);
2314  if (progressive_score > interlaced_score) {
2315  s->interlaced_dct = 1;
2316 
2317  dct_offset = wrap_y;
2318  uv_dct_offset = wrap_c;
2319  wrap_y <<= 1;
2320  if (s->chroma_format == CHROMA_422 ||
2321  s->chroma_format == CHROMA_444)
2322  wrap_c <<= 1;
2323  }
2324  }
2325  }
2326 
2327  s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2328  s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2329  s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2330  s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2331 
2332  if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2333  skip_dct[4] = 1;
2334  skip_dct[5] = 1;
2335  } else {
2336  s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2337  s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2338  if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2339  s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2340  s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2341  } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2342  s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2343  s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2344  s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2345  s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2346  s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2347  s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2348  }
2349  }
2350  } else {
2351  op_pixels_func (*op_pix)[4];
2352  qpel_mc_func (*op_qpix)[16];
2353  uint8_t *dest_y, *dest_cb, *dest_cr;
2354 
2355  dest_y = s->dest[0];
2356  dest_cb = s->dest[1];
2357  dest_cr = s->dest[2];
2358 
2359  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2360  op_pix = s->hdsp.put_pixels_tab;
2361  op_qpix = s->qdsp.put_qpel_pixels_tab;
2362  } else {
2363  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2364  op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2365  }
2366 
2367  if (s->mv_dir & MV_DIR_FORWARD) {
2368  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2369  s->last_picture.f->data,
2370  op_pix, op_qpix);
2371  op_pix = s->hdsp.avg_pixels_tab;
2372  op_qpix = s->qdsp.avg_qpel_pixels_tab;
2373  }
2374  if (s->mv_dir & MV_DIR_BACKWARD) {
2375  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2376  s->next_picture.f->data,
2377  op_pix, op_qpix);
2378  }
2379 
2381  int progressive_score, interlaced_score;
2382 
2383  s->interlaced_dct = 0;
2384  progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2385  s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2386  ptr_y + wrap_y * 8,
2387  wrap_y, 8) - 400;
2388 
2389  if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2390  progressive_score -= 400;
2391 
2392  if (progressive_score > 0) {
2393  interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2394  wrap_y * 2, 8) +
2395  s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2396  ptr_y + wrap_y,
2397  wrap_y * 2, 8);
2398 
2399  if (progressive_score > interlaced_score) {
2400  s->interlaced_dct = 1;
2401 
2402  dct_offset = wrap_y;
2403  uv_dct_offset = wrap_c;
2404  wrap_y <<= 1;
2405  if (s->chroma_format == CHROMA_422)
2406  wrap_c <<= 1;
2407  }
2408  }
2409  }
2410 
2411  s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2412  s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2413  s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2414  dest_y + dct_offset, wrap_y);
2415  s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2416  dest_y + dct_offset + 8, wrap_y);
2417 
2418  if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2419  skip_dct[4] = 1;
2420  skip_dct[5] = 1;
2421  } else {
2422  s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2423  s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2424  if (!s->chroma_y_shift) { /* 422 */
2425  s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2426  dest_cb + uv_dct_offset, wrap_c);
2427  s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2428  dest_cr + uv_dct_offset, wrap_c);
2429  }
2430  }
2431  /* pre quantization */
2432  if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2433  2 * s->qscale * s->qscale) {
2434  // FIXME optimize
2435  if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2436  skip_dct[0] = 1;
2437  if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2438  skip_dct[1] = 1;
2439  if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2440  wrap_y, 8) < 20 * s->qscale)
2441  skip_dct[2] = 1;
2442  if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2443  wrap_y, 8) < 20 * s->qscale)
2444  skip_dct[3] = 1;
2445  if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2446  skip_dct[4] = 1;
2447  if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2448  skip_dct[5] = 1;
2449  if (!s->chroma_y_shift) { /* 422 */
2450  if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2451  dest_cb + uv_dct_offset,
2452  wrap_c, 8) < 20 * s->qscale)
2453  skip_dct[6] = 1;
2454  if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2455  dest_cr + uv_dct_offset,
2456  wrap_c, 8) < 20 * s->qscale)
2457  skip_dct[7] = 1;
2458  }
2459  }
2460  }
2461 
2462  if (s->quantizer_noise_shaping) {
2463  if (!skip_dct[0])
2464  get_visual_weight(weight[0], ptr_y , wrap_y);
2465  if (!skip_dct[1])
2466  get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2467  if (!skip_dct[2])
2468  get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2469  if (!skip_dct[3])
2470  get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2471  if (!skip_dct[4])
2472  get_visual_weight(weight[4], ptr_cb , wrap_c);
2473  if (!skip_dct[5])
2474  get_visual_weight(weight[5], ptr_cr , wrap_c);
2475  if (!s->chroma_y_shift) { /* 422 */
2476  if (!skip_dct[6])
2477  get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2478  wrap_c);
2479  if (!skip_dct[7])
2480  get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2481  wrap_c);
2482  }
2483  memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2484  }
2485 
2486  /* DCT & quantize */
2487  av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2488  {
2489  for (i = 0; i < mb_block_count; i++) {
2490  if (!skip_dct[i]) {
2491  int overflow;
2492  s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2493  // FIXME we could decide to change to quantizer instead of
2494  // clipping
2495  // JS: I don't think that would be a good idea it could lower
2496  // quality instead of improve it. Just INTRADC clipping
2497  // deserves changes in quantizer
2498  if (overflow)
2499  clip_coeffs(s, s->block[i], s->block_last_index[i]);
2500  } else
2501  s->block_last_index[i] = -1;
2502  }
2503  if (s->quantizer_noise_shaping) {
2504  for (i = 0; i < mb_block_count; i++) {
2505  if (!skip_dct[i]) {
2506  s->block_last_index[i] =
2507  dct_quantize_refine(s, s->block[i], weight[i],
2508  orig[i], i, s->qscale);
2509  }
2510  }
2511  }
2512 
2513  if (s->luma_elim_threshold && !s->mb_intra)
2514  for (i = 0; i < 4; i++)
2516  if (s->chroma_elim_threshold && !s->mb_intra)
2517  for (i = 4; i < mb_block_count; i++)
2519 
2520  if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2521  for (i = 0; i < mb_block_count; i++) {
2522  if (s->block_last_index[i] == -1)
2523  s->coded_score[i] = INT_MAX / 256;
2524  }
2525  }
2526  }
2527 
2528  if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2529  s->block_last_index[4] =
2530  s->block_last_index[5] = 0;
2531  s->block[4][0] =
2532  s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2533  if (!s->chroma_y_shift) { /* 422 / 444 */
2534  for (i=6; i<12; i++) {
2535  s->block_last_index[i] = 0;
2536  s->block[i][0] = s->block[4][0];
2537  }
2538  }
2539  }
2540 
2541  // non c quantize code returns incorrect block_last_index FIXME
2542  if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2543  for (i = 0; i < mb_block_count; i++) {
2544  int j;
2545  if (s->block_last_index[i] > 0) {
2546  for (j = 63; j > 0; j--) {
2547  if (s->block[i][s->intra_scantable.permutated[j]])
2548  break;
2549  }
2550  s->block_last_index[i] = j;
2551  }
2552  }
2553  }
2554 
2555  /* huffman encode */
2556  switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2559  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2560  ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2561  break;
2562  case AV_CODEC_ID_MPEG4:
2563  if (CONFIG_MPEG4_ENCODER)
2564  ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2565  break;
2566  case AV_CODEC_ID_MSMPEG4V2:
2567  case AV_CODEC_ID_MSMPEG4V3:
2568  case AV_CODEC_ID_WMV1:
2570  ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2571  break;
2572  case AV_CODEC_ID_WMV2:
2573  if (CONFIG_WMV2_ENCODER)
2574  ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2575  break;
2576  case AV_CODEC_ID_H261:
2577  if (CONFIG_H261_ENCODER)
2578  ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2579  break;
2580  case AV_CODEC_ID_H263:
2581  case AV_CODEC_ID_H263P:
2582  case AV_CODEC_ID_FLV1:
2583  case AV_CODEC_ID_RV10:
2584  case AV_CODEC_ID_RV20:
2585  if (CONFIG_H263_ENCODER)
2586  ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2587  break;
2588  case AV_CODEC_ID_MJPEG:
2589  case AV_CODEC_ID_AMV:
2590  if (CONFIG_MJPEG_ENCODER)
2591  ff_mjpeg_encode_mb(s, s->block);
2592  break;
2593  default:
2594  av_assert1(0);
2595  }
2596 }
2597 
2598 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2599 {
2600  if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2601  else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2602  else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2603 }
2604 
2606  int i;
2607 
2608  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2609 
2610  /* mpeg1 */
2611  d->mb_skip_run= s->mb_skip_run;
2612  for(i=0; i<3; i++)
2613  d->last_dc[i] = s->last_dc[i];
2614 
2615  /* statistics */
2616  d->mv_bits= s->mv_bits;
2617  d->i_tex_bits= s->i_tex_bits;
2618  d->p_tex_bits= s->p_tex_bits;
2619  d->i_count= s->i_count;
2620  d->f_count= s->f_count;
2621  d->b_count= s->b_count;
2622  d->skip_count= s->skip_count;
2623  d->misc_bits= s->misc_bits;
2624  d->last_bits= 0;
2625 
2626  d->mb_skipped= 0;
2627  d->qscale= s->qscale;
2628  d->dquant= s->dquant;
2629 
2631 }
2632 
2634  int i;
2635 
2636  memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2637  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2638 
2639  /* mpeg1 */
2640  d->mb_skip_run= s->mb_skip_run;
2641  for(i=0; i<3; i++)
2642  d->last_dc[i] = s->last_dc[i];
2643 
2644  /* statistics */
2645  d->mv_bits= s->mv_bits;
2646  d->i_tex_bits= s->i_tex_bits;
2647  d->p_tex_bits= s->p_tex_bits;
2648  d->i_count= s->i_count;
2649  d->f_count= s->f_count;
2650  d->b_count= s->b_count;
2651  d->skip_count= s->skip_count;
2652  d->misc_bits= s->misc_bits;
2653 
2654  d->mb_intra= s->mb_intra;
2655  d->mb_skipped= s->mb_skipped;
2656  d->mv_type= s->mv_type;
2657  d->mv_dir= s->mv_dir;
2658  d->pb= s->pb;
2659  if(s->data_partitioning){
2660  d->pb2= s->pb2;
2661  d->tex_pb= s->tex_pb;
2662  }
2663  d->block= s->block;
2664  for(i=0; i<8; i++)
2665  d->block_last_index[i]= s->block_last_index[i];
2667  d->qscale= s->qscale;
2668 
2670 }
2671 
2672 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2674  int *dmin, int *next_block, int motion_x, int motion_y)
2675 {
2676  int score;
2677  uint8_t *dest_backup[3];
2678 
2679  copy_context_before_encode(s, backup, type);
2680 
2681  s->block= s->blocks[*next_block];
2682  s->pb= pb[*next_block];
2683  if(s->data_partitioning){
2684  s->pb2 = pb2 [*next_block];
2685  s->tex_pb= tex_pb[*next_block];
2686  }
2687 
2688  if(*next_block){
2689  memcpy(dest_backup, s->dest, sizeof(s->dest));
2690  s->dest[0] = s->sc.rd_scratchpad;
2691  s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2692  s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2693  av_assert0(s->linesize >= 32); //FIXME
2694  }
2695 
2696  encode_mb(s, motion_x, motion_y);
2697 
2698  score= put_bits_count(&s->pb);
2699  if(s->data_partitioning){
2700  score+= put_bits_count(&s->pb2);
2701  score+= put_bits_count(&s->tex_pb);
2702  }
2703 
2704  if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2705  ff_mpv_decode_mb(s, s->block);
2706 
2707  score *= s->lambda2;
2708  score += sse_mb(s) << FF_LAMBDA_SHIFT;
2709  }
2710 
2711  if(*next_block){
2712  memcpy(s->dest, dest_backup, sizeof(s->dest));
2713  }
2714 
2715  if(score<*dmin){
2716  *dmin= score;
2717  *next_block^=1;
2718 
2719  copy_context_after_encode(best, s, type);
2720  }
2721 }
2722 
2723 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2724  uint32_t *sq = ff_square_tab + 256;
2725  int acc=0;
2726  int x,y;
2727 
2728  if(w==16 && h==16)
2729  return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2730  else if(w==8 && h==8)
2731  return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2732 
2733  for(y=0; y<h; y++){
2734  for(x=0; x<w; x++){
2735  acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2736  }
2737  }
2738 
2739  av_assert2(acc>=0);
2740 
2741  return acc;
2742 }
2743 
2744 static int sse_mb(MpegEncContext *s){
2745  int w= 16;
2746  int h= 16;
2747 
2748  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2749  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2750 
2751  if(w==16 && h==16)
2752  if(s->avctx->mb_cmp == FF_CMP_NSSE){
2753  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) +
2754  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) +
2755  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);
2756  }else{
2757  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) +
2758  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) +
2759  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);
2760  }
2761  else
2762  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)
2763  +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)
2764  +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);
2765 }
2766 
2768  MpegEncContext *s= *(void**)arg;
2769 
2770 
2771  s->me.pre_pass=1;
2772  s->me.dia_size= s->avctx->pre_dia_size;
2773  s->first_slice_line=1;
2774  for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2775  for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2777  }
2778  s->first_slice_line=0;
2779  }
2780 
2781  s->me.pre_pass=0;
2782 
2783  return 0;
2784 }
2785 
2787  MpegEncContext *s= *(void**)arg;
2788 
2790 
2791  s->me.dia_size= s->avctx->dia_size;
2792  s->first_slice_line=1;
2793  for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2794  s->mb_x=0; //for block init below
2796  for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2797  s->block_index[0]+=2;
2798  s->block_index[1]+=2;
2799  s->block_index[2]+=2;
2800  s->block_index[3]+=2;
2801 
2802  /* compute motion vector & mb_type and store in context */
2805  else
2807  }
2808  s->first_slice_line=0;
2809  }
2810  return 0;
2811 }
2812 
2813 static int mb_var_thread(AVCodecContext *c, void *arg){
2814  MpegEncContext *s= *(void**)arg;
2815  int mb_x, mb_y;
2816 
2818 
2819  for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2820  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2821  int xx = mb_x * 16;
2822  int yy = mb_y * 16;
2823  uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2824  int varc;
2825  int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2826 
2827  varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2828  (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2829 
2830  s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2831  s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2832  s->me.mb_var_sum_temp += varc;
2833  }
2834  }
2835  return 0;
2836 }
2837 
2839  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2840  if(s->partitioned_frame){
2842  }
2843 
2844  ff_mpeg4_stuffing(&s->pb);
2845  }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2847  }
2848 
2850  flush_put_bits(&s->pb);
2851 
2852  if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2853  s->misc_bits+= get_bits_diff(s);
2854 }
2855 
2857 {
2858  uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2859  int offset = put_bits_count(&s->pb);
2860  int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2861  int gobn = s->mb_y / s->gob_index;
2862  int pred_x, pred_y;
2863  if (CONFIG_H263_ENCODER)
2864  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2865  bytestream_put_le32(&ptr, offset);
2866  bytestream_put_byte(&ptr, s->qscale);
2867  bytestream_put_byte(&ptr, gobn);
2868  bytestream_put_le16(&ptr, mba);
2869  bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2870  bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2871  /* 4MV not implemented */
2872  bytestream_put_byte(&ptr, 0); /* hmv2 */
2873  bytestream_put_byte(&ptr, 0); /* vmv2 */
2874 }
2875 
2876 static void update_mb_info(MpegEncContext *s, int startcode)
2877 {
2878  if (!s->mb_info)
2879  return;
2880  if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2881  s->mb_info_size += 12;
2882  s->prev_mb_info = s->last_mb_info;
2883  }
2884  if (startcode) {
2885  s->prev_mb_info = put_bits_count(&s->pb)/8;
2886  /* This might have incremented mb_info_size above, and we return without
2887  * actually writing any info into that slot yet. But in that case,
2888  * this will be called again at the start of the after writing the
2889  * start code, actually writing the mb info. */
2890  return;
2891  }
2892 
2893  s->last_mb_info = put_bits_count(&s->pb)/8;
2894  if (!s->mb_info_size)
2895  s->mb_info_size += 12;
2896  write_mb_info(s);
2897 }
2898 
2899 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2900 {
2901  if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2902  && s->slice_context_count == 1
2903  && s->pb.buf == s->avctx->internal->byte_buffer) {
2904  int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2905  int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2906 
2907  uint8_t *new_buffer = NULL;
2908  int new_buffer_size = 0;
2909 
2910  if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2911  av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2912  return AVERROR(ENOMEM);
2913  }
2914 
2915  av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2916  s->avctx->internal->byte_buffer_size + size_increase);
2917  if (!new_buffer)
2918  return AVERROR(ENOMEM);
2919 
2920  memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2922  s->avctx->internal->byte_buffer = new_buffer;
2923  s->avctx->internal->byte_buffer_size = new_buffer_size;
2924  rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2925  s->ptr_lastgob = s->pb.buf + lastgob_pos;
2926  s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2927  }
2928  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2929  return AVERROR(EINVAL);
2930  return 0;
2931 }
2932 
2933 static int encode_thread(AVCodecContext *c, void *arg){
2934  MpegEncContext *s= *(void**)arg;
2935  int mb_x, mb_y, pdif = 0;
2936  int chr_h= 16>>s->chroma_y_shift;
2937  int i, j;
2938  MpegEncContext best_s = { 0 }, backup_s;
2939  uint8_t bit_buf[2][MAX_MB_BYTES];
2940  uint8_t bit_buf2[2][MAX_MB_BYTES];
2941  uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2942  PutBitContext pb[2], pb2[2], tex_pb[2];
2943 
2945 
2946  for(i=0; i<2; i++){
2947  init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2948  init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2949  init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2950  }
2951 
2952  s->last_bits= put_bits_count(&s->pb);
2953  s->mv_bits=0;
2954  s->misc_bits=0;
2955  s->i_tex_bits=0;
2956  s->p_tex_bits=0;
2957  s->i_count=0;
2958  s->f_count=0;
2959  s->b_count=0;
2960  s->skip_count=0;
2961 
2962  for(i=0; i<3; i++){
2963  /* init last dc values */
2964  /* note: quant matrix value (8) is implied here */
2965  s->last_dc[i] = 128 << s->intra_dc_precision;
2966 
2967  s->current_picture.encoding_error[i] = 0;
2968  }
2969  if(s->codec_id==AV_CODEC_ID_AMV){
2970  s->last_dc[0] = 128*8/13;
2971  s->last_dc[1] = 128*8/14;
2972  s->last_dc[2] = 128*8/14;
2973  }
2974  s->mb_skip_run = 0;
2975  memset(s->last_mv, 0, sizeof(s->last_mv));
2976 
2977  s->last_mv_dir = 0;
2978 
2979  switch(s->codec_id){
2980  case AV_CODEC_ID_H263:
2981  case AV_CODEC_ID_H263P:
2982  case AV_CODEC_ID_FLV1:
2983  if (CONFIG_H263_ENCODER)
2984  s->gob_index = H263_GOB_HEIGHT(s->height);
2985  break;
2986  case AV_CODEC_ID_MPEG4:
2987  if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2989  break;
2990  }
2991 
2992  s->resync_mb_x=0;
2993  s->resync_mb_y=0;
2994  s->first_slice_line = 1;
2995  s->ptr_lastgob = s->pb.buf;
2996  for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2997  s->mb_x=0;
2998  s->mb_y= mb_y;
2999 
3000  ff_set_qscale(s, s->qscale);
3002 
3003  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3004  int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3005  int mb_type= s->mb_type[xy];
3006 // int d;
3007  int dmin= INT_MAX;
3008  int dir;
3009  int size_increase = s->avctx->internal->byte_buffer_size/4
3010  + s->mb_width*MAX_MB_BYTES;
3011 
3012  ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3013  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3014  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3015  return -1;
3016  }
3017  if(s->data_partitioning){
3018  if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
3019  || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3020  av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3021  return -1;
3022  }
3023  }
3024 
3025  s->mb_x = mb_x;
3026  s->mb_y = mb_y; // moved into loop, can get changed by H.261
3028 
3029  if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3031  xy= s->mb_y*s->mb_stride + s->mb_x;
3032  mb_type= s->mb_type[xy];
3033  }
3034 
3035  /* write gob / video packet header */
3036  if(s->rtp_mode){
3037  int current_packet_size, is_gob_start;
3038 
3039  current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3040 
3041  is_gob_start = s->rtp_payload_size &&
3042  current_packet_size >= s->rtp_payload_size &&
3043  mb_y + mb_x > 0;
3044 
3045  if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3046 
3047  switch(s->codec_id){
3048  case AV_CODEC_ID_H263:
3049  case AV_CODEC_ID_H263P:
3050  if(!s->h263_slice_structured)
3051  if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3052  break;
3054  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3056  if(s->mb_skip_run) is_gob_start=0;
3057  break;
3058  case AV_CODEC_ID_MJPEG:
3059  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3060  break;
3061  }
3062 
3063  if(is_gob_start){
3064  if(s->start_mb_y != mb_y || mb_x!=0){
3065  write_slice_end(s);
3066 
3067  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3069  }
3070  }
3071 
3072  av_assert2((put_bits_count(&s->pb)&7) == 0);
3073  current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3074 
3075  if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3076  int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3077  int d = 100 / s->error_rate;
3078  if(r % d == 0){
3079  current_packet_size=0;
3080  s->pb.buf_ptr= s->ptr_lastgob;
3081  assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3082  }
3083  }
3084 
3085 #if FF_API_RTP_CALLBACK
3087  if (s->avctx->rtp_callback){
3088  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3089  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3090  }
3092 #endif
3093  update_mb_info(s, 1);
3094 
3095  switch(s->codec_id){
3096  case AV_CODEC_ID_MPEG4:
3097  if (CONFIG_MPEG4_ENCODER) {
3100  }
3101  break;
3104  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3107  }
3108  break;
3109  case AV_CODEC_ID_H263:
3110  case AV_CODEC_ID_H263P:
3111  if (CONFIG_H263_ENCODER)
3112  ff_h263_encode_gob_header(s, mb_y);
3113  break;
3114  }
3115 
3116  if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3117  int bits= put_bits_count(&s->pb);
3118  s->misc_bits+= bits - s->last_bits;
3119  s->last_bits= bits;
3120  }
3121 
3122  s->ptr_lastgob += current_packet_size;
3123  s->first_slice_line=1;
3124  s->resync_mb_x=mb_x;
3125  s->resync_mb_y=mb_y;
3126  }
3127  }
3128 
3129  if( (s->resync_mb_x == s->mb_x)
3130  && s->resync_mb_y+1 == s->mb_y){
3131  s->first_slice_line=0;
3132  }
3133 
3134  s->mb_skipped=0;
3135  s->dquant=0; //only for QP_RD
3136 
3137  update_mb_info(s, 0);
3138 
3139  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
3140  int next_block=0;
3141  int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3142 
3143  copy_context_before_encode(&backup_s, s, -1);
3144  backup_s.pb= s->pb;
3147  if(s->data_partitioning){
3148  backup_s.pb2= s->pb2;
3149  backup_s.tex_pb= s->tex_pb;
3150  }
3151 
3152  if(mb_type&CANDIDATE_MB_TYPE_INTER){
3153  s->mv_dir = MV_DIR_FORWARD;
3154  s->mv_type = MV_TYPE_16X16;
3155  s->mb_intra= 0;
3156  s->mv[0][0][0] = s->p_mv_table[xy][0];
3157  s->mv[0][0][1] = s->p_mv_table[xy][1];
3158  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3159  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3160  }
3161  if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3162  s->mv_dir = MV_DIR_FORWARD;
3163  s->mv_type = MV_TYPE_FIELD;
3164  s->mb_intra= 0;
3165  for(i=0; i<2; i++){
3166  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3167  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3168  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3169  }
3170  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3171  &dmin, &next_block, 0, 0);
3172  }
3173  if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3174  s->mv_dir = MV_DIR_FORWARD;
3175  s->mv_type = MV_TYPE_16X16;
3176  s->mb_intra= 0;
3177  s->mv[0][0][0] = 0;
3178  s->mv[0][0][1] = 0;
3179  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3180  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3181  }
3182  if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3183  s->mv_dir = MV_DIR_FORWARD;
3184  s->mv_type = MV_TYPE_8X8;
3185  s->mb_intra= 0;
3186  for(i=0; i<4; i++){
3187  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3188  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3189  }
3190  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3191  &dmin, &next_block, 0, 0);
3192  }
3193  if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3194  s->mv_dir = MV_DIR_FORWARD;
3195  s->mv_type = MV_TYPE_16X16;
3196  s->mb_intra= 0;
3197  s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3198  s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3199  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3200  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3201  }
3202  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3203  s->mv_dir = MV_DIR_BACKWARD;
3204  s->mv_type = MV_TYPE_16X16;
3205  s->mb_intra= 0;
3206  s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3207  s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3208  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3209  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3210  }
3211  if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3213  s->mv_type = MV_TYPE_16X16;
3214  s->mb_intra= 0;
3215  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3216  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3217  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3218  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3219  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3220  &dmin, &next_block, 0, 0);
3221  }
3222  if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3223  s->mv_dir = MV_DIR_FORWARD;
3224  s->mv_type = MV_TYPE_FIELD;
3225  s->mb_intra= 0;
3226  for(i=0; i<2; i++){
3227  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3228  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3229  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3230  }
3231  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3232  &dmin, &next_block, 0, 0);
3233  }
3234  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3235  s->mv_dir = MV_DIR_BACKWARD;
3236  s->mv_type = MV_TYPE_FIELD;
3237  s->mb_intra= 0;
3238  for(i=0; i<2; i++){
3239  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3240  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3241  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3242  }
3243  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3244  &dmin, &next_block, 0, 0);
3245  }
3246  if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3248  s->mv_type = MV_TYPE_FIELD;
3249  s->mb_intra= 0;
3250  for(dir=0; dir<2; dir++){
3251  for(i=0; i<2; i++){
3252  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3253  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3254  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3255  }
3256  }
3257  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3258  &dmin, &next_block, 0, 0);
3259  }
3260  if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3261  s->mv_dir = 0;
3262  s->mv_type = MV_TYPE_16X16;
3263  s->mb_intra= 1;
3264  s->mv[0][0][0] = 0;
3265  s->mv[0][0][1] = 0;
3266  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3267  &dmin, &next_block, 0, 0);
3268  if(s->h263_pred || s->h263_aic){
3269  if(best_s.mb_intra)
3270  s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3271  else
3272  ff_clean_intra_table_entries(s); //old mode?
3273  }
3274  }
3275 
3276  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3277  if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3278  const int last_qp= backup_s.qscale;
3279  int qpi, qp, dc[6];
3280  int16_t ac[6][16];
3281  const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3282  static const int dquant_tab[4]={-1,1,-2,2};
3283  int storecoefs = s->mb_intra && s->dc_val[0];
3284 
3285  av_assert2(backup_s.dquant == 0);
3286 
3287  //FIXME intra
3288  s->mv_dir= best_s.mv_dir;
3289  s->mv_type = MV_TYPE_16X16;
3290  s->mb_intra= best_s.mb_intra;
3291  s->mv[0][0][0] = best_s.mv[0][0][0];
3292  s->mv[0][0][1] = best_s.mv[0][0][1];
3293  s->mv[1][0][0] = best_s.mv[1][0][0];
3294  s->mv[1][0][1] = best_s.mv[1][0][1];
3295 
3296  qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3297  for(; qpi<4; qpi++){
3298  int dquant= dquant_tab[qpi];
3299  qp= last_qp + dquant;
3300  if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3301  continue;
3302  backup_s.dquant= dquant;
3303  if(storecoefs){
3304  for(i=0; i<6; i++){
3305  dc[i]= s->dc_val[0][ s->block_index[i] ];
3306  memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3307  }
3308  }
3309 
3310  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3311  &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3312  if(best_s.qscale != qp){
3313  if(storecoefs){
3314  for(i=0; i<6; i++){
3315  s->dc_val[0][ s->block_index[i] ]= dc[i];
3316  memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3317  }
3318  }
3319  }
3320  }
3321  }
3322  }
3323  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3324  int mx= s->b_direct_mv_table[xy][0];
3325  int my= s->b_direct_mv_table[xy][1];
3326 
3327  backup_s.dquant = 0;
3329  s->mb_intra= 0;
3330  ff_mpeg4_set_direct_mv(s, mx, my);
3331  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3332  &dmin, &next_block, mx, my);
3333  }
3334  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3335  backup_s.dquant = 0;
3337  s->mb_intra= 0;
3338  ff_mpeg4_set_direct_mv(s, 0, 0);
3339  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3340  &dmin, &next_block, 0, 0);
3341  }
3342  if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3343  int coded=0;
3344  for(i=0; i<6; i++)
3345  coded |= s->block_last_index[i];
3346  if(coded){
3347  int mx,my;
3348  memcpy(s->mv, best_s.mv, sizeof(s->mv));
3349  if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3350  mx=my=0; //FIXME find the one we actually used
3351  ff_mpeg4_set_direct_mv(s, mx, my);
3352  }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3353  mx= s->mv[1][0][0];
3354  my= s->mv[1][0][1];
3355  }else{
3356  mx= s->mv[0][0][0];
3357  my= s->mv[0][0][1];
3358  }
3359 
3360  s->mv_dir= best_s.mv_dir;
3361  s->mv_type = best_s.mv_type;
3362  s->mb_intra= 0;
3363 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3364  s->mv[0][0][1] = best_s.mv[0][0][1];
3365  s->mv[1][0][0] = best_s.mv[1][0][0];
3366  s->mv[1][0][1] = best_s.mv[1][0][1];*/
3367  backup_s.dquant= 0;
3368  s->skipdct=1;
3369  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3370  &dmin, &next_block, mx, my);
3371  s->skipdct=0;
3372  }
3373  }
3374 
3375  s->current_picture.qscale_table[xy] = best_s.qscale;
3376 
3377  copy_context_after_encode(s, &best_s, -1);
3378 
3379  pb_bits_count= put_bits_count(&s->pb);
3380  flush_put_bits(&s->pb);
3381  avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3382  s->pb= backup_s.pb;
3383 
3384  if(s->data_partitioning){
3385  pb2_bits_count= put_bits_count(&s->pb2);
3386  flush_put_bits(&s->pb2);
3387  avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3388  s->pb2= backup_s.pb2;
3389 
3390  tex_pb_bits_count= put_bits_count(&s->tex_pb);
3391  flush_put_bits(&s->tex_pb);
3392  avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3393  s->tex_pb= backup_s.tex_pb;
3394  }
3395  s->last_bits= put_bits_count(&s->pb);
3396 
3397  if (CONFIG_H263_ENCODER &&
3400 
3401  if(next_block==0){ //FIXME 16 vs linesize16
3402  s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3403  s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3404  s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3405  }
3406 
3408  ff_mpv_decode_mb(s, s->block);
3409  } else {
3410  int motion_x = 0, motion_y = 0;
3412  // only one MB-Type possible
3413 
3414  switch(mb_type){
3416  s->mv_dir = 0;
3417  s->mb_intra= 1;
3418  motion_x= s->mv[0][0][0] = 0;
3419  motion_y= s->mv[0][0][1] = 0;
3420  break;
3422  s->mv_dir = MV_DIR_FORWARD;
3423  s->mb_intra= 0;
3424  motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3425  motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3426  break;
3428  s->mv_dir = MV_DIR_FORWARD;
3429  s->mv_type = MV_TYPE_FIELD;
3430  s->mb_intra= 0;
3431  for(i=0; i<2; i++){
3432  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3433  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3434  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3435  }
3436  break;
3438  s->mv_dir = MV_DIR_FORWARD;
3439  s->mv_type = MV_TYPE_8X8;
3440  s->mb_intra= 0;
3441  for(i=0; i<4; i++){
3442  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3443  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3444  }
3445  break;
3447  if (CONFIG_MPEG4_ENCODER) {
3449  s->mb_intra= 0;
3450  motion_x=s->b_direct_mv_table[xy][0];
3451  motion_y=s->b_direct_mv_table[xy][1];
3452  ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3453  }
3454  break;
3456  if (CONFIG_MPEG4_ENCODER) {
3458  s->mb_intra= 0;
3459  ff_mpeg4_set_direct_mv(s, 0, 0);
3460  }
3461  break;
3464  s->mb_intra= 0;
3465  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3466  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3467  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3468  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3469  break;
3471  s->mv_dir = MV_DIR_BACKWARD;
3472  s->mb_intra= 0;
3473  motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3474  motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3475  break;
3477  s->mv_dir = MV_DIR_FORWARD;
3478  s->mb_intra= 0;
3479  motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3480  motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3481  break;
3483  s->mv_dir = MV_DIR_FORWARD;
3484  s->mv_type = MV_TYPE_FIELD;
3485  s->mb_intra= 0;
3486  for(i=0; i<2; i++){
3487  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3488  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3489  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3490  }
3491  break;
3493  s->mv_dir = MV_DIR_BACKWARD;
3494  s->mv_type = MV_TYPE_FIELD;
3495  s->mb_intra= 0;
3496  for(i=0; i<2; i++){
3497  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3498  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3499  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3500  }
3501  break;
3504  s->mv_type = MV_TYPE_FIELD;
3505  s->mb_intra= 0;
3506  for(dir=0; dir<2; dir++){
3507  for(i=0; i<2; i++){
3508  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3509  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3510  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3511  }
3512  }
3513  break;
3514  default:
3515  av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3516  }
3517 
3518  encode_mb(s, motion_x, motion_y);
3519 
3520  // RAL: Update last macroblock type
3521  s->last_mv_dir = s->mv_dir;
3522 
3523  if (CONFIG_H263_ENCODER &&
3526 
3527  ff_mpv_decode_mb(s, s->block);
3528  }
3529 
3530  /* clean the MV table in IPS frames for direct mode in B frames */
3531  if(s->mb_intra /* && I,P,S_TYPE */){
3532  s->p_mv_table[xy][0]=0;
3533  s->p_mv_table[xy][1]=0;
3534  }
3535 
3536  if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3537  int w= 16;
3538  int h= 16;
3539 
3540  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3541  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3542 
3544  s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3545  s->dest[0], w, h, s->linesize);
3547  s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3548  s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3550  s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3551  s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3552  }
3553  if(s->loop_filter){
3554  if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3556  }
3557  ff_dlog(s->avctx, "MB %d %d bits\n",
3558  s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3559  }
3560  }
3561 
3562  //not beautiful here but we must write it before flushing so it has to be here
3565 
3566  write_slice_end(s);
3567 
3568 #if FF_API_RTP_CALLBACK
3570  /* Send the last GOB if RTP */
3571  if (s->avctx->rtp_callback) {
3572  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3573  pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3574  /* Call the RTP callback to send the last GOB */
3575  emms_c();
3576  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3577  }
3579 #endif
3580 
3581  return 0;
3582 }
3583 
3584 #define MERGE(field) dst->field += src->field; src->field=0
3586  MERGE(me.scene_change_score);
3587  MERGE(me.mc_mb_var_sum_temp);
3588  MERGE(me.mb_var_sum_temp);
3589 }
3590 
3592  int i;
3593 
3594  MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3595  MERGE(dct_count[1]);
3596  MERGE(mv_bits);
3597  MERGE(i_tex_bits);
3598  MERGE(p_tex_bits);
3599  MERGE(i_count);
3600  MERGE(f_count);
3601  MERGE(b_count);
3602  MERGE(skip_count);
3603  MERGE(misc_bits);
3604  MERGE(er.error_count);
3609 
3610  if (dst->noise_reduction){
3611  for(i=0; i<64; i++){
3612  MERGE(dct_error_sum[0][i]);
3613  MERGE(dct_error_sum[1][i]);
3614  }
3615  }
3616 
3617  assert(put_bits_count(&src->pb) % 8 ==0);
3618  assert(put_bits_count(&dst->pb) % 8 ==0);
3619  avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3620  flush_put_bits(&dst->pb);
3621 }
3622 
3623 static int estimate_qp(MpegEncContext *s, int dry_run){
3624  if (s->next_lambda){
3627  if(!dry_run) s->next_lambda= 0;
3628  } else if (!s->fixed_qscale) {
3631  if (s->current_picture.f->quality < 0)
3632  return -1;
3633  }
3634 
3635  if(s->adaptive_quant){
3636  switch(s->codec_id){
3637  case AV_CODEC_ID_MPEG4:
3638  if (CONFIG_MPEG4_ENCODER)
3640  break;
3641  case AV_CODEC_ID_H263:
3642  case AV_CODEC_ID_H263P:
3643  case AV_CODEC_ID_FLV1:
3644  if (CONFIG_H263_ENCODER)
3646  break;
3647  default:
3648  ff_init_qscale_tab(s);
3649  }
3650 
3651  s->lambda= s->lambda_table[0];
3652  //FIXME broken
3653  }else
3654  s->lambda = s->current_picture.f->quality;
3655  update_qscale(s);
3656  return 0;
3657 }
3658 
3659 /* must be called before writing the header */
3662  s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3663 
3664  if(s->pict_type==AV_PICTURE_TYPE_B){
3665  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3666  assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3667  }else{
3668  s->pp_time= s->time - s->last_non_b_time;
3669  s->last_non_b_time= s->time;
3670  assert(s->picture_number==0 || s->pp_time > 0);
3671  }
3672 }
3673 
3675 {
3676  int i, ret;
3677  int bits;
3678  int context_count = s->slice_context_count;
3679 
3681 
3682  /* Reset the average MB variance */
3683  s->me.mb_var_sum_temp =
3684  s->me.mc_mb_var_sum_temp = 0;
3685 
3686  /* we need to initialize some time vars before we can encode b-frames */
3687  // RAL: Condition added for MPEG1VIDEO
3690  if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3691  ff_set_mpeg4_time(s);
3692 
3693  s->me.scene_change_score=0;
3694 
3695 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3696 
3697  if(s->pict_type==AV_PICTURE_TYPE_I){
3698  if(s->msmpeg4_version >= 3) s->no_rounding=1;
3699  else s->no_rounding=0;
3700  }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3702  s->no_rounding ^= 1;
3703  }
3704 
3705  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3706  if (estimate_qp(s,1) < 0)
3707  return -1;
3708  ff_get_2pass_fcode(s);
3709  } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3711  s->lambda= s->last_lambda_for[s->pict_type];
3712  else
3714  update_qscale(s);
3715  }
3716 
3722  }
3723 
3724  s->mb_intra=0; //for the rate distortion & bit compare functions
3725  for(i=1; i<context_count; i++){
3727  if (ret < 0)
3728  return ret;
3729  }
3730 
3731  if(ff_init_me(s)<0)
3732  return -1;
3733 
3734  /* Estimate motion for every MB */
3735  if(s->pict_type != AV_PICTURE_TYPE_I){
3736  s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3737  s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3738  if (s->pict_type != AV_PICTURE_TYPE_B) {
3739  if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3740  s->me_pre == 2) {
3741  s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3742  }
3743  }
3744 
3745  s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3746  }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3747  /* I-Frame */
3748  for(i=0; i<s->mb_stride*s->mb_height; i++)
3750 
3751  if(!s->fixed_qscale){
3752  /* finding spatial complexity for I-frame rate control */
3753  s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3754  }
3755  }
3756  for(i=1; i<context_count; i++){
3758  }
3760  s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3761  emms_c();
3762 
3764  s->pict_type == AV_PICTURE_TYPE_P) {
3766  for(i=0; i<s->mb_stride*s->mb_height; i++)
3768  if(s->msmpeg4_version >= 3)
3769  s->no_rounding=1;
3770  ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3772  }
3773 
3774  if(!s->umvplus){
3777 
3779  int a,b;
3780  a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3782  s->f_code= FFMAX3(s->f_code, a, b);
3783  }
3784 
3785  ff_fix_long_p_mvs(s);
3788  int j;
3789  for(i=0; i<2; i++){
3790  for(j=0; j<2; j++)
3793  }
3794  }
3795  }
3796 
3797  if(s->pict_type==AV_PICTURE_TYPE_B){
3798  int a, b;
3799 
3802  s->f_code = FFMAX(a, b);
3803 
3806  s->b_code = FFMAX(a, b);
3807 
3813  int dir, j;
3814  for(dir=0; dir<2; dir++){
3815  for(i=0; i<2; i++){
3816  for(j=0; j<2; j++){
3819  ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3820  s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3821  }
3822  }
3823  }
3824  }
3825  }
3826  }
3827 
3828  if (estimate_qp(s, 0) < 0)
3829  return -1;
3830 
3831  if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3832  s->pict_type == AV_PICTURE_TYPE_I &&
3833  !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3834  s->qscale= 3; //reduce clipping problems
3835 
3836  if (s->out_format == FMT_MJPEG) {
3837  const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3838  const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3839 
3840  if (s->avctx->intra_matrix) {
3841  chroma_matrix =
3842  luma_matrix = s->avctx->intra_matrix;
3843  }
3844  if (s->avctx->chroma_intra_matrix)
3845  chroma_matrix = s->avctx->chroma_intra_matrix;
3846 
3847  /* for mjpeg, we do include qscale in the matrix */
3848  for(i=1;i<64;i++){
3849  int j = s->idsp.idct_permutation[i];
3850 
3851  s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3852  s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3853  }
3854  s->y_dc_scale_table=
3856  s->chroma_intra_matrix[0] =
3859  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3861  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3862  s->qscale= 8;
3863  }
3864  if(s->codec_id == AV_CODEC_ID_AMV){
3865  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};
3866  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};
3867  for(i=1;i<64;i++){
3868  int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3869 
3870  s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3871  s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3872  }
3873  s->y_dc_scale_table= y;
3874  s->c_dc_scale_table= c;
3875  s->intra_matrix[0] = 13;
3876  s->chroma_intra_matrix[0] = 14;
3878  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3880  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3881  s->qscale= 8;
3882  }
3883 
3884  //FIXME var duplication
3886  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3889 
3890  if (s->current_picture.f->key_frame)
3891  s->picture_in_gop_number=0;
3892 
3893  s->mb_x = s->mb_y = 0;
3894  s->last_bits= put_bits_count(&s->pb);
3895  switch(s->out_format) {
3896  case FMT_MJPEG:
3897  if (CONFIG_MJPEG_ENCODER)
3900  break;
3901  case FMT_H261:
3902  if (CONFIG_H261_ENCODER)
3903  ff_h261_encode_picture_header(s, picture_number);
3904  break;
3905  case FMT_H263:
3906  if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3907  ff_wmv2_encode_picture_header(s, picture_number);
3908  else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3909  ff_msmpeg4_encode_picture_header(s, picture_number);
3910  else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3911  ret = ff_mpeg4_encode_picture_header(s, picture_number);
3912  if (ret < 0)
3913  return ret;
3914  } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3915  ret = ff_rv10_encode_picture_header(s, picture_number);
3916  if (ret < 0)
3917  return ret;
3918  }
3919  else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3920  ff_rv20_encode_picture_header(s, picture_number);
3921  else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3922  ff_flv_encode_picture_header(s, picture_number);
3923  else if (CONFIG_H263_ENCODER)
3924  ff_h263_encode_picture_header(s, picture_number);
3925  break;
3926  case FMT_MPEG1:
3927  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3928  ff_mpeg1_encode_picture_header(s, picture_number);
3929  break;
3930  default:
3931  av_assert0(0);
3932  }
3933  bits= put_bits_count(&s->pb);
3934  s->header_bits= bits - s->last_bits;
3935 
3936  for(i=1; i<context_count; i++){
3938  }
3939  s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3940  for(i=1; i<context_count; i++){
3941  if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3942  set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
3944  }
3945  emms_c();
3946  return 0;
3947 }
3948 
3949 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3950  const int intra= s->mb_intra;
3951  int i;
3952 
3953  s->dct_count[intra]++;
3954 
3955  for(i=0; i<64; i++){
3956  int level= block[i];
3957 
3958  if(level){
3959  if(level>0){
3960  s->dct_error_sum[intra][i] += level;
3961  level -= s->dct_offset[intra][i];
3962  if(level<0) level=0;
3963  }else{
3964  s->dct_error_sum[intra][i] -= level;
3965  level += s->dct_offset[intra][i];
3966  if(level>0) level=0;
3967  }
3968  block[i]= level;
3969  }
3970  }
3971 }
3972 
3974  int16_t *block, int n,
3975  int qscale, int *overflow){
3976  const int *qmat;
3977  const uint16_t *matrix;
3978  const uint8_t *scantable= s->intra_scantable.scantable;
3979  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3980  int max=0;
3981  unsigned int threshold1, threshold2;
3982  int bias=0;
3983  int run_tab[65];
3984  int level_tab[65];
3985  int score_tab[65];
3986  int survivor[65];
3987  int survivor_count;
3988  int last_run=0;
3989  int last_level=0;
3990  int last_score= 0;
3991  int last_i;
3992  int coeff[2][64];
3993  int coeff_count[64];
3994  int qmul, qadd, start_i, last_non_zero, i, dc;
3995  const int esc_length= s->ac_esc_length;
3996  uint8_t * length;
3997  uint8_t * last_length;
3998  const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3999  int mpeg2_qscale;
4000 
4001  s->fdsp.fdct(block);
4002 
4003  if(s->dct_error_sum)
4004  s->denoise_dct(s, block);
4005  qmul= qscale*16;
4006  qadd= ((qscale-1)|1)*8;
4007 
4008  if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
4009  else mpeg2_qscale = qscale << 1;
4010 
4011  if (s->mb_intra) {
4012  int q;
4013  if (!s->h263_aic) {
4014  if (n < 4)
4015  q = s->y_dc_scale;
4016  else
4017  q = s->c_dc_scale;
4018  q = q << 3;
4019  } else{
4020  /* For AIC we skip quant/dequant of INTRADC */
4021  q = 1 << 3;
4022  qadd=0;
4023  }
4024 
4025  /* note: block[0] is assumed to be positive */
4026  block[0] = (block[0] + (q >> 1)) / q;
4027  start_i = 1;
4028  last_non_zero = 0;
4029  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4030  matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4031  if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4032  bias= 1<<(QMAT_SHIFT-1);
4033 
4034  if (n > 3 && s->intra_chroma_ac_vlc_length) {
4035  length = s->intra_chroma_ac_vlc_length;
4036  last_length= s->intra_chroma_ac_vlc_last_length;
4037  } else {
4038  length = s->intra_ac_vlc_length;
4039  last_length= s->intra_ac_vlc_last_length;
4040  }
4041  } else {
4042  start_i = 0;
4043  last_non_zero = -1;
4044  qmat = s->q_inter_matrix[qscale];
4045  matrix = s->inter_matrix;
4046  length = s->inter_ac_vlc_length;
4047  last_length= s->inter_ac_vlc_last_length;
4048  }
4049  last_i= start_i;
4050 
4051  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4052  threshold2= (threshold1<<1);
4053 
4054  for(i=63; i>=start_i; i--) {
4055  const int j = scantable[i];
4056  int level = block[j] * qmat[j];
4057 
4058  if(((unsigned)(level+threshold1))>threshold2){
4059  last_non_zero = i;
4060  break;
4061  }
4062  }
4063 
4064  for(i=start_i; i<=last_non_zero; i++) {
4065  const int j = scantable[i];
4066  int level = block[j] * qmat[j];
4067 
4068 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4069 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4070  if(((unsigned)(level+threshold1))>threshold2){
4071  if(level>0){
4072  level= (bias + level)>>QMAT_SHIFT;
4073  coeff[0][i]= level;
4074  coeff[1][i]= level-1;
4075 // coeff[2][k]= level-2;
4076  }else{
4077  level= (bias - level)>>QMAT_SHIFT;
4078  coeff[0][i]= -level;
4079  coeff[1][i]= -level+1;
4080 // coeff[2][k]= -level+2;
4081  }
4082  coeff_count[i]= FFMIN(level, 2);
4083  av_assert2(coeff_count[i]);
4084  max |=level;
4085  }else{
4086  coeff[0][i]= (level>>31)|1;
4087  coeff_count[i]= 1;
4088  }
4089  }
4090 
4091  *overflow= s->max_qcoeff < max; //overflow might have happened
4092 
4093  if(last_non_zero < start_i){
4094  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4095  return last_non_zero;
4096  }
4097 
4098  score_tab[start_i]= 0;
4099  survivor[0]= start_i;
4100  survivor_count= 1;
4101 
4102  for(i=start_i; i<=last_non_zero; i++){
4103  int level_index, j, zero_distortion;
4104  int dct_coeff= FFABS(block[ scantable[i] ]);
4105  int best_score=256*256*256*120;
4106 
4107  if (s->fdsp.fdct == ff_fdct_ifast)
4108  dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4109  zero_distortion= dct_coeff*dct_coeff;
4110 
4111  for(level_index=0; level_index < coeff_count[i]; level_index++){
4112  int distortion;
4113  int level= coeff[level_index][i];
4114  const int alevel= FFABS(level);
4115  int unquant_coeff;
4116 
4117  av_assert2(level);
4118 
4119  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4120  unquant_coeff= alevel*qmul + qadd;
4121  } else if(s->out_format == FMT_MJPEG) {
4122  j = s->idsp.idct_permutation[scantable[i]];
4123  unquant_coeff = alevel * matrix[j] * 8;
4124  }else{ //MPEG1
4125  j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4126  if(s->mb_intra){
4127  unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4128  unquant_coeff = (unquant_coeff - 1) | 1;
4129  }else{
4130  unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4131  unquant_coeff = (unquant_coeff - 1) | 1;
4132  }
4133  unquant_coeff<<= 3;
4134  }
4135 
4136  distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4137  level+=64;
4138  if((level&(~127)) == 0){
4139  for(j=survivor_count-1; j>=0; j--){
4140  int run= i - survivor[j];
4141  int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4142  score += score_tab[i-run];
4143 
4144  if(score < best_score){
4145  best_score= score;
4146  run_tab[i+1]= run;
4147  level_tab[i+1]= level-64;
4148  }
4149  }
4150 
4151  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4152  for(j=survivor_count-1; j>=0; j--){
4153  int run= i - survivor[j];
4154  int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4155  score += score_tab[i-run];
4156  if(score < last_score){
4157  last_score= score;
4158  last_run= run;
4159  last_level= level-64;
4160  last_i= i+1;
4161  }
4162  }
4163  }
4164  }else{
4165  distortion += esc_length*lambda;
4166  for(j=survivor_count-1; j>=0; j--){
4167  int run= i - survivor[j];
4168  int score= distortion + score_tab[i-run];
4169 
4170  if(score < best_score){
4171  best_score= score;
4172  run_tab[i+1]= run;
4173  level_tab[i+1]= level-64;
4174  }
4175  }
4176 
4177  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4178  for(j=survivor_count-1; j>=0; j--){
4179  int run= i - survivor[j];
4180  int score= distortion + score_tab[i-run];
4181  if(score < last_score){
4182  last_score= score;
4183  last_run= run;
4184  last_level= level-64;
4185  last_i= i+1;
4186  }
4187  }
4188  }
4189  }
4190  }
4191 
4192  score_tab[i+1]= best_score;
4193 
4194  //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4195  if(last_non_zero <= 27){
4196  for(; survivor_count; survivor_count--){
4197  if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4198  break;
4199  }
4200  }else{
4201  for(; survivor_count; survivor_count--){
4202  if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4203  break;
4204  }
4205  }
4206 
4207  survivor[ survivor_count++ ]= i+1;
4208  }
4209 
4210  if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4211  last_score= 256*256*256*120;
4212  for(i= survivor[0]; i<=last_non_zero + 1; i++){
4213  int score= score_tab[i];
4214  if(i) score += lambda*2; //FIXME exacter?
4215 
4216  if(score < last_score){
4217  last_score= score;
4218  last_i= i;
4219  last_level= level_tab[i];
4220  last_run= run_tab[i];
4221  }
4222  }
4223  }
4224 
4225  s->coded_score[n] = last_score;
4226 
4227  dc= FFABS(block[0]);
4228  last_non_zero= last_i - 1;
4229  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4230 
4231  if(last_non_zero < start_i)
4232  return last_non_zero;
4233 
4234  if(last_non_zero == 0 && start_i == 0){
4235  int best_level= 0;
4236  int best_score= dc * dc;
4237 
4238  for(i=0; i<coeff_count[0]; i++){
4239  int level= coeff[i][0];
4240  int alevel= FFABS(level);
4241  int unquant_coeff, score, distortion;
4242 
4243  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4244  unquant_coeff= (alevel*qmul + qadd)>>3;
4245  }else{ //MPEG1
4246  unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4247  unquant_coeff = (unquant_coeff - 1) | 1;
4248  }
4249  unquant_coeff = (unquant_coeff + 4) >> 3;
4250  unquant_coeff<<= 3 + 3;
4251 
4252  distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4253  level+=64;
4254  if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4255  else score= distortion + esc_length*lambda;
4256 
4257  if(score < best_score){
4258  best_score= score;
4259  best_level= level - 64;
4260  }
4261  }
4262  block[0]= best_level;
4263  s->coded_score[n] = best_score - dc*dc;
4264  if(best_level == 0) return -1;
4265  else return last_non_zero;
4266  }
4267 
4268  i= last_i;
4269  av_assert2(last_level);
4270 
4271  block[ perm_scantable[last_non_zero] ]= last_level;
4272  i -= last_run + 1;
4273 
4274  for(; i>start_i; i -= run_tab[i] + 1){
4275  block[ perm_scantable[i-1] ]= level_tab[i];
4276  }
4277 
4278  return last_non_zero;
4279 }
4280 
4281 //#define REFINE_STATS 1
4282 static int16_t basis[64][64];
4283 
4284 static void build_basis(uint8_t *perm){
4285  int i, j, x, y;
4286  emms_c();
4287  for(i=0; i<8; i++){
4288  for(j=0; j<8; j++){
4289  for(y=0; y<8; y++){
4290  for(x=0; x<8; x++){
4291  double s= 0.25*(1<<BASIS_SHIFT);
4292  int index= 8*i + j;
4293  int perm_index= perm[index];
4294  if(i==0) s*= sqrt(0.5);
4295  if(j==0) s*= sqrt(0.5);
4296  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)));
4297  }
4298  }
4299  }
4300  }
4301 }
4302 
4303 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4304  int16_t *block, int16_t *weight, int16_t *orig,
4305  int n, int qscale){
4306  int16_t rem[64];
4307  LOCAL_ALIGNED_16(int16_t, d1, [64]);
4308  const uint8_t *scantable= s->intra_scantable.scantable;
4309  const uint8_t *perm_scantable= s->intra_scantable.permutated;
4310 // unsigned int threshold1, threshold2;
4311 // int bias=0;
4312  int run_tab[65];
4313  int prev_run=0;
4314  int prev_level=0;
4315  int qmul, qadd, start_i, last_non_zero, i, dc;
4316  uint8_t * length;
4317  uint8_t * last_length;
4318  int lambda;
4319  int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4320 #ifdef REFINE_STATS
4321 static int count=0;
4322 static int after_last=0;
4323 static int to_zero=0;
4324 static int from_zero=0;
4325 static int raise=0;
4326 static int lower=0;
4327 static int messed_sign=0;
4328 #endif
4329 
4330  if(basis[0][0] == 0)
4332 
4333  qmul= qscale*2;
4334  qadd= (qscale-1)|1;
4335  if (s->mb_intra) {
4336  if (!s->h263_aic) {
4337  if (n < 4)
4338  q = s->y_dc_scale;
4339  else
4340  q = s->c_dc_scale;
4341  } else{
4342  /* For AIC we skip quant/dequant of INTRADC */
4343  q = 1;
4344  qadd=0;
4345  }
4346  q <<= RECON_SHIFT-3;
4347  /* note: block[0] is assumed to be positive */
4348  dc= block[0]*q;
4349 // block[0] = (block[0] + (q >> 1)) / q;
4350  start_i = 1;
4351 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4352 // bias= 1<<(QMAT_SHIFT-1);
4353  if (n > 3 && s->intra_chroma_ac_vlc_length) {
4354  length = s->intra_chroma_ac_vlc_length;
4355  last_length= s->intra_chroma_ac_vlc_last_length;
4356  } else {
4357  length = s->intra_ac_vlc_length;
4358  last_length= s->intra_ac_vlc_last_length;
4359  }
4360  } else {
4361  dc= 0;
4362  start_i = 0;
4363  length = s->inter_ac_vlc_length;
4364  last_length= s->inter_ac_vlc_last_length;
4365  }
4366  last_non_zero = s->block_last_index[n];
4367 
4368 #ifdef REFINE_STATS
4369 {START_TIMER
4370 #endif
4371  dc += (1<<(RECON_SHIFT-1));
4372  for(i=0; i<64; i++){
4373  rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
4374  }
4375 #ifdef REFINE_STATS
4376 STOP_TIMER("memset rem[]")}
4377 #endif
4378  sum=0;
4379  for(i=0; i<64; i++){
4380  int one= 36;
4381  int qns=4;
4382  int w;
4383 
4384  w= FFABS(weight[i]) + qns*one;
4385  w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4386 
4387  weight[i] = w;
4388 // w=weight[i] = (63*qns + (w/2)) / w;
4389 
4390  av_assert2(w>0);
4391  av_assert2(w<(1<<6));
4392  sum += w*w;
4393  }
4394  lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4395 #ifdef REFINE_STATS
4396 {START_TIMER
4397 #endif
4398  run=0;
4399  rle_index=0;
4400  for(i=start_i; i<=last_non_zero; i++){
4401  int j= perm_scantable[i];
4402  const int level= block[j];
4403  int coeff;
4404 
4405  if(level){
4406  if(level<0) coeff= qmul*level - qadd;
4407  else coeff= qmul*level + qadd;
4408  run_tab[rle_index++]=run;
4409  run=0;
4410 
4411  s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4412  }else{
4413  run++;
4414  }
4415  }
4416 #ifdef REFINE_STATS
4417 if(last_non_zero>0){
4418 STOP_TIMER("init rem[]")
4419 }
4420 }
4421 
4422 {START_TIMER
4423 #endif
4424  for(;;){
4425  int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4426  int best_coeff=0;
4427  int best_change=0;
4428  int run2, best_unquant_change=0, analyze_gradient;
4429 #ifdef REFINE_STATS
4430 {START_TIMER
4431 #endif
4432  analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4433 
4434  if(analyze_gradient){
4435 #ifdef REFINE_STATS
4436 {START_TIMER
4437 #endif
4438  for(i=0; i<64; i++){
4439  int w= weight[i];
4440 
4441  d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4442  }
4443 #ifdef REFINE_STATS
4444 STOP_TIMER("rem*w*w")}
4445 {START_TIMER
4446 #endif
4447  s->fdsp.fdct(d1);
4448 #ifdef REFINE_STATS
4449 STOP_TIMER("dct")}
4450 #endif
4451  }
4452 
4453  if(start_i){
4454  const int level= block[0];
4455  int change, old_coeff;
4456 
4457  av_assert2(s->mb_intra);
4458 
4459  old_coeff= q*level;
4460 
4461  for(change=-1; change<=1; change+=2){
4462  int new_level= level + change;
4463  int score, new_coeff;
4464 
4465  new_coeff= q*new_level;
4466  if(new_coeff >= 2048 || new_coeff < 0)
4467  continue;
4468 
4469  score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4470  new_coeff - old_coeff);
4471  if(score<best_score){
4472  best_score= score;
4473  best_coeff= 0;
4474  best_change= change;
4475  best_unquant_change= new_coeff - old_coeff;
4476  }
4477  }
4478  }
4479 
4480  run=0;
4481  rle_index=0;
4482  run2= run_tab[rle_index++];
4483  prev_level=0;
4484  prev_run=0;
4485 
4486  for(i=start_i; i<64; i++){
4487  int j= perm_scantable[i];
4488  const int level= block[j];
4489  int change, old_coeff;
4490 
4491  if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4492  break;
4493 
4494  if(level){
4495  if(level<0) old_coeff= qmul*level - qadd;
4496  else old_coeff= qmul*level + qadd;
4497  run2= run_tab[rle_index++]; //FIXME ! maybe after last
4498  }else{
4499  old_coeff=0;
4500  run2--;
4501  av_assert2(run2>=0 || i >= last_non_zero );
4502  }
4503 
4504  for(change=-1; change<=1; change+=2){
4505  int new_level= level + change;
4506  int score, new_coeff, unquant_change;
4507 
4508  score=0;
4509  if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4510  continue;
4511 
4512  if(new_level){
4513  if(new_level<0) new_coeff= qmul*new_level - qadd;
4514  else new_coeff= qmul*new_level + qadd;
4515  if(new_coeff >= 2048 || new_coeff <= -2048)
4516  continue;
4517  //FIXME check for overflow
4518 
4519  if(level){
4520  if(level < 63 && level > -63){
4521  if(i < last_non_zero)
4522  score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4523  - length[UNI_AC_ENC_INDEX(run, level+64)];
4524  else
4525  score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4526  - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4527  }
4528  }else{
4529  av_assert2(FFABS(new_level)==1);
4530 
4531  if(analyze_gradient){
4532  int g= d1[ scantable[i] ];
4533  if(g && (g^new_level) >= 0)
4534  continue;
4535  }
4536 
4537  if(i < last_non_zero){
4538  int next_i= i + run2 + 1;
4539  int next_level= block[ perm_scantable[next_i] ] + 64;
4540 
4541  if(next_level&(~127))
4542  next_level= 0;
4543 
4544  if(next_i < last_non_zero)
4545  score += length[UNI_AC_ENC_INDEX(run, 65)]
4546  + length[UNI_AC_ENC_INDEX(run2, next_level)]
4547  - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4548  else
4549  score += length[UNI_AC_ENC_INDEX(run, 65)]
4550  + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4551  - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4552  }else{
4553  score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4554  if(prev_level){
4555  score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4556  - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4557  }
4558  }
4559  }
4560  }else{
4561  new_coeff=0;
4562  av_assert2(FFABS(level)==1);
4563 
4564  if(i < last_non_zero){
4565  int next_i= i + run2 + 1;
4566  int next_level= block[ perm_scantable[next_i] ] + 64;
4567 
4568  if(next_level&(~127))
4569  next_level= 0;
4570 
4571  if(next_i < last_non_zero)
4572  score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4573  - length[UNI_AC_ENC_INDEX(run2, next_level)]
4574  - length[UNI_AC_ENC_INDEX(run, 65)];
4575  else
4576  score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4577  - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4578  - length[UNI_AC_ENC_INDEX(run, 65)];
4579  }else{
4580  score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4581  if(prev_level){
4582  score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4583  - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4584  }
4585  }
4586  }
4587 
4588  score *= lambda;
4589 
4590  unquant_change= new_coeff - old_coeff;
4591  av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4592 
4593  score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4594  unquant_change);
4595  if(score<best_score){
4596  best_score= score;
4597  best_coeff= i;
4598  best_change= change;
4599  best_unquant_change= unquant_change;
4600  }
4601  }
4602  if(level){
4603  prev_level= level + 64;
4604  if(prev_level&(~127))
4605  prev_level= 0;
4606  prev_run= run;
4607  run=0;
4608  }else{
4609  run++;
4610  }
4611  }
4612 #ifdef REFINE_STATS
4613 STOP_TIMER("iterative step")}
4614 #endif
4615 
4616  if(best_change){
4617  int j= perm_scantable[ best_coeff ];
4618 
4619  block[j] += best_change;
4620 
4621  if(best_coeff > last_non_zero){
4622  last_non_zero= best_coeff;
4623  av_assert2(block[j]);
4624 #ifdef REFINE_STATS
4625 after_last++;
4626 #endif
4627  }else{
4628 #ifdef REFINE_STATS
4629 if(block[j]){
4630  if(block[j] - best_change){
4631  if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4632  raise++;
4633  }else{
4634  lower++;
4635  }
4636  }else{
4637  from_zero++;
4638  }
4639 }else{
4640  to_zero++;
4641 }
4642 #endif
4643  for(; last_non_zero>=start_i; last_non_zero--){
4644  if(block[perm_scantable[last_non_zero]])
4645  break;
4646  }
4647  }
4648 #ifdef REFINE_STATS
4649 count++;
4650 if(256*256*256*64 % count == 0){
4651  av_log(s->avctx, AV_LOG_DEBUG, "after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4652 }
4653 #endif
4654  run=0;
4655  rle_index=0;
4656  for(i=start_i; i<=last_non_zero; i++){
4657  int j= perm_scantable[i];
4658  const int level= block[j];
4659 
4660  if(level){
4661  run_tab[rle_index++]=run;
4662  run=0;
4663  }else{
4664  run++;
4665  }
4666  }
4667 
4668  s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4669  }else{
4670  break;
4671  }
4672  }
4673 #ifdef REFINE_STATS
4674 if(last_non_zero>0){
4675 STOP_TIMER("iterative search")
4676 }
4677 }
4678 #endif
4679 
4680  return last_non_zero;
4681 }
4682 
4683 /**
4684  * Permute an 8x8 block according to permuatation.
4685  * @param block the block which will be permuted according to
4686  * the given permutation vector
4687  * @param permutation the permutation vector
4688  * @param last the last non zero coefficient in scantable order, used to
4689  * speed the permutation up
4690  * @param scantable the used scantable, this is only used to speed the
4691  * permutation up, the block is not (inverse) permutated
4692  * to scantable order!
4693  */
4694 void ff_block_permute(int16_t *block, uint8_t *permutation,
4695  const uint8_t *scantable, int last)
4696 {
4697  int i;
4698  int16_t temp[64];
4699 
4700  if (last <= 0)
4701  return;
4702  //FIXME it is ok but not clean and might fail for some permutations
4703  // if (permutation[1] == 1)
4704  // return;
4705 
4706  for (i = 0; i <= last; i++) {
4707  const int j = scantable[i];
4708  temp[j] = block[j];
4709  block[j] = 0;
4710  }
4711 
4712  for (i = 0; i <= last; i++) {
4713  const int j = scantable[i];
4714  const int perm_j = permutation[j];
4715  block[perm_j] = temp[j];
4716  }
4717 }
4718 
4720  int16_t *block, int n,
4721  int qscale, int *overflow)
4722 {
4723  int i, j, level, last_non_zero, q, start_i;
4724  const int *qmat;
4725  const uint8_t *scantable= s->intra_scantable.scantable;
4726  int bias;
4727  int max=0;
4728  unsigned int threshold1, threshold2;
4729 
4730  s->fdsp.fdct(block);
4731 
4732  if(s->dct_error_sum)
4733  s->denoise_dct(s, block);
4734 
4735  if (s->mb_intra) {
4736  if (!s->h263_aic) {
4737  if (n < 4)
4738  q = s->y_dc_scale;
4739  else
4740  q = s->c_dc_scale;
4741  q = q << 3;
4742  } else
4743  /* For AIC we skip quant/dequant of INTRADC */
4744  q = 1 << 3;
4745 
4746  /* note: block[0] is assumed to be positive */
4747  block[0] = (block[0] + (q >> 1)) / q;
4748  start_i = 1;
4749  last_non_zero = 0;
4750  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4751  bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4752  } else {
4753  start_i = 0;
4754  last_non_zero = -1;
4755  qmat = s->q_inter_matrix[qscale];
4756  bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4757  }
4758  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4759  threshold2= (threshold1<<1);
4760  for(i=63;i>=start_i;i--) {
4761  j = scantable[i];
4762  level = block[j] * qmat[j];
4763 
4764  if(((unsigned)(level+threshold1))>threshold2){
4765  last_non_zero = i;
4766  break;
4767  }else{
4768  block[j]=0;
4769  }
4770  }
4771  for(i=start_i; i<=last_non_zero; i++) {
4772  j = scantable[i];
4773  level = block[j] * qmat[j];
4774 
4775 // if( bias+level >= (1<<QMAT_SHIFT)
4776 // || bias-level >= (1<<QMAT_SHIFT)){
4777  if(((unsigned)(level+threshold1))>threshold2){
4778  if(level>0){
4779  level= (bias + level)>>QMAT_SHIFT;
4780  block[j]= level;
4781  }else{
4782  level= (bias - level)>>QMAT_SHIFT;
4783  block[j]= -level;
4784  }
4785  max |=level;
4786  }else{
4787  block[j]=0;
4788  }
4789  }
4790  *overflow= s->max_qcoeff < max; //overflow might have happened
4791 
4792  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4793  if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4795  scantable, last_non_zero);
4796 
4797  return last_non_zero;
4798 }
4799 
4800 #define OFFSET(x) offsetof(MpegEncContext, x)
4801 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4802 static const AVOption h263_options[] = {
4803  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4804  { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4806  { NULL },
4807 };
4808 
4809 static const AVClass h263_class = {
4810  .class_name = "H.263 encoder",
4811  .item_name = av_default_item_name,
4812  .option = h263_options,
4813  .version = LIBAVUTIL_VERSION_INT,
4814 };
4815 
4817  .name = "h263",
4818  .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4819  .type = AVMEDIA_TYPE_VIDEO,
4820  .id = AV_CODEC_ID_H263,
4821  .priv_data_size = sizeof(MpegEncContext),
4823  .encode2 = ff_mpv_encode_picture,
4824  .close = ff_mpv_encode_end,
4826  .priv_class = &h263_class,
4827 };
4828 
4829 static const AVOption h263p_options[] = {
4830  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4831  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4832  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4833  { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
4835  { NULL },
4836 };
4837 static const AVClass h263p_class = {
4838  .class_name = "H.263p encoder",
4839  .item_name = av_default_item_name,
4840  .option = h263p_options,
4841  .version = LIBAVUTIL_VERSION_INT,
4842 };
4843 
4845  .name = "h263p",
4846  .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4847  .type = AVMEDIA_TYPE_VIDEO,
4848  .id = AV_CODEC_ID_H263P,
4849  .priv_data_size = sizeof(MpegEncContext),
4851  .encode2 = ff_mpv_encode_picture,
4852  .close = ff_mpv_encode_end,
4853  .capabilities = AV_CODEC_CAP_SLICE_THREADS,
4855  .priv_class = &h263p_class,
4856 };
4857 
4858 static const AVClass msmpeg4v2_class = {
4859  .class_name = "msmpeg4v2 encoder",
4860  .item_name = av_default_item_name,
4861  .option = ff_mpv_generic_options,
4862  .version = LIBAVUTIL_VERSION_INT,
4863 };
4864 
4866  .name = "msmpeg4v2",
4867  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4868  .type = AVMEDIA_TYPE_VIDEO,
4869  .id = AV_CODEC_ID_MSMPEG4V2,
4870  .priv_data_size = sizeof(MpegEncContext),
4872  .encode2 = ff_mpv_encode_picture,
4873  .close = ff_mpv_encode_end,
4875  .priv_class = &msmpeg4v2_class,
4876 };
4877 
4878 static const AVClass msmpeg4v3_class = {
4879  .class_name = "msmpeg4v3 encoder",
4880  .item_name = av_default_item_name,
4881  .option = ff_mpv_generic_options,
4882  .version = LIBAVUTIL_VERSION_INT,
4883 };
4884 
4886  .name = "msmpeg4",
4887  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4888  .type = AVMEDIA_TYPE_VIDEO,
4889  .id = AV_CODEC_ID_MSMPEG4V3,
4890  .priv_data_size = sizeof(MpegEncContext),
4892  .encode2 = ff_mpv_encode_picture,
4893  .close = ff_mpv_encode_end,
4895  .priv_class = &msmpeg4v3_class,
4896 };
4897 
4898 static const AVClass wmv1_class = {
4899  .class_name = "wmv1 encoder",
4900  .item_name = av_default_item_name,
4901  .option = ff_mpv_generic_options,
4902  .version = LIBAVUTIL_VERSION_INT,
4903 };
4904 
4906  .name = "wmv1",
4907  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4908  .type = AVMEDIA_TYPE_VIDEO,
4909  .id = AV_CODEC_ID_WMV1,
4910  .priv_data_size = sizeof(MpegEncContext),
4912  .encode2 = ff_mpv_encode_picture,
4913  .close = ff_mpv_encode_end,
4915  .priv_class = &wmv1_class,
4916 };
int last_time_base
Definition: mpegvideo.h:386
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:41
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:796
int plane
Definition: avisynth_c.h:291
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2746
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:936
static const AVClass wmv1_class
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:108
int(* try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale)
int chroma_elim_threshold
Definition: mpegvideo.h:114
#define INPLACE_OFFSET
Definition: mpegutils.h:123
void ff_jpeg_fdct_islow_10(int16_t *data)
static const AVOption h263_options[]
int frame_bits
bits used for the current frame
Definition: mpegvideo.h:338
IDCTDSPContext idsp
Definition: mpegvideo.h:227
av_cold int ff_dct_encode_init(MpegEncContext *s)
#define NULL
Definition: coverity.c:32
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
Definition: mpegvideo.h:341
const struct AVCodec * codec
Definition: avcodec.h:1541
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
av_cold void ff_rate_control_uninit(MpegEncContext *s)
Definition: ratecontrol.c:312
#define FF_MPV_FLAG_STRICT_GOP
Definition: mpegvideo.h:571
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2739
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:1509
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:74
int picture_number
Definition: mpegvideo.h:124
const char * s
Definition: avisynth_c.h:631
#define RECON_SHIFT
attribute_deprecated int intra_quant_bias
Definition: avcodec.h:2052
me_cmp_func frame_skip_cmp[6]
Definition: me_cmp.h:76
#define CANDIDATE_MB_TYPE_SKIPPED
Definition: mpegutils.h:109
rate control context.
Definition: ratecontrol.h:63
static int shift(int a, int b)
Definition: sonic.c:82
S(GMC)-VOP MPEG4.
Definition: avutil.h:269
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:519
void ff_mpeg1_encode_init(MpegEncContext *s)
Definition: mpeg12enc.c:1002
int esc3_level_length
Definition: mpegvideo.h:437
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2157
static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
int time_increment_bits
< number of bits to represent the fractional part of time (encoder only)
Definition: mpegvideo.h:385
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: ituh263enc.c:104
This structure describes decoded (raw) audio or video data.
Definition: frame.h:181
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:2610
int16_t(* p_mv_table)[2]
MV table (1MV per MB) p-frame encoding.
Definition: mpegvideo.h:245
#define FF_CMP_DCTMAX
Definition: avcodec.h:1974
void ff_fdct_ifast(int16_t *data)
Definition: jfdctfst.c:208
#define FF_MB_DECISION_BITS
chooses the one which needs the fewest bits
Definition: avcodec.h:2088
AVOption.
Definition: opt.h:245
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:618
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:279
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:150
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:904
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:185
uint8_t * mb_mean
Table for MB luminance.
Definition: mpegpicture.h:74
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:2862
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:775
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG1 & B-frame MPEG4
Definition: mpegvideo.h:278
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
int pre_pass
= 1 for the pre pass
Definition: motion_est.h:72
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:758
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:68
#define FF_MPV_FLAG_SKIP_RD
Definition: mpegvideo.h:570
AVFrame * tmp_frames[MAX_B_FRAMES+2]
Definition: mpegvideo.h:555
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:168
attribute_deprecated int rc_qmod_freq
Definition: avcodec.h:2492
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
RateControlEntry * entry
Definition: ratecontrol.h:65
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:75
void(* shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height)
#define CANDIDATE_MB_TYPE_INTER_I
Definition: mpegutils.h:116
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1597
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
else temp
Definition: vf_mcdeint.c:259
attribute_deprecated void(* rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb)
Definition: avcodec.h:2649
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:357
const char * g
Definition: vf_curves.c:108
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:762
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:151
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
#define OFFSET(x)
uint16_t * mb_var
Table for MB variances.
Definition: mpegpicture.h:65
uint16_t(* q_chroma_intra_matrix16)[2][64]
Definition: mpegvideo.h:328
uint16_t chroma_intra_matrix[64]
Definition: mpegvideo.h:301
static int estimate_qp(MpegEncContext *s, int dry_run)
#define MAX_MV
Definition: motion_est.h:35
int acc
Definition: yuv2rgb.c:543
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1203
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1810
int16_t(*[3] ac_val)[16]
used for mpeg4 AC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:191
MJPEG encoder.
void(* add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale)
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:129
attribute_deprecated int frame_skip_cmp
Definition: avcodec.h:2614
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:603
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2262
#define me
int frame_skip_cmp
Definition: mpegvideo.h:563
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:435
int b_frame_strategy
Definition: mpegvideo.h:556
#define CANDIDATE_MB_TYPE_BIDIR
Definition: mpegutils.h:114
int num
numerator
Definition: rational.h:44
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
int size
Definition: avcodec.h:1468
attribute_deprecated int lmax
Definition: avcodec.h:2596
enum AVCodecID codec_id
Definition: mpegvideo.h:109
const char * b
Definition: vf_curves.c:109
void ff_get_2pass_fcode(MpegEncContext *s)
Definition: ratecontrol.c:742
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:65
int av_log2(unsigned v)
Definition: intmath.c:26
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:366
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:49
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:123
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1935
int frame_skip_exp
Definition: mpegvideo.h:562
int ff_h261_get_picture_format(int width, int height)
Definition: h261enc.c:40
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1752
#define FF_MPV_FLAG_NAQ
Definition: mpegvideo.h:574
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced p-frame encoding.
Definition: mpegvideo.h:251
static int select_input_picture(MpegEncContext *s)
static const AVClass msmpeg4v3_class
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:308
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:119
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:1960
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
int coded_score[12]
Definition: mpegvideo.h:320
mpegvideo header.
const uint16_t ff_h263_format[8][2]
Definition: h263data.c:238
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:71
int scene_change_score
Definition: motion_est.h:87
int mpv_flags
flags set by private options
Definition: mpegvideo.h:525
uint8_t permutated[64]
Definition: idctdsp.h:31
static const AVClass h263_class
uint8_t run
Definition: svq3.c:149
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2924
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
#define EDGE_TOP
int padding_bug_score
used to detect the VERY common padding bug in MPEG4
Definition: mpegvideo.h:409
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:358
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:318
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:130
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
#define FF_LAMBDA_SHIFT
Definition: avutil.h:217
static void clip_coeffs(MpegEncContext *s, int16_t *block, int last_index)
QpelDSPContext qdsp
Definition: mpegvideo.h:232
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: avcodec.h:1289
AVCodec.
Definition: avcodec.h:3392
#define MAX_FCODE
Definition: mpegutils.h:48
static void write_mb_info(MpegEncContext *s)
int time_base
time in seconds of last I,P,S Frame
Definition: mpegvideo.h:387
uint8_t(* mv_penalty)[MAX_DMV *2+1]
bit amount needed to encode a MV
Definition: motion_est.h:93
int qscale
QP.
Definition: mpegvideo.h:201
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:84
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode b-frame encoding.
Definition: mpegvideo.h:247
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:310
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1208
int chroma_x_shift
Definition: mpegvideo.h:475
int encoding
true if we are encoding (vs decoding)
Definition: mpegvideo.h:111
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:513
int field_select[2][2]
Definition: mpegvideo.h:277
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:517
attribute_deprecated int frame_skip_exp
Definition: avcodec.h:2610
attribute_deprecated int me_method
This option does nothing.
Definition: avcodec.h:1759
uint32_t ff_square_tab[512]
Definition: me_cmp.c:32
int quant_precision
Definition: mpegvideo.h:398
void ff_mpeg4_merge_partitions(MpegEncContext *s)
static int mb_var_thread(AVCodecContext *c, void *arg)
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:2431
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:515
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1661
int modified_quant
Definition: mpegvideo.h:379
static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
#define FF_MPV_FLAG_CBP_RD
Definition: mpegvideo.h:573
int skipdct
skip dct and code zero residual
Definition: mpegvideo.h:217
float rc_buffer_aggressivity
Definition: mpegvideo.h:536
int b_frame_score
Definition: mpegpicture.h:84
const uint8_t ff_mpeg2_non_linear_qscale[32]
Definition: mpegvideodata.c:27
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
Definition: avcodec.h:1228
void ff_mpeg4_clean_buffers(MpegEncContext *s)
Definition: mpeg4video.c:45
attribute_deprecated int mv_bits
Definition: avcodec.h:2666
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegutils.h:107
float p_masking
p block masking (0-> disabled)
Definition: avcodec.h:1896
int picture_in_gop_number
0-> first pic in gop, ...
Definition: mpegvideo.h:125
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
int alt_inter_vlc
alternative inter vlc
Definition: mpegvideo.h:378
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
Definition: mpeg12enc.c:407
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
uint8_t * ptr_lastgob
Definition: mpegvideo.h:492
int64_t time
time of current frame
Definition: mpegvideo.h:388
static int encode_picture(MpegEncContext *s, int picture_number)
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
Definition: avcodec.h:1605
static const AVClass msmpeg4v2_class
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (mpeg4) ...
Definition: mpegvideo.h:264
ScratchpadContext sc
Definition: mpegvideo.h:199
uint8_t bits
Definition: crc.c:295
attribute_deprecated const char * rc_eq
Definition: avcodec.h:2515
attribute_deprecated float rc_buffer_aggressivity
Definition: avcodec.h:2537
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:141
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
Picture ** input_picture
next pictures on display order for encoding
Definition: mpegvideo.h:134
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegutils.h:108
void(* get_pixels)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size)
Definition: pixblockdsp.h:27
AVOptions.
void(* denoise_dct)(struct MpegEncContext *s, int16_t *block)
Definition: mpegvideo.h:523
PutBitContext pb2
used for data partitioned VOPs
Definition: mpegvideo.h:407
enum OutputFormat out_format
output format
Definition: mpegvideo.h:101
attribute_deprecated int i_count
Definition: avcodec.h:2674
#define CANDIDATE_MB_TYPE_FORWARD_I
Definition: mpegutils.h:117
uint16_t(* dct_offset)[64]
Definition: mpegvideo.h:334
int noise_reduction
Definition: mpegvideo.h:566
void ff_dct_encode_init_x86(MpegEncContext *s)
Definition: mpegvideoenc.c:204
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix Code outside libavcodec should access this field using av_codec_g/se...
Definition: avcodec.h:3319
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: msmpeg4enc.c:224
static void mpv_encode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for encoding.
Multithreading support functions.
int pre_dia_size
ME prepass diamond size & shape.
Definition: avcodec.h:2010
AVCodec ff_h263_encoder
int frame_skip_threshold
Definition: mpegvideo.h:560
static const AVOption h263p_options[]
static int get_sae(uint8_t *src, int ref, int stride)
#define FF_CMP_VSSE
Definition: avcodec.h:1970
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:779
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:455
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:375
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:262
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:352
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1647
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:284
H.263 tables.
#define CANDIDATE_MB_TYPE_BACKWARD_I
Definition: mpegutils.h:118
int interlaced_dct
Definition: mpegvideo.h:480
int(* q_chroma_intra_matrix)[64]
Definition: mpegvideo.h:324
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1942
void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2720
#define QUANT_BIAS_SHIFT
Definition: mpegvideo_enc.c:70
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:177
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:1848
#define CHROMA_420
Definition: mpegvideo.h:472
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:441
int intra_dc_precision
Definition: mpegvideo.h:460
int repeat_first_field
Definition: mpegvideo.h:469
static AVFrame * frame
quarterpel DSP functions
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:80
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode b-frame encoding.
Definition: mpegvideo.h:248
static void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
uint8_t * data
Definition: avcodec.h:1467
const uint16_t ff_aanscales[64]
Definition: aandcttab.c:26
int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: wmv2enc.c:74
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:76
#define ff_dlog(a,...)
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:390
me_cmp_func nsse[6]
Definition: me_cmp.h:65
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define lrintf(x)
Definition: libm_mips.h:70
#define CODEC_FLAG_MV0
Definition: avcodec.h:967
const uint8_t * scantable
Definition: idctdsp.h:30
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:330
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:126
static void rebase_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Rebase the bit writer onto a reallocated buffer.
Definition: put_bits.h:71
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1219
float lumi_masking
luminance masking (0-> disabled)
Definition: avcodec.h:1875
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2692
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:762
high precision timer, useful to profile code
static void update_noise_reduction(MpegEncContext *s)
#define FF_MPV_FLAG_QP_RD
Definition: mpegvideo.h:572
int scenechange_threshold
Definition: mpegvideo.h:565
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
Definition: utils.c:3519
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64], int motion_x, int motion_y)
Definition: mpeg12enc.c:993
#define FFALIGN(x, a)
Definition: macros.h:48
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
Definition: frame.h:300
#define MAX_LEVEL
Definition: rl.h:35
attribute_deprecated int frame_skip_threshold
Definition: avcodec.h:2602
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: h261enc.c:53
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:207
int flipflop_rounding
Definition: mpegvideo.h:434
#define CHROMA_444
Definition: mpegvideo.h:474
int num_entries
number of RateControlEntries
Definition: ratecontrol.h:64
int gop_picture_number
index of the first picture of a GOP based on fake_pic_num & mpeg1 specific
Definition: mpegvideo.h:448
uint8_t * mb_info_ptr
Definition: mpegvideo.h:369
#define av_log(a,...)
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:729
#define ff_sqrt
Definition: mathops.h:214
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2802
#define ROUNDED_DIV(a, b)
Definition: common.h:56
int(* q_inter_matrix)[64]
Definition: mpegvideo.h:325
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2745
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1499
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:743
attribute_deprecated int skip_count
Definition: avcodec.h:2678
#define EDGE_WIDTH
Definition: mpegpicture.h:33
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
Definition: mpegvideo.h:323
#define FF_MPV_FLAG_MV0
Definition: mpegvideo.h:575
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:99
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:2529
int16_t * dc_val[3]
used for mpeg4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:184
enum AVCodecID id
Definition: avcodec.h:3406
int h263_plus
h263 plus headers
Definition: mpegvideo.h:106
H263DSPContext h263dsp
Definition: mpegvideo.h:234
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:153
#define MAX_DMV
Definition: motion_est.h:37
int last_non_b_pict_type
used for mpeg4 gmc b-frames & ratecontrol
Definition: mpegvideo.h:212
int width
width and height of the video frame
Definition: frame.h:230
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permuatation.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:227
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1846
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:182
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
attribute_deprecated float rc_initial_cplx
Definition: avcodec.h:2540
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:316
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:738
#define MAX_MB_BYTES
Definition: mpegutils.h:47
int64_t total_bits
Definition: mpegvideo.h:337
#define PTRDIFF_SPECIFIER
Definition: internal.h:250
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:192
int chroma_y_shift
Definition: mpegvideo.h:476
int strict_std_compliance
strictly follow the std (MPEG4, ...)
Definition: mpegvideo.h:115
av_default_item_name
int partitioned_frame
is current frame partitioned
Definition: mpegvideo.h:403
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
Definition: mpegpicture.h:37
#define AVERROR(e)
Definition: error.h:43
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
Definition: mpegpicture.h:90
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
av_cold int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:84
int me_sub_cmp
subpixel motion estimation comparison function
Definition: avcodec.h:1948
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:154
attribute_deprecated uint64_t vbv_delay
VBV delay coded in the last frame (in periods of a 27 MHz clock).
Definition: avcodec.h:3171
int qmax
maximum quantizer
Definition: avcodec.h:2473
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2185
static void update_mb_info(MpegEncContext *s, int startcode)
#define MERGE(field)
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:42
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:220
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
ERContext er
Definition: mpegvideo.h:550
int last_lambda_for[5]
last lambda for a specific pict type
Definition: mpegvideo.h:216
static int sse_mb(MpegEncContext *s)
int reference
Definition: mpegpicture.h:87
const char * r
Definition: vf_curves.c:107
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
int out_size
Definition: movenc-test.c:55
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:511
PixblockDSPContext pdsp
Definition: mpegvideo.h:231
const char * arg
Definition: jacosubdec.c:66
uint8_t * intra_chroma_ac_vlc_length
Definition: mpegvideo.h:313
void(* dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:505
int h263_slice_structured
Definition: mpegvideo.h:377
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1627
uint8_t * buf
Definition: put_bits.h:38
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of a and b.
Definition: mathematics.c:37
GLsizei GLsizei * length
Definition: opengl_enc.c:115
MpegvideoEncDSPContext mpvencdsp
Definition: mpegvideo.h:230
attribute_deprecated int inter_quant_bias
Definition: avcodec.h:2058
const char * name
Name of the codec implementation.
Definition: avcodec.h:3399
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:399
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
Definition: mpegvideo.h:291
int me_pre
prepass for motion estimation
Definition: mpegvideo.h:260
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Shrink the already allocated side data buffer.
Definition: avpacket.c:497
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:404
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: qpeldsp.h:73
uint8_t *[2][2] b_field_select_table
Definition: mpegvideo.h:254
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1116
#define FFMAX(a, b)
Definition: common.h:94
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
Definition: pixblockdsp.c:81
#define fail()
Definition: checkasm.h:80
int64_t mb_var_sum_temp
Definition: motion_est.h:86
attribute_deprecated int b_sensitivity
Definition: avcodec.h:2233
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1473
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:67
static void frame_end(MpegEncContext *s)
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:356
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2500
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
Definition: ituh263enc.c:267
int coded_picture_number
used to set pic->coded_picture_number, should not be used for/by anything else
Definition: mpegvideo.h:123
int * lambda_table
Definition: mpegvideo.h:205
static int estimate_best_b_count(MpegEncContext *s)
int intra_dc_precision
precision of the intra DC coefficient - 8
Definition: avcodec.h:2134
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: wmv2enc.c:147
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2530
common internal API header
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_width, int mb_block_count)
const uint8_t *const ff_mpeg2_dc_scale_table[4]
Definition: mpegvideodata.c:82
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:136
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
#define CHROMA_422
Definition: mpegvideo.h:473
float border_masking
Definition: mpegvideo.h:537
int progressive_frame
Definition: mpegvideo.h:478
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:252
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.c:262
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:734
#define FFMIN(a, b)
Definition: common.h:96
int display_picture_number
picture number in display order
Definition: frame.h:283
uint16_t(* q_inter_matrix16)[2][64]
Definition: mpegvideo.h:329
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
Definition: mpegvideo.h:450
int fixed_qscale
fixed qscale if non zero
Definition: mpegvideo.h:110
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is actually possible in mpeg4
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:75
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
Definition: avcodec.h:792
int me_method
ME algorithm.
Definition: mpegvideo.h:256
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
int umvplus
== H263+ && unrestricted_mv
Definition: mpegvideo.h:375
Picture new_picture
copy of the source picture structure for encoding.
Definition: mpegvideo.h:171
int intra_quant_bias
bias for the quantizer
Definition: mpegvideo.h:306
int width
picture width / height.
Definition: avcodec.h:1711
int(* pix_sum)(uint8_t *pix, int line_size)
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:181
Picture.
Definition: mpegpicture.h:45
attribute_deprecated int noise_reduction
Definition: avcodec.h:2112
int alternate_scan
Definition: mpegvideo.h:467
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow. ...
Definition: avcodec.h:2548
int ff_rv10_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: rv10enc.c:32
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:766
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:753
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:750
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
Definition: mpegvideo.h:327
attribute_deprecated int frame_skip_factor
Definition: avcodec.h:2606
#define FF_MB_DECISION_SIMPLE
uses mb_cmp
Definition: avcodec.h:2087
perm
Definition: f_perms.c:74
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:288
int(* ac_stats)[2][MAX_LEVEL+1][MAX_RUN+1][2]
[mb_intra][isChroma][level][run][last]
Definition: mpegvideo.h:440
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:83
MotionEstContext me
Definition: mpegvideo.h:282
int frame_skip_factor
Definition: mpegvideo.h:561
int n
Definition: avisynth_c.h:547
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale)
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
const int16_t ff_mpeg4_default_non_intra_matrix[64]
Definition: mpeg4data.h:348
int mb_decision
macroblock decision mode
Definition: avcodec.h:2086
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride)
attribute_deprecated float rc_qsquish
Definition: avcodec.h:2487
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
Definition: mpegvideo.h:195
#define src
Definition: vp9dsp.c:530
#define MAX_B_FRAMES
Definition: mpegvideo.h:63
int ff_msmpeg4_encode_init(MpegEncContext *s)
Definition: msmpeg4enc.c:121
int ac_esc_length
num of bits needed to encode the longest esc
Definition: mpegvideo.h:310
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:106
static void set_put_bits_buffer_size(PutBitContext *s, int size)
Change the end of the buffer.
Definition: put_bits.h:261
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2954
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:443
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:297
static uint8_t default_fcode_tab[MAX_MV *2+1]
Definition: mpegvideo_enc.c:82
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:923
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:242
AVCodec ff_h263p_encoder
attribute_deprecated int i_tex_bits
Definition: avcodec.h:2670
static void build_basis(uint8_t *perm)
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:433
int frame_pred_frame_dct
Definition: mpegvideo.h:461
attribute_deprecated int misc_bits
Definition: avcodec.h:2680
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1198
uint16_t * mc_mb_var
Table for motion compensated MB variances.
Definition: mpegpicture.h:68
void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: flvenc.c:27
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
int coded_picture_number
picture number in bitstream order
Definition: frame.h:279
#define src1
Definition: h264pred.c:139
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
uint16_t inter_matrix[64]
Definition: mpegvideo.h:302
#define FF_LAMBDA_SCALE
Definition: avutil.h:218
void ff_jpeg_fdct_islow_8(int16_t *data)
int64_t last_non_b_time
Definition: mpegvideo.h:389
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h261enc.c:237
#define QMAT_SHIFT
Definition: mpegvideo_enc.c:73
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:152
#define CONFIG_MSMPEG4_ENCODER
Definition: msmpeg4.h:75
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Definition: mpegvideo.h:204
#define CODEC_FLAG_NORMALIZE_AQP
Definition: avcodec.h:994
void ff_faandct(int16_t *data)
Definition: faandct.c:122
double buffer_index
amount of bits in the video/audio buffer
Definition: ratecontrol.h:66
Libavcodec external API header.
attribute_deprecated int mpeg_quant
Definition: avcodec.h:1851
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:43
int h263_flv
use flv h263 header
Definition: mpegvideo.h:107
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:2108
static const AVClass h263p_class
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:131
enum AVCodecID codec_id
Definition: avcodec.h:1549
#define QMAT_SHIFT_MMX
Definition: mpegvideo_enc.c:72
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:267
attribute_deprecated int prediction_method
Definition: avcodec.h:1915
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:209
void ff_convert_matrix(MpegEncContext *s, int(*qmat)[64], uint16_t(*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
Definition: mpegvideo_enc.c:89
const uint16_t ff_inv_aanscales[64]
Definition: aandcttab.c:38
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1830
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:370
#define START_TIMER
Definition: timer.h:94
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
uint8_t * intra_chroma_ac_vlc_last_length
Definition: mpegvideo.h:314
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
main external API structure.
Definition: avcodec.h:1532
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
Definition: mpegpicture.c:228
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:545
ScanTable intra_scantable
Definition: mpegvideo.h:88
int qmin
minimum quantizer
Definition: avcodec.h:2466
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:97
#define FF_CMP_NSSE
Definition: avcodec.h:1971
#define FF_DEFAULT_QUANT_BIAS
Definition: avcodec.h:2053
static void write_slice_end(MpegEncContext *s)
int64_t dts_delta
pts difference between the first and second input frame, used for calculating dts of the first frame ...
Definition: mpegvideo.h:141
int64_t user_specified_pts
last non-zero pts from AVFrame which was passed into avcodec_encode_video2()
Definition: mpegvideo.h:137
FDCTDSPContext fdsp
Definition: mpegvideo.h:224
static void denoise_dct_c(MpegEncContext *s, int16_t *block)
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
uint8_t * buf_end
Definition: put_bits.h:38
static int frame_start(MpegEncContext *s)
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
Definition: avcodec.h:1889
float rc_qmod_amp
Definition: mpegvideo.h:533
int luma_elim_threshold
Definition: mpegvideo.h:113
attribute_deprecated int header_bits
Definition: avcodec.h:2668
GLint GLenum type
Definition: opengl_enc.c:105
void ff_fix_long_p_mvs(MpegEncContext *s)
Definition: motion_est.c:1670
Picture * picture
main picture buffer
Definition: mpegvideo.h:133
int data_partitioning
data partitioning flag from header
Definition: mpegvideo.h:402
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:315
int progressive_sequence
Definition: mpegvideo.h:453
uint16_t * intra_matrix
custom intra quantization matrix
Definition: avcodec.h:2096
h261codec.
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: ituh263enc.c:241
uint8_t * buf_ptr
Definition: put_bits.h:38
Describe the class of an AVClass context structure.
Definition: log.h:67
int stuffing_bits
bits used for stuffing
Definition: mpegvideo.h:339
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
Definition: hpeldsp.h:80
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced b-frame encoding.
Definition: mpegvideo.h:252
int(* pix_norm1)(uint8_t *pix, int line_size)
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegpicture.h:82
int index
Definition: gxfenc.c:89
#define CANDIDATE_MB_TYPE_DIRECT
Definition: mpegutils.h:111
struct AVFrame * f
Definition: mpegpicture.h:46
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:2089
static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type)
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:277
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
int input_picture_number
used to set pic->display_picture_number, should not be used for/by anything else
Definition: mpegvideo.h:122
AVCodec ff_wmv1_encoder
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:132
int mb_info
interval for outputting info about mb offsets as side data
Definition: mpegvideo.h:367
void ff_set_mpeg4_time(MpegEncContext *s)
static void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type)
attribute_deprecated int brd_scale
Definition: avcodec.h:2190
#define STRIDE_ALIGN
Definition: internal.h:82
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
Definition: mjpegenc.c:116
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:1170
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1621
#define CANDIDATE_MB_TYPE_BIDIR_I
Definition: mpegutils.h:119
const int16_t ff_mpeg4_default_intra_matrix[64]
Definition: mpeg4data.h:337
int f_code
forward MV resolution
Definition: mpegvideo.h:235
int ff_pre_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:1080
#define CANDIDATE_MB_TYPE_DIRECT0
Definition: mpegutils.h:121
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
Definition: mpeg4video.c:117
int ff_mjpeg_encode_stuffing(MpegEncContext *s)
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, ScanTable *intra_scantable, int pred, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64])
attribute_deprecated int p_tex_bits
Definition: avcodec.h:2672
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1413
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
uint16_t * inter_matrix
custom inter quantization matrix
Definition: avcodec.h:2103
int max_b_frames
max number of b-frames for encoding
Definition: mpegvideo.h:112
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:209
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
int last_mv_dir
last mv_dir, used for b frame encoding
Definition: mpegvideo.h:449
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:271
int h263_pred
use mpeg4/h263 ac/dc predictions
Definition: mpegvideo.h:102
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode b-frame encoding.
Definition: mpegvideo.h:249
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:474
float dark_masking
darkness masking (0-> disabled)
Definition: avcodec.h:1903
static int64_t pts
Global timestamp for the audio frames.
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
Definition: avcodec.h:1882
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:306
uint8_t *[2] p_field_select_table
Definition: mpegvideo.h:253
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode b-frame encoding.
Definition: mpegvideo.h:250
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:746
AAN (Arai, Agui and Nakajima) (I)DCT tables.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:186
uint8_t level
Definition: svq3.c:150
me_cmp_func sad[6]
Definition: me_cmp.h:56
int me_penalty_compensation
Definition: mpegvideo.h:259
int64_t mc_mb_var_sum_temp
Definition: motion_est.h:85
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode b-frame encoding.
Definition: mpegvideo.h:246
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:128
me_cmp_func sse[6]
Definition: me_cmp.h:57
static int estimate_motion_thread(AVCodecContext *c, void *arg)
int vbv_ignore_qmax
Definition: mpegvideo.h:539
#define BASIS_SHIFT
MpegEncContext.
Definition: mpegvideo.h:78
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:180
char * rc_eq
Definition: mpegvideo.h:541
int8_t * qscale_table
Definition: mpegpicture.h:50
#define MAX_RUN
Definition: rl.h:34
struct AVCodecContext * avctx
Definition: mpegvideo.h:95
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1737
PutBitContext pb
bit output
Definition: mpegvideo.h:148
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:291
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
volatile int error_count
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
static void update_qscale(MpegEncContext *s)
int mb_cmp
macroblock comparison function (not supported yet)
Definition: avcodec.h:1954
int quantizer_noise_shaping
Definition: mpegvideo.h:526
int(* dct_error_sum)[64]
Definition: mpegvideo.h:332
MECmpContext mecc
Definition: mpegvideo.h:228
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
void ff_msmpeg4_encode_ext_header(MpegEncContext *s)
Definition: msmpeg4enc.c:284
float rc_initial_cplx
Definition: mpegvideo.h:535
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg)
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
static const int32_t qmat16[MAT_SIZE]
Definition: hq_hqadata.c:342
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:127
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
if(ret< 0)
Definition: vf_mcdeint.c:282
#define CANDIDATE_MB_TYPE_FORWARD
Definition: mpegutils.h:112
attribute_deprecated int rtp_payload_size
Definition: avcodec.h:2655
uint8_t * dest[3]
Definition: mpegvideo.h:295
int shared
Definition: mpegpicture.h:88
static double c[64]
int last_pict_type
Definition: mpegvideo.h:211
#define COPY(a)
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: ituh263enc.c:448
int adaptive_quant
use adaptive quantization
Definition: mpegvideo.h:206
static int16_t basis[64][64]
attribute_deprecated float border_masking
Definition: avcodec.h:2155
static int score_tab[256]
Definition: zmbvenc.c:59
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:159
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:179
Bi-dir predicted.
Definition: avutil.h:268
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:77
float rc_qsquish
ratecontrol qmin qmax limiting method 0-> clipping, 1-> use a nice continuous function to limit qscal...
Definition: mpegvideo.h:532
int64_t reordered_pts
reordered pts to be used as dts for the next output frame when there's a delay
Definition: mpegvideo.h:145
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2945
int ff_vbv_update(MpegEncContext *s, int frame_size)
Definition: ratecontrol.c:326
#define H263_GOB_HEIGHT(h)
Definition: h263.h:44
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
int den
denominator
Definition: rational.h:45
attribute_deprecated float rc_qmod_amp
Definition: avcodec.h:2490
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
Definition: mpegvideo.h:187
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
AVCodec ff_msmpeg4v3_encoder
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:455
int trellis
trellis RD quantization
Definition: avcodec.h:2622
void(* dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:507
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:3533
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:635
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:754
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: mpeg12enc.c:421
void ff_mpeg4_stuffing(PutBitContext *pbc)
add mpeg4 stuffing bits (01...1)
#define CANDIDATE_MB_TYPE_INTRA
Definition: mpegutils.h:106
int16_t(* blocks)[12][64]
Definition: mpegvideo.h:498
#define STOP_TIMER(id)
Definition: timer.h:95
int slices
Number of slices.
Definition: avcodec.h:2278
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
void * priv_data
Definition: avcodec.h:1574
const AVOption ff_mpv_generic_options[]
Definition: mpegvideo_enc.c:84
#define PICT_FRAME
Definition: mpegutils.h:39
int last_bits
temp var used for calculating the above vars
Definition: mpegvideo.h:353
void ff_mpeg4_init_partitions(MpegEncContext *s)
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:878
void(* diff_pixels)(int16_t *block, const uint8_t *s1, const uint8_t *s2, int stride)
Definition: pixblockdsp.h:30
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int picture_structure
Definition: mpegvideo.h:457
int dia_size
ME diamond size & shape.
Definition: avcodec.h:1983
#define av_free(p)
attribute_deprecated int frame_bits
Definition: avcodec.h:2684
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2994
VideoDSPContext vdsp
Definition: mpegvideo.h:233
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
#define VE
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src)
attribute_deprecated int me_penalty_compensation
Definition: avcodec.h:2177
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1213
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
int ff_get_best_fcode(MpegEncContext *s, int16_t(*mv_table)[2], int type)
Definition: motion_est.c:1617
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:357
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1582
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:497
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mjpegenc.c:179
int64_t bit_rate
wanted bit rate
Definition: mpegvideo.h:100
This side data corresponds to the AVCPBProperties struct.
Definition: avcodec.h:1341
PutBitContext tex_pb
used for data partitioned VOPs
Definition: mpegvideo.h:406
Picture next_picture
copy of the next picture structure.
Definition: mpegvideo.h:165
attribute_deprecated int p_count
Definition: avcodec.h:2676
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:247
attribute_deprecated int error_rate
Definition: avcodec.h:3158
static void set_frame_distances(MpegEncContext *s)
static const double coeff[2][5]
Definition: vf_owdenoise.c:71
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:219
#define EDGE_BOTTOM
void ff_fix_long_mvs(MpegEncContext *s, uint8_t *field_select_table, int field_select, int16_t(*mv_table)[2], int f_code, int type, int truncate)
Definition: motion_est.c:1720
Picture ** reordered_input_picture
pointer to the next pictures in codedorder for encoding
Definition: mpegvideo.h:135
static const struct twinvq_data tab
unsigned int byte_buffer_size
Definition: internal.h:150
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
void ff_rv20_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: rv20enc.c:35
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1466
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:509
static int encode_thread(AVCodecContext *c, void *arg)
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
Definition: mpegvideo.c:634
int height
Definition: frame.h:230
int(* fast_dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:522
void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:300
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:121
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
#define av_freep(p)
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src)
void INT64 start
Definition: avisynth_c.h:553
#define av_always_inline
Definition: attributes.h:39
#define M_PI
Definition: mathematics.h:46
int ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
int rtp_payload_size
Definition: mpegvideo.h:487
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:797
Floating point AAN DCT
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: mpegvideo_enc.c:81
int inter_quant_bias
bias for the quantizer
Definition: mpegvideo.h:307
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:783
attribute_deprecated int lmin
Definition: avcodec.h:2590
#define CANDIDATE_MB_TYPE_BACKWARD
Definition: mpegutils.h:113
#define stride
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:299
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:521
#define MV_TYPE_8X8
4 vectors (h263, mpeg4 4MV)
Definition: mpegvideo.h:267
int b_code
backward MV resolution for B Frames (mpeg4)
Definition: mpegvideo.h:236
void ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: msmpeg4enc.c:381
void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:365
int dct_count[2]
Definition: mpegvideo.h:333
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:81
static int encode_frame(AVCodecContext *c, AVFrame *frame)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
This structure stores compressed data.
Definition: avcodec.h:1444
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:149
int delay
Codec delay.
Definition: avcodec.h:1694
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: avcodec.h:2741
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1460
int ff_check_alignment(void)
Definition: me_cmp.c:915
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:565
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:139
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
Definition: utils.c:3229
me_cmp_func ildct_cmp[6]
Definition: me_cmp.h:75
#define FFMAX3(a, b, c)
Definition: common.h:95
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:240
static void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], int *dmin, int *next_block, int motion_x, int motion_y)
Predicted.
Definition: avutil.h:267
unsigned int lambda
lagrange multipler used in rate distortion
Definition: mpegvideo.h:203
AVCodec ff_msmpeg4v2_encoder
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2523
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:391
enum idct_permutation_type perm_type
Definition: idctdsp.h:95
attribute_deprecated int pre_me
Definition: avcodec.h:1995
HpelDSPContext hdsp
Definition: mpegvideo.h:226
static const uint8_t sp5x_quant_table[20][64]
Definition: sp5x.h:135
int next_lambda
next lambda used for retrying to encode a frame
Definition: mpegvideo.h:340
static int16_t block[64]
Definition: dct-test.c:112