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