FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mpegvideo_enc.c
Go to the documentation of this file.
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /*
26  * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
27  */
28 
29 /**
30  * @file
31  * The simplest mpeg encoder (well, it was the simplest!).
32  */
33 
34 #include <stdint.h>
35 
36 #include "libavutil/internal.h"
37 #include "libavutil/intmath.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/timer.h"
42 #include "avcodec.h"
43 #include "dct.h"
44 #include "idctdsp.h"
45 #include "mpeg12.h"
46 #include "mpegvideo.h"
47 #include "mpegvideodata.h"
48 #include "h261.h"
49 #include "h263.h"
50 #include "h263data.h"
51 #include "mjpegenc_common.h"
52 #include "mathops.h"
53 #include "mpegutils.h"
54 #include "mjpegenc.h"
55 #include "msmpeg4.h"
56 #include "pixblockdsp.h"
57 #include "qpeldsp.h"
58 #include "faandct.h"
59 #include "thread.h"
60 #include "aandcttab.h"
61 #include "flv.h"
62 #include "mpeg4video.h"
63 #include "internal.h"
64 #include "bytestream.h"
65 #include "wmv2.h"
66 #include "rv10.h"
67 #include "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 
274  if (CONFIG_H263_ENCODER)
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  av_log(avctx, AV_LOG_WARNING,
496  "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
497  avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
498  }
499 
500  if (s->avctx->rc_max_rate &&
501  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
504  90000LL * (avctx->rc_buffer_size - 1) >
505  s->avctx->rc_max_rate * 0xFFFFLL) {
506  av_log(avctx, AV_LOG_INFO,
507  "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
508  "specified vbv buffer is too large for the given bitrate!\n");
509  }
510 
511  if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
513  s->codec_id != AV_CODEC_ID_FLV1) {
514  av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
515  return -1;
516  }
517 
518  if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
519  av_log(avctx, AV_LOG_ERROR,
520  "OBMC is only supported with simple mb decision\n");
521  return -1;
522  }
523 
524  if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
525  av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
526  return -1;
527  }
528 
529  if (s->max_b_frames &&
530  s->codec_id != AV_CODEC_ID_MPEG4 &&
533  av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
534  return -1;
535  }
536  if (s->max_b_frames < 0) {
537  av_log(avctx, AV_LOG_ERROR,
538  "max b frames must be 0 or positive for mpegvideo based encoders\n");
539  return -1;
540  }
541 
542  if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
543  s->codec_id == AV_CODEC_ID_H263 ||
544  s->codec_id == AV_CODEC_ID_H263P) &&
545  (avctx->sample_aspect_ratio.num > 255 ||
546  avctx->sample_aspect_ratio.den > 255)) {
547  av_log(avctx, AV_LOG_WARNING,
548  "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
551  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
552  }
553 
554  if ((s->codec_id == AV_CODEC_ID_H263 ||
555  s->codec_id == AV_CODEC_ID_H263P) &&
556  (avctx->width > 2048 ||
557  avctx->height > 1152 )) {
558  av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
559  return -1;
560  }
561  if ((s->codec_id == AV_CODEC_ID_H263 ||
562  s->codec_id == AV_CODEC_ID_H263P) &&
563  ((avctx->width &3) ||
564  (avctx->height&3) )) {
565  av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
566  return -1;
567  }
568 
569  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
570  (avctx->width > 4095 ||
571  avctx->height > 4095 )) {
572  av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
573  return -1;
574  }
575 
576  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
577  (avctx->width > 16383 ||
578  avctx->height > 16383 )) {
579  av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
580  return -1;
581  }
582 
583  if (s->codec_id == AV_CODEC_ID_RV10 &&
584  (avctx->width &15 ||
585  avctx->height&15 )) {
586  av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
587  return AVERROR(EINVAL);
588  }
589 
590  if (s->codec_id == AV_CODEC_ID_RV20 &&
591  (avctx->width &3 ||
592  avctx->height&3 )) {
593  av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
594  return AVERROR(EINVAL);
595  }
596 
597  if ((s->codec_id == AV_CODEC_ID_WMV1 ||
598  s->codec_id == AV_CODEC_ID_WMV2) &&
599  avctx->width & 1) {
600  av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
601  return -1;
602  }
603 
606  av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
607  return -1;
608  }
609 
610 #if FF_API_PRIVATE_OPT
612  if (avctx->mpeg_quant)
613  s->mpeg_quant = avctx->mpeg_quant;
615 #endif
616 
617  // FIXME mpeg2 uses that too
618  if (s->mpeg_quant && ( s->codec_id != AV_CODEC_ID_MPEG4
619  && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
620  av_log(avctx, AV_LOG_ERROR,
621  "mpeg2 style quantization not supported by codec\n");
622  return -1;
623  }
624 
625  if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
626  av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
627  return -1;
628  }
629 
630  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
632  av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
633  return -1;
634  }
635 
636  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
637  (s->codec_id == AV_CODEC_ID_AMV ||
638  s->codec_id == AV_CODEC_ID_MJPEG)) {
639  // Used to produce garbage with MJPEG.
640  av_log(avctx, AV_LOG_ERROR,
641  "QP RD is no longer compatible with MJPEG or AMV\n");
642  return -1;
643  }
644 
645 #if FF_API_PRIVATE_OPT
647  if (avctx->scenechange_threshold)
650 #endif
651 
652  if (s->scenechange_threshold < 1000000000 &&
654  av_log(avctx, AV_LOG_ERROR,
655  "closed gop with scene change detection are not supported yet, "
656  "set threshold to 1000000000\n");
657  return -1;
658  }
659 
660  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
661  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
663  av_log(avctx, AV_LOG_ERROR,
664  "low delay forcing is only available for mpeg2, "
665  "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
666  return -1;
667  }
668  if (s->max_b_frames != 0) {
669  av_log(avctx, AV_LOG_ERROR,
670  "B-frames cannot be used with low delay\n");
671  return -1;
672  }
673  }
674 
675  if (s->q_scale_type == 1) {
676  if (avctx->qmax > 28) {
677  av_log(avctx, AV_LOG_ERROR,
678  "non linear quant only supports qmax <= 28 currently\n");
679  return -1;
680  }
681  }
682 
683  if (avctx->slices > 1 &&
684  (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
685  av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
686  return AVERROR(EINVAL);
687  }
688 
689  if (s->avctx->thread_count > 1 &&
690  s->codec_id != AV_CODEC_ID_MPEG4 &&
693  s->codec_id != AV_CODEC_ID_MJPEG &&
694  (s->codec_id != AV_CODEC_ID_H263P)) {
695  av_log(avctx, AV_LOG_ERROR,
696  "multi threaded encoding not supported by codec\n");
697  return -1;
698  }
699 
700  if (s->avctx->thread_count < 1) {
701  av_log(avctx, AV_LOG_ERROR,
702  "automatic thread number detection not supported by codec, "
703  "patch welcome\n");
704  return -1;
705  }
706 
707  if (!avctx->time_base.den || !avctx->time_base.num) {
708  av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
709  return -1;
710  }
711 
712 #if FF_API_PRIVATE_OPT
714  if (avctx->b_frame_strategy)
716  if (avctx->b_sensitivity != 40)
717  s->b_sensitivity = avctx->b_sensitivity;
719 #endif
720 
721  if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
722  av_log(avctx, AV_LOG_INFO,
723  "notice: b_frame_strategy only affects the first pass\n");
724  s->b_frame_strategy = 0;
725  }
726 
727  i = av_gcd(avctx->time_base.den, avctx->time_base.num);
728  if (i > 1) {
729  av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
730  avctx->time_base.den /= i;
731  avctx->time_base.num /= i;
732  //return -1;
733  }
734 
736  // (a + x * 3 / 8) / x
737  s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
738  s->inter_quant_bias = 0;
739  } else {
740  s->intra_quant_bias = 0;
741  // (a - x / 4) / x
742  s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
743  }
744 
745  if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
746  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
747  return AVERROR(EINVAL);
748  }
749 
750  av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
751 
752  if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
753  s->avctx->time_base.den > (1 << 16) - 1) {
754  av_log(avctx, AV_LOG_ERROR,
755  "timebase %d/%d not supported by MPEG 4 standard, "
756  "the maximum admitted value for the timebase denominator "
757  "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
758  (1 << 16) - 1);
759  return -1;
760  }
761  s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
762 
763  switch (avctx->codec->id) {
765  s->out_format = FMT_MPEG1;
767  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
768  break;
770  s->out_format = FMT_MPEG1;
772  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
773  s->rtp_mode = 1;
774  break;
775  case AV_CODEC_ID_MJPEG:
776  case AV_CODEC_ID_AMV:
777  s->out_format = FMT_MJPEG;
778  s->intra_only = 1; /* force intra only for jpeg */
779  if (!CONFIG_MJPEG_ENCODER ||
780  ff_mjpeg_encode_init(s) < 0)
781  return -1;
782  avctx->delay = 0;
783  s->low_delay = 1;
784  break;
785  case AV_CODEC_ID_H261:
786  if (!CONFIG_H261_ENCODER)
787  return -1;
788  if (ff_h261_get_picture_format(s->width, s->height) < 0) {
789  av_log(avctx, AV_LOG_ERROR,
790  "The specified picture size of %dx%d is not valid for the "
791  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
792  s->width, s->height);
793  return -1;
794  }
795  s->out_format = FMT_H261;
796  avctx->delay = 0;
797  s->low_delay = 1;
798  s->rtp_mode = 0; /* Sliced encoding not supported */
799  break;
800  case AV_CODEC_ID_H263:
801  if (!CONFIG_H263_ENCODER)
802  return -1;
804  s->width, s->height) == 8) {
805  av_log(avctx, AV_LOG_ERROR,
806  "The specified picture size of %dx%d is not valid for "
807  "the H.263 codec.\nValid sizes are 128x96, 176x144, "
808  "352x288, 704x576, and 1408x1152. "
809  "Try H.263+.\n", s->width, s->height);
810  return -1;
811  }
812  s->out_format = FMT_H263;
813  avctx->delay = 0;
814  s->low_delay = 1;
815  break;
816  case AV_CODEC_ID_H263P:
817  s->out_format = FMT_H263;
818  s->h263_plus = 1;
819  /* Fx */
820  s->h263_aic = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
821  s->modified_quant = s->h263_aic;
822  s->loop_filter = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
823  s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
824 
825  /* /Fx */
826  /* These are just to be sure */
827  avctx->delay = 0;
828  s->low_delay = 1;
829  break;
830  case AV_CODEC_ID_FLV1:
831  s->out_format = FMT_H263;
832  s->h263_flv = 2; /* format = 1; 11-bit codes */
833  s->unrestricted_mv = 1;
834  s->rtp_mode = 0; /* don't allow GOB */
835  avctx->delay = 0;
836  s->low_delay = 1;
837  break;
838  case AV_CODEC_ID_RV10:
839  s->out_format = FMT_H263;
840  avctx->delay = 0;
841  s->low_delay = 1;
842  break;
843  case AV_CODEC_ID_RV20:
844  s->out_format = FMT_H263;
845  avctx->delay = 0;
846  s->low_delay = 1;
847  s->modified_quant = 1;
848  s->h263_aic = 1;
849  s->h263_plus = 1;
850  s->loop_filter = 1;
851  s->unrestricted_mv = 0;
852  break;
853  case AV_CODEC_ID_MPEG4:
854  s->out_format = FMT_H263;
855  s->h263_pred = 1;
856  s->unrestricted_mv = 1;
857  s->low_delay = s->max_b_frames ? 0 : 1;
858  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
859  break;
861  s->out_format = FMT_H263;
862  s->h263_pred = 1;
863  s->unrestricted_mv = 1;
864  s->msmpeg4_version = 2;
865  avctx->delay = 0;
866  s->low_delay = 1;
867  break;
869  s->out_format = FMT_H263;
870  s->h263_pred = 1;
871  s->unrestricted_mv = 1;
872  s->msmpeg4_version = 3;
873  s->flipflop_rounding = 1;
874  avctx->delay = 0;
875  s->low_delay = 1;
876  break;
877  case AV_CODEC_ID_WMV1:
878  s->out_format = FMT_H263;
879  s->h263_pred = 1;
880  s->unrestricted_mv = 1;
881  s->msmpeg4_version = 4;
882  s->flipflop_rounding = 1;
883  avctx->delay = 0;
884  s->low_delay = 1;
885  break;
886  case AV_CODEC_ID_WMV2:
887  s->out_format = FMT_H263;
888  s->h263_pred = 1;
889  s->unrestricted_mv = 1;
890  s->msmpeg4_version = 5;
891  s->flipflop_rounding = 1;
892  avctx->delay = 0;
893  s->low_delay = 1;
894  break;
895  default:
896  return -1;
897  }
898 
899 #if FF_API_PRIVATE_OPT
901  if (avctx->noise_reduction)
902  s->noise_reduction = avctx->noise_reduction;
904 #endif
905 
906  avctx->has_b_frames = !s->low_delay;
907 
908  s->encoding = 1;
909 
910  s->progressive_frame =
913  s->alternate_scan);
914 
915  /* init */
916  ff_mpv_idct_init(s);
917  if (ff_mpv_common_init(s) < 0)
918  return -1;
919 
920  ff_fdctdsp_init(&s->fdsp, avctx);
921  ff_me_cmp_init(&s->mecc, avctx);
923  ff_pixblockdsp_init(&s->pdsp, avctx);
924  ff_qpeldsp_init(&s->qdsp);
925 
926  if (s->msmpeg4_version) {
928  2 * 2 * (MAX_LEVEL + 1) *
929  (MAX_RUN + 1) * 2 * sizeof(int), fail);
930  }
931  FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
932 
933  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix, 64 * 32 * sizeof(int), fail);
934  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
935  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix, 64 * 32 * sizeof(int), fail);
936  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
937  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
938  FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
940  MAX_PICTURE_COUNT * sizeof(Picture *), fail);
942  MAX_PICTURE_COUNT * sizeof(Picture *), fail);
943 
944 
945  if (s->noise_reduction) {
947  2 * 64 * sizeof(uint16_t), fail);
948  }
949 
951 
952  if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
954 
955  if (s->slice_context_count > 1) {
956  s->rtp_mode = 1;
957 
958  if (avctx->codec_id == AV_CODEC_ID_H263P)
959  s->h263_slice_structured = 1;
960  }
961 
962  s->quant_precision = 5;
963 
964 #if FF_API_PRIVATE_OPT
966  if (avctx->frame_skip_threshold)
968  if (avctx->frame_skip_factor)
970  if (avctx->frame_skip_exp)
971  s->frame_skip_exp = avctx->frame_skip_exp;
972  if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
973  s->frame_skip_cmp = avctx->frame_skip_cmp;
975 #endif
976 
979 
980  if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
982  if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
985  if ((ret = ff_msmpeg4_encode_init(s)) < 0)
986  return ret;
987  if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
988  && s->out_format == FMT_MPEG1)
990 
991  /* init q matrix */
992  for (i = 0; i < 64; i++) {
993  int j = s->idsp.idct_permutation[i];
994  if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
995  s->mpeg_quant) {
998  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
999  s->intra_matrix[j] =
1001  } else {
1002  /* MPEG-1/2 */
1003  s->chroma_intra_matrix[j] =
1006  }
1007  if (s->avctx->intra_matrix)
1008  s->intra_matrix[j] = s->avctx->intra_matrix[i];
1009  if (s->avctx->inter_matrix)
1010  s->inter_matrix[j] = s->avctx->inter_matrix[i];
1011  }
1012 
1013  /* precompute matrix */
1014  /* for mjpeg, we do include qscale in the matrix */
1015  if (s->out_format != FMT_MJPEG) {
1017  s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1018  31, 1);
1020  s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1021  31, 0);
1022  }
1023 
1024  if (ff_rate_control_init(s) < 0)
1025  return -1;
1026 
1027 #if FF_API_PRIVATE_OPT
1029  if (avctx->brd_scale)
1030  s->brd_scale = avctx->brd_scale;
1031 
1032  if (avctx->prediction_method)
1033  s->pred = avctx->prediction_method + 1;
1035 #endif
1036 
1037  if (s->b_frame_strategy == 2) {
1038  for (i = 0; i < s->max_b_frames + 2; i++) {
1039  s->tmp_frames[i] = av_frame_alloc();
1040  if (!s->tmp_frames[i])
1041  return AVERROR(ENOMEM);
1042 
1044  s->tmp_frames[i]->width = s->width >> s->brd_scale;
1045  s->tmp_frames[i]->height = s->height >> s->brd_scale;
1046 
1047  ret = av_frame_get_buffer(s->tmp_frames[i], 32);
1048  if (ret < 0)
1049  return ret;
1050  }
1051  }
1052 
1053  cpb_props = ff_add_cpb_side_data(avctx);
1054  if (!cpb_props)
1055  return AVERROR(ENOMEM);
1056  cpb_props->max_bitrate = avctx->rc_max_rate;
1057  cpb_props->min_bitrate = avctx->rc_min_rate;
1058  cpb_props->avg_bitrate = avctx->bit_rate;
1059  cpb_props->buffer_size = avctx->rc_buffer_size;
1060 
1061  return 0;
1062 fail:
1063  ff_mpv_encode_end(avctx);
1064  return AVERROR_UNKNOWN;
1065 }
1066 
1068 {
1069  MpegEncContext *s = avctx->priv_data;
1070  int i;
1071 
1073 
1074  ff_mpv_common_end(s);
1075  if (CONFIG_MJPEG_ENCODER &&
1076  s->out_format == FMT_MJPEG)
1078 
1079  av_freep(&avctx->extradata);
1080 
1081  for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1082  av_frame_free(&s->tmp_frames[i]);
1083 
1086 
1087  av_freep(&s->avctx->stats_out);
1088  av_freep(&s->ac_stats);
1089 
1094  av_freep(&s->q_intra_matrix);
1095  av_freep(&s->q_inter_matrix);
1098  av_freep(&s->input_picture);
1100  av_freep(&s->dct_offset);
1101 
1102  return 0;
1103 }
1104 
1105 static int get_sae(uint8_t *src, int ref, int stride)
1106 {
1107  int x,y;
1108  int acc = 0;
1109 
1110  for (y = 0; y < 16; y++) {
1111  for (x = 0; x < 16; x++) {
1112  acc += FFABS(src[x + y * stride] - ref);
1113  }
1114  }
1115 
1116  return acc;
1117 }
1118 
1120  uint8_t *ref, int stride)
1121 {
1122  int x, y, w, h;
1123  int acc = 0;
1124 
1125  w = s->width & ~15;
1126  h = s->height & ~15;
1127 
1128  for (y = 0; y < h; y += 16) {
1129  for (x = 0; x < w; x += 16) {
1130  int offset = x + y * stride;
1131  int sad = s->mecc.sad[0](NULL, src + offset, ref + offset,
1132  stride, 16);
1133  int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1134  int sae = get_sae(src + offset, mean, stride);
1135 
1136  acc += sae + 500 < sad;
1137  }
1138  }
1139  return acc;
1140 }
1141 
1142 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1143 {
1144  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1146  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1147  &s->linesize, &s->uvlinesize);
1148 }
1149 
1150 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1151 {
1152  Picture *pic = NULL;
1153  int64_t pts;
1154  int i, display_picture_number = 0, ret;
1155  int encoding_delay = s->max_b_frames ? s->max_b_frames
1156  : (s->low_delay ? 0 : 1);
1157  int flush_offset = 1;
1158  int direct = 1;
1159 
1160  if (pic_arg) {
1161  pts = pic_arg->pts;
1162  display_picture_number = s->input_picture_number++;
1163 
1164  if (pts != AV_NOPTS_VALUE) {
1165  if (s->user_specified_pts != AV_NOPTS_VALUE) {
1166  int64_t last = s->user_specified_pts;
1167 
1168  if (pts <= last) {
1170  "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1171  pts, last);
1172  return AVERROR(EINVAL);
1173  }
1174 
1175  if (!s->low_delay && display_picture_number == 1)
1176  s->dts_delta = pts - last;
1177  }
1178  s->user_specified_pts = pts;
1179  } else {
1180  if (s->user_specified_pts != AV_NOPTS_VALUE) {
1181  s->user_specified_pts =
1182  pts = s->user_specified_pts + 1;
1183  av_log(s->avctx, AV_LOG_INFO,
1184  "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1185  pts);
1186  } else {
1187  pts = display_picture_number;
1188  }
1189  }
1190 
1191  if (!pic_arg->buf[0] ||
1192  pic_arg->linesize[0] != s->linesize ||
1193  pic_arg->linesize[1] != s->uvlinesize ||
1194  pic_arg->linesize[2] != s->uvlinesize)
1195  direct = 0;
1196  if ((s->width & 15) || (s->height & 15))
1197  direct = 0;
1198  if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1199  direct = 0;
1200  if (s->linesize & (STRIDE_ALIGN-1))
1201  direct = 0;
1202 
1203  ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1204  pic_arg->linesize[1], s->linesize, s->uvlinesize);
1205 
1206  i = ff_find_unused_picture(s->avctx, s->picture, direct);
1207  if (i < 0)
1208  return i;
1209 
1210  pic = &s->picture[i];
1211  pic->reference = 3;
1212 
1213  if (direct) {
1214  if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1215  return ret;
1216  }
1217  ret = alloc_picture(s, pic, direct);
1218  if (ret < 0)
1219  return ret;
1220 
1221  if (!direct) {
1222  if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1223  pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1224  pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1225  // empty
1226  } else {
1227  int h_chroma_shift, v_chroma_shift;
1229  &h_chroma_shift,
1230  &v_chroma_shift);
1231 
1232  for (i = 0; i < 3; i++) {
1233  int src_stride = pic_arg->linesize[i];
1234  int dst_stride = i ? s->uvlinesize : s->linesize;
1235  int h_shift = i ? h_chroma_shift : 0;
1236  int v_shift = i ? v_chroma_shift : 0;
1237  int w = s->width >> h_shift;
1238  int h = s->height >> v_shift;
1239  uint8_t *src = pic_arg->data[i];
1240  uint8_t *dst = pic->f->data[i];
1241  int vpad = 16;
1242 
1243  if ( s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1244  && !s->progressive_sequence
1245  && FFALIGN(s->height, 32) - s->height > 16)
1246  vpad = 32;
1247 
1248  if (!s->avctx->rc_buffer_size)
1249  dst += INPLACE_OFFSET;
1250 
1251  if (src_stride == dst_stride)
1252  memcpy(dst, src, src_stride * h);
1253  else {
1254  int h2 = h;
1255  uint8_t *dst2 = dst;
1256  while (h2--) {
1257  memcpy(dst2, src, w);
1258  dst2 += dst_stride;
1259  src += src_stride;
1260  }
1261  }
1262  if ((s->width & 15) || (s->height & (vpad-1))) {
1263  s->mpvencdsp.draw_edges(dst, dst_stride,
1264  w, h,
1265  16 >> h_shift,
1266  vpad >> v_shift,
1267  EDGE_BOTTOM);
1268  }
1269  }
1270  emms_c();
1271  }
1272  }
1273  ret = av_frame_copy_props(pic->f, pic_arg);
1274  if (ret < 0)
1275  return ret;
1276 
1277  pic->f->display_picture_number = display_picture_number;
1278  pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1279  } else {
1280  /* Flushing: When we have not received enough input frames,
1281  * ensure s->input_picture[0] contains the first picture */
1282  for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1283  if (s->input_picture[flush_offset])
1284  break;
1285 
1286  if (flush_offset <= 1)
1287  flush_offset = 1;
1288  else
1289  encoding_delay = encoding_delay - flush_offset + 1;
1290  }
1291 
1292  /* shift buffer entries */
1293  for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1294  s->input_picture[i - flush_offset] = s->input_picture[i];
1295 
1296  s->input_picture[encoding_delay] = (Picture*) pic;
1297 
1298  return 0;
1299 }
1300 
1302 {
1303  int x, y, plane;
1304  int score = 0;
1305  int64_t score64 = 0;
1306 
1307  for (plane = 0; plane < 3; plane++) {
1308  const int stride = p->f->linesize[plane];
1309  const int bw = plane ? 1 : 2;
1310  for (y = 0; y < s->mb_height * bw; y++) {
1311  for (x = 0; x < s->mb_width * bw; x++) {
1312  int off = p->shared ? 0 : 16;
1313  uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1314  uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1315  int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1316 
1317  switch (FFABS(s->frame_skip_exp)) {
1318  case 0: score = FFMAX(score, v); break;
1319  case 1: score += FFABS(v); break;
1320  case 2: score64 += v * (int64_t)v; break;
1321  case 3: score64 += FFABS(v * (int64_t)v * v); break;
1322  case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v); break;
1323  }
1324  }
1325  }
1326  }
1327  emms_c();
1328 
1329  if (score)
1330  score64 = score;
1331  if (s->frame_skip_exp < 0)
1332  score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1333  -1.0/s->frame_skip_exp);
1334 
1335  if (score64 < s->frame_skip_threshold)
1336  return 1;
1337  if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1338  return 1;
1339  return 0;
1340 }
1341 
1343 {
1344  AVPacket pkt = { 0 };
1345  int ret;
1346  int size = 0;
1347 
1348  av_init_packet(&pkt);
1349 
1350  ret = avcodec_send_frame(c, frame);
1351  if (ret < 0)
1352  return ret;
1353 
1354  do {
1355  ret = avcodec_receive_packet(c, &pkt);
1356  if (ret >= 0) {
1357  size += pkt.size;
1358  av_packet_unref(&pkt);
1359  } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1360  return ret;
1361  } while (ret >= 0);
1362 
1363  return size;
1364 }
1365 
1367 {
1368  const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1369  const int scale = s->brd_scale;
1370  int width = s->width >> scale;
1371  int height = s->height >> scale;
1372  int i, j, out_size, p_lambda, b_lambda, lambda2;
1373  int64_t best_rd = INT64_MAX;
1374  int best_b_count = -1;
1375  int ret = 0;
1376 
1377  av_assert0(scale >= 0 && scale <= 3);
1378 
1379  //emms_c();
1380  //s->next_picture_ptr->quality;
1381  p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1382  //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1383  b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1384  if (!b_lambda) // FIXME we should do this somewhere else
1385  b_lambda = p_lambda;
1386  lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1388 
1389  for (i = 0; i < s->max_b_frames + 2; i++) {
1390  Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1391  s->next_picture_ptr;
1392  uint8_t *data[4];
1393 
1394  if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1395  pre_input = *pre_input_ptr;
1396  memcpy(data, pre_input_ptr->f->data, sizeof(data));
1397 
1398  if (!pre_input.shared && i) {
1399  data[0] += INPLACE_OFFSET;
1400  data[1] += INPLACE_OFFSET;
1401  data[2] += INPLACE_OFFSET;
1402  }
1403 
1404  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1405  s->tmp_frames[i]->linesize[0],
1406  data[0],
1407  pre_input.f->linesize[0],
1408  width, height);
1409  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1410  s->tmp_frames[i]->linesize[1],
1411  data[1],
1412  pre_input.f->linesize[1],
1413  width >> 1, height >> 1);
1414  s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1415  s->tmp_frames[i]->linesize[2],
1416  data[2],
1417  pre_input.f->linesize[2],
1418  width >> 1, height >> 1);
1419  }
1420  }
1421 
1422  for (j = 0; j < s->max_b_frames + 1; j++) {
1423  AVCodecContext *c;
1424  int64_t rd = 0;
1425 
1426  if (!s->input_picture[j])
1427  break;
1428 
1430  if (!c)
1431  return AVERROR(ENOMEM);
1432 
1433  c->width = width;
1434  c->height = height;
1436  c->flags |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1437  c->mb_decision = s->avctx->mb_decision;
1438  c->me_cmp = s->avctx->me_cmp;
1439  c->mb_cmp = s->avctx->mb_cmp;
1440  c->me_sub_cmp = s->avctx->me_sub_cmp;
1442  c->time_base = s->avctx->time_base;
1443  c->max_b_frames = s->max_b_frames;
1444 
1445  ret = avcodec_open2(c, codec, NULL);
1446  if (ret < 0)
1447  goto fail;
1448 
1450  s->tmp_frames[0]->quality = 1 * FF_QP2LAMBDA;
1451 
1452  out_size = encode_frame(c, s->tmp_frames[0]);
1453  if (out_size < 0) {
1454  ret = out_size;
1455  goto fail;
1456  }
1457 
1458  //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1459 
1460  for (i = 0; i < s->max_b_frames + 1; i++) {
1461  int is_p = i % (j + 1) == j || i == s->max_b_frames;
1462 
1463  s->tmp_frames[i + 1]->pict_type = is_p ?
1465  s->tmp_frames[i + 1]->quality = is_p ? p_lambda : b_lambda;
1466 
1467  out_size = encode_frame(c, s->tmp_frames[i + 1]);
1468  if (out_size < 0) {
1469  ret = out_size;
1470  goto fail;
1471  }
1472 
1473  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1474  }
1475 
1476  /* get the delayed frames */
1477  out_size = encode_frame(c, NULL);
1478  if (out_size < 0) {
1479  ret = out_size;
1480  goto fail;
1481  }
1482  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1483 
1484  rd += c->error[0] + c->error[1] + c->error[2];
1485 
1486  if (rd < best_rd) {
1487  best_rd = rd;
1488  best_b_count = j;
1489  }
1490 
1491 fail:
1493  if (ret < 0)
1494  return ret;
1495  }
1496 
1497  return best_b_count;
1498 }
1499 
1501 {
1502  int i, ret;
1503 
1504  for (i = 1; i < MAX_PICTURE_COUNT; i++)
1506  s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1507 
1508  /* set next picture type & ordering */
1509  if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1510  if (s->frame_skip_threshold || s->frame_skip_factor) {
1511  if (s->picture_in_gop_number < s->gop_size &&
1512  s->next_picture_ptr &&
1513  skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1514  // FIXME check that the gop check above is +-1 correct
1515  av_frame_unref(s->input_picture[0]->f);
1516 
1517  ff_vbv_update(s, 0);
1518 
1519  goto no_output_pic;
1520  }
1521  }
1522 
1523  if (/*s->picture_in_gop_number >= s->gop_size ||*/
1524  !s->next_picture_ptr || s->intra_only) {
1525  s->reordered_input_picture[0] = s->input_picture[0];
1528  s->coded_picture_number++;
1529  } else {
1530  int b_frames = 0;
1531 
1532  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1533  for (i = 0; i < s->max_b_frames + 1; i++) {
1534  int pict_num = s->input_picture[0]->f->display_picture_number + i;
1535 
1536  if (pict_num >= s->rc_context.num_entries)
1537  break;
1538  if (!s->input_picture[i]) {
1539  s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1540  break;
1541  }
1542 
1543  s->input_picture[i]->f->pict_type =
1544  s->rc_context.entry[pict_num].new_pict_type;
1545  }
1546  }
1547 
1548  if (s->b_frame_strategy == 0) {
1549  b_frames = s->max_b_frames;
1550  while (b_frames && !s->input_picture[b_frames])
1551  b_frames--;
1552  } else if (s->b_frame_strategy == 1) {
1553  for (i = 1; i < s->max_b_frames + 1; i++) {
1554  if (s->input_picture[i] &&
1555  s->input_picture[i]->b_frame_score == 0) {
1556  s->input_picture[i]->b_frame_score =
1557  get_intra_count(s,
1558  s->input_picture[i ]->f->data[0],
1559  s->input_picture[i - 1]->f->data[0],
1560  s->linesize) + 1;
1561  }
1562  }
1563  for (i = 0; i < s->max_b_frames + 1; i++) {
1564  if (!s->input_picture[i] ||
1565  s->input_picture[i]->b_frame_score - 1 >
1566  s->mb_num / s->b_sensitivity)
1567  break;
1568  }
1569 
1570  b_frames = FFMAX(0, i - 1);
1571 
1572  /* reset scores */
1573  for (i = 0; i < b_frames + 1; i++) {
1574  s->input_picture[i]->b_frame_score = 0;
1575  }
1576  } else if (s->b_frame_strategy == 2) {
1577  b_frames = estimate_best_b_count(s);
1578  if (b_frames < 0)
1579  return b_frames;
1580  }
1581 
1582  emms_c();
1583 
1584  for (i = b_frames - 1; i >= 0; i--) {
1585  int type = s->input_picture[i]->f->pict_type;
1586  if (type && type != AV_PICTURE_TYPE_B)
1587  b_frames = i;
1588  }
1589  if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1590  b_frames == s->max_b_frames) {
1592  "warning, too many B-frames in a row\n");
1593  }
1594 
1595  if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1596  if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1597  s->gop_size > s->picture_in_gop_number) {
1598  b_frames = s->gop_size - s->picture_in_gop_number - 1;
1599  } else {
1601  b_frames = 0;
1602  s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1603  }
1604  }
1605 
1606  if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1607  s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1608  b_frames--;
1609 
1610  s->reordered_input_picture[0] = s->input_picture[b_frames];
1614  s->coded_picture_number++;
1615  for (i = 0; i < b_frames; i++) {
1616  s->reordered_input_picture[i + 1] = s->input_picture[i];
1617  s->reordered_input_picture[i + 1]->f->pict_type =
1620  s->coded_picture_number++;
1621  }
1622  }
1623  }
1624 no_output_pic:
1626 
1627  if (s->reordered_input_picture[0]) {
1630  AV_PICTURE_TYPE_B ? 3 : 0;
1631 
1632  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1633  return ret;
1634 
1635  if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1636  // input is a shared pix, so we can't modify it -> allocate a new
1637  // one & ensure that the shared one is reuseable
1638 
1639  Picture *pic;
1640  int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1641  if (i < 0)
1642  return i;
1643  pic = &s->picture[i];
1644 
1646  if (alloc_picture(s, pic, 0) < 0) {
1647  return -1;
1648  }
1649 
1650  ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1651  if (ret < 0)
1652  return ret;
1653 
1654  /* mark us unused / free shared pic */
1656  s->reordered_input_picture[0]->shared = 0;
1657 
1658  s->current_picture_ptr = pic;
1659  } else {
1660  // input is not a shared pix -> reuse buffer for current_pix
1662  for (i = 0; i < 4; i++) {
1663  s->new_picture.f->data[i] += INPLACE_OFFSET;
1664  }
1665  }
1667  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1668  s->current_picture_ptr)) < 0)
1669  return ret;
1670 
1672  }
1673  return 0;
1674 }
1675 
1676 static void frame_end(MpegEncContext *s)
1677 {
1678  if (s->unrestricted_mv &&
1680  !s->intra_only) {
1682  int hshift = desc->log2_chroma_w;
1683  int vshift = desc->log2_chroma_h;
1685  s->current_picture.f->linesize[0],
1686  s->h_edge_pos, s->v_edge_pos,
1688  EDGE_TOP | EDGE_BOTTOM);
1690  s->current_picture.f->linesize[1],
1691  s->h_edge_pos >> hshift,
1692  s->v_edge_pos >> vshift,
1693  EDGE_WIDTH >> hshift,
1694  EDGE_WIDTH >> vshift,
1695  EDGE_TOP | EDGE_BOTTOM);
1697  s->current_picture.f->linesize[2],
1698  s->h_edge_pos >> hshift,
1699  s->v_edge_pos >> vshift,
1700  EDGE_WIDTH >> hshift,
1701  EDGE_WIDTH >> vshift,
1702  EDGE_TOP | EDGE_BOTTOM);
1703  }
1704 
1705  emms_c();
1706 
1707  s->last_pict_type = s->pict_type;
1709  if (s->pict_type!= AV_PICTURE_TYPE_B)
1711 
1712 #if FF_API_CODED_FRAME
1717 #endif
1718 #if FF_API_ERROR_FRAME
1721  sizeof(s->current_picture.encoding_error));
1723 #endif
1724 }
1725 
1727 {
1728  int intra, i;
1729 
1730  for (intra = 0; intra < 2; intra++) {
1731  if (s->dct_count[intra] > (1 << 16)) {
1732  for (i = 0; i < 64; i++) {
1733  s->dct_error_sum[intra][i] >>= 1;
1734  }
1735  s->dct_count[intra] >>= 1;
1736  }
1737 
1738  for (i = 0; i < 64; i++) {
1739  s->dct_offset[intra][i] = (s->noise_reduction *
1740  s->dct_count[intra] +
1741  s->dct_error_sum[intra][i] / 2) /
1742  (s->dct_error_sum[intra][i] + 1);
1743  }
1744  }
1745 }
1746 
1748 {
1749  int ret;
1750 
1751  /* mark & release old frames */
1752  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1754  s->last_picture_ptr->f->buf[0]) {
1756  }
1757 
1760 
1762  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1763  s->current_picture_ptr)) < 0)
1764  return ret;
1765 
1766  if (s->pict_type != AV_PICTURE_TYPE_B) {
1768  if (!s->droppable)
1770  }
1771 
1772  if (s->last_picture_ptr) {
1774  if (s->last_picture_ptr->f->buf[0] &&
1775  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1776  s->last_picture_ptr)) < 0)
1777  return ret;
1778  }
1779  if (s->next_picture_ptr) {
1781  if (s->next_picture_ptr->f->buf[0] &&
1782  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1783  s->next_picture_ptr)) < 0)
1784  return ret;
1785  }
1786 
1787  if (s->picture_structure!= PICT_FRAME) {
1788  int i;
1789  for (i = 0; i < 4; i++) {
1791  s->current_picture.f->data[i] +=
1792  s->current_picture.f->linesize[i];
1793  }
1794  s->current_picture.f->linesize[i] *= 2;
1795  s->last_picture.f->linesize[i] *= 2;
1796  s->next_picture.f->linesize[i] *= 2;
1797  }
1798  }
1799 
1800  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1803  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1806  } else {
1809  }
1810 
1811  if (s->dct_error_sum) {
1814  }
1815 
1816  return 0;
1817 }
1818 
1820  const AVFrame *pic_arg, int *got_packet)
1821 {
1822  MpegEncContext *s = avctx->priv_data;
1823  int i, stuffing_count, ret;
1824  int context_count = s->slice_context_count;
1825 
1826  s->vbv_ignore_qmax = 0;
1827 
1828  s->picture_in_gop_number++;
1829 
1830  if (load_input_picture(s, pic_arg) < 0)
1831  return -1;
1832 
1833  if (select_input_picture(s) < 0) {
1834  return -1;
1835  }
1836 
1837  /* output? */
1838  if (s->new_picture.f->data[0]) {
1839  int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1840  int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1841  :
1842  s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1843  if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1844  return ret;
1845  if (s->mb_info) {
1848  s->mb_width*s->mb_height*12);
1849  s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1850  }
1851 
1852  for (i = 0; i < context_count; i++) {
1853  int start_y = s->thread_context[i]->start_mb_y;
1854  int end_y = s->thread_context[i]-> end_mb_y;
1855  int h = s->mb_height;
1856  uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1857  uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1858 
1859  init_put_bits(&s->thread_context[i]->pb, start, end - start);
1860  }
1861 
1862  s->pict_type = s->new_picture.f->pict_type;
1863  //emms_c();
1864  ret = frame_start(s);
1865  if (ret < 0)
1866  return ret;
1867 vbv_retry:
1868  ret = encode_picture(s, s->picture_number);
1869  if (growing_buffer) {
1870  av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1871  pkt->data = s->pb.buf;
1872  pkt->size = avctx->internal->byte_buffer_size;
1873  }
1874  if (ret < 0)
1875  return -1;
1876 
1877 #if FF_API_STAT_BITS
1879  avctx->header_bits = s->header_bits;
1880  avctx->mv_bits = s->mv_bits;
1881  avctx->misc_bits = s->misc_bits;
1882  avctx->i_tex_bits = s->i_tex_bits;
1883  avctx->p_tex_bits = s->p_tex_bits;
1884  avctx->i_count = s->i_count;
1885  // FIXME f/b_count in avctx
1886  avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1887  avctx->skip_count = s->skip_count;
1889 #endif
1890 
1891  frame_end(s);
1892 
1893  if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1895 
1896  if (avctx->rc_buffer_size) {
1897  RateControlContext *rcc = &s->rc_context;
1898  int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1899  int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1900  int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1901 
1902  if (put_bits_count(&s->pb) > max_size &&
1903  s->lambda < s->lmax) {
1904  s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1905  (s->qscale + 1) / s->qscale);
1906  if (s->adaptive_quant) {
1907  int i;
1908  for (i = 0; i < s->mb_height * s->mb_stride; i++)
1909  s->lambda_table[i] =
1910  FFMAX(s->lambda_table[i] + min_step,
1911  s->lambda_table[i] * (s->qscale + 1) /
1912  s->qscale);
1913  }
1914  s->mb_skipped = 0; // done in frame_start()
1915  // done in encode_picture() so we must undo it
1916  if (s->pict_type == AV_PICTURE_TYPE_P) {
1917  if (s->flipflop_rounding ||
1918  s->codec_id == AV_CODEC_ID_H263P ||
1920  s->no_rounding ^= 1;
1921  }
1922  if (s->pict_type != AV_PICTURE_TYPE_B) {
1923  s->time_base = s->last_time_base;
1924  s->last_non_b_time = s->time - s->pp_time;
1925  }
1926  for (i = 0; i < context_count; i++) {
1927  PutBitContext *pb = &s->thread_context[i]->pb;
1928  init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1929  }
1930  s->vbv_ignore_qmax = 1;
1931  av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1932  goto vbv_retry;
1933  }
1934 
1936  }
1937 
1938  if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1940 
1941  for (i = 0; i < 4; i++) {
1943  avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1944  }
1947  (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1948  s->pict_type);
1949 
1950  if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1951  assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1952  s->misc_bits + s->i_tex_bits +
1953  s->p_tex_bits);
1954  flush_put_bits(&s->pb);
1955  s->frame_bits = put_bits_count(&s->pb);
1956 
1957  stuffing_count = ff_vbv_update(s, s->frame_bits);
1958  s->stuffing_bits = 8*stuffing_count;
1959  if (stuffing_count) {
1960  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1961  stuffing_count + 50) {
1962  av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1963  return -1;
1964  }
1965 
1966  switch (s->codec_id) {
1969  while (stuffing_count--) {
1970  put_bits(&s->pb, 8, 0);
1971  }
1972  break;
1973  case AV_CODEC_ID_MPEG4:
1974  put_bits(&s->pb, 16, 0);
1975  put_bits(&s->pb, 16, 0x1C3);
1976  stuffing_count -= 4;
1977  while (stuffing_count--) {
1978  put_bits(&s->pb, 8, 0xFF);
1979  }
1980  break;
1981  default:
1982  av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1983  }
1984  flush_put_bits(&s->pb);
1985  s->frame_bits = put_bits_count(&s->pb);
1986  }
1987 
1988  /* update MPEG-1/2 vbv_delay for CBR */
1989  if (s->avctx->rc_max_rate &&
1990  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1991  s->out_format == FMT_MPEG1 &&
1992  90000LL * (avctx->rc_buffer_size - 1) <=
1993  s->avctx->rc_max_rate * 0xFFFFLL) {
1994  AVCPBProperties *props;
1995  size_t props_size;
1996 
1997  int vbv_delay, min_delay;
1998  double inbits = s->avctx->rc_max_rate *
1999  av_q2d(s->avctx->time_base);
2000  int minbits = s->frame_bits - 8 *
2001  (s->vbv_delay_ptr - s->pb.buf - 1);
2002  double bits = s->rc_context.buffer_index + minbits - inbits;
2003 
2004  if (bits < 0)
2006  "Internal error, negative bits\n");
2007 
2008  assert(s->repeat_first_field == 0);
2009 
2010  vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
2011  min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
2012  s->avctx->rc_max_rate;
2013 
2014  vbv_delay = FFMAX(vbv_delay, min_delay);
2015 
2016  av_assert0(vbv_delay < 0xFFFF);
2017 
2018  s->vbv_delay_ptr[0] &= 0xF8;
2019  s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2020  s->vbv_delay_ptr[1] = vbv_delay >> 5;
2021  s->vbv_delay_ptr[2] &= 0x07;
2022  s->vbv_delay_ptr[2] |= vbv_delay << 3;
2023 
2024  props = av_cpb_properties_alloc(&props_size);
2025  if (!props)
2026  return AVERROR(ENOMEM);
2027  props->vbv_delay = vbv_delay * 300;
2028 
2030  (uint8_t*)props, props_size);
2031  if (ret < 0) {
2032  av_freep(&props);
2033  return ret;
2034  }
2035 
2036 #if FF_API_VBV_DELAY
2038  avctx->vbv_delay = vbv_delay * 300;
2040 #endif
2041  }
2042  s->total_bits += s->frame_bits;
2043 #if FF_API_STAT_BITS
2045  avctx->frame_bits = s->frame_bits;
2047 #endif
2048 
2049 
2050  pkt->pts = s->current_picture.f->pts;
2051  if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2053  pkt->dts = pkt->pts - s->dts_delta;
2054  else
2055  pkt->dts = s->reordered_pts;
2056  s->reordered_pts = pkt->pts;
2057  } else
2058  pkt->dts = pkt->pts;
2059  if (s->current_picture.f->key_frame)
2060  pkt->flags |= AV_PKT_FLAG_KEY;
2061  if (s->mb_info)
2063  } else {
2064  s->frame_bits = 0;
2065  }
2066 
2067  /* release non-reference frames */
2068  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2069  if (!s->picture[i].reference)
2070  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2071  }
2072 
2073  av_assert1((s->frame_bits & 7) == 0);
2074 
2075  pkt->size = s->frame_bits / 8;
2076  *got_packet = !!pkt->size;
2077  return 0;
2078 }
2079 
2081  int n, int threshold)
2082 {
2083  static const char tab[64] = {
2084  3, 2, 2, 1, 1, 1, 1, 1,
2085  1, 1, 1, 1, 1, 1, 1, 1,
2086  1, 1, 1, 1, 1, 1, 1, 1,
2087  0, 0, 0, 0, 0, 0, 0, 0,
2088  0, 0, 0, 0, 0, 0, 0, 0,
2089  0, 0, 0, 0, 0, 0, 0, 0,
2090  0, 0, 0, 0, 0, 0, 0, 0,
2091  0, 0, 0, 0, 0, 0, 0, 0
2092  };
2093  int score = 0;
2094  int run = 0;
2095  int i;
2096  int16_t *block = s->block[n];
2097  const int last_index = s->block_last_index[n];
2098  int skip_dc;
2099 
2100  if (threshold < 0) {
2101  skip_dc = 0;
2102  threshold = -threshold;
2103  } else
2104  skip_dc = 1;
2105 
2106  /* Are all we could set to zero already zero? */
2107  if (last_index <= skip_dc - 1)
2108  return;
2109 
2110  for (i = 0; i <= last_index; i++) {
2111  const int j = s->intra_scantable.permutated[i];
2112  const int level = FFABS(block[j]);
2113  if (level == 1) {
2114  if (skip_dc && i == 0)
2115  continue;
2116  score += tab[run];
2117  run = 0;
2118  } else if (level > 1) {
2119  return;
2120  } else {
2121  run++;
2122  }
2123  }
2124  if (score >= threshold)
2125  return;
2126  for (i = skip_dc; i <= last_index; i++) {
2127  const int j = s->intra_scantable.permutated[i];
2128  block[j] = 0;
2129  }
2130  if (block[0])
2131  s->block_last_index[n] = 0;
2132  else
2133  s->block_last_index[n] = -1;
2134 }
2135 
2136 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2137  int last_index)
2138 {
2139  int i;
2140  const int maxlevel = s->max_qcoeff;
2141  const int minlevel = s->min_qcoeff;
2142  int overflow = 0;
2143 
2144  if (s->mb_intra) {
2145  i = 1; // skip clipping of intra dc
2146  } else
2147  i = 0;
2148 
2149  for (; i <= last_index; i++) {
2150  const int j = s->intra_scantable.permutated[i];
2151  int level = block[j];
2152 
2153  if (level > maxlevel) {
2154  level = maxlevel;
2155  overflow++;
2156  } else if (level < minlevel) {
2157  level = minlevel;
2158  overflow++;
2159  }
2160 
2161  block[j] = level;
2162  }
2163 
2164  if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2165  av_log(s->avctx, AV_LOG_INFO,
2166  "warning, clipping %d dct coefficients to %d..%d\n",
2167  overflow, minlevel, maxlevel);
2168 }
2169 
2170 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2171 {
2172  int x, y;
2173  // FIXME optimize
2174  for (y = 0; y < 8; y++) {
2175  for (x = 0; x < 8; x++) {
2176  int x2, y2;
2177  int sum = 0;
2178  int sqr = 0;
2179  int count = 0;
2180 
2181  for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2182  for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2183  int v = ptr[x2 + y2 * stride];
2184  sum += v;
2185  sqr += v * v;
2186  count++;
2187  }
2188  }
2189  weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2190  }
2191  }
2192 }
2193 
2195  int motion_x, int motion_y,
2196  int mb_block_height,
2197  int mb_block_width,
2198  int mb_block_count)
2199 {
2200  int16_t weight[12][64];
2201  int16_t orig[12][64];
2202  const int mb_x = s->mb_x;
2203  const int mb_y = s->mb_y;
2204  int i;
2205  int skip_dct[12];
2206  int dct_offset = s->linesize * 8; // default for progressive frames
2207  int uv_dct_offset = s->uvlinesize * 8;
2208  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2209  ptrdiff_t wrap_y, wrap_c;
2210 
2211  for (i = 0; i < mb_block_count; i++)
2212  skip_dct[i] = s->skipdct;
2213 
2214  if (s->adaptive_quant) {
2215  const int last_qp = s->qscale;
2216  const int mb_xy = mb_x + mb_y * s->mb_stride;
2217 
2218  s->lambda = s->lambda_table[mb_xy];
2219  update_qscale(s);
2220 
2221  if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2222  s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2223  s->dquant = s->qscale - last_qp;
2224 
2225  if (s->out_format == FMT_H263) {
2226  s->dquant = av_clip(s->dquant, -2, 2);
2227 
2228  if (s->codec_id == AV_CODEC_ID_MPEG4) {
2229  if (!s->mb_intra) {
2230  if (s->pict_type == AV_PICTURE_TYPE_B) {
2231  if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2232  s->dquant = 0;
2233  }
2234  if (s->mv_type == MV_TYPE_8X8)
2235  s->dquant = 0;
2236  }
2237  }
2238  }
2239  }
2240  ff_set_qscale(s, last_qp + s->dquant);
2241  } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2242  ff_set_qscale(s, s->qscale + s->dquant);
2243 
2244  wrap_y = s->linesize;
2245  wrap_c = s->uvlinesize;
2246  ptr_y = s->new_picture.f->data[0] +
2247  (mb_y * 16 * wrap_y) + mb_x * 16;
2248  ptr_cb = s->new_picture.f->data[1] +
2249  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2250  ptr_cr = s->new_picture.f->data[2] +
2251  (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2252 
2253  if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2254  uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2255  int cw = (s->width + s->chroma_x_shift) >> s->chroma_x_shift;
2256  int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2257  s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2258  wrap_y, wrap_y,
2259  16, 16, mb_x * 16, mb_y * 16,
2260  s->width, s->height);
2261  ptr_y = ebuf;
2262  s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2263  wrap_c, wrap_c,
2264  mb_block_width, mb_block_height,
2265  mb_x * mb_block_width, mb_y * mb_block_height,
2266  cw, ch);
2267  ptr_cb = ebuf + 16 * wrap_y;
2268  s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2269  wrap_c, wrap_c,
2270  mb_block_width, mb_block_height,
2271  mb_x * mb_block_width, mb_y * mb_block_height,
2272  cw, ch);
2273  ptr_cr = ebuf + 16 * wrap_y + 16;
2274  }
2275 
2276  if (s->mb_intra) {
2278  int progressive_score, interlaced_score;
2279 
2280  s->interlaced_dct = 0;
2281  progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2282  s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2283  NULL, wrap_y, 8) - 400;
2284 
2285  if (progressive_score > 0) {
2286  interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2287  NULL, wrap_y * 2, 8) +
2288  s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2289  NULL, wrap_y * 2, 8);
2290  if (progressive_score > interlaced_score) {
2291  s->interlaced_dct = 1;
2292 
2293  dct_offset = wrap_y;
2294  uv_dct_offset = wrap_c;
2295  wrap_y <<= 1;
2296  if (s->chroma_format == CHROMA_422 ||
2297  s->chroma_format == CHROMA_444)
2298  wrap_c <<= 1;
2299  }
2300  }
2301  }
2302 
2303  s->pdsp.get_pixels(s->block[0], ptr_y, wrap_y);
2304  s->pdsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
2305  s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset, wrap_y);
2306  s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2307 
2308  if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2309  skip_dct[4] = 1;
2310  skip_dct[5] = 1;
2311  } else {
2312  s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2313  s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2314  if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2315  s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2316  s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2317  } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2318  s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2319  s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2320  s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2321  s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2322  s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2323  s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2324  }
2325  }
2326  } else {
2327  op_pixels_func (*op_pix)[4];
2328  qpel_mc_func (*op_qpix)[16];
2329  uint8_t *dest_y, *dest_cb, *dest_cr;
2330 
2331  dest_y = s->dest[0];
2332  dest_cb = s->dest[1];
2333  dest_cr = s->dest[2];
2334 
2335  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2336  op_pix = s->hdsp.put_pixels_tab;
2337  op_qpix = s->qdsp.put_qpel_pixels_tab;
2338  } else {
2339  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2340  op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2341  }
2342 
2343  if (s->mv_dir & MV_DIR_FORWARD) {
2344  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2345  s->last_picture.f->data,
2346  op_pix, op_qpix);
2347  op_pix = s->hdsp.avg_pixels_tab;
2348  op_qpix = s->qdsp.avg_qpel_pixels_tab;
2349  }
2350  if (s->mv_dir & MV_DIR_BACKWARD) {
2351  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2352  s->next_picture.f->data,
2353  op_pix, op_qpix);
2354  }
2355 
2357  int progressive_score, interlaced_score;
2358 
2359  s->interlaced_dct = 0;
2360  progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2361  s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2362  ptr_y + wrap_y * 8,
2363  wrap_y, 8) - 400;
2364 
2365  if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2366  progressive_score -= 400;
2367 
2368  if (progressive_score > 0) {
2369  interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2370  wrap_y * 2, 8) +
2371  s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2372  ptr_y + wrap_y,
2373  wrap_y * 2, 8);
2374 
2375  if (progressive_score > interlaced_score) {
2376  s->interlaced_dct = 1;
2377 
2378  dct_offset = wrap_y;
2379  uv_dct_offset = wrap_c;
2380  wrap_y <<= 1;
2381  if (s->chroma_format == CHROMA_422)
2382  wrap_c <<= 1;
2383  }
2384  }
2385  }
2386 
2387  s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2388  s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2389  s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2390  dest_y + dct_offset, wrap_y);
2391  s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2392  dest_y + dct_offset + 8, wrap_y);
2393 
2394  if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2395  skip_dct[4] = 1;
2396  skip_dct[5] = 1;
2397  } else {
2398  s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2399  s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2400  if (!s->chroma_y_shift) { /* 422 */
2401  s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2402  dest_cb + uv_dct_offset, wrap_c);
2403  s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2404  dest_cr + uv_dct_offset, wrap_c);
2405  }
2406  }
2407  /* pre quantization */
2408  if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2409  2 * s->qscale * s->qscale) {
2410  // FIXME optimize
2411  if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2412  skip_dct[0] = 1;
2413  if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2414  skip_dct[1] = 1;
2415  if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2416  wrap_y, 8) < 20 * s->qscale)
2417  skip_dct[2] = 1;
2418  if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2419  wrap_y, 8) < 20 * s->qscale)
2420  skip_dct[3] = 1;
2421  if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2422  skip_dct[4] = 1;
2423  if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2424  skip_dct[5] = 1;
2425  if (!s->chroma_y_shift) { /* 422 */
2426  if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2427  dest_cb + uv_dct_offset,
2428  wrap_c, 8) < 20 * s->qscale)
2429  skip_dct[6] = 1;
2430  if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2431  dest_cr + uv_dct_offset,
2432  wrap_c, 8) < 20 * s->qscale)
2433  skip_dct[7] = 1;
2434  }
2435  }
2436  }
2437 
2438  if (s->quantizer_noise_shaping) {
2439  if (!skip_dct[0])
2440  get_visual_weight(weight[0], ptr_y , wrap_y);
2441  if (!skip_dct[1])
2442  get_visual_weight(weight[1], ptr_y + 8, wrap_y);
2443  if (!skip_dct[2])
2444  get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
2445  if (!skip_dct[3])
2446  get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2447  if (!skip_dct[4])
2448  get_visual_weight(weight[4], ptr_cb , wrap_c);
2449  if (!skip_dct[5])
2450  get_visual_weight(weight[5], ptr_cr , wrap_c);
2451  if (!s->chroma_y_shift) { /* 422 */
2452  if (!skip_dct[6])
2453  get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2454  wrap_c);
2455  if (!skip_dct[7])
2456  get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2457  wrap_c);
2458  }
2459  memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2460  }
2461 
2462  /* DCT & quantize */
2463  av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2464  {
2465  for (i = 0; i < mb_block_count; i++) {
2466  if (!skip_dct[i]) {
2467  int overflow;
2468  s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2469  // FIXME we could decide to change to quantizer instead of
2470  // clipping
2471  // JS: I don't think that would be a good idea it could lower
2472  // quality instead of improve it. Just INTRADC clipping
2473  // deserves changes in quantizer
2474  if (overflow)
2475  clip_coeffs(s, s->block[i], s->block_last_index[i]);
2476  } else
2477  s->block_last_index[i] = -1;
2478  }
2479  if (s->quantizer_noise_shaping) {
2480  for (i = 0; i < mb_block_count; i++) {
2481  if (!skip_dct[i]) {
2482  s->block_last_index[i] =
2483  dct_quantize_refine(s, s->block[i], weight[i],
2484  orig[i], i, s->qscale);
2485  }
2486  }
2487  }
2488 
2489  if (s->luma_elim_threshold && !s->mb_intra)
2490  for (i = 0; i < 4; i++)
2492  if (s->chroma_elim_threshold && !s->mb_intra)
2493  for (i = 4; i < mb_block_count; i++)
2495 
2496  if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2497  for (i = 0; i < mb_block_count; i++) {
2498  if (s->block_last_index[i] == -1)
2499  s->coded_score[i] = INT_MAX / 256;
2500  }
2501  }
2502  }
2503 
2504  if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2505  s->block_last_index[4] =
2506  s->block_last_index[5] = 0;
2507  s->block[4][0] =
2508  s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2509  if (!s->chroma_y_shift) { /* 422 / 444 */
2510  for (i=6; i<12; i++) {
2511  s->block_last_index[i] = 0;
2512  s->block[i][0] = s->block[4][0];
2513  }
2514  }
2515  }
2516 
2517  // non c quantize code returns incorrect block_last_index FIXME
2518  if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2519  for (i = 0; i < mb_block_count; i++) {
2520  int j;
2521  if (s->block_last_index[i] > 0) {
2522  for (j = 63; j > 0; j--) {
2523  if (s->block[i][s->intra_scantable.permutated[j]])
2524  break;
2525  }
2526  s->block_last_index[i] = j;
2527  }
2528  }
2529  }
2530 
2531  /* huffman encode */
2532  switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2535  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2536  ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2537  break;
2538  case AV_CODEC_ID_MPEG4:
2539  if (CONFIG_MPEG4_ENCODER)
2540  ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2541  break;
2542  case AV_CODEC_ID_MSMPEG4V2:
2543  case AV_CODEC_ID_MSMPEG4V3:
2544  case AV_CODEC_ID_WMV1:
2546  ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2547  break;
2548  case AV_CODEC_ID_WMV2:
2549  if (CONFIG_WMV2_ENCODER)
2550  ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2551  break;
2552  case AV_CODEC_ID_H261:
2553  if (CONFIG_H261_ENCODER)
2554  ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2555  break;
2556  case AV_CODEC_ID_H263:
2557  case AV_CODEC_ID_H263P:
2558  case AV_CODEC_ID_FLV1:
2559  case AV_CODEC_ID_RV10:
2560  case AV_CODEC_ID_RV20:
2561  if (CONFIG_H263_ENCODER)
2562  ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2563  break;
2564  case AV_CODEC_ID_MJPEG:
2565  case AV_CODEC_ID_AMV:
2566  if (CONFIG_MJPEG_ENCODER)
2567  ff_mjpeg_encode_mb(s, s->block);
2568  break;
2569  default:
2570  av_assert1(0);
2571  }
2572 }
2573 
2574 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2575 {
2576  if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
2577  else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2578  else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2579 }
2580 
2582  int i;
2583 
2584  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2585 
2586  /* MPEG-1 */
2587  d->mb_skip_run= s->mb_skip_run;
2588  for(i=0; i<3; i++)
2589  d->last_dc[i] = s->last_dc[i];
2590 
2591  /* statistics */
2592  d->mv_bits= s->mv_bits;
2593  d->i_tex_bits= s->i_tex_bits;
2594  d->p_tex_bits= s->p_tex_bits;
2595  d->i_count= s->i_count;
2596  d->f_count= s->f_count;
2597  d->b_count= s->b_count;
2598  d->skip_count= s->skip_count;
2599  d->misc_bits= s->misc_bits;
2600  d->last_bits= 0;
2601 
2602  d->mb_skipped= 0;
2603  d->qscale= s->qscale;
2604  d->dquant= s->dquant;
2605 
2607 }
2608 
2610  int i;
2611 
2612  memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2613  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2614 
2615  /* MPEG-1 */
2616  d->mb_skip_run= s->mb_skip_run;
2617  for(i=0; i<3; i++)
2618  d->last_dc[i] = s->last_dc[i];
2619 
2620  /* statistics */
2621  d->mv_bits= s->mv_bits;
2622  d->i_tex_bits= s->i_tex_bits;
2623  d->p_tex_bits= s->p_tex_bits;
2624  d->i_count= s->i_count;
2625  d->f_count= s->f_count;
2626  d->b_count= s->b_count;
2627  d->skip_count= s->skip_count;
2628  d->misc_bits= s->misc_bits;
2629 
2630  d->mb_intra= s->mb_intra;
2631  d->mb_skipped= s->mb_skipped;
2632  d->mv_type= s->mv_type;
2633  d->mv_dir= s->mv_dir;
2634  d->pb= s->pb;
2635  if(s->data_partitioning){
2636  d->pb2= s->pb2;
2637  d->tex_pb= s->tex_pb;
2638  }
2639  d->block= s->block;
2640  for(i=0; i<8; i++)
2641  d->block_last_index[i]= s->block_last_index[i];
2643  d->qscale= s->qscale;
2644 
2646 }
2647 
2648 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2650  int *dmin, int *next_block, int motion_x, int motion_y)
2651 {
2652  int score;
2653  uint8_t *dest_backup[3];
2654 
2655  copy_context_before_encode(s, backup, type);
2656 
2657  s->block= s->blocks[*next_block];
2658  s->pb= pb[*next_block];
2659  if(s->data_partitioning){
2660  s->pb2 = pb2 [*next_block];
2661  s->tex_pb= tex_pb[*next_block];
2662  }
2663 
2664  if(*next_block){
2665  memcpy(dest_backup, s->dest, sizeof(s->dest));
2666  s->dest[0] = s->sc.rd_scratchpad;
2667  s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2668  s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2669  av_assert0(s->linesize >= 32); //FIXME
2670  }
2671 
2672  encode_mb(s, motion_x, motion_y);
2673 
2674  score= put_bits_count(&s->pb);
2675  if(s->data_partitioning){
2676  score+= put_bits_count(&s->pb2);
2677  score+= put_bits_count(&s->tex_pb);
2678  }
2679 
2680  if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2682 
2683  score *= s->lambda2;
2684  score += sse_mb(s) << FF_LAMBDA_SHIFT;
2685  }
2686 
2687  if(*next_block){
2688  memcpy(s->dest, dest_backup, sizeof(s->dest));
2689  }
2690 
2691  if(score<*dmin){
2692  *dmin= score;
2693  *next_block^=1;
2694 
2695  copy_context_after_encode(best, s, type);
2696  }
2697 }
2698 
2699 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2700  const uint32_t *sq = ff_square_tab + 256;
2701  int acc=0;
2702  int x,y;
2703 
2704  if(w==16 && h==16)
2705  return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2706  else if(w==8 && h==8)
2707  return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2708 
2709  for(y=0; y<h; y++){
2710  for(x=0; x<w; x++){
2711  acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2712  }
2713  }
2714 
2715  av_assert2(acc>=0);
2716 
2717  return acc;
2718 }
2719 
2720 static int sse_mb(MpegEncContext *s){
2721  int w= 16;
2722  int h= 16;
2723 
2724  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2725  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2726 
2727  if(w==16 && h==16)
2728  if(s->avctx->mb_cmp == FF_CMP_NSSE){
2729  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) +
2730  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) +
2731  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);
2732  }else{
2733  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) +
2734  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) +
2735  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);
2736  }
2737  else
2738  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)
2739  +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)
2740  +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);
2741 }
2742 
2744  MpegEncContext *s= *(void**)arg;
2745 
2746 
2747  s->me.pre_pass=1;
2748  s->me.dia_size= s->avctx->pre_dia_size;
2749  s->first_slice_line=1;
2750  for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2751  for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2753  }
2754  s->first_slice_line=0;
2755  }
2756 
2757  s->me.pre_pass=0;
2758 
2759  return 0;
2760 }
2761 
2763  MpegEncContext *s= *(void**)arg;
2764 
2766 
2767  s->me.dia_size= s->avctx->dia_size;
2768  s->first_slice_line=1;
2769  for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2770  s->mb_x=0; //for block init below
2772  for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2773  s->block_index[0]+=2;
2774  s->block_index[1]+=2;
2775  s->block_index[2]+=2;
2776  s->block_index[3]+=2;
2777 
2778  /* compute motion vector & mb_type and store in context */
2781  else
2783  }
2784  s->first_slice_line=0;
2785  }
2786  return 0;
2787 }
2788 
2789 static int mb_var_thread(AVCodecContext *c, void *arg){
2790  MpegEncContext *s= *(void**)arg;
2791  int mb_x, mb_y;
2792 
2794 
2795  for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2796  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2797  int xx = mb_x * 16;
2798  int yy = mb_y * 16;
2799  uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2800  int varc;
2801  int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2802 
2803  varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2804  (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2805 
2806  s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2807  s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2808  s->me.mb_var_sum_temp += varc;
2809  }
2810  }
2811  return 0;
2812 }
2813 
2815  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2816  if(s->partitioned_frame){
2818  }
2819 
2820  ff_mpeg4_stuffing(&s->pb);
2821  }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2823  }
2824 
2826  flush_put_bits(&s->pb);
2827 
2828  if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2829  s->misc_bits+= get_bits_diff(s);
2830 }
2831 
2833 {
2834  uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2835  int offset = put_bits_count(&s->pb);
2836  int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2837  int gobn = s->mb_y / s->gob_index;
2838  int pred_x, pred_y;
2839  if (CONFIG_H263_ENCODER)
2840  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2841  bytestream_put_le32(&ptr, offset);
2842  bytestream_put_byte(&ptr, s->qscale);
2843  bytestream_put_byte(&ptr, gobn);
2844  bytestream_put_le16(&ptr, mba);
2845  bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2846  bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2847  /* 4MV not implemented */
2848  bytestream_put_byte(&ptr, 0); /* hmv2 */
2849  bytestream_put_byte(&ptr, 0); /* vmv2 */
2850 }
2851 
2852 static void update_mb_info(MpegEncContext *s, int startcode)
2853 {
2854  if (!s->mb_info)
2855  return;
2856  if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2857  s->mb_info_size += 12;
2858  s->prev_mb_info = s->last_mb_info;
2859  }
2860  if (startcode) {
2861  s->prev_mb_info = put_bits_count(&s->pb)/8;
2862  /* This might have incremented mb_info_size above, and we return without
2863  * actually writing any info into that slot yet. But in that case,
2864  * this will be called again at the start of the after writing the
2865  * start code, actually writing the mb info. */
2866  return;
2867  }
2868 
2869  s->last_mb_info = put_bits_count(&s->pb)/8;
2870  if (!s->mb_info_size)
2871  s->mb_info_size += 12;
2872  write_mb_info(s);
2873 }
2874 
2875 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2876 {
2877  if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2878  && s->slice_context_count == 1
2879  && s->pb.buf == s->avctx->internal->byte_buffer) {
2880  int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2881  int vbv_pos = s->vbv_delay_ptr - s->pb.buf;
2882 
2883  uint8_t *new_buffer = NULL;
2884  int new_buffer_size = 0;
2885 
2886  if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2887  av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2888  return AVERROR(ENOMEM);
2889  }
2890 
2891  emms_c();
2892 
2893  av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2894  s->avctx->internal->byte_buffer_size + size_increase);
2895  if (!new_buffer)
2896  return AVERROR(ENOMEM);
2897 
2898  memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2900  s->avctx->internal->byte_buffer = new_buffer;
2901  s->avctx->internal->byte_buffer_size = new_buffer_size;
2902  rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2903  s->ptr_lastgob = s->pb.buf + lastgob_pos;
2904  s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2905  }
2906  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2907  return AVERROR(EINVAL);
2908  return 0;
2909 }
2910 
2911 static int encode_thread(AVCodecContext *c, void *arg){
2912  MpegEncContext *s= *(void**)arg;
2913  int mb_x, mb_y;
2914  int chr_h= 16>>s->chroma_y_shift;
2915  int i, j;
2916  MpegEncContext best_s = { 0 }, backup_s;
2917  uint8_t bit_buf[2][MAX_MB_BYTES];
2918  uint8_t bit_buf2[2][MAX_MB_BYTES];
2919  uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2920  PutBitContext pb[2], pb2[2], tex_pb[2];
2921 
2923 
2924  for(i=0; i<2; i++){
2925  init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2926  init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2927  init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2928  }
2929 
2930  s->last_bits= put_bits_count(&s->pb);
2931  s->mv_bits=0;
2932  s->misc_bits=0;
2933  s->i_tex_bits=0;
2934  s->p_tex_bits=0;
2935  s->i_count=0;
2936  s->f_count=0;
2937  s->b_count=0;
2938  s->skip_count=0;
2939 
2940  for(i=0; i<3; i++){
2941  /* init last dc values */
2942  /* note: quant matrix value (8) is implied here */
2943  s->last_dc[i] = 128 << s->intra_dc_precision;
2944 
2945  s->current_picture.encoding_error[i] = 0;
2946  }
2947  if(s->codec_id==AV_CODEC_ID_AMV){
2948  s->last_dc[0] = 128*8/13;
2949  s->last_dc[1] = 128*8/14;
2950  s->last_dc[2] = 128*8/14;
2951  }
2952  s->mb_skip_run = 0;
2953  memset(s->last_mv, 0, sizeof(s->last_mv));
2954 
2955  s->last_mv_dir = 0;
2956 
2957  switch(s->codec_id){
2958  case AV_CODEC_ID_H263:
2959  case AV_CODEC_ID_H263P:
2960  case AV_CODEC_ID_FLV1:
2961  if (CONFIG_H263_ENCODER)
2962  s->gob_index = H263_GOB_HEIGHT(s->height);
2963  break;
2964  case AV_CODEC_ID_MPEG4:
2965  if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2967  break;
2968  }
2969 
2970  s->resync_mb_x=0;
2971  s->resync_mb_y=0;
2972  s->first_slice_line = 1;
2973  s->ptr_lastgob = s->pb.buf;
2974  for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2975  s->mb_x=0;
2976  s->mb_y= mb_y;
2977 
2978  ff_set_qscale(s, s->qscale);
2980 
2981  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2982  int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2983  int mb_type= s->mb_type[xy];
2984 // int d;
2985  int dmin= INT_MAX;
2986  int dir;
2987  int size_increase = s->avctx->internal->byte_buffer_size/4
2988  + s->mb_width*MAX_MB_BYTES;
2989 
2990  ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
2991  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2992  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2993  return -1;
2994  }
2995  if(s->data_partitioning){
2996  if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2997  || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2998  av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2999  return -1;
3000  }
3001  }
3002 
3003  s->mb_x = mb_x;
3004  s->mb_y = mb_y; // moved into loop, can get changed by H.261
3006 
3007  if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3009  xy= s->mb_y*s->mb_stride + s->mb_x;
3010  mb_type= s->mb_type[xy];
3011  }
3012 
3013  /* write gob / video packet header */
3014  if(s->rtp_mode){
3015  int current_packet_size, is_gob_start;
3016 
3017  current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3018 
3019  is_gob_start = s->rtp_payload_size &&
3020  current_packet_size >= s->rtp_payload_size &&
3021  mb_y + mb_x > 0;
3022 
3023  if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3024 
3025  switch(s->codec_id){
3026  case AV_CODEC_ID_H263:
3027  case AV_CODEC_ID_H263P:
3028  if(!s->h263_slice_structured)
3029  if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3030  break;
3032  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3034  if(s->mb_skip_run) is_gob_start=0;
3035  break;
3036  case AV_CODEC_ID_MJPEG:
3037  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3038  break;
3039  }
3040 
3041  if(is_gob_start){
3042  if(s->start_mb_y != mb_y || mb_x!=0){
3043  write_slice_end(s);
3044 
3045  if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3047  }
3048  }
3049 
3050  av_assert2((put_bits_count(&s->pb)&7) == 0);
3051  current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3052 
3053  if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3054  int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3055  int d = 100 / s->error_rate;
3056  if(r % d == 0){
3057  current_packet_size=0;
3058  s->pb.buf_ptr= s->ptr_lastgob;
3059  assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3060  }
3061  }
3062 
3063 #if FF_API_RTP_CALLBACK
3065  if (s->avctx->rtp_callback){
3066  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3067  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3068  }
3070 #endif
3071  update_mb_info(s, 1);
3072 
3073  switch(s->codec_id){
3074  case AV_CODEC_ID_MPEG4:
3075  if (CONFIG_MPEG4_ENCODER) {
3078  }
3079  break;
3082  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3085  }
3086  break;
3087  case AV_CODEC_ID_H263:
3088  case AV_CODEC_ID_H263P:
3089  if (CONFIG_H263_ENCODER)
3090  ff_h263_encode_gob_header(s, mb_y);
3091  break;
3092  }
3093 
3094  if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3095  int bits= put_bits_count(&s->pb);
3096  s->misc_bits+= bits - s->last_bits;
3097  s->last_bits= bits;
3098  }
3099 
3100  s->ptr_lastgob += current_packet_size;
3101  s->first_slice_line=1;
3102  s->resync_mb_x=mb_x;
3103  s->resync_mb_y=mb_y;
3104  }
3105  }
3106 
3107  if( (s->resync_mb_x == s->mb_x)
3108  && s->resync_mb_y+1 == s->mb_y){
3109  s->first_slice_line=0;
3110  }
3111 
3112  s->mb_skipped=0;
3113  s->dquant=0; //only for QP_RD
3114 
3115  update_mb_info(s, 0);
3116 
3117  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
3118  int next_block=0;
3119  int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3120 
3121  copy_context_before_encode(&backup_s, s, -1);
3122  backup_s.pb= s->pb;
3125  if(s->data_partitioning){
3126  backup_s.pb2= s->pb2;
3127  backup_s.tex_pb= s->tex_pb;
3128  }
3129 
3130  if(mb_type&CANDIDATE_MB_TYPE_INTER){
3131  s->mv_dir = MV_DIR_FORWARD;
3132  s->mv_type = MV_TYPE_16X16;
3133  s->mb_intra= 0;
3134  s->mv[0][0][0] = s->p_mv_table[xy][0];
3135  s->mv[0][0][1] = s->p_mv_table[xy][1];
3136  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3137  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3138  }
3139  if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3140  s->mv_dir = MV_DIR_FORWARD;
3141  s->mv_type = MV_TYPE_FIELD;
3142  s->mb_intra= 0;
3143  for(i=0; i<2; i++){
3144  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3145  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3146  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3147  }
3148  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3149  &dmin, &next_block, 0, 0);
3150  }
3151  if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3152  s->mv_dir = MV_DIR_FORWARD;
3153  s->mv_type = MV_TYPE_16X16;
3154  s->mb_intra= 0;
3155  s->mv[0][0][0] = 0;
3156  s->mv[0][0][1] = 0;
3157  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3158  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3159  }
3160  if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3161  s->mv_dir = MV_DIR_FORWARD;
3162  s->mv_type = MV_TYPE_8X8;
3163  s->mb_intra= 0;
3164  for(i=0; i<4; i++){
3165  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3166  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3167  }
3168  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3169  &dmin, &next_block, 0, 0);
3170  }
3171  if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3172  s->mv_dir = MV_DIR_FORWARD;
3173  s->mv_type = MV_TYPE_16X16;
3174  s->mb_intra= 0;
3175  s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3176  s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3177  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3178  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3179  }
3180  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3181  s->mv_dir = MV_DIR_BACKWARD;
3182  s->mv_type = MV_TYPE_16X16;
3183  s->mb_intra= 0;
3184  s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3185  s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3186  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3187  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3188  }
3189  if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3191  s->mv_type = MV_TYPE_16X16;
3192  s->mb_intra= 0;
3193  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3194  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3195  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3196  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3197  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3198  &dmin, &next_block, 0, 0);
3199  }
3200  if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3201  s->mv_dir = MV_DIR_FORWARD;
3202  s->mv_type = MV_TYPE_FIELD;
3203  s->mb_intra= 0;
3204  for(i=0; i<2; i++){
3205  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3206  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3207  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3208  }
3209  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3210  &dmin, &next_block, 0, 0);
3211  }
3212  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3213  s->mv_dir = MV_DIR_BACKWARD;
3214  s->mv_type = MV_TYPE_FIELD;
3215  s->mb_intra= 0;
3216  for(i=0; i<2; i++){
3217  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3218  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3219  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3220  }
3221  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3222  &dmin, &next_block, 0, 0);
3223  }
3224  if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3226  s->mv_type = MV_TYPE_FIELD;
3227  s->mb_intra= 0;
3228  for(dir=0; dir<2; dir++){
3229  for(i=0; i<2; i++){
3230  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3231  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3232  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3233  }
3234  }
3235  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3236  &dmin, &next_block, 0, 0);
3237  }
3238  if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3239  s->mv_dir = 0;
3240  s->mv_type = MV_TYPE_16X16;
3241  s->mb_intra= 1;
3242  s->mv[0][0][0] = 0;
3243  s->mv[0][0][1] = 0;
3244  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3245  &dmin, &next_block, 0, 0);
3246  if(s->h263_pred || s->h263_aic){
3247  if(best_s.mb_intra)
3248  s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3249  else
3250  ff_clean_intra_table_entries(s); //old mode?
3251  }
3252  }
3253 
3254  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3255  if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3256  const int last_qp= backup_s.qscale;
3257  int qpi, qp, dc[6];
3258  int16_t ac[6][16];
3259  const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3260  static const int dquant_tab[4]={-1,1,-2,2};
3261  int storecoefs = s->mb_intra && s->dc_val[0];
3262 
3263  av_assert2(backup_s.dquant == 0);
3264 
3265  //FIXME intra
3266  s->mv_dir= best_s.mv_dir;
3267  s->mv_type = MV_TYPE_16X16;
3268  s->mb_intra= best_s.mb_intra;
3269  s->mv[0][0][0] = best_s.mv[0][0][0];
3270  s->mv[0][0][1] = best_s.mv[0][0][1];
3271  s->mv[1][0][0] = best_s.mv[1][0][0];
3272  s->mv[1][0][1] = best_s.mv[1][0][1];
3273 
3274  qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3275  for(; qpi<4; qpi++){
3276  int dquant= dquant_tab[qpi];
3277  qp= last_qp + dquant;
3278  if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3279  continue;
3280  backup_s.dquant= dquant;
3281  if(storecoefs){
3282  for(i=0; i<6; i++){
3283  dc[i]= s->dc_val[0][ s->block_index[i] ];
3284  memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3285  }
3286  }
3287 
3288  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3289  &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3290  if(best_s.qscale != qp){
3291  if(storecoefs){
3292  for(i=0; i<6; i++){
3293  s->dc_val[0][ s->block_index[i] ]= dc[i];
3294  memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3295  }
3296  }
3297  }
3298  }
3299  }
3300  }
3301  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3302  int mx= s->b_direct_mv_table[xy][0];
3303  int my= s->b_direct_mv_table[xy][1];
3304 
3305  backup_s.dquant = 0;
3307  s->mb_intra= 0;
3308  ff_mpeg4_set_direct_mv(s, mx, my);
3309  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3310  &dmin, &next_block, mx, my);
3311  }
3312  if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3313  backup_s.dquant = 0;
3315  s->mb_intra= 0;
3316  ff_mpeg4_set_direct_mv(s, 0, 0);
3317  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3318  &dmin, &next_block, 0, 0);
3319  }
3320  if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3321  int coded=0;
3322  for(i=0; i<6; i++)
3323  coded |= s->block_last_index[i];
3324  if(coded){
3325  int mx,my;
3326  memcpy(s->mv, best_s.mv, sizeof(s->mv));
3327  if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3328  mx=my=0; //FIXME find the one we actually used
3329  ff_mpeg4_set_direct_mv(s, mx, my);
3330  }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3331  mx= s->mv[1][0][0];
3332  my= s->mv[1][0][1];
3333  }else{
3334  mx= s->mv[0][0][0];
3335  my= s->mv[0][0][1];
3336  }
3337 
3338  s->mv_dir= best_s.mv_dir;
3339  s->mv_type = best_s.mv_type;
3340  s->mb_intra= 0;
3341 /* s->mv[0][0][0] = best_s.mv[0][0][0];
3342  s->mv[0][0][1] = best_s.mv[0][0][1];
3343  s->mv[1][0][0] = best_s.mv[1][0][0];
3344  s->mv[1][0][1] = best_s.mv[1][0][1];*/
3345  backup_s.dquant= 0;
3346  s->skipdct=1;
3347  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3348  &dmin, &next_block, mx, my);
3349  s->skipdct=0;
3350  }
3351  }
3352 
3353  s->current_picture.qscale_table[xy] = best_s.qscale;
3354 
3355  copy_context_after_encode(s, &best_s, -1);
3356 
3357  pb_bits_count= put_bits_count(&s->pb);
3358  flush_put_bits(&s->pb);
3359  avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3360  s->pb= backup_s.pb;
3361 
3362  if(s->data_partitioning){
3363  pb2_bits_count= put_bits_count(&s->pb2);
3364  flush_put_bits(&s->pb2);
3365  avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3366  s->pb2= backup_s.pb2;
3367 
3368  tex_pb_bits_count= put_bits_count(&s->tex_pb);
3369  flush_put_bits(&s->tex_pb);
3370  avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3371  s->tex_pb= backup_s.tex_pb;
3372  }
3373  s->last_bits= put_bits_count(&s->pb);
3374 
3375  if (CONFIG_H263_ENCODER &&
3378 
3379  if(next_block==0){ //FIXME 16 vs linesize16
3380  s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad , s->linesize ,16);
3381  s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
3382  s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3383  }
3384 
3387  } else {
3388  int motion_x = 0, motion_y = 0;
3390  // only one MB-Type possible
3391 
3392  switch(mb_type){
3394  s->mv_dir = 0;
3395  s->mb_intra= 1;
3396  motion_x= s->mv[0][0][0] = 0;
3397  motion_y= s->mv[0][0][1] = 0;
3398  break;
3400  s->mv_dir = MV_DIR_FORWARD;
3401  s->mb_intra= 0;
3402  motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3403  motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3404  break;
3406  s->mv_dir = MV_DIR_FORWARD;
3407  s->mv_type = MV_TYPE_FIELD;
3408  s->mb_intra= 0;
3409  for(i=0; i<2; i++){
3410  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3411  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3412  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3413  }
3414  break;
3416  s->mv_dir = MV_DIR_FORWARD;
3417  s->mv_type = MV_TYPE_8X8;
3418  s->mb_intra= 0;
3419  for(i=0; i<4; i++){
3420  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3421  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3422  }
3423  break;
3425  if (CONFIG_MPEG4_ENCODER) {
3427  s->mb_intra= 0;
3428  motion_x=s->b_direct_mv_table[xy][0];
3429  motion_y=s->b_direct_mv_table[xy][1];
3430  ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3431  }
3432  break;
3434  if (CONFIG_MPEG4_ENCODER) {
3436  s->mb_intra= 0;
3437  ff_mpeg4_set_direct_mv(s, 0, 0);
3438  }
3439  break;
3442  s->mb_intra= 0;
3443  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3444  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3445  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3446  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3447  break;
3449  s->mv_dir = MV_DIR_BACKWARD;
3450  s->mb_intra= 0;
3451  motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3452  motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3453  break;
3455  s->mv_dir = MV_DIR_FORWARD;
3456  s->mb_intra= 0;
3457  motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3458  motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3459  break;
3461  s->mv_dir = MV_DIR_FORWARD;
3462  s->mv_type = MV_TYPE_FIELD;
3463  s->mb_intra= 0;
3464  for(i=0; i<2; i++){
3465  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3466  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3467  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3468  }
3469  break;
3471  s->mv_dir = MV_DIR_BACKWARD;
3472  s->mv_type = MV_TYPE_FIELD;
3473  s->mb_intra= 0;
3474  for(i=0; i<2; i++){
3475  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3476  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3477  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3478  }
3479  break;
3482  s->mv_type = MV_TYPE_FIELD;
3483  s->mb_intra= 0;
3484  for(dir=0; dir<2; dir++){
3485  for(i=0; i<2; i++){
3486  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3487  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3488  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3489  }
3490  }
3491  break;
3492  default:
3493  av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3494  }
3495 
3496  encode_mb(s, motion_x, motion_y);
3497 
3498  // RAL: Update last macroblock type
3499  s->last_mv_dir = s->mv_dir;
3500 
3501  if (CONFIG_H263_ENCODER &&
3504 
3506  }
3507 
3508  /* clean the MV table in IPS frames for direct mode in B-frames */
3509  if(s->mb_intra /* && I,P,S_TYPE */){
3510  s->p_mv_table[xy][0]=0;
3511  s->p_mv_table[xy][1]=0;
3512  }
3513 
3514  if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3515  int w= 16;
3516  int h= 16;
3517 
3518  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3519  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3520 
3522  s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3523  s->dest[0], w, h, s->linesize);
3525  s, s->new_picture.f->data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3526  s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3528  s, s->new_picture.f->data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
3529  s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3530  }
3531  if(s->loop_filter){
3532  if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3534  }
3535  ff_dlog(s->avctx, "MB %d %d bits\n",
3536  s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3537  }
3538  }
3539 
3540  //not beautiful here but we must write it before flushing so it has to be here
3543 
3544  write_slice_end(s);
3545 
3546 #if FF_API_RTP_CALLBACK
3548  /* Send the last GOB if RTP */
3549  if (s->avctx->rtp_callback) {
3550  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3551  int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3552  /* Call the RTP callback to send the last GOB */
3553  emms_c();
3554  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3555  }
3557 #endif
3558 
3559  return 0;
3560 }
3561 
3562 #define MERGE(field) dst->field += src->field; src->field=0
3564  MERGE(me.scene_change_score);
3565  MERGE(me.mc_mb_var_sum_temp);
3566  MERGE(me.mb_var_sum_temp);
3567 }
3568 
3570  int i;
3571 
3572  MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3573  MERGE(dct_count[1]);
3574  MERGE(mv_bits);
3575  MERGE(i_tex_bits);
3576  MERGE(p_tex_bits);
3577  MERGE(i_count);
3578  MERGE(f_count);
3579  MERGE(b_count);
3580  MERGE(skip_count);
3581  MERGE(misc_bits);
3582  MERGE(er.error_count);
3587 
3588  if (dst->noise_reduction){
3589  for(i=0; i<64; i++){
3590  MERGE(dct_error_sum[0][i]);
3591  MERGE(dct_error_sum[1][i]);
3592  }
3593  }
3594 
3595  assert(put_bits_count(&src->pb) % 8 ==0);
3596  assert(put_bits_count(&dst->pb) % 8 ==0);
3597  avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3598  flush_put_bits(&dst->pb);
3599 }
3600 
3601 static int estimate_qp(MpegEncContext *s, int dry_run){
3602  if (s->next_lambda){
3605  if(!dry_run) s->next_lambda= 0;
3606  } else if (!s->fixed_qscale) {
3607  int quality = ff_rate_estimate_qscale(s, dry_run);
3609  s->current_picture.f->quality = quality;
3610  if (s->current_picture.f->quality < 0)
3611  return -1;
3612  }
3613 
3614  if(s->adaptive_quant){
3615  switch(s->codec_id){
3616  case AV_CODEC_ID_MPEG4:
3617  if (CONFIG_MPEG4_ENCODER)
3619  break;
3620  case AV_CODEC_ID_H263:
3621  case AV_CODEC_ID_H263P:
3622  case AV_CODEC_ID_FLV1:
3623  if (CONFIG_H263_ENCODER)
3625  break;
3626  default:
3627  ff_init_qscale_tab(s);
3628  }
3629 
3630  s->lambda= s->lambda_table[0];
3631  //FIXME broken
3632  }else
3633  s->lambda = s->current_picture.f->quality;
3634  update_qscale(s);
3635  return 0;
3636 }
3637 
3638 /* must be called before writing the header */
3641  s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3642 
3643  if(s->pict_type==AV_PICTURE_TYPE_B){
3644  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3645  assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3646  }else{
3647  s->pp_time= s->time - s->last_non_b_time;
3648  s->last_non_b_time= s->time;
3649  assert(s->picture_number==0 || s->pp_time > 0);
3650  }
3651 }
3652 
3654 {
3655  int i, ret;
3656  int bits;
3657  int context_count = s->slice_context_count;
3658 
3660 
3661  /* Reset the average MB variance */
3662  s->me.mb_var_sum_temp =
3663  s->me.mc_mb_var_sum_temp = 0;
3664 
3665  /* we need to initialize some time vars before we can encode B-frames */
3666  // RAL: Condition added for MPEG1VIDEO
3669  if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3670  ff_set_mpeg4_time(s);
3671 
3672  s->me.scene_change_score=0;
3673 
3674 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3675 
3676  if(s->pict_type==AV_PICTURE_TYPE_I){
3677  if(s->msmpeg4_version >= 3) s->no_rounding=1;
3678  else s->no_rounding=0;
3679  }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3681  s->no_rounding ^= 1;
3682  }
3683 
3684  if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3685  if (estimate_qp(s,1) < 0)
3686  return -1;
3687  ff_get_2pass_fcode(s);
3688  } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3690  s->lambda= s->last_lambda_for[s->pict_type];
3691  else
3693  update_qscale(s);
3694  }
3695 
3701  }
3702 
3703  s->mb_intra=0; //for the rate distortion & bit compare functions
3704  for(i=1; i<context_count; i++){
3706  if (ret < 0)
3707  return ret;
3708  }
3709 
3710  if(ff_init_me(s)<0)
3711  return -1;
3712 
3713  /* Estimate motion for every MB */
3714  if(s->pict_type != AV_PICTURE_TYPE_I){
3715  s->lambda = (s->lambda * s->me_penalty_compensation + 128) >> 8;
3716  s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3717  if (s->pict_type != AV_PICTURE_TYPE_B) {
3718  if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3719  s->me_pre == 2) {
3720  s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3721  }
3722  }
3723 
3724  s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3725  }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3726  /* I-Frame */
3727  for(i=0; i<s->mb_stride*s->mb_height; i++)
3729 
3730  if(!s->fixed_qscale){
3731  /* finding spatial complexity for I-frame rate control */
3732  s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3733  }
3734  }
3735  for(i=1; i<context_count; i++){
3737  }
3739  s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3740  emms_c();
3741 
3743  s->pict_type == AV_PICTURE_TYPE_P) {
3745  for(i=0; i<s->mb_stride*s->mb_height; i++)
3747  if(s->msmpeg4_version >= 3)
3748  s->no_rounding=1;
3749  ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3751  }
3752 
3753  if(!s->umvplus){
3756 
3758  int a,b;
3759  a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3761  s->f_code= FFMAX3(s->f_code, a, b);
3762  }
3763 
3764  ff_fix_long_p_mvs(s);
3767  int j;
3768  for(i=0; i<2; i++){
3769  for(j=0; j<2; j++)
3772  }
3773  }
3774  }
3775 
3776  if(s->pict_type==AV_PICTURE_TYPE_B){
3777  int a, b;
3778 
3781  s->f_code = FFMAX(a, b);
3782 
3785  s->b_code = FFMAX(a, b);
3786 
3792  int dir, j;
3793  for(dir=0; dir<2; dir++){
3794  for(i=0; i<2; i++){
3795  for(j=0; j<2; j++){
3798  ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3799  s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3800  }
3801  }
3802  }
3803  }
3804  }
3805  }
3806 
3807  if (estimate_qp(s, 0) < 0)
3808  return -1;
3809 
3810  if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3811  s->pict_type == AV_PICTURE_TYPE_I &&
3812  !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3813  s->qscale= 3; //reduce clipping problems
3814 
3815  if (s->out_format == FMT_MJPEG) {
3816  const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
3817  const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3818 
3819  if (s->avctx->intra_matrix) {
3820  chroma_matrix =
3821  luma_matrix = s->avctx->intra_matrix;
3822  }
3823  if (s->avctx->chroma_intra_matrix)
3824  chroma_matrix = s->avctx->chroma_intra_matrix;
3825 
3826  /* for mjpeg, we do include qscale in the matrix */
3827  for(i=1;i<64;i++){
3828  int j = s->idsp.idct_permutation[i];
3829 
3830  s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3831  s-> intra_matrix[j] = av_clip_uint8(( luma_matrix[i] * s->qscale) >> 3);
3832  }
3833  s->y_dc_scale_table=
3835  s->chroma_intra_matrix[0] =
3838  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3840  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3841  s->qscale= 8;
3842  }
3843  if(s->codec_id == AV_CODEC_ID_AMV){
3844  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};
3845  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};
3846  for(i=1;i<64;i++){
3847  int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3848 
3849  s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3850  s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3851  }
3852  s->y_dc_scale_table= y;
3853  s->c_dc_scale_table= c;
3854  s->intra_matrix[0] = 13;
3855  s->chroma_intra_matrix[0] = 14;
3857  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3859  s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3860  s->qscale= 8;
3861  }
3862 
3863  //FIXME var duplication
3865  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3868 
3869  if (s->current_picture.f->key_frame)
3870  s->picture_in_gop_number=0;
3871 
3872  s->mb_x = s->mb_y = 0;
3873  s->last_bits= put_bits_count(&s->pb);
3874  switch(s->out_format) {
3875  case FMT_MJPEG:
3876  if (CONFIG_MJPEG_ENCODER && s->huffman != HUFFMAN_TABLE_OPTIMAL)
3879  break;
3880  case FMT_H261:
3881  if (CONFIG_H261_ENCODER)
3882  ff_h261_encode_picture_header(s, picture_number);
3883  break;
3884  case FMT_H263:
3885  if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3886  ff_wmv2_encode_picture_header(s, picture_number);
3887  else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3888  ff_msmpeg4_encode_picture_header(s, picture_number);
3889  else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3890  ret = ff_mpeg4_encode_picture_header(s, picture_number);
3891  if (ret < 0)
3892  return ret;
3893  } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3894  ret = ff_rv10_encode_picture_header(s, picture_number);
3895  if (ret < 0)
3896  return ret;
3897  }
3898  else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3899  ff_rv20_encode_picture_header(s, picture_number);
3900  else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3901  ff_flv_encode_picture_header(s, picture_number);
3902  else if (CONFIG_H263_ENCODER)
3903  ff_h263_encode_picture_header(s, picture_number);
3904  break;
3905  case FMT_MPEG1:
3906  if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3907  ff_mpeg1_encode_picture_header(s, picture_number);
3908  break;
3909  default:
3910  av_assert0(0);
3911  }
3912  bits= put_bits_count(&s->pb);
3913  s->header_bits= bits - s->last_bits;
3914 
3915  for(i=1; i<context_count; i++){
3917  }
3918  s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3919  for(i=1; i<context_count; i++){
3920  if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3921  set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
3923  }
3924  emms_c();
3925  return 0;
3926 }
3927 
3928 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3929  const int intra= s->mb_intra;
3930  int i;
3931 
3932  s->dct_count[intra]++;
3933 
3934  for(i=0; i<64; i++){
3935  int level= block[i];
3936 
3937  if(level){
3938  if(level>0){
3939  s->dct_error_sum[intra][i] += level;
3940  level -= s->dct_offset[intra][i];
3941  if(level<0) level=0;
3942  }else{
3943  s->dct_error_sum[intra][i] -= level;
3944  level += s->dct_offset[intra][i];
3945  if(level>0) level=0;
3946  }
3947  block[i]= level;
3948  }
3949  }
3950 }
3951 
3953  int16_t *block, int n,
3954  int qscale, int *overflow){
3955  const int *qmat;
3956  const uint16_t *matrix;
3957  const uint8_t *scantable;
3958  const uint8_t *perm_scantable;
3959  int max=0;
3960  unsigned int threshold1, threshold2;
3961  int bias=0;
3962  int run_tab[65];
3963  int level_tab[65];
3964  int score_tab[65];
3965  int survivor[65];
3966  int survivor_count;
3967  int last_run=0;
3968  int last_level=0;
3969  int last_score= 0;
3970  int last_i;
3971  int coeff[2][64];
3972  int coeff_count[64];
3973  int qmul, qadd, start_i, last_non_zero, i, dc;
3974  const int esc_length= s->ac_esc_length;
3975  uint8_t * length;
3976  uint8_t * last_length;
3977  const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3978  int mpeg2_qscale;
3979 
3980  s->fdsp.fdct(block);
3981 
3982  if(s->dct_error_sum)
3983  s->denoise_dct(s, block);
3984  qmul= qscale*16;
3985  qadd= ((qscale-1)|1)*8;
3986 
3987  if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
3988  else mpeg2_qscale = qscale << 1;
3989 
3990  if (s->mb_intra) {
3991  int q;
3992  scantable= s->intra_scantable.scantable;
3993  perm_scantable= s->intra_scantable.permutated;
3994  if (!s->h263_aic) {
3995  if (n < 4)
3996  q = s->y_dc_scale;
3997  else
3998  q = s->c_dc_scale;
3999  q = q << 3;
4000  } else{
4001  /* For AIC we skip quant/dequant of INTRADC */
4002  q = 1 << 3;
4003  qadd=0;
4004  }
4005 
4006  /* note: block[0] is assumed to be positive */
4007  block[0] = (block[0] + (q >> 1)) / q;
4008  start_i = 1;
4009  last_non_zero = 0;
4010  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4011  matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4012  if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4013  bias= 1<<(QMAT_SHIFT-1);
4014 
4015  if (n > 3 && s->intra_chroma_ac_vlc_length) {
4016  length = s->intra_chroma_ac_vlc_length;
4017  last_length= s->intra_chroma_ac_vlc_last_length;
4018  } else {
4019  length = s->intra_ac_vlc_length;
4020  last_length= s->intra_ac_vlc_last_length;
4021  }
4022  } else {
4023  scantable= s->inter_scantable.scantable;
4024  perm_scantable= s->inter_scantable.permutated;
4025  start_i = 0;
4026  last_non_zero = -1;
4027  qmat = s->q_inter_matrix[qscale];
4028  matrix = s->inter_matrix;
4029  length = s->inter_ac_vlc_length;
4030  last_length= s->inter_ac_vlc_last_length;
4031  }
4032  last_i= start_i;
4033 
4034  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4035  threshold2= (threshold1<<1);
4036 
4037  for(i=63; i>=start_i; i--) {
4038  const int j = scantable[i];
4039  int level = block[j] * qmat[j];
4040 
4041  if(((unsigned)(level+threshold1))>threshold2){
4042  last_non_zero = i;
4043  break;
4044  }
4045  }
4046 
4047  for(i=start_i; i<=last_non_zero; i++) {
4048  const int j = scantable[i];
4049  int level = block[j] * qmat[j];
4050 
4051 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4052 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4053  if(((unsigned)(level+threshold1))>threshold2){
4054  if(level>0){
4055  level= (bias + level)>>QMAT_SHIFT;
4056  coeff[0][i]= level;
4057  coeff[1][i]= level-1;
4058 // coeff[2][k]= level-2;
4059  }else{
4060  level= (bias - level)>>QMAT_SHIFT;
4061  coeff[0][i]= -level;
4062  coeff[1][i]= -level+1;
4063 // coeff[2][k]= -level+2;
4064  }
4065  coeff_count[i]= FFMIN(level, 2);
4066  av_assert2(coeff_count[i]);
4067  max |=level;
4068  }else{
4069  coeff[0][i]= (level>>31)|1;
4070  coeff_count[i]= 1;
4071  }
4072  }
4073 
4074  *overflow= s->max_qcoeff < max; //overflow might have happened
4075 
4076  if(last_non_zero < start_i){
4077  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4078  return last_non_zero;
4079  }
4080 
4081  score_tab[start_i]= 0;
4082  survivor[0]= start_i;
4083  survivor_count= 1;
4084 
4085  for(i=start_i; i<=last_non_zero; i++){
4086  int level_index, j, zero_distortion;
4087  int dct_coeff= FFABS(block[ scantable[i] ]);
4088  int best_score=256*256*256*120;
4089 
4090  if (s->fdsp.fdct == ff_fdct_ifast)
4091  dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4092  zero_distortion= dct_coeff*dct_coeff;
4093 
4094  for(level_index=0; level_index < coeff_count[i]; level_index++){
4095  int distortion;
4096  int level= coeff[level_index][i];
4097  const int alevel= FFABS(level);
4098  int unquant_coeff;
4099 
4100  av_assert2(level);
4101 
4102  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4103  unquant_coeff= alevel*qmul + qadd;
4104  } else if(s->out_format == FMT_MJPEG) {
4105  j = s->idsp.idct_permutation[scantable[i]];
4106  unquant_coeff = alevel * matrix[j] * 8;
4107  }else{ // MPEG-1
4108  j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4109  if(s->mb_intra){
4110  unquant_coeff = (int)( alevel * mpeg2_qscale * matrix[j]) >> 4;
4111  unquant_coeff = (unquant_coeff - 1) | 1;
4112  }else{
4113  unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4114  unquant_coeff = (unquant_coeff - 1) | 1;
4115  }
4116  unquant_coeff<<= 3;
4117  }
4118 
4119  distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4120  level+=64;
4121  if((level&(~127)) == 0){
4122  for(j=survivor_count-1; j>=0; j--){
4123  int run= i - survivor[j];
4124  int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4125  score += score_tab[i-run];
4126 
4127  if(score < best_score){
4128  best_score= score;
4129  run_tab[i+1]= run;
4130  level_tab[i+1]= level-64;
4131  }
4132  }
4133 
4134  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4135  for(j=survivor_count-1; j>=0; j--){
4136  int run= i - survivor[j];
4137  int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4138  score += score_tab[i-run];
4139  if(score < last_score){
4140  last_score= score;
4141  last_run= run;
4142  last_level= level-64;
4143  last_i= i+1;
4144  }
4145  }
4146  }
4147  }else{
4148  distortion += esc_length*lambda;
4149  for(j=survivor_count-1; j>=0; j--){
4150  int run= i - survivor[j];
4151  int score= distortion + score_tab[i-run];
4152 
4153  if(score < best_score){
4154  best_score= score;
4155  run_tab[i+1]= run;
4156  level_tab[i+1]= level-64;
4157  }
4158  }
4159 
4160  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4161  for(j=survivor_count-1; j>=0; j--){
4162  int run= i - survivor[j];
4163  int score= distortion + score_tab[i-run];
4164  if(score < last_score){
4165  last_score= score;
4166  last_run= run;
4167  last_level= level-64;
4168  last_i= i+1;
4169  }
4170  }
4171  }
4172  }
4173  }
4174 
4175  score_tab[i+1]= best_score;
4176 
4177  // 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
4178  if(last_non_zero <= 27){
4179  for(; survivor_count; survivor_count--){
4180  if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4181  break;
4182  }
4183  }else{
4184  for(; survivor_count; survivor_count--){
4185  if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4186  break;
4187  }
4188  }
4189 
4190  survivor[ survivor_count++ ]= i+1;
4191  }
4192 
4193  if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4194  last_score= 256*256*256*120;
4195  for(i= survivor[0]; i<=last_non_zero + 1; i++){
4196  int score= score_tab[i];
4197  if (i)
4198  score += lambda * 2; // FIXME more exact?
4199 
4200  if(score < last_score){
4201  last_score= score;
4202  last_i= i;
4203  last_level= level_tab[i];
4204  last_run= run_tab[i];
4205  }
4206  }
4207  }
4208 
4209  s->coded_score[n] = last_score;
4210 
4211  dc= FFABS(block[0]);
4212  last_non_zero= last_i - 1;
4213  memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4214 
4215  if(last_non_zero < start_i)
4216  return last_non_zero;
4217 
4218  if(last_non_zero == 0 && start_i == 0){
4219  int best_level= 0;
4220  int best_score= dc * dc;
4221 
4222  for(i=0; i<coeff_count[0]; i++){
4223  int level= coeff[i][0];
4224  int alevel= FFABS(level);
4225  int unquant_coeff, score, distortion;
4226 
4227  if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4228  unquant_coeff= (alevel*qmul + qadd)>>3;
4229  } else{ // MPEG-1
4230  unquant_coeff = ((( alevel << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4231  unquant_coeff = (unquant_coeff - 1) | 1;
4232  }
4233  unquant_coeff = (unquant_coeff + 4) >> 3;
4234  unquant_coeff<<= 3 + 3;
4235 
4236  distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4237  level+=64;
4238  if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4239  else score= distortion + esc_length*lambda;
4240 
4241  if(score < best_score){
4242  best_score= score;
4243  best_level= level - 64;
4244  }
4245  }
4246  block[0]= best_level;
4247  s->coded_score[n] = best_score - dc*dc;
4248  if(best_level == 0) return -1;
4249  else return last_non_zero;
4250  }
4251 
4252  i= last_i;
4253  av_assert2(last_level);
4254 
4255  block[ perm_scantable[last_non_zero] ]= last_level;
4256  i -= last_run + 1;
4257 
4258  for(; i>start_i; i -= run_tab[i] + 1){
4259  block[ perm_scantable[i-1] ]= level_tab[i];
4260  }
4261 
4262  return last_non_zero;
4263 }
4264 
4265 //#define REFINE_STATS 1
4266 static int16_t basis[64][64];
4267 
4268 static void build_basis(uint8_t *perm){
4269  int i, j, x, y;
4270  emms_c();
4271  for(i=0; i<8; i++){
4272  for(j=0; j<8; j++){
4273  for(y=0; y<8; y++){
4274  for(x=0; x<8; x++){
4275  double s= 0.25*(1<<BASIS_SHIFT);
4276  int index= 8*i + j;
4277  int perm_index= perm[index];
4278  if(i==0) s*= sqrt(0.5);
4279  if(j==0) s*= sqrt(0.5);
4280  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)));
4281  }
4282  }
4283  }
4284  }
4285 }
4286 
4287 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4288  int16_t *block, int16_t *weight, int16_t *orig,
4289  int n, int qscale){
4290  int16_t rem[64];
4291  LOCAL_ALIGNED_16(int16_t, d1, [64]);
4292  const uint8_t *scantable;
4293  const uint8_t *perm_scantable;
4294 // unsigned int threshold1, threshold2;
4295 // int bias=0;
4296  int run_tab[65];
4297  int prev_run=0;
4298  int prev_level=0;
4299  int qmul, qadd, start_i, last_non_zero, i, dc;
4300  uint8_t * length;
4301  uint8_t * last_length;
4302  int lambda;
4303  int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4304 #ifdef REFINE_STATS
4305 static int count=0;
4306 static int after_last=0;
4307 static int to_zero=0;
4308 static int from_zero=0;
4309 static int raise=0;
4310 static int lower=0;
4311 static int messed_sign=0;
4312 #endif
4313 
4314  if(basis[0][0] == 0)
4316 
4317  qmul= qscale*2;
4318  qadd= (qscale-1)|1;
4319  if (s->mb_intra) {
4320  scantable= s->intra_scantable.scantable;
4321  perm_scantable= s->intra_scantable.permutated;
4322  if (!s->h263_aic) {
4323  if (n < 4)
4324  q = s->y_dc_scale;
4325  else
4326  q = s->c_dc_scale;
4327  } else{
4328  /* For AIC we skip quant/dequant of INTRADC */
4329  q = 1;
4330  qadd=0;
4331  }
4332  q <<= RECON_SHIFT-3;
4333  /* note: block[0] is assumed to be positive */
4334  dc= block[0]*q;
4335 // block[0] = (block[0] + (q >> 1)) / q;
4336  start_i = 1;
4337 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4338 // bias= 1<<(QMAT_SHIFT-1);
4339  if (n > 3 && s->intra_chroma_ac_vlc_length) {
4340  length = s->intra_chroma_ac_vlc_length;
4341  last_length= s->intra_chroma_ac_vlc_last_length;
4342  } else {
4343  length = s->intra_ac_vlc_length;
4344  last_length= s->intra_ac_vlc_last_length;
4345  }
4346  } else {
4347  scantable= s->inter_scantable.scantable;
4348  perm_scantable= s->inter_scantable.permutated;
4349  dc= 0;
4350  start_i = 0;
4351  length = s->inter_ac_vlc_length;
4352  last_length= s->inter_ac_vlc_last_length;
4353  }
4354  last_non_zero = s->block_last_index[n];
4355 
4356 #ifdef REFINE_STATS
4357 {START_TIMER
4358 #endif
4359  dc += (1<<(RECON_SHIFT-1));
4360  for(i=0; i<64; i++){
4361  rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4362  }
4363 #ifdef REFINE_STATS
4364 STOP_TIMER("memset rem[]")}
4365 #endif
4366  sum=0;
4367  for(i=0; i<64; i++){
4368  int one= 36;
4369  int qns=4;
4370  int w;
4371 
4372  w= FFABS(weight[i]) + qns*one;
4373  w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4374 
4375  weight[i] = w;
4376 // w=weight[i] = (63*qns + (w/2)) / w;
4377 
4378  av_assert2(w>0);
4379  av_assert2(w<(1<<6));
4380  sum += w*w;
4381  }
4382  lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4383 #ifdef REFINE_STATS
4384 {START_TIMER
4385 #endif
4386  run=0;
4387  rle_index=0;
4388  for(i=start_i; i<=last_non_zero; i++){
4389  int j= perm_scantable[i];
4390  const int level= block[j];
4391  int coeff;
4392 
4393  if(level){
4394  if(level<0) coeff= qmul*level - qadd;
4395  else coeff= qmul*level + qadd;
4396  run_tab[rle_index++]=run;
4397  run=0;
4398 
4399  s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4400  }else{
4401  run++;
4402  }
4403  }
4404 #ifdef REFINE_STATS
4405 if(last_non_zero>0){
4406 STOP_TIMER("init rem[]")
4407 }
4408 }
4409 
4410 {START_TIMER
4411 #endif
4412  for(;;){
4413  int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4414  int best_coeff=0;
4415  int best_change=0;
4416  int run2, best_unquant_change=0, analyze_gradient;
4417 #ifdef REFINE_STATS
4418 {START_TIMER
4419 #endif
4420  analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4421 
4422  if(analyze_gradient){
4423 #ifdef REFINE_STATS
4424 {START_TIMER
4425 #endif
4426  for(i=0; i<64; i++){
4427  int w= weight[i];
4428 
4429  d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4430  }
4431 #ifdef REFINE_STATS
4432 STOP_TIMER("rem*w*w")}
4433 {START_TIMER
4434 #endif
4435  s->fdsp.fdct(d1);
4436 #ifdef REFINE_STATS
4437 STOP_TIMER("dct")}
4438 #endif
4439  }
4440 
4441  if(start_i){
4442  const int level= block[0];
4443  int change, old_coeff;
4444 
4445  av_assert2(s->mb_intra);
4446 
4447  old_coeff= q*level;
4448 
4449  for(change=-1; change<=1; change+=2){
4450  int new_level= level + change;
4451  int score, new_coeff;
4452 
4453  new_coeff= q*new_level;
4454  if(new_coeff >= 2048 || new_coeff < 0)
4455  continue;
4456 
4457  score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4458  new_coeff - old_coeff);
4459  if(score<best_score){
4460  best_score= score;
4461  best_coeff= 0;
4462  best_change= change;
4463  best_unquant_change= new_coeff - old_coeff;
4464  }
4465  }
4466  }
4467 
4468  run=0;
4469  rle_index=0;
4470  run2= run_tab[rle_index++];
4471  prev_level=0;
4472  prev_run=0;
4473 
4474  for(i=start_i; i<64; i++){
4475  int j= perm_scantable[i];
4476  const int level= block[j];
4477  int change, old_coeff;
4478 
4479  if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4480  break;
4481 
4482  if(level){
4483  if(level<0) old_coeff= qmul*level - qadd;
4484  else old_coeff= qmul*level + qadd;
4485  run2= run_tab[rle_index++]; //FIXME ! maybe after last
4486  }else{
4487  old_coeff=0;
4488  run2--;
4489  av_assert2(run2>=0 || i >= last_non_zero );
4490  }
4491 
4492  for(change=-1; change<=1; change+=2){
4493  int new_level= level + change;
4494  int score, new_coeff, unquant_change;
4495 
4496  score=0;
4497  if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4498  continue;
4499 
4500  if(new_level){
4501  if(new_level<0) new_coeff= qmul*new_level - qadd;
4502  else new_coeff= qmul*new_level + qadd;
4503  if(new_coeff >= 2048 || new_coeff <= -2048)
4504  continue;
4505  //FIXME check for overflow
4506 
4507  if(level){
4508  if(level < 63 && level > -63){
4509  if(i < last_non_zero)
4510  score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
4511  - length[UNI_AC_ENC_INDEX(run, level+64)];
4512  else
4513  score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4514  - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4515  }
4516  }else{
4517  av_assert2(FFABS(new_level)==1);
4518 
4519  if(analyze_gradient){
4520  int g= d1[ scantable[i] ];
4521  if(g && (g^new_level) >= 0)
4522  continue;
4523  }
4524 
4525  if(i < last_non_zero){
4526  int next_i= i + run2 + 1;
4527  int next_level= block[ perm_scantable[next_i] ] + 64;
4528 
4529  if(next_level&(~127))
4530  next_level= 0;
4531 
4532  if(next_i < last_non_zero)
4533  score += length[UNI_AC_ENC_INDEX(run, 65)]
4534  + length[UNI_AC_ENC_INDEX(run2, next_level)]
4535  - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4536  else
4537  score += length[UNI_AC_ENC_INDEX(run, 65)]
4538  + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4539  - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4540  }else{
4541  score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4542  if(prev_level){
4543  score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4544  - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4545  }
4546  }
4547  }
4548  }else{
4549  new_coeff=0;
4550  av_assert2(FFABS(level)==1);
4551 
4552  if(i < last_non_zero){
4553  int next_i= i + run2 + 1;
4554  int next_level= block[ perm_scantable[next_i] ] + 64;
4555 
4556  if(next_level&(~127))
4557  next_level= 0;
4558 
4559  if(next_i < last_non_zero)
4560  score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4561  - length[UNI_AC_ENC_INDEX(run2, next_level)]
4562  - length[UNI_AC_ENC_INDEX(run, 65)];
4563  else
4564  score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4565  - last_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, 65)];
4569  if(prev_level){
4570  score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4571  - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4572  }
4573  }
4574  }
4575 
4576  score *= lambda;
4577 
4578  unquant_change= new_coeff - old_coeff;
4579  av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4580 
4581  score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4582  unquant_change);
4583  if(score<best_score){
4584  best_score= score;
4585  best_coeff= i;
4586  best_change= change;
4587  best_unquant_change= unquant_change;
4588  }
4589  }
4590  if(level){
4591  prev_level= level + 64;
4592  if(prev_level&(~127))
4593  prev_level= 0;
4594  prev_run= run;
4595  run=0;
4596  }else{
4597  run++;
4598  }
4599  }
4600 #ifdef REFINE_STATS
4601 STOP_TIMER("iterative step")}
4602 #endif
4603 
4604  if(best_change){
4605  int j= perm_scantable[ best_coeff ];
4606 
4607  block[j] += best_change;
4608 
4609  if(best_coeff > last_non_zero){
4610  last_non_zero= best_coeff;
4611  av_assert2(block[j]);
4612 #ifdef REFINE_STATS
4613 after_last++;
4614 #endif
4615  }else{
4616 #ifdef REFINE_STATS
4617 if(block[j]){
4618  if(block[j] - best_change){
4619  if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4620  raise++;
4621  }else{
4622  lower++;
4623  }
4624  }else{
4625  from_zero++;
4626  }
4627 }else{
4628  to_zero++;
4629 }
4630 #endif
4631  for(; last_non_zero>=start_i; last_non_zero--){
4632  if(block[perm_scantable[last_non_zero]])
4633  break;
4634  }
4635  }
4636 #ifdef REFINE_STATS
4637 count++;
4638 if(256*256*256*64 % count == 0){
4639  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);
4640 }
4641 #endif
4642  run=0;
4643  rle_index=0;
4644  for(i=start_i; i<=last_non_zero; i++){
4645  int j= perm_scantable[i];
4646  const int level= block[j];
4647 
4648  if(level){
4649  run_tab[rle_index++]=run;
4650  run=0;
4651  }else{
4652  run++;
4653  }
4654  }
4655 
4656  s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4657  }else{
4658  break;
4659  }
4660  }
4661 #ifdef REFINE_STATS
4662 if(last_non_zero>0){
4663 STOP_TIMER("iterative search")
4664 }
4665 }
4666 #endif
4667 
4668  return last_non_zero;
4669 }
4670 
4671 /**
4672  * Permute an 8x8 block according to permutation.
4673  * @param block the block which will be permuted according to
4674  * the given permutation vector
4675  * @param permutation the permutation vector
4676  * @param last the last non zero coefficient in scantable order, used to
4677  * speed the permutation up
4678  * @param scantable the used scantable, this is only used to speed the
4679  * permutation up, the block is not (inverse) permutated
4680  * to scantable order!
4681  */
4682 void ff_block_permute(int16_t *block, uint8_t *permutation,
4683  const uint8_t *scantable, int last)
4684 {
4685  int i;
4686  int16_t temp[64];
4687 
4688  if (last <= 0)
4689  return;
4690  //FIXME it is ok but not clean and might fail for some permutations
4691  // if (permutation[1] == 1)
4692  // return;
4693 
4694  for (i = 0; i <= last; i++) {
4695  const int j = scantable[i];
4696  temp[j] = block[j];
4697  block[j] = 0;
4698  }
4699 
4700  for (i = 0; i <= last; i++) {
4701  const int j = scantable[i];
4702  const int perm_j = permutation[j];
4703  block[perm_j] = temp[j];
4704  }
4705 }
4706 
4708  int16_t *block, int n,
4709  int qscale, int *overflow)
4710 {
4711  int i, j, level, last_non_zero, q, start_i;
4712  const int *qmat;
4713  const uint8_t *scantable;
4714  int bias;
4715  int max=0;
4716  unsigned int threshold1, threshold2;
4717 
4718  s->fdsp.fdct(block);
4719 
4720  if(s->dct_error_sum)
4721  s->denoise_dct(s, block);
4722 
4723  if (s->mb_intra) {
4724  scantable= s->intra_scantable.scantable;
4725  if (!s->h263_aic) {
4726  if (n < 4)
4727  q = s->y_dc_scale;
4728  else
4729  q = s->c_dc_scale;
4730  q = q << 3;
4731  } else
4732  /* For AIC we skip quant/dequant of INTRADC */
4733  q = 1 << 3;
4734 
4735  /* note: block[0] is assumed to be positive */
4736  block[0] = (block[0] + (q >> 1)) / q;
4737  start_i = 1;
4738  last_non_zero = 0;
4739  qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4740  bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4741  } else {
4742  scantable= s->inter_scantable.scantable;
4743  start_i = 0;
4744  last_non_zero = -1;
4745  qmat = s->q_inter_matrix[qscale];
4746  bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4747  }
4748  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4749  threshold2= (threshold1<<1);
4750  for(i=63;i>=start_i;i--) {
4751  j = scantable[i];
4752  level = block[j] * qmat[j];
4753 
4754  if(((unsigned)(level+threshold1))>threshold2){
4755  last_non_zero = i;
4756  break;
4757  }else{
4758  block[j]=0;
4759  }
4760  }
4761  for(i=start_i; i<=last_non_zero; i++) {
4762  j = scantable[i];
4763  level = block[j] * qmat[j];
4764 
4765 // if( bias+level >= (1<<QMAT_SHIFT)
4766 // || bias-level >= (1<<QMAT_SHIFT)){
4767  if(((unsigned)(level+threshold1))>threshold2){
4768  if(level>0){
4769  level= (bias + level)>>QMAT_SHIFT;
4770  block[j]= level;
4771  }else{
4772  level= (bias - level)>>QMAT_SHIFT;
4773  block[j]= -level;
4774  }
4775  max |=level;
4776  }else{
4777  block[j]=0;
4778  }
4779  }
4780  *overflow= s->max_qcoeff < max; //overflow might have happened
4781 
4782  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4783  if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4785  scantable, last_non_zero);
4786 
4787  return last_non_zero;
4788 }
4789 
4790 #define OFFSET(x) offsetof(MpegEncContext, x)
4791 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4792 static const AVOption h263_options[] = {
4793  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4794  { "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 },
4796  { NULL },
4797 };
4798 
4799 static const AVClass h263_class = {
4800  .class_name = "H.263 encoder",
4801  .item_name = av_default_item_name,
4802  .option = h263_options,
4803  .version = LIBAVUTIL_VERSION_INT,
4804 };
4805 
4807  .name = "h263",
4808  .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4809  .type = AVMEDIA_TYPE_VIDEO,
4810  .id = AV_CODEC_ID_H263,
4811  .priv_data_size = sizeof(MpegEncContext),
4813  .encode2 = ff_mpv_encode_picture,
4814  .close = ff_mpv_encode_end,
4816  .priv_class = &h263_class,
4817 };
4818 
4819 static const AVOption h263p_options[] = {
4820  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4821  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4822  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4823  { "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},
4825  { NULL },
4826 };
4827 static const AVClass h263p_class = {
4828  .class_name = "H.263p encoder",
4829  .item_name = av_default_item_name,
4830  .option = h263p_options,
4831  .version = LIBAVUTIL_VERSION_INT,
4832 };
4833 
4835  .name = "h263p",
4836  .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4837  .type = AVMEDIA_TYPE_VIDEO,
4838  .id = AV_CODEC_ID_H263P,
4839  .priv_data_size = sizeof(MpegEncContext),
4841  .encode2 = ff_mpv_encode_picture,
4842  .close = ff_mpv_encode_end,
4843  .capabilities = AV_CODEC_CAP_SLICE_THREADS,
4845  .priv_class = &h263p_class,
4846 };
4847 
4848 static const AVClass msmpeg4v2_class = {
4849  .class_name = "msmpeg4v2 encoder",
4850  .item_name = av_default_item_name,
4851  .option = ff_mpv_generic_options,
4852  .version = LIBAVUTIL_VERSION_INT,
4853 };
4854 
4856  .name = "msmpeg4v2",
4857  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4858  .type = AVMEDIA_TYPE_VIDEO,
4859  .id = AV_CODEC_ID_MSMPEG4V2,
4860  .priv_data_size = sizeof(MpegEncContext),
4862  .encode2 = ff_mpv_encode_picture,
4863  .close = ff_mpv_encode_end,
4865  .priv_class = &msmpeg4v2_class,
4866 };
4867 
4868 static const AVClass msmpeg4v3_class = {
4869  .class_name = "msmpeg4v3 encoder",
4870  .item_name = av_default_item_name,
4871  .option = ff_mpv_generic_options,
4872  .version = LIBAVUTIL_VERSION_INT,
4873 };
4874 
4876  .name = "msmpeg4",
4877  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4878  .type = AVMEDIA_TYPE_VIDEO,
4879  .id = AV_CODEC_ID_MSMPEG4V3,
4880  .priv_data_size = sizeof(MpegEncContext),
4882  .encode2 = ff_mpv_encode_picture,
4883  .close = ff_mpv_encode_end,
4885  .priv_class = &msmpeg4v3_class,
4886 };
4887 
4888 static const AVClass wmv1_class = {
4889  .class_name = "wmv1 encoder",
4890  .item_name = av_default_item_name,
4891  .option = ff_mpv_generic_options,
4892  .version = LIBAVUTIL_VERSION_INT,
4893 };
4894 
4896  .name = "wmv1",
4897  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4898  .type = AVMEDIA_TYPE_VIDEO,
4899  .id = AV_CODEC_ID_WMV1,
4900  .priv_data_size = sizeof(MpegEncContext),
4902  .encode2 = ff_mpv_encode_picture,
4903  .close = ff_mpv_encode_end,
4905  .priv_class = &wmv1_class,
4906 };
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(* try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale)
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:2272
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
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:534
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
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:279
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h: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 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
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
attribute_deprecated void(* rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb)
Definition: avcodec.h:2505
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:554
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.
void(* add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale)
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h: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
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
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 av_log2(unsigned v)
Definition: intmath.c:26
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:366
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c: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
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
int coded_score[12]
Definition: mpegvideo.h:320
mpegvideo header.
const uint16_t ff_h263_format[8][2]
Definition: h263data.c:238
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c: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:361
#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
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
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:528
int field_select[2][2]
Definition: mpegvideo.h:277
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:532
attribute_deprecated int frame_skip_exp
Definition: avcodec.h:2466
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:1909
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:530
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
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
int alt_inter_vlc
alternative inter vlc
Definition: mpegvideo.h:378
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
Definition: mpeg12enc.c: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.
void(* denoise_dct)(struct MpegEncContext *s, int16_t *block)
Definition: mpegvideo.h:538
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
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 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:460
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
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
void(* diff_pixels)(int16_t *av_restrict block, const uint8_t *s1, const uint8_t *s2, ptrdiff_t stride)
Definition: pixblockdsp.h:32
#define CHROMA_420
Definition: mpegvideo.h:482
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:446
int intra_dc_precision
Definition: mpegvideo.h:463
int repeat_first_field
Definition: mpegvideo.h:479
static AVFrame * frame
quarterpel DSP functions
#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
ptrdiff_t size
Definition: opengl_enc.c:101
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:1932
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:2336
#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
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:261
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:195
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:186
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
void(* get_pixels)(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t stride)
Definition: pixblockdsp.h:29
#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)
void(* dct_unquantize_mpeg2_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:526
PixblockDSPContext pdsp
Definition: mpegvideo.h:234
const char * arg
Definition: jacosubdec.c:66
uint8_t * intra_chroma_ac_vlc_length
Definition: mpegvideo.h:313
void(* dct_unquantize_mpeg1_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:520
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
GLsizei GLsizei * length
Definition: opengl_enc.c:115
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
GLsizei count
Definition: opengl_enc.c:109
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1131
#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
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
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
#define CHROMA_422
Definition: mpegvideo.h: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
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
int(* pix_sum)(uint8_t *pix, int line_size)
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h: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
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
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
const int16_t ff_mpeg4_default_non_intra_matrix[64]
Definition: mpeg4data.h:348
int mb_decision
macroblock decision mode
Definition: avcodec.h:2021
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
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
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
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
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:231
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:598
ScanTable intra_scantable
Definition: mpegvideo.h:91
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
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
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
GLint GLenum type
Definition: opengl_enc.c:105
void ff_fix_long_p_mvs(MpegEncContext *s)
Definition: motion_est.c:1651
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
int(* pix_norm1)(uint8_t *pix, int line_size)
#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
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)
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
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:538
#define CANDIDATE_MB_TYPE_BIDIR_I
Definition: mpegutils.h:117
const int16_t ff_mpeg4_default_intra_matrix[64]
Definition: mpeg4data.h:337
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 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:1547
#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)
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
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:294
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
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
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
if(ret< 0)
Definition: vf_mcdeint.c:279
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 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'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
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
void(* dct_unquantize_mpeg1_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:522
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1946
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
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
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:2253
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1123
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
int ff_get_best_fcode(MpegEncContext *s, int16_t(*mv_table)[2], int type)
Definition: motion_est.c: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
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:1700
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
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
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
void(* dct_unquantize_mpeg2_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:524
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
int(* fast_dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:537
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 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
#define CANDIDATE_MB_TYPE_BACKWARD
Definition: mpegutils.h:111
#define stride
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:536
#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
void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:365
int dct_count[2]
Definition: mpegvideo.h:333
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:81
static int encode_frame(AVCodecContext *c, AVFrame *frame)
AVPixelFormat
Pixel format.
Definition: pixfmt.h: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:1750
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
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) 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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
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