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