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 Libav.
9  *
10  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
30 #include "libavutil/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/opt.h"
34 #include "avcodec.h"
35 #include "dsputil.h"
36 #include "mpegvideo.h"
37 #include "h263.h"
38 #include "mathops.h"
39 #include "mjpegenc.h"
40 #include "msmpeg4.h"
41 #include "faandct.h"
42 #include "thread.h"
43 #include "aandcttab.h"
44 #include "flv.h"
45 #include "mpeg4video.h"
46 #include "internal.h"
47 #include "bytestream.h"
48 #include <limits.h>
49 
50 //#undef NDEBUG
51 //#include <assert.h>
52 
53 static int encode_picture(MpegEncContext *s, int picture_number);
54 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
55 static int sse_mb(MpegEncContext *s);
56 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
57 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
58 
59 /* enable all paranoid tests for rounding, overflows, etc... */
60 //#define PARANOID
61 
62 //#define DEBUG
63 
66 
69  { NULL },
70 };
71 
72 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
73  uint16_t (*qmat16)[2][64],
74  const uint16_t *quant_matrix,
75  int bias, int qmin, int qmax, int intra)
76 {
77  int qscale;
78  int shift = 0;
79 
80  for (qscale = qmin; qscale <= qmax; qscale++) {
81  int i;
82  if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
83  dsp->fdct == ff_jpeg_fdct_islow_10 ||
84  dsp->fdct == ff_faandct) {
85  for (i = 0; i < 64; i++) {
86  const int j = dsp->idct_permutation[i];
87  /* 16 <= qscale * quant_matrix[i] <= 7905
88  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
89  * 19952 <= x <= 249205026
90  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
91  * 3444240 >= (1 << 36) / (x) >= 275 */
92 
93  qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
94  (qscale * quant_matrix[j]));
95  }
96  } else if (dsp->fdct == ff_fdct_ifast) {
97  for (i = 0; i < 64; i++) {
98  const int j = dsp->idct_permutation[i];
99  /* 16 <= qscale * quant_matrix[i] <= 7905
100  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
101  * 19952 <= x <= 249205026
102  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
103  * 3444240 >= (1 << 36) / (x) >= 275 */
104 
105  qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
106  (ff_aanscales[i] * qscale *
107  quant_matrix[j]));
108  }
109  } else {
110  for (i = 0; i < 64; i++) {
111  const int j = dsp->idct_permutation[i];
112  /* We can safely suppose that 16 <= quant_matrix[i] <= 255
113  * Assume x = qscale * quant_matrix[i]
114  * So 16 <= x <= 7905
115  * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
116  * so 32768 >= (1 << 19) / (x) >= 67 */
117  qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
118  (qscale * quant_matrix[j]));
119  //qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) /
120  // (qscale * quant_matrix[i]);
121  qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
122  (qscale * quant_matrix[j]);
123 
124  if (qmat16[qscale][0][i] == 0 ||
125  qmat16[qscale][0][i] == 128 * 256)
126  qmat16[qscale][0][i] = 128 * 256 - 1;
127  qmat16[qscale][1][i] =
128  ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
129  qmat16[qscale][0][i]);
130  }
131  }
132 
133  for (i = intra; i < 64; i++) {
134  int64_t max = 8191;
135  if (dsp->fdct == ff_fdct_ifast) {
136  max = (8191LL * ff_aanscales[i]) >> 14;
137  }
138  while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
139  shift++;
140  }
141  }
142  }
143  if (shift) {
145  "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
146  QMAT_SHIFT - shift);
147  }
148 }
149 
150 static inline void update_qscale(MpegEncContext *s)
151 {
152  s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
153  (FF_LAMBDA_SHIFT + 7);
154  s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
155 
156  s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
158 }
159 
160 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
161 {
162  int i;
163 
164  if (matrix) {
165  put_bits(pb, 1, 1);
166  for (i = 0; i < 64; i++) {
167  put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
168  }
169  } else
170  put_bits(pb, 1, 0);
171 }
172 
177 {
178  int8_t * const qscale_table = s->current_picture.f.qscale_table;
179  int i;
180 
181  for (i = 0; i < s->mb_num; i++) {
182  unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
183  int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
184  qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
185  s->avctx->qmax);
186  }
187 }
188 
190  AVFrame *dst,
191  AVFrame *src)
192 {
193  int i;
194 
195  dst->pict_type = src->pict_type;
196  dst->quality = src->quality;
199  //dst->reference = src->reference;
200  dst->pts = src->pts;
202  dst->top_field_first = src->top_field_first;
203 
204  if (s->avctx->me_threshold) {
205  if (!src->motion_val[0])
206  av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
207  if (!src->mb_type)
208  av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
209  if (!src->ref_index[0])
210  av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
213  "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
215 
216  memcpy(dst->mb_type, src->mb_type,
217  s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
218 
219  for (i = 0; i < 2; i++) {
220  int stride = ((16 * s->mb_width ) >>
221  src->motion_subsample_log2) + 1;
222  int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
223 
224  if (src->motion_val[i] &&
225  src->motion_val[i] != dst->motion_val[i]) {
226  memcpy(dst->motion_val[i], src->motion_val[i],
227  2 * stride * height * sizeof(int16_t));
228  }
229  if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
230  memcpy(dst->ref_index[i], src->ref_index[i],
231  s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
232  }
233  }
234  }
235 }
236 
238  MpegEncContext *src)
239 {
240 #define COPY(a) dst->a= src->a
241  COPY(pict_type);
243  COPY(f_code);
244  COPY(b_code);
245  COPY(qscale);
246  COPY(lambda);
247  COPY(lambda2);
250  COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
251  COPY(progressive_frame); // FIXME don't set in encode_header
252  COPY(partitioned_frame); // FIXME don't set in encode_header
253 #undef COPY
254 }
255 
261 {
262  int i;
264 
265  for (i = -16; i < 16; i++) {
266  default_fcode_tab[i + MAX_MV] = 1;
267  }
270 }
271 
272 /* init video encoder */
274 {
275  MpegEncContext *s = avctx->priv_data;
276  int i;
277  int chroma_h_shift, chroma_v_shift;
278 
280 
281  switch (avctx->codec_id) {
283  if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
284  avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
285  av_log(avctx, AV_LOG_ERROR,
286  "only YUV420 and YUV422 are supported\n");
287  return -1;
288  }
289  break;
290  case AV_CODEC_ID_LJPEG:
291  if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
292  avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
293  avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
294  avctx->pix_fmt != AV_PIX_FMT_BGRA &&
295  ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
296  avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
297  avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
299  av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
300  return -1;
301  }
302  break;
303  case AV_CODEC_ID_MJPEG:
304  if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
305  avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
306  ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
307  avctx->pix_fmt != AV_PIX_FMT_YUV422P) ||
309  av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
310  return -1;
311  }
312  break;
313  default:
314  if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
315  av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
316  return -1;
317  }
318  }
319 
320  switch (avctx->pix_fmt) {
321  case AV_PIX_FMT_YUVJ422P:
322  case AV_PIX_FMT_YUV422P:
324  break;
325  case AV_PIX_FMT_YUVJ420P:
326  case AV_PIX_FMT_YUV420P:
327  default:
329  break;
330  }
331 
332  s->bit_rate = avctx->bit_rate;
333  s->width = avctx->width;
334  s->height = avctx->height;
335  if (avctx->gop_size > 600 &&
337  av_log(avctx, AV_LOG_ERROR,
338  "Warning keyframe interval too large! reducing it ...\n");
339  avctx->gop_size = 600;
340  }
341  s->gop_size = avctx->gop_size;
342  s->avctx = avctx;
343  s->flags = avctx->flags;
344  s->flags2 = avctx->flags2;
345  s->max_b_frames = avctx->max_b_frames;
346  s->codec_id = avctx->codec->id;
347 #if FF_API_MPV_GLOBAL_OPTS
348  if (avctx->luma_elim_threshold)
349  s->luma_elim_threshold = avctx->luma_elim_threshold;
350  if (avctx->chroma_elim_threshold)
351  s->chroma_elim_threshold = avctx->chroma_elim_threshold;
352 #endif
354  s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
355  s->mpeg_quant = avctx->mpeg_quant;
356  s->rtp_mode = !!avctx->rtp_payload_size;
359 
360  if (s->gop_size <= 1) {
361  s->intra_only = 1;
362  s->gop_size = 12;
363  } else {
364  s->intra_only = 0;
365  }
366 
367  s->me_method = avctx->me_method;
368 
369  /* Fixed QSCALE */
370  s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
371 
372 #if FF_API_MPV_GLOBAL_OPTS
373  if (s->flags & CODEC_FLAG_QP_RD)
375 #endif
376 
377  s->adaptive_quant = (s->avctx->lumi_masking ||
378  s->avctx->dark_masking ||
381  s->avctx->p_masking ||
382  s->avctx->border_masking ||
383  (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
384  !s->fixed_qscale;
385 
387 
388  if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
389  av_log(avctx, AV_LOG_ERROR,
390  "a vbv buffer size is needed, "
391  "for encoding with a maximum bitrate\n");
392  return -1;
393  }
394 
395  if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
396  av_log(avctx, AV_LOG_INFO,
397  "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
398  }
399 
400  if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
401  av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
402  return -1;
403  }
404 
405  if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
406  av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
407  return -1;
408  }
409 
410  if (avctx->rc_max_rate &&
411  avctx->rc_max_rate == avctx->bit_rate &&
412  avctx->rc_max_rate != avctx->rc_min_rate) {
413  av_log(avctx, AV_LOG_INFO,
414  "impossible bitrate constraints, this will fail\n");
415  }
416 
417  if (avctx->rc_buffer_size &&
418  avctx->bit_rate * (int64_t)avctx->time_base.num >
419  avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
420  av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
421  return -1;
422  }
423 
424  if (!s->fixed_qscale &&
425  avctx->bit_rate * av_q2d(avctx->time_base) >
426  avctx->bit_rate_tolerance) {
427  av_log(avctx, AV_LOG_ERROR,
428  "bitrate tolerance too small for bitrate\n");
429  return -1;
430  }
431 
432  if (s->avctx->rc_max_rate &&
433  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
436  90000LL * (avctx->rc_buffer_size - 1) >
437  s->avctx->rc_max_rate * 0xFFFFLL) {
438  av_log(avctx, AV_LOG_INFO,
439  "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
440  "specified vbv buffer is too large for the given bitrate!\n");
441  }
442 
443  if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
445  s->codec_id != AV_CODEC_ID_FLV1) {
446  av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
447  return -1;
448  }
449 
450  if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
451  av_log(avctx, AV_LOG_ERROR,
452  "OBMC is only supported with simple mb decision\n");
453  return -1;
454  }
455 
456  if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
457  av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
458  return -1;
459  }
460 
461  if (s->max_b_frames &&
462  s->codec_id != AV_CODEC_ID_MPEG4 &&
465  av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
466  return -1;
467  }
468 
469  if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
470  s->codec_id == AV_CODEC_ID_H263 ||
471  s->codec_id == AV_CODEC_ID_H263P) &&
472  (avctx->sample_aspect_ratio.num > 255 ||
473  avctx->sample_aspect_ratio.den > 255)) {
474  av_log(avctx, AV_LOG_ERROR,
475  "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
477  return -1;
478  }
479 
482  av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
483  return -1;
484  }
485 
486  // FIXME mpeg2 uses that too
487  if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
488  av_log(avctx, AV_LOG_ERROR,
489  "mpeg2 style quantization not supported by codec\n");
490  return -1;
491  }
492 
493 #if FF_API_MPV_GLOBAL_OPTS
494  if (s->flags & CODEC_FLAG_CBP_RD)
496 #endif
497 
498  if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
499  av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
500  return -1;
501  }
502 
503  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
505  av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
506  return -1;
507  }
508 
509  if (s->avctx->scenechange_threshold < 1000000000 &&
510  (s->flags & CODEC_FLAG_CLOSED_GOP)) {
511  av_log(avctx, AV_LOG_ERROR,
512  "closed gop with scene change detection are not supported yet, "
513  "set threshold to 1000000000\n");
514  return -1;
515  }
516 
517  if (s->flags & CODEC_FLAG_LOW_DELAY) {
518  if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
519  av_log(avctx, AV_LOG_ERROR,
520  "low delay forcing is only available for mpeg2\n");
521  return -1;
522  }
523  if (s->max_b_frames != 0) {
524  av_log(avctx, AV_LOG_ERROR,
525  "b frames cannot be used with low delay\n");
526  return -1;
527  }
528  }
529 
530  if (s->q_scale_type == 1) {
531  if (avctx->qmax > 12) {
532  av_log(avctx, AV_LOG_ERROR,
533  "non linear quant only supports qmax <= 12 currently\n");
534  return -1;
535  }
536  }
537 
538  if (s->avctx->thread_count > 1 &&
539  s->codec_id != AV_CODEC_ID_MPEG4 &&
542  (s->codec_id != AV_CODEC_ID_H263P)) {
543  av_log(avctx, AV_LOG_ERROR,
544  "multi threaded encoding not supported by codec\n");
545  return -1;
546  }
547 
548  if (s->avctx->thread_count < 1) {
549  av_log(avctx, AV_LOG_ERROR,
550  "automatic thread number detection not supported by codec,"
551  "patch welcome\n");
552  return -1;
553  }
554 
555  if (s->avctx->thread_count > 1)
556  s->rtp_mode = 1;
557 
558  if (!avctx->time_base.den || !avctx->time_base.num) {
559  av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
560  return -1;
561  }
562 
563  i = (INT_MAX / 2 + 128) >> 8;
564  if (avctx->me_threshold >= i) {
565  av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
566  i - 1);
567  return -1;
568  }
569  if (avctx->mb_threshold >= i) {
570  av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
571  i - 1);
572  return -1;
573  }
574 
575  if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
576  av_log(avctx, AV_LOG_INFO,
577  "notice: b_frame_strategy only affects the first pass\n");
578  avctx->b_frame_strategy = 0;
579  }
580 
581  i = av_gcd(avctx->time_base.den, avctx->time_base.num);
582  if (i > 1) {
583  av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
584  avctx->time_base.den /= i;
585  avctx->time_base.num /= i;
586  //return -1;
587  }
588 
589  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
591  // (a + x * 3 / 8) / x
592  s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
593  s->inter_quant_bias = 0;
594  } else {
595  s->intra_quant_bias = 0;
596  // (a - x / 4) / x
597  s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
598  }
599 
604 
605  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
606  &chroma_v_shift);
607 
608  if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
609  s->avctx->time_base.den > (1 << 16) - 1) {
610  av_log(avctx, AV_LOG_ERROR,
611  "timebase %d/%d not supported by MPEG 4 standard, "
612  "the maximum admitted value for the timebase denominator "
613  "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
614  (1 << 16) - 1);
615  return -1;
616  }
617  s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
618 
619 #if FF_API_MPV_GLOBAL_OPTS
620  if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
622  if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
624  if (avctx->quantizer_noise_shaping)
625  s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
626 #endif
627 
628  switch (avctx->codec->id) {
630  s->out_format = FMT_MPEG1;
631  s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
632  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
633  break;
635  s->out_format = FMT_MPEG1;
636  s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
637  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
638  s->rtp_mode = 1;
639  break;
640  case AV_CODEC_ID_LJPEG:
641  case AV_CODEC_ID_MJPEG:
642  s->out_format = FMT_MJPEG;
643  s->intra_only = 1; /* force intra only for jpeg */
644  if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
645  avctx->pix_fmt == AV_PIX_FMT_BGRA) {
646  s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
647  s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
648  s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
649  } else {
650  s->mjpeg_vsample[0] = 2;
651  s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
652  s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
653  s->mjpeg_hsample[0] = 2;
654  s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
655  s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
656  }
658  ff_mjpeg_encode_init(s) < 0)
659  return -1;
660  avctx->delay = 0;
661  s->low_delay = 1;
662  break;
663  case AV_CODEC_ID_H261:
664  if (!CONFIG_H261_ENCODER)
665  return -1;
666  if (ff_h261_get_picture_format(s->width, s->height) < 0) {
667  av_log(avctx, AV_LOG_ERROR,
668  "The specified picture size of %dx%d is not valid for the "
669  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
670  s->width, s->height);
671  return -1;
672  }
673  s->out_format = FMT_H261;
674  avctx->delay = 0;
675  s->low_delay = 1;
676  break;
677  case AV_CODEC_ID_H263:
678  if (!CONFIG_H263_ENCODER)
679  return -1;
681  s->width, s->height) == 8) {
682  av_log(avctx, AV_LOG_INFO,
683  "The specified picture size of %dx%d is not valid for "
684  "the H.263 codec.\nValid sizes are 128x96, 176x144, "
685  "352x288, 704x576, and 1408x1152."
686  "Try H.263+.\n", s->width, s->height);
687  return -1;
688  }
689  s->out_format = FMT_H263;
690  avctx->delay = 0;
691  s->low_delay = 1;
692  break;
693  case AV_CODEC_ID_H263P:
694  s->out_format = FMT_H263;
695  s->h263_plus = 1;
696  /* Fx */
697  s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
698  s->modified_quant = s->h263_aic;
699  s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
700  s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
701 
702  /* /Fx */
703  /* These are just to be sure */
704  avctx->delay = 0;
705  s->low_delay = 1;
706  break;
707  case AV_CODEC_ID_FLV1:
708  s->out_format = FMT_H263;
709  s->h263_flv = 2; /* format = 1; 11-bit codes */
710  s->unrestricted_mv = 1;
711  s->rtp_mode = 0; /* don't allow GOB */
712  avctx->delay = 0;
713  s->low_delay = 1;
714  break;
715  case AV_CODEC_ID_RV10:
716  s->out_format = FMT_H263;
717  avctx->delay = 0;
718  s->low_delay = 1;
719  break;
720  case AV_CODEC_ID_RV20:
721  s->out_format = FMT_H263;
722  avctx->delay = 0;
723  s->low_delay = 1;
724  s->modified_quant = 1;
725  s->h263_aic = 1;
726  s->h263_plus = 1;
727  s->loop_filter = 1;
728  s->unrestricted_mv = 0;
729  break;
730  case AV_CODEC_ID_MPEG4:
731  s->out_format = FMT_H263;
732  s->h263_pred = 1;
733  s->unrestricted_mv = 1;
734  s->low_delay = s->max_b_frames ? 0 : 1;
735  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
736  break;
738  s->out_format = FMT_H263;
739  s->h263_pred = 1;
740  s->unrestricted_mv = 1;
741  s->msmpeg4_version = 2;
742  avctx->delay = 0;
743  s->low_delay = 1;
744  break;
746  s->out_format = FMT_H263;
747  s->h263_pred = 1;
748  s->unrestricted_mv = 1;
749  s->msmpeg4_version = 3;
750  s->flipflop_rounding = 1;
751  avctx->delay = 0;
752  s->low_delay = 1;
753  break;
754  case AV_CODEC_ID_WMV1:
755  s->out_format = FMT_H263;
756  s->h263_pred = 1;
757  s->unrestricted_mv = 1;
758  s->msmpeg4_version = 4;
759  s->flipflop_rounding = 1;
760  avctx->delay = 0;
761  s->low_delay = 1;
762  break;
763  case AV_CODEC_ID_WMV2:
764  s->out_format = FMT_H263;
765  s->h263_pred = 1;
766  s->unrestricted_mv = 1;
767  s->msmpeg4_version = 5;
768  s->flipflop_rounding = 1;
769  avctx->delay = 0;
770  s->low_delay = 1;
771  break;
772  default:
773  return -1;
774  }
775 
776  avctx->has_b_frames = !s->low_delay;
777 
778  s->encoding = 1;
779 
780  s->progressive_frame =
783  s->alternate_scan);
784 
785  /* init */
786  if (ff_MPV_common_init(s) < 0)
787  return -1;
788 
789  if (ARCH_X86)
791 
792  if (!s->dct_quantize)
794  if (!s->denoise_dct)
797  if (avctx->trellis)
799 
802 
803  s->quant_precision = 5;
804 
805  ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
807 
815  && s->out_format == FMT_MPEG1)
817 
818  /* init q matrix */
819  for (i = 0; i < 64; i++) {
820  int j = s->dsp.idct_permutation[i];
822  s->mpeg_quant) {
825  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
826  s->intra_matrix[j] =
828  } else {
829  /* mpeg1/2 */
832  }
833  if (s->avctx->intra_matrix)
834  s->intra_matrix[j] = s->avctx->intra_matrix[i];
835  if (s->avctx->inter_matrix)
836  s->inter_matrix[j] = s->avctx->inter_matrix[i];
837  }
838 
839  /* precompute matrix */
840  /* for mjpeg, we do include qscale in the matrix */
841  if (s->out_format != FMT_MJPEG) {
843  s->intra_matrix, s->intra_quant_bias, avctx->qmin,
844  31, 1);
846  s->inter_matrix, s->inter_quant_bias, avctx->qmin,
847  31, 0);
848  }
849 
850  if (ff_rate_control_init(s) < 0)
851  return -1;
852 
853  return 0;
854 }
855 
857 {
858  MpegEncContext *s = avctx->priv_data;
859 
861 
864  s->out_format == FMT_MJPEG)
866 
867  av_freep(&avctx->extradata);
868 
869  return 0;
870 }
871 
872 static int get_sae(uint8_t *src, int ref, int stride)
873 {
874  int x,y;
875  int acc = 0;
876 
877  for (y = 0; y < 16; y++) {
878  for (x = 0; x < 16; x++) {
879  acc += FFABS(src[x + y * stride] - ref);
880  }
881  }
882 
883  return acc;
884 }
885 
887  uint8_t *ref, int stride)
888 {
889  int x, y, w, h;
890  int acc = 0;
891 
892  w = s->width & ~15;
893  h = s->height & ~15;
894 
895  for (y = 0; y < h; y += 16) {
896  for (x = 0; x < w; x += 16) {
897  int offset = x + y * stride;
898  int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
899  16);
900  int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
901  int sae = get_sae(src + offset, mean, stride);
902 
903  acc += sae + 500 < sad;
904  }
905  }
906  return acc;
907 }
908 
909 
910 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
911 {
912  AVFrame *pic = NULL;
913  int64_t pts;
914  int i;
915  const int encoding_delay = s->max_b_frames ? s->max_b_frames :
916  (s->low_delay ? 0 : 1);
917  int direct = 1;
918 
919  if (pic_arg) {
920  pts = pic_arg->pts;
922 
923  if (pts != AV_NOPTS_VALUE) {
925  int64_t time = pts;
926  int64_t last = s->user_specified_pts;
927 
928  if (time <= last) {
930  "Error, Invalid timestamp=%"PRId64", "
931  "last=%"PRId64"\n", pts, s->user_specified_pts);
932  return -1;
933  }
934 
935  if (!s->low_delay && pic_arg->display_picture_number == 1)
936  s->dts_delta = time - last;
937  }
938  s->user_specified_pts = pts;
939  } else {
941  s->user_specified_pts =
942  pts = s->user_specified_pts + 1;
944  "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
945  pts);
946  } else {
947  pts = pic_arg->display_picture_number;
948  }
949  }
950  }
951 
952  if (pic_arg) {
953  if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
954  direct = 0;
955  if (pic_arg->linesize[0] != s->linesize)
956  direct = 0;
957  if (pic_arg->linesize[1] != s->uvlinesize)
958  direct = 0;
959  if (pic_arg->linesize[2] != s->uvlinesize)
960  direct = 0;
961 
962  av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
963  pic_arg->linesize[1], s->linesize, s->uvlinesize);
964 
965  if (direct) {
966  i = ff_find_unused_picture(s, 1);
967  if (i < 0)
968  return i;
969 
970  pic = &s->picture[i].f;
971  pic->reference = 3;
972 
973  for (i = 0; i < 4; i++) {
974  pic->data[i] = pic_arg->data[i];
975  pic->linesize[i] = pic_arg->linesize[i];
976  }
977  if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
978  return -1;
979  }
980  } else {
981  i = ff_find_unused_picture(s, 0);
982  if (i < 0)
983  return i;
984 
985  pic = &s->picture[i].f;
986  pic->reference = 3;
987 
988  if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
989  return -1;
990  }
991 
992  if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
993  pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
994  pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
995  // empty
996  } else {
997  int h_chroma_shift, v_chroma_shift;
999  &h_chroma_shift,
1000  &v_chroma_shift);
1001 
1002  for (i = 0; i < 3; i++) {
1003  int src_stride = pic_arg->linesize[i];
1004  int dst_stride = i ? s->uvlinesize : s->linesize;
1005  int h_shift = i ? h_chroma_shift : 0;
1006  int v_shift = i ? v_chroma_shift : 0;
1007  int w = s->width >> h_shift;
1008  int h = s->height >> v_shift;
1009  uint8_t *src = pic_arg->data[i];
1010  uint8_t *dst = pic->data[i];
1011 
1012  if (!s->avctx->rc_buffer_size)
1013  dst += INPLACE_OFFSET;
1014 
1015  if (src_stride == dst_stride)
1016  memcpy(dst, src, src_stride * h);
1017  else {
1018  while (h--) {
1019  memcpy(dst, src, w);
1020  dst += dst_stride;
1021  src += src_stride;
1022  }
1023  }
1024  }
1025  }
1026  }
1027  copy_picture_attributes(s, pic, pic_arg);
1028  pic->pts = pts; // we set this here to avoid modifiying pic_arg
1029  }
1030 
1031  /* shift buffer entries */
1032  for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1033  s->input_picture[i - 1] = s->input_picture[i];
1034 
1035  s->input_picture[encoding_delay] = (Picture*) pic;
1036 
1037  return 0;
1038 }
1039 
1040 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1041 {
1042  int x, y, plane;
1043  int score = 0;
1044  int64_t score64 = 0;
1045 
1046  for (plane = 0; plane < 3; plane++) {
1047  const int stride = p->f.linesize[plane];
1048  const int bw = plane ? 1 : 2;
1049  for (y = 0; y < s->mb_height * bw; y++) {
1050  for (x = 0; x < s->mb_width * bw; x++) {
1051  int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1052  uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1053  uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1054  int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1055 
1056  switch (s->avctx->frame_skip_exp) {
1057  case 0: score = FFMAX(score, v); break;
1058  case 1: score += FFABS(v); break;
1059  case 2: score += v * v; break;
1060  case 3: score64 += FFABS(v * v * (int64_t)v); break;
1061  case 4: score64 += v * v * (int64_t)(v * v); break;
1062  }
1063  }
1064  }
1065  }
1066 
1067  if (score)
1068  score64 = score;
1069 
1070  if (score64 < s->avctx->frame_skip_threshold)
1071  return 1;
1072  if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1073  return 1;
1074  return 0;
1075 }
1076 
1077 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1078 {
1079  AVPacket pkt = { 0 };
1080  int ret, got_output;
1081 
1082  av_init_packet(&pkt);
1083  ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1084  if (ret < 0)
1085  return ret;
1086 
1087  ret = pkt.size;
1088  av_free_packet(&pkt);
1089  return ret;
1090 }
1091 
1093 {
1096  AVFrame input[FF_MAX_B_FRAMES + 2];
1097  const int scale = s->avctx->brd_scale;
1098  int i, j, out_size, p_lambda, b_lambda, lambda2;
1099  int64_t best_rd = INT64_MAX;
1100  int best_b_count = -1;
1101 
1102  assert(scale >= 0 && scale <= 3);
1103 
1104  //emms_c();
1105  //s->next_picture_ptr->quality;
1106  p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1107  //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1108  b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1109  if (!b_lambda) // FIXME we should do this somewhere else
1110  b_lambda = p_lambda;
1111  lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1113 
1114  c->width = s->width >> scale;
1115  c->height = s->height >> scale;
1117  CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1118  c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1119  c->mb_decision = s->avctx->mb_decision;
1120  c->me_cmp = s->avctx->me_cmp;
1121  c->mb_cmp = s->avctx->mb_cmp;
1122  c->me_sub_cmp = s->avctx->me_sub_cmp;
1124  c->time_base = s->avctx->time_base;
1125  c->max_b_frames = s->max_b_frames;
1126 
1127  if (avcodec_open2(c, codec, NULL) < 0)
1128  return -1;
1129 
1130  for (i = 0; i < s->max_b_frames + 2; i++) {
1131  int ysize = c->width * c->height;
1132  int csize = (c->width / 2) * (c->height / 2);
1133  Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1134  s->next_picture_ptr;
1135 
1136  avcodec_get_frame_defaults(&input[i]);
1137  input[i].data[0] = av_malloc(ysize + 2 * csize);
1138  input[i].data[1] = input[i].data[0] + ysize;
1139  input[i].data[2] = input[i].data[1] + csize;
1140  input[i].linesize[0] = c->width;
1141  input[i].linesize[1] =
1142  input[i].linesize[2] = c->width / 2;
1143 
1144  if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1145  pre_input = *pre_input_ptr;
1146 
1147  if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1148  pre_input.f.data[0] += INPLACE_OFFSET;
1149  pre_input.f.data[1] += INPLACE_OFFSET;
1150  pre_input.f.data[2] += INPLACE_OFFSET;
1151  }
1152 
1153  s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1154  pre_input.f.data[0], pre_input.f.linesize[0],
1155  c->width, c->height);
1156  s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1157  pre_input.f.data[1], pre_input.f.linesize[1],
1158  c->width >> 1, c->height >> 1);
1159  s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1160  pre_input.f.data[2], pre_input.f.linesize[2],
1161  c->width >> 1, c->height >> 1);
1162  }
1163  }
1164 
1165  for (j = 0; j < s->max_b_frames + 1; j++) {
1166  int64_t rd = 0;
1167 
1168  if (!s->input_picture[j])
1169  break;
1170 
1171  c->error[0] = c->error[1] = c->error[2] = 0;
1172 
1173  input[0].pict_type = AV_PICTURE_TYPE_I;
1174  input[0].quality = 1 * FF_QP2LAMBDA;
1175 
1176  out_size = encode_frame(c, &input[0]);
1177 
1178  //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1179 
1180  for (i = 0; i < s->max_b_frames + 1; i++) {
1181  int is_p = i % (j + 1) == j || i == s->max_b_frames;
1182 
1183  input[i + 1].pict_type = is_p ?
1185  input[i + 1].quality = is_p ? p_lambda : b_lambda;
1186 
1187  out_size = encode_frame(c, &input[i + 1]);
1188 
1189  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1190  }
1191 
1192  /* get the delayed frames */
1193  while (out_size) {
1194  out_size = encode_frame(c, NULL);
1195  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1196  }
1197 
1198  rd += c->error[0] + c->error[1] + c->error[2];
1199 
1200  if (rd < best_rd) {
1201  best_rd = rd;
1202  best_b_count = j;
1203  }
1204  }
1205 
1206  avcodec_close(c);
1207  av_freep(&c);
1208 
1209  for (i = 0; i < s->max_b_frames + 2; i++) {
1210  av_freep(&input[i].data[0]);
1211  }
1212 
1213  return best_b_count;
1214 }
1215 
1217 {
1218  int i;
1219 
1220  for (i = 1; i < MAX_PICTURE_COUNT; i++)
1222  s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1223 
1224  /* set next picture type & ordering */
1225  if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1226  if (/*s->picture_in_gop_number >= s->gop_size ||*/
1227  s->next_picture_ptr == NULL || s->intra_only) {
1228  s->reordered_input_picture[0] = s->input_picture[0];
1231  s->coded_picture_number++;
1232  } else {
1233  int b_frames;
1234 
1236  if (s->picture_in_gop_number < s->gop_size &&
1237  skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1238  // FIXME check that te gop check above is +-1 correct
1239  if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1240  for (i = 0; i < 4; i++)
1241  s->input_picture[0]->f.data[i] = NULL;
1242  s->input_picture[0]->f.type = 0;
1243  } else {
1244  assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1246 
1247  s->avctx->release_buffer(s->avctx,
1248  &s->input_picture[0]->f);
1249  }
1250 
1251  emms_c();
1252  ff_vbv_update(s, 0);
1253 
1254  goto no_output_pic;
1255  }
1256  }
1257 
1258  if (s->flags & CODEC_FLAG_PASS2) {
1259  for (i = 0; i < s->max_b_frames + 1; i++) {
1260  int pict_num = s->input_picture[0]->f.display_picture_number + i;
1261 
1262  if (pict_num >= s->rc_context.num_entries)
1263  break;
1264  if (!s->input_picture[i]) {
1265  s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1266  break;
1267  }
1268 
1269  s->input_picture[i]->f.pict_type =
1270  s->rc_context.entry[pict_num].new_pict_type;
1271  }
1272  }
1273 
1274  if (s->avctx->b_frame_strategy == 0) {
1275  b_frames = s->max_b_frames;
1276  while (b_frames && !s->input_picture[b_frames])
1277  b_frames--;
1278  } else if (s->avctx->b_frame_strategy == 1) {
1279  for (i = 1; i < s->max_b_frames + 1; i++) {
1280  if (s->input_picture[i] &&
1281  s->input_picture[i]->b_frame_score == 0) {
1282  s->input_picture[i]->b_frame_score =
1283  get_intra_count(s,
1284  s->input_picture[i ]->f.data[0],
1285  s->input_picture[i - 1]->f.data[0],
1286  s->linesize) + 1;
1287  }
1288  }
1289  for (i = 0; i < s->max_b_frames + 1; i++) {
1290  if (s->input_picture[i] == NULL ||
1291  s->input_picture[i]->b_frame_score - 1 >
1292  s->mb_num / s->avctx->b_sensitivity)
1293  break;
1294  }
1295 
1296  b_frames = FFMAX(0, i - 1);
1297 
1298  /* reset scores */
1299  for (i = 0; i < b_frames + 1; i++) {
1300  s->input_picture[i]->b_frame_score = 0;
1301  }
1302  } else if (s->avctx->b_frame_strategy == 2) {
1303  b_frames = estimate_best_b_count(s);
1304  } else {
1305  av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1306  b_frames = 0;
1307  }
1308 
1309  emms_c();
1310 
1311  for (i = b_frames - 1; i >= 0; i--) {
1312  int type = s->input_picture[i]->f.pict_type;
1313  if (type && type != AV_PICTURE_TYPE_B)
1314  b_frames = i;
1315  }
1316  if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1317  b_frames == s->max_b_frames) {
1319  "warning, too many b frames in a row\n");
1320  }
1321 
1322  if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1323  if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1324  s->gop_size > s->picture_in_gop_number) {
1325  b_frames = s->gop_size - s->picture_in_gop_number - 1;
1326  } else {
1327  if (s->flags & CODEC_FLAG_CLOSED_GOP)
1328  b_frames = 0;
1329  s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1330  }
1331  }
1332 
1333  if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1334  s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1335  b_frames--;
1336 
1337  s->reordered_input_picture[0] = s->input_picture[b_frames];
1341  s->coded_picture_number++;
1342  for (i = 0; i < b_frames; i++) {
1343  s->reordered_input_picture[i + 1] = s->input_picture[i];
1344  s->reordered_input_picture[i + 1]->f.pict_type =
1347  s->coded_picture_number++;
1348  }
1349  }
1350  }
1351 no_output_pic:
1352  if (s->reordered_input_picture[0]) {
1355  AV_PICTURE_TYPE_B ? 3 : 0;
1356 
1358 
1360  s->avctx->rc_buffer_size) {
1361  // input is a shared pix, so we can't modifiy it -> alloc a new
1362  // one & ensure that the shared one is reuseable
1363 
1364  Picture *pic;
1365  int i = ff_find_unused_picture(s, 0);
1366  if (i < 0)
1367  return i;
1368  pic = &s->picture[i];
1369 
1371  if (ff_alloc_picture(s, pic, 0) < 0) {
1372  return -1;
1373  }
1374 
1375  /* mark us unused / free shared pic */
1377  s->avctx->release_buffer(s->avctx,
1378  &s->reordered_input_picture[0]->f);
1379  for (i = 0; i < 4; i++)
1380  s->reordered_input_picture[0]->f.data[i] = NULL;
1381  s->reordered_input_picture[0]->f.type = 0;
1382 
1383  copy_picture_attributes(s, &pic->f,
1384  &s->reordered_input_picture[0]->f);
1385 
1386  s->current_picture_ptr = pic;
1387  } else {
1388  // input is not a shared pix -> reuse buffer for current_pix
1389 
1390  assert(s->reordered_input_picture[0]->f.type ==
1392  s->reordered_input_picture[0]->f.type ==
1394 
1396  for (i = 0; i < 4; i++) {
1397  s->new_picture.f.data[i] += INPLACE_OFFSET;
1398  }
1399  }
1401 
1403  } else {
1404  memset(&s->new_picture, 0, sizeof(Picture));
1405  }
1406  return 0;
1407 }
1408 
1410  const AVFrame *pic_arg, int *got_packet)
1411 {
1412  MpegEncContext *s = avctx->priv_data;
1413  int i, stuffing_count, ret;
1414  int context_count = s->slice_context_count;
1415 
1416  s->picture_in_gop_number++;
1417 
1418  if (load_input_picture(s, pic_arg) < 0)
1419  return -1;
1420 
1421  if (select_input_picture(s) < 0) {
1422  return -1;
1423  }
1424 
1425  /* output? */
1426  if (s->new_picture.f.data[0]) {
1427  if (!pkt->data &&
1428  (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1429  return ret;
1430  if (s->mb_info) {
1433  s->mb_width*s->mb_height*12);
1434  s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1435  }
1436 
1437  for (i = 0; i < context_count; i++) {
1438  int start_y = s->thread_context[i]->start_mb_y;
1439  int end_y = s->thread_context[i]-> end_mb_y;
1440  int h = s->mb_height;
1441  uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1442  uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
1443 
1444  init_put_bits(&s->thread_context[i]->pb, start, end - start);
1445  }
1446 
1447  s->pict_type = s->new_picture.f.pict_type;
1448  //emms_c();
1449  ff_MPV_frame_start(s, avctx);
1450 vbv_retry:
1451  if (encode_picture(s, s->picture_number) < 0)
1452  return -1;
1453 
1454  avctx->header_bits = s->header_bits;
1455  avctx->mv_bits = s->mv_bits;
1456  avctx->misc_bits = s->misc_bits;
1457  avctx->i_tex_bits = s->i_tex_bits;
1458  avctx->p_tex_bits = s->p_tex_bits;
1459  avctx->i_count = s->i_count;
1460  // FIXME f/b_count in avctx
1461  avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1462  avctx->skip_count = s->skip_count;
1463 
1464  ff_MPV_frame_end(s);
1465 
1468 
1469  if (avctx->rc_buffer_size) {
1470  RateControlContext *rcc = &s->rc_context;
1471  int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1472 
1473  if (put_bits_count(&s->pb) > max_size &&
1474  s->lambda < s->avctx->lmax) {
1475  s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1476  (s->qscale + 1) / s->qscale);
1477  if (s->adaptive_quant) {
1478  int i;
1479  for (i = 0; i < s->mb_height * s->mb_stride; i++)
1480  s->lambda_table[i] =
1481  FFMAX(s->lambda_table[i] + 1,
1482  s->lambda_table[i] * (s->qscale + 1) /
1483  s->qscale);
1484  }
1485  s->mb_skipped = 0; // done in MPV_frame_start()
1486  // done in encode_picture() so we must undo it
1487  if (s->pict_type == AV_PICTURE_TYPE_P) {
1488  if (s->flipflop_rounding ||
1489  s->codec_id == AV_CODEC_ID_H263P ||
1491  s->no_rounding ^= 1;
1492  }
1493  if (s->pict_type != AV_PICTURE_TYPE_B) {
1494  s->time_base = s->last_time_base;
1495  s->last_non_b_time = s->time - s->pp_time;
1496  }
1497  for (i = 0; i < context_count; i++) {
1498  PutBitContext *pb = &s->thread_context[i]->pb;
1499  init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1500  }
1501  goto vbv_retry;
1502  }
1503 
1504  assert(s->avctx->rc_max_rate);
1505  }
1506 
1507  if (s->flags & CODEC_FLAG_PASS1)
1509 
1510  for (i = 0; i < 4; i++) {
1512  avctx->error[i] += s->current_picture_ptr->f.error[i];
1513  }
1514 
1515  if (s->flags & CODEC_FLAG_PASS1)
1516  assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1517  avctx->i_tex_bits + avctx->p_tex_bits ==
1518  put_bits_count(&s->pb));
1519  flush_put_bits(&s->pb);
1520  s->frame_bits = put_bits_count(&s->pb);
1521 
1522  stuffing_count = ff_vbv_update(s, s->frame_bits);
1523  if (stuffing_count) {
1524  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1525  stuffing_count + 50) {
1526  av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1527  return -1;
1528  }
1529 
1530  switch (s->codec_id) {
1533  while (stuffing_count--) {
1534  put_bits(&s->pb, 8, 0);
1535  }
1536  break;
1537  case AV_CODEC_ID_MPEG4:
1538  put_bits(&s->pb, 16, 0);
1539  put_bits(&s->pb, 16, 0x1C3);
1540  stuffing_count -= 4;
1541  while (stuffing_count--) {
1542  put_bits(&s->pb, 8, 0xFF);
1543  }
1544  break;
1545  default:
1546  av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1547  }
1548  flush_put_bits(&s->pb);
1549  s->frame_bits = put_bits_count(&s->pb);
1550  }
1551 
1552  /* update mpeg1/2 vbv_delay for CBR */
1553  if (s->avctx->rc_max_rate &&
1554  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1555  s->out_format == FMT_MPEG1 &&
1556  90000LL * (avctx->rc_buffer_size - 1) <=
1557  s->avctx->rc_max_rate * 0xFFFFLL) {
1558  int vbv_delay, min_delay;
1559  double inbits = s->avctx->rc_max_rate *
1560  av_q2d(s->avctx->time_base);
1561  int minbits = s->frame_bits - 8 *
1562  (s->vbv_delay_ptr - s->pb.buf - 1);
1563  double bits = s->rc_context.buffer_index + minbits - inbits;
1564 
1565  if (bits < 0)
1567  "Internal error, negative bits\n");
1568 
1569  assert(s->repeat_first_field == 0);
1570 
1571  vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1572  min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1573  s->avctx->rc_max_rate;
1574 
1575  vbv_delay = FFMAX(vbv_delay, min_delay);
1576 
1577  assert(vbv_delay < 0xFFFF);
1578 
1579  s->vbv_delay_ptr[0] &= 0xF8;
1580  s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1581  s->vbv_delay_ptr[1] = vbv_delay >> 5;
1582  s->vbv_delay_ptr[2] &= 0x07;
1583  s->vbv_delay_ptr[2] |= vbv_delay << 3;
1584  avctx->vbv_delay = vbv_delay * 300;
1585  }
1586  s->total_bits += s->frame_bits;
1587  avctx->frame_bits = s->frame_bits;
1588 
1589  pkt->pts = s->current_picture.f.pts;
1590  if (!s->low_delay) {
1592  pkt->dts = pkt->pts - s->dts_delta;
1593  else
1594  pkt->dts = s->reordered_pts;
1595  s->reordered_pts = s->input_picture[0]->f.pts;
1596  } else
1597  pkt->dts = pkt->pts;
1598  if (s->current_picture.f.key_frame)
1599  pkt->flags |= AV_PKT_FLAG_KEY;
1600  if (s->mb_info)
1602  } else {
1603  s->frame_bits = 0;
1604  }
1605  assert((s->frame_bits & 7) == 0);
1606 
1607  pkt->size = s->frame_bits / 8;
1608  *got_packet = !!pkt->size;
1609  return 0;
1610 }
1611 
1613  int n, int threshold)
1614 {
1615  static const char tab[64] = {
1616  3, 2, 2, 1, 1, 1, 1, 1,
1617  1, 1, 1, 1, 1, 1, 1, 1,
1618  1, 1, 1, 1, 1, 1, 1, 1,
1619  0, 0, 0, 0, 0, 0, 0, 0,
1620  0, 0, 0, 0, 0, 0, 0, 0,
1621  0, 0, 0, 0, 0, 0, 0, 0,
1622  0, 0, 0, 0, 0, 0, 0, 0,
1623  0, 0, 0, 0, 0, 0, 0, 0
1624  };
1625  int score = 0;
1626  int run = 0;
1627  int i;
1628  DCTELEM *block = s->block[n];
1629  const int last_index = s->block_last_index[n];
1630  int skip_dc;
1631 
1632  if (threshold < 0) {
1633  skip_dc = 0;
1634  threshold = -threshold;
1635  } else
1636  skip_dc = 1;
1637 
1638  /* Are all we could set to zero already zero? */
1639  if (last_index <= skip_dc - 1)
1640  return;
1641 
1642  for (i = 0; i <= last_index; i++) {
1643  const int j = s->intra_scantable.permutated[i];
1644  const int level = FFABS(block[j]);
1645  if (level == 1) {
1646  if (skip_dc && i == 0)
1647  continue;
1648  score += tab[run];
1649  run = 0;
1650  } else if (level > 1) {
1651  return;
1652  } else {
1653  run++;
1654  }
1655  }
1656  if (score >= threshold)
1657  return;
1658  for (i = skip_dc; i <= last_index; i++) {
1659  const int j = s->intra_scantable.permutated[i];
1660  block[j] = 0;
1661  }
1662  if (block[0])
1663  s->block_last_index[n] = 0;
1664  else
1665  s->block_last_index[n] = -1;
1666 }
1667 
1668 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1669  int last_index)
1670 {
1671  int i;
1672  const int maxlevel = s->max_qcoeff;
1673  const int minlevel = s->min_qcoeff;
1674  int overflow = 0;
1675 
1676  if (s->mb_intra) {
1677  i = 1; // skip clipping of intra dc
1678  } else
1679  i = 0;
1680 
1681  for (; i <= last_index; i++) {
1682  const int j = s->intra_scantable.permutated[i];
1683  int level = block[j];
1684 
1685  if (level > maxlevel) {
1686  level = maxlevel;
1687  overflow++;
1688  } else if (level < minlevel) {
1689  level = minlevel;
1690  overflow++;
1691  }
1692 
1693  block[j] = level;
1694  }
1695 
1696  if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1697  av_log(s->avctx, AV_LOG_INFO,
1698  "warning, clipping %d dct coefficients to %d..%d\n",
1699  overflow, minlevel, maxlevel);
1700 }
1701 
1702 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1703 {
1704  int x, y;
1705  // FIXME optimize
1706  for (y = 0; y < 8; y++) {
1707  for (x = 0; x < 8; x++) {
1708  int x2, y2;
1709  int sum = 0;
1710  int sqr = 0;
1711  int count = 0;
1712 
1713  for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1714  for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1715  int v = ptr[x2 + y2 * stride];
1716  sum += v;
1717  sqr += v * v;
1718  count++;
1719  }
1720  }
1721  weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1722  }
1723  }
1724 }
1725 
1727  int motion_x, int motion_y,
1728  int mb_block_height,
1729  int mb_block_count)
1730 {
1731  int16_t weight[8][64];
1732  DCTELEM orig[8][64];
1733  const int mb_x = s->mb_x;
1734  const int mb_y = s->mb_y;
1735  int i;
1736  int skip_dct[8];
1737  int dct_offset = s->linesize * 8; // default for progressive frames
1738  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1739  int wrap_y, wrap_c;
1740 
1741  for (i = 0; i < mb_block_count; i++)
1742  skip_dct[i] = s->skipdct;
1743 
1744  if (s->adaptive_quant) {
1745  const int last_qp = s->qscale;
1746  const int mb_xy = mb_x + mb_y * s->mb_stride;
1747 
1748  s->lambda = s->lambda_table[mb_xy];
1749  update_qscale(s);
1750 
1751  if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1752  s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1753  s->dquant = s->qscale - last_qp;
1754 
1755  if (s->out_format == FMT_H263) {
1756  s->dquant = av_clip(s->dquant, -2, 2);
1757 
1758  if (s->codec_id == AV_CODEC_ID_MPEG4) {
1759  if (!s->mb_intra) {
1760  if (s->pict_type == AV_PICTURE_TYPE_B) {
1761  if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1762  s->dquant = 0;
1763  }
1764  if (s->mv_type == MV_TYPE_8X8)
1765  s->dquant = 0;
1766  }
1767  }
1768  }
1769  }
1770  ff_set_qscale(s, last_qp + s->dquant);
1771  } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1772  ff_set_qscale(s, s->qscale + s->dquant);
1773 
1774  wrap_y = s->linesize;
1775  wrap_c = s->uvlinesize;
1776  ptr_y = s->new_picture.f.data[0] +
1777  (mb_y * 16 * wrap_y) + mb_x * 16;
1778  ptr_cb = s->new_picture.f.data[1] +
1779  (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1780  ptr_cr = s->new_picture.f.data[2] +
1781  (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1782 
1783  if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1784  uint8_t *ebuf = s->edge_emu_buffer + 32;
1785  s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1786  mb_y * 16, s->width, s->height);
1787  ptr_y = ebuf;
1788  s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1789  mb_block_height, mb_x * 8, mb_y * 8,
1790  s->width >> 1, s->height >> 1);
1791  ptr_cb = ebuf + 18 * wrap_y;
1792  s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1793  mb_block_height, mb_x * 8, mb_y * 8,
1794  s->width >> 1, s->height >> 1);
1795  ptr_cr = ebuf + 18 * wrap_y + 8;
1796  }
1797 
1798  if (s->mb_intra) {
1799  if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1800  int progressive_score, interlaced_score;
1801 
1802  s->interlaced_dct = 0;
1803  progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1804  NULL, wrap_y, 8) +
1805  s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1806  NULL, wrap_y, 8) - 400;
1807 
1808  if (progressive_score > 0) {
1809  interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1810  NULL, wrap_y * 2, 8) +
1811  s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1812  NULL, wrap_y * 2, 8);
1813  if (progressive_score > interlaced_score) {
1814  s->interlaced_dct = 1;
1815 
1816  dct_offset = wrap_y;
1817  wrap_y <<= 1;
1818  if (s->chroma_format == CHROMA_422)
1819  wrap_c <<= 1;
1820  }
1821  }
1822  }
1823 
1824  s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1825  s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1826  s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1827  s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1828 
1829  if (s->flags & CODEC_FLAG_GRAY) {
1830  skip_dct[4] = 1;
1831  skip_dct[5] = 1;
1832  } else {
1833  s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1834  s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1835  if (!s->chroma_y_shift) { /* 422 */
1836  s->dsp.get_pixels(s->block[6],
1837  ptr_cb + (dct_offset >> 1), wrap_c);
1838  s->dsp.get_pixels(s->block[7],
1839  ptr_cr + (dct_offset >> 1), wrap_c);
1840  }
1841  }
1842  } else {
1843  op_pixels_func (*op_pix)[4];
1844  qpel_mc_func (*op_qpix)[16];
1845  uint8_t *dest_y, *dest_cb, *dest_cr;
1846 
1847  dest_y = s->dest[0];
1848  dest_cb = s->dest[1];
1849  dest_cr = s->dest[2];
1850 
1851  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1852  op_pix = s->dsp.put_pixels_tab;
1853  op_qpix = s->dsp.put_qpel_pixels_tab;
1854  } else {
1855  op_pix = s->dsp.put_no_rnd_pixels_tab;
1856  op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1857  }
1858 
1859  if (s->mv_dir & MV_DIR_FORWARD) {
1860  ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1861  s->last_picture.f.data,
1862  op_pix, op_qpix);
1863  op_pix = s->dsp.avg_pixels_tab;
1864  op_qpix = s->dsp.avg_qpel_pixels_tab;
1865  }
1866  if (s->mv_dir & MV_DIR_BACKWARD) {
1867  ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1868  s->next_picture.f.data,
1869  op_pix, op_qpix);
1870  }
1871 
1872  if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1873  int progressive_score, interlaced_score;
1874 
1875  s->interlaced_dct = 0;
1876  progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1877  ptr_y, wrap_y,
1878  8) +
1879  s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1880  ptr_y + wrap_y * 8, wrap_y,
1881  8) - 400;
1882 
1883  if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1884  progressive_score -= 400;
1885 
1886  if (progressive_score > 0) {
1887  interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1888  ptr_y,
1889  wrap_y * 2, 8) +
1890  s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1891  ptr_y + wrap_y,
1892  wrap_y * 2, 8);
1893 
1894  if (progressive_score > interlaced_score) {
1895  s->interlaced_dct = 1;
1896 
1897  dct_offset = wrap_y;
1898  wrap_y <<= 1;
1899  if (s->chroma_format == CHROMA_422)
1900  wrap_c <<= 1;
1901  }
1902  }
1903  }
1904 
1905  s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1906  s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1907  s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1908  dest_y + dct_offset, wrap_y);
1909  s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1910  dest_y + dct_offset + 8, wrap_y);
1911 
1912  if (s->flags & CODEC_FLAG_GRAY) {
1913  skip_dct[4] = 1;
1914  skip_dct[5] = 1;
1915  } else {
1916  s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1917  s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1918  if (!s->chroma_y_shift) { /* 422 */
1919  s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1920  dest_cb + (dct_offset >> 1), wrap_c);
1921  s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1922  dest_cr + (dct_offset >> 1), wrap_c);
1923  }
1924  }
1925  /* pre quantization */
1926  if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1927  2 * s->qscale * s->qscale) {
1928  // FIXME optimize
1929  if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1930  wrap_y, 8) < 20 * s->qscale)
1931  skip_dct[0] = 1;
1932  if (s->dsp.sad[1](NULL, ptr_y + 8,
1933  dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1934  skip_dct[1] = 1;
1935  if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1936  dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1937  skip_dct[2] = 1;
1938  if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1939  dest_y + dct_offset + 8,
1940  wrap_y, 8) < 20 * s->qscale)
1941  skip_dct[3] = 1;
1942  if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1943  wrap_c, 8) < 20 * s->qscale)
1944  skip_dct[4] = 1;
1945  if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1946  wrap_c, 8) < 20 * s->qscale)
1947  skip_dct[5] = 1;
1948  if (!s->chroma_y_shift) { /* 422 */
1949  if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1950  dest_cb + (dct_offset >> 1),
1951  wrap_c, 8) < 20 * s->qscale)
1952  skip_dct[6] = 1;
1953  if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1954  dest_cr + (dct_offset >> 1),
1955  wrap_c, 8) < 20 * s->qscale)
1956  skip_dct[7] = 1;
1957  }
1958  }
1959  }
1960 
1961  if (s->quantizer_noise_shaping) {
1962  if (!skip_dct[0])
1963  get_visual_weight(weight[0], ptr_y , wrap_y);
1964  if (!skip_dct[1])
1965  get_visual_weight(weight[1], ptr_y + 8, wrap_y);
1966  if (!skip_dct[2])
1967  get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
1968  if (!skip_dct[3])
1969  get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
1970  if (!skip_dct[4])
1971  get_visual_weight(weight[4], ptr_cb , wrap_c);
1972  if (!skip_dct[5])
1973  get_visual_weight(weight[5], ptr_cr , wrap_c);
1974  if (!s->chroma_y_shift) { /* 422 */
1975  if (!skip_dct[6])
1976  get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
1977  wrap_c);
1978  if (!skip_dct[7])
1979  get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
1980  wrap_c);
1981  }
1982  memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
1983  }
1984 
1985  /* DCT & quantize */
1986  assert(s->out_format != FMT_MJPEG || s->qscale == 8);
1987  {
1988  for (i = 0; i < mb_block_count; i++) {
1989  if (!skip_dct[i]) {
1990  int overflow;
1991  s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
1992  // FIXME we could decide to change to quantizer instead of
1993  // clipping
1994  // JS: I don't think that would be a good idea it could lower
1995  // quality instead of improve it. Just INTRADC clipping
1996  // deserves changes in quantizer
1997  if (overflow)
1998  clip_coeffs(s, s->block[i], s->block_last_index[i]);
1999  } else
2000  s->block_last_index[i] = -1;
2001  }
2002  if (s->quantizer_noise_shaping) {
2003  for (i = 0; i < mb_block_count; i++) {
2004  if (!skip_dct[i]) {
2005  s->block_last_index[i] =
2006  dct_quantize_refine(s, s->block[i], weight[i],
2007  orig[i], i, s->qscale);
2008  }
2009  }
2010  }
2011 
2012  if (s->luma_elim_threshold && !s->mb_intra)
2013  for (i = 0; i < 4; i++)
2015  if (s->chroma_elim_threshold && !s->mb_intra)
2016  for (i = 4; i < mb_block_count; i++)
2018 
2019  if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2020  for (i = 0; i < mb_block_count; i++) {
2021  if (s->block_last_index[i] == -1)
2022  s->coded_score[i] = INT_MAX / 256;
2023  }
2024  }
2025  }
2026 
2027  if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2028  s->block_last_index[4] =
2029  s->block_last_index[5] = 0;
2030  s->block[4][0] =
2031  s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2032  }
2033 
2034  // non c quantize code returns incorrect block_last_index FIXME
2035  if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2036  for (i = 0; i < mb_block_count; i++) {
2037  int j;
2038  if (s->block_last_index[i] > 0) {
2039  for (j = 63; j > 0; j--) {
2040  if (s->block[i][s->intra_scantable.permutated[j]])
2041  break;
2042  }
2043  s->block_last_index[i] = j;
2044  }
2045  }
2046  }
2047 
2048  /* huffman encode */
2049  switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2053  ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2054  break;
2055  case AV_CODEC_ID_MPEG4:
2057  ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2058  break;
2059  case AV_CODEC_ID_MSMPEG4V2:
2060  case AV_CODEC_ID_MSMPEG4V3:
2061  case AV_CODEC_ID_WMV1:
2063  ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2064  break;
2065  case AV_CODEC_ID_WMV2:
2066  if (CONFIG_WMV2_ENCODER)
2067  ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2068  break;
2069  case AV_CODEC_ID_H261:
2070  if (CONFIG_H261_ENCODER)
2071  ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2072  break;
2073  case AV_CODEC_ID_H263:
2074  case AV_CODEC_ID_H263P:
2075  case AV_CODEC_ID_FLV1:
2076  case AV_CODEC_ID_RV10:
2077  case AV_CODEC_ID_RV20:
2078  if (CONFIG_H263_ENCODER)
2079  ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2080  break;
2081  case AV_CODEC_ID_MJPEG:
2083  ff_mjpeg_encode_mb(s, s->block);
2084  break;
2085  default:
2086  assert(0);
2087  }
2088 }
2089 
2090 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2091 {
2092  if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2093  else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2094 }
2095 
2096 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2097  int i;
2098 
2099  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2100 
2101  /* mpeg1 */
2102  d->mb_skip_run= s->mb_skip_run;
2103  for(i=0; i<3; i++)
2104  d->last_dc[i] = s->last_dc[i];
2105 
2106  /* statistics */
2107  d->mv_bits= s->mv_bits;
2108  d->i_tex_bits= s->i_tex_bits;
2109  d->p_tex_bits= s->p_tex_bits;
2110  d->i_count= s->i_count;
2111  d->f_count= s->f_count;
2112  d->b_count= s->b_count;
2113  d->skip_count= s->skip_count;
2114  d->misc_bits= s->misc_bits;
2115  d->last_bits= 0;
2116 
2117  d->mb_skipped= 0;
2118  d->qscale= s->qscale;
2119  d->dquant= s->dquant;
2120 
2122 }
2123 
2124 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2125  int i;
2126 
2127  memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2128  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2129 
2130  /* mpeg1 */
2131  d->mb_skip_run= s->mb_skip_run;
2132  for(i=0; i<3; i++)
2133  d->last_dc[i] = s->last_dc[i];
2134 
2135  /* statistics */
2136  d->mv_bits= s->mv_bits;
2137  d->i_tex_bits= s->i_tex_bits;
2138  d->p_tex_bits= s->p_tex_bits;
2139  d->i_count= s->i_count;
2140  d->f_count= s->f_count;
2141  d->b_count= s->b_count;
2142  d->skip_count= s->skip_count;
2143  d->misc_bits= s->misc_bits;
2144 
2145  d->mb_intra= s->mb_intra;
2146  d->mb_skipped= s->mb_skipped;
2147  d->mv_type= s->mv_type;
2148  d->mv_dir= s->mv_dir;
2149  d->pb= s->pb;
2150  if(s->data_partitioning){
2151  d->pb2= s->pb2;
2152  d->tex_pb= s->tex_pb;
2153  }
2154  d->block= s->block;
2155  for(i=0; i<8; i++)
2156  d->block_last_index[i]= s->block_last_index[i];
2158  d->qscale= s->qscale;
2159 
2161 }
2162 
2163 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2165  int *dmin, int *next_block, int motion_x, int motion_y)
2166 {
2167  int score;
2168  uint8_t *dest_backup[3];
2169 
2170  copy_context_before_encode(s, backup, type);
2171 
2172  s->block= s->blocks[*next_block];
2173  s->pb= pb[*next_block];
2174  if(s->data_partitioning){
2175  s->pb2 = pb2 [*next_block];
2176  s->tex_pb= tex_pb[*next_block];
2177  }
2178 
2179  if(*next_block){
2180  memcpy(dest_backup, s->dest, sizeof(s->dest));
2181  s->dest[0] = s->rd_scratchpad;
2182  s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2183  s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2184  assert(s->linesize >= 32); //FIXME
2185  }
2186 
2187  encode_mb(s, motion_x, motion_y);
2188 
2189  score= put_bits_count(&s->pb);
2190  if(s->data_partitioning){
2191  score+= put_bits_count(&s->pb2);
2192  score+= put_bits_count(&s->tex_pb);
2193  }
2194 
2195  if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2196  ff_MPV_decode_mb(s, s->block);
2197 
2198  score *= s->lambda2;
2199  score += sse_mb(s) << FF_LAMBDA_SHIFT;
2200  }
2201 
2202  if(*next_block){
2203  memcpy(s->dest, dest_backup, sizeof(s->dest));
2204  }
2205 
2206  if(score<*dmin){
2207  *dmin= score;
2208  *next_block^=1;
2209 
2210  copy_context_after_encode(best, s, type);
2211  }
2212 }
2213 
2214 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2215  uint32_t *sq = ff_squareTbl + 256;
2216  int acc=0;
2217  int x,y;
2218 
2219  if(w==16 && h==16)
2220  return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2221  else if(w==8 && h==8)
2222  return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2223 
2224  for(y=0; y<h; y++){
2225  for(x=0; x<w; x++){
2226  acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2227  }
2228  }
2229 
2230  assert(acc>=0);
2231 
2232  return acc;
2233 }
2234 
2235 static int sse_mb(MpegEncContext *s){
2236  int w= 16;
2237  int h= 16;
2238 
2239  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2240  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2241 
2242  if(w==16 && h==16)
2243  if(s->avctx->mb_cmp == FF_CMP_NSSE){
2244  return s->dsp.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)
2245  +s->dsp.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)
2246  +s->dsp.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);
2247  }else{
2248  return s->dsp.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)
2249  +s->dsp.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)
2250  +s->dsp.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);
2251  }
2252  else
2253  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)
2254  +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)
2255  +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);
2256 }
2257 
2258 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2259  MpegEncContext *s= *(void**)arg;
2260 
2261 
2262  s->me.pre_pass=1;
2263  s->me.dia_size= s->avctx->pre_dia_size;
2264  s->first_slice_line=1;
2265  for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2266  for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2268  }
2269  s->first_slice_line=0;
2270  }
2271 
2272  s->me.pre_pass=0;
2273 
2274  return 0;
2275 }
2276 
2277 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2278  MpegEncContext *s= *(void**)arg;
2279 
2281 
2282  s->me.dia_size= s->avctx->dia_size;
2283  s->first_slice_line=1;
2284  for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2285  s->mb_x=0; //for block init below
2287  for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2288  s->block_index[0]+=2;
2289  s->block_index[1]+=2;
2290  s->block_index[2]+=2;
2291  s->block_index[3]+=2;
2292 
2293  /* compute motion vector & mb_type and store in context */
2296  else
2298  }
2299  s->first_slice_line=0;
2300  }
2301  return 0;
2302 }
2303 
2304 static int mb_var_thread(AVCodecContext *c, void *arg){
2305  MpegEncContext *s= *(void**)arg;
2306  int mb_x, mb_y;
2307 
2309 
2310  for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2311  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2312  int xx = mb_x * 16;
2313  int yy = mb_y * 16;
2314  uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2315  int varc;
2316  int sum = s->dsp.pix_sum(pix, s->linesize);
2317 
2318  varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2319 
2320  s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2321  s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2322  s->me.mb_var_sum_temp += varc;
2323  }
2324  }
2325  return 0;
2326 }
2327 
2330  if(s->partitioned_frame){
2332  }
2333 
2334  ff_mpeg4_stuffing(&s->pb);
2335  }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2337  }
2338 
2340  flush_put_bits(&s->pb);
2341 
2342  if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2343  s->misc_bits+= get_bits_diff(s);
2344 }
2345 
2347 {
2348  uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2349  int offset = put_bits_count(&s->pb);
2350  int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2351  int gobn = s->mb_y / s->gob_index;
2352  int pred_x, pred_y;
2353  if (CONFIG_H263_ENCODER)
2354  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2355  bytestream_put_le32(&ptr, offset);
2356  bytestream_put_byte(&ptr, s->qscale);
2357  bytestream_put_byte(&ptr, gobn);
2358  bytestream_put_le16(&ptr, mba);
2359  bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2360  bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2361  /* 4MV not implemented */
2362  bytestream_put_byte(&ptr, 0); /* hmv2 */
2363  bytestream_put_byte(&ptr, 0); /* vmv2 */
2364 }
2365 
2366 static void update_mb_info(MpegEncContext *s, int startcode)
2367 {
2368  if (!s->mb_info)
2369  return;
2370  if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2371  s->mb_info_size += 12;
2372  s->prev_mb_info = s->last_mb_info;
2373  }
2374  if (startcode) {
2375  s->prev_mb_info = put_bits_count(&s->pb)/8;
2376  /* This might have incremented mb_info_size above, and we return without
2377  * actually writing any info into that slot yet. But in that case,
2378  * this will be called again at the start of the after writing the
2379  * start code, actually writing the mb info. */
2380  return;
2381  }
2382 
2383  s->last_mb_info = put_bits_count(&s->pb)/8;
2384  if (!s->mb_info_size)
2385  s->mb_info_size += 12;
2386  write_mb_info(s);
2387 }
2388 
2389 static int encode_thread(AVCodecContext *c, void *arg){
2390  MpegEncContext *s= *(void**)arg;
2391  int mb_x, mb_y, pdif = 0;
2392  int chr_h= 16>>s->chroma_y_shift;
2393  int i, j;
2394  MpegEncContext best_s, backup_s;
2395  uint8_t bit_buf[2][MAX_MB_BYTES];
2396  uint8_t bit_buf2[2][MAX_MB_BYTES];
2397  uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2398  PutBitContext pb[2], pb2[2], tex_pb[2];
2399 
2401 
2402  for(i=0; i<2; i++){
2403  init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2404  init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2405  init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2406  }
2407 
2408  s->last_bits= put_bits_count(&s->pb);
2409  s->mv_bits=0;
2410  s->misc_bits=0;
2411  s->i_tex_bits=0;
2412  s->p_tex_bits=0;
2413  s->i_count=0;
2414  s->f_count=0;
2415  s->b_count=0;
2416  s->skip_count=0;
2417 
2418  for(i=0; i<3; i++){
2419  /* init last dc values */
2420  /* note: quant matrix value (8) is implied here */
2421  s->last_dc[i] = 128 << s->intra_dc_precision;
2422 
2423  s->current_picture.f.error[i] = 0;
2424  }
2425  s->mb_skip_run = 0;
2426  memset(s->last_mv, 0, sizeof(s->last_mv));
2427 
2428  s->last_mv_dir = 0;
2429 
2430  switch(s->codec_id){
2431  case AV_CODEC_ID_H263:
2432  case AV_CODEC_ID_H263P:
2433  case AV_CODEC_ID_FLV1:
2434  if (CONFIG_H263_ENCODER)
2436  break;
2437  case AV_CODEC_ID_MPEG4:
2440  break;
2441  }
2442 
2443  s->resync_mb_x=0;
2444  s->resync_mb_y=0;
2445  s->first_slice_line = 1;
2446  s->ptr_lastgob = s->pb.buf;
2447  for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2448  s->mb_x=0;
2449  s->mb_y= mb_y;
2450 
2451  ff_set_qscale(s, s->qscale);
2453 
2454  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2455  int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2456  int mb_type= s->mb_type[xy];
2457 // int d;
2458  int dmin= INT_MAX;
2459  int dir;
2460 
2461  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2462  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2463  return -1;
2464  }
2465  if(s->data_partitioning){
2466  if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2467  || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2468  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2469  return -1;
2470  }
2471  }
2472 
2473  s->mb_x = mb_x;
2474  s->mb_y = mb_y; // moved into loop, can get changed by H.261
2476 
2479  xy= s->mb_y*s->mb_stride + s->mb_x;
2480  mb_type= s->mb_type[xy];
2481  }
2482 
2483  /* write gob / video packet header */
2484  if(s->rtp_mode){
2485  int current_packet_size, is_gob_start;
2486 
2487  current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2488 
2489  is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2490 
2491  if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2492 
2493  switch(s->codec_id){
2494  case AV_CODEC_ID_H263:
2495  case AV_CODEC_ID_H263P:
2496  if(!s->h263_slice_structured)
2497  if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2498  break;
2500  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2502  if(s->mb_skip_run) is_gob_start=0;
2503  break;
2504  }
2505 
2506  if(is_gob_start){
2507  if(s->start_mb_y != mb_y || mb_x!=0){
2508  write_slice_end(s);
2509 
2512  }
2513  }
2514 
2515  assert((put_bits_count(&s->pb)&7) == 0);
2516  current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2517 
2518  if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2519  int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2520  int d= 100 / s->avctx->error_rate;
2521  if(r % d == 0){
2522  current_packet_size=0;
2523  s->pb.buf_ptr= s->ptr_lastgob;
2524  assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2525  }
2526  }
2527 
2528  if (s->avctx->rtp_callback){
2529  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2530  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2531  }
2532  update_mb_info(s, 1);
2533 
2534  switch(s->codec_id){
2535  case AV_CODEC_ID_MPEG4:
2536  if (CONFIG_MPEG4_ENCODER) {
2539  }
2540  break;
2546  }
2547  break;
2548  case AV_CODEC_ID_H263:
2549  case AV_CODEC_ID_H263P:
2550  if (CONFIG_H263_ENCODER)
2551  ff_h263_encode_gob_header(s, mb_y);
2552  break;
2553  }
2554 
2555  if(s->flags&CODEC_FLAG_PASS1){
2556  int bits= put_bits_count(&s->pb);
2557  s->misc_bits+= bits - s->last_bits;
2558  s->last_bits= bits;
2559  }
2560 
2561  s->ptr_lastgob += current_packet_size;
2562  s->first_slice_line=1;
2563  s->resync_mb_x=mb_x;
2564  s->resync_mb_y=mb_y;
2565  }
2566  }
2567 
2568  if( (s->resync_mb_x == s->mb_x)
2569  && s->resync_mb_y+1 == s->mb_y){
2570  s->first_slice_line=0;
2571  }
2572 
2573  s->mb_skipped=0;
2574  s->dquant=0; //only for QP_RD
2575 
2576  update_mb_info(s, 0);
2577 
2578  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
2579  int next_block=0;
2580  int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2581 
2582  copy_context_before_encode(&backup_s, s, -1);
2583  backup_s.pb= s->pb;
2586  if(s->data_partitioning){
2587  backup_s.pb2= s->pb2;
2588  backup_s.tex_pb= s->tex_pb;
2589  }
2590 
2591  if(mb_type&CANDIDATE_MB_TYPE_INTER){
2592  s->mv_dir = MV_DIR_FORWARD;
2593  s->mv_type = MV_TYPE_16X16;
2594  s->mb_intra= 0;
2595  s->mv[0][0][0] = s->p_mv_table[xy][0];
2596  s->mv[0][0][1] = s->p_mv_table[xy][1];
2597  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2598  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2599  }
2600  if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2601  s->mv_dir = MV_DIR_FORWARD;
2602  s->mv_type = MV_TYPE_FIELD;
2603  s->mb_intra= 0;
2604  for(i=0; i<2; i++){
2605  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2606  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2607  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2608  }
2609  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2610  &dmin, &next_block, 0, 0);
2611  }
2612  if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2613  s->mv_dir = MV_DIR_FORWARD;
2614  s->mv_type = MV_TYPE_16X16;
2615  s->mb_intra= 0;
2616  s->mv[0][0][0] = 0;
2617  s->mv[0][0][1] = 0;
2618  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2619  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2620  }
2621  if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2622  s->mv_dir = MV_DIR_FORWARD;
2623  s->mv_type = MV_TYPE_8X8;
2624  s->mb_intra= 0;
2625  for(i=0; i<4; i++){
2626  s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2627  s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2628  }
2629  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2630  &dmin, &next_block, 0, 0);
2631  }
2632  if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2633  s->mv_dir = MV_DIR_FORWARD;
2634  s->mv_type = MV_TYPE_16X16;
2635  s->mb_intra= 0;
2636  s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2637  s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2638  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2639  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2640  }
2641  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2642  s->mv_dir = MV_DIR_BACKWARD;
2643  s->mv_type = MV_TYPE_16X16;
2644  s->mb_intra= 0;
2645  s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2646  s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2647  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2648  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2649  }
2650  if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2652  s->mv_type = MV_TYPE_16X16;
2653  s->mb_intra= 0;
2654  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2655  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2656  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2657  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2658  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2659  &dmin, &next_block, 0, 0);
2660  }
2661  if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2662  s->mv_dir = MV_DIR_FORWARD;
2663  s->mv_type = MV_TYPE_FIELD;
2664  s->mb_intra= 0;
2665  for(i=0; i<2; i++){
2666  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2667  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2668  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2669  }
2670  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2671  &dmin, &next_block, 0, 0);
2672  }
2673  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2674  s->mv_dir = MV_DIR_BACKWARD;
2675  s->mv_type = MV_TYPE_FIELD;
2676  s->mb_intra= 0;
2677  for(i=0; i<2; i++){
2678  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2679  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2680  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2681  }
2682  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2683  &dmin, &next_block, 0, 0);
2684  }
2685  if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2687  s->mv_type = MV_TYPE_FIELD;
2688  s->mb_intra= 0;
2689  for(dir=0; dir<2; dir++){
2690  for(i=0; i<2; i++){
2691  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2692  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2693  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2694  }
2695  }
2696  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2697  &dmin, &next_block, 0, 0);
2698  }
2699  if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2700  s->mv_dir = 0;
2701  s->mv_type = MV_TYPE_16X16;
2702  s->mb_intra= 1;
2703  s->mv[0][0][0] = 0;
2704  s->mv[0][0][1] = 0;
2705  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2706  &dmin, &next_block, 0, 0);
2707  if(s->h263_pred || s->h263_aic){
2708  if(best_s.mb_intra)
2709  s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2710  else
2711  ff_clean_intra_table_entries(s); //old mode?
2712  }
2713  }
2714 
2715  if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2716  if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2717  const int last_qp= backup_s.qscale;
2718  int qpi, qp, dc[6];
2719  DCTELEM ac[6][16];
2720  const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2721  static const int dquant_tab[4]={-1,1,-2,2};
2722 
2723  assert(backup_s.dquant == 0);
2724 
2725  //FIXME intra
2726  s->mv_dir= best_s.mv_dir;
2727  s->mv_type = MV_TYPE_16X16;
2728  s->mb_intra= best_s.mb_intra;
2729  s->mv[0][0][0] = best_s.mv[0][0][0];
2730  s->mv[0][0][1] = best_s.mv[0][0][1];
2731  s->mv[1][0][0] = best_s.mv[1][0][0];
2732  s->mv[1][0][1] = best_s.mv[1][0][1];
2733 
2734  qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2735  for(; qpi<4; qpi++){
2736  int dquant= dquant_tab[qpi];
2737  qp= last_qp + dquant;
2738  if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2739  continue;
2740  backup_s.dquant= dquant;
2741  if(s->mb_intra && s->dc_val[0]){
2742  for(i=0; i<6; i++){
2743  dc[i]= s->dc_val[0][ s->block_index[i] ];
2744  memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2745  }
2746  }
2747 
2748  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2749  &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2750  if(best_s.qscale != qp){
2751  if(s->mb_intra && s->dc_val[0]){
2752  for(i=0; i<6; i++){
2753  s->dc_val[0][ s->block_index[i] ]= dc[i];
2754  memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2755  }
2756  }
2757  }
2758  }
2759  }
2760  }
2762  int mx= s->b_direct_mv_table[xy][0];
2763  int my= s->b_direct_mv_table[xy][1];
2764 
2765  backup_s.dquant = 0;
2767  s->mb_intra= 0;
2768  ff_mpeg4_set_direct_mv(s, mx, my);
2769  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2770  &dmin, &next_block, mx, my);
2771  }
2773  backup_s.dquant = 0;
2775  s->mb_intra= 0;
2776  ff_mpeg4_set_direct_mv(s, 0, 0);
2777  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2778  &dmin, &next_block, 0, 0);
2779  }
2780  if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2781  int coded=0;
2782  for(i=0; i<6; i++)
2783  coded |= s->block_last_index[i];
2784  if(coded){
2785  int mx,my;
2786  memcpy(s->mv, best_s.mv, sizeof(s->mv));
2787  if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2788  mx=my=0; //FIXME find the one we actually used
2789  ff_mpeg4_set_direct_mv(s, mx, my);
2790  }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2791  mx= s->mv[1][0][0];
2792  my= s->mv[1][0][1];
2793  }else{
2794  mx= s->mv[0][0][0];
2795  my= s->mv[0][0][1];
2796  }
2797 
2798  s->mv_dir= best_s.mv_dir;
2799  s->mv_type = best_s.mv_type;
2800  s->mb_intra= 0;
2801 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2802  s->mv[0][0][1] = best_s.mv[0][0][1];
2803  s->mv[1][0][0] = best_s.mv[1][0][0];
2804  s->mv[1][0][1] = best_s.mv[1][0][1];*/
2805  backup_s.dquant= 0;
2806  s->skipdct=1;
2807  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2808  &dmin, &next_block, mx, my);
2809  s->skipdct=0;
2810  }
2811  }
2812 
2813  s->current_picture.f.qscale_table[xy] = best_s.qscale;
2814 
2815  copy_context_after_encode(s, &best_s, -1);
2816 
2817  pb_bits_count= put_bits_count(&s->pb);
2818  flush_put_bits(&s->pb);
2819  avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2820  s->pb= backup_s.pb;
2821 
2822  if(s->data_partitioning){
2823  pb2_bits_count= put_bits_count(&s->pb2);
2824  flush_put_bits(&s->pb2);
2825  avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2826  s->pb2= backup_s.pb2;
2827 
2828  tex_pb_bits_count= put_bits_count(&s->tex_pb);
2829  flush_put_bits(&s->tex_pb);
2830  avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2831  s->tex_pb= backup_s.tex_pb;
2832  }
2833  s->last_bits= put_bits_count(&s->pb);
2834 
2835  if (CONFIG_H263_ENCODER &&
2838 
2839  if(next_block==0){ //FIXME 16 vs linesize16
2840  s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2841  s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2842  s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2843  }
2844 
2846  ff_MPV_decode_mb(s, s->block);
2847  } else {
2848  int motion_x = 0, motion_y = 0;
2850  // only one MB-Type possible
2851 
2852  switch(mb_type){
2854  s->mv_dir = 0;
2855  s->mb_intra= 1;
2856  motion_x= s->mv[0][0][0] = 0;
2857  motion_y= s->mv[0][0][1] = 0;
2858  break;
2860  s->mv_dir = MV_DIR_FORWARD;
2861  s->mb_intra= 0;
2862  motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2863  motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2864  break;
2866  s->mv_dir = MV_DIR_FORWARD;
2867  s->mv_type = MV_TYPE_FIELD;
2868  s->mb_intra= 0;
2869  for(i=0; i<2; i++){
2870  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2871  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2872  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2873  }
2874  break;
2876  s->mv_dir = MV_DIR_FORWARD;
2877  s->mv_type = MV_TYPE_8X8;
2878  s->mb_intra= 0;
2879  for(i=0; i<4; i++){
2880  s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2881  s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2882  }
2883  break;
2885  if (CONFIG_MPEG4_ENCODER) {
2887  s->mb_intra= 0;
2888  motion_x=s->b_direct_mv_table[xy][0];
2889  motion_y=s->b_direct_mv_table[xy][1];
2890  ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2891  }
2892  break;
2894  if (CONFIG_MPEG4_ENCODER) {
2896  s->mb_intra= 0;
2897  ff_mpeg4_set_direct_mv(s, 0, 0);
2898  }
2899  break;
2902  s->mb_intra= 0;
2903  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2904  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2905  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2906  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2907  break;
2909  s->mv_dir = MV_DIR_BACKWARD;
2910  s->mb_intra= 0;
2911  motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2912  motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2913  break;
2915  s->mv_dir = MV_DIR_FORWARD;
2916  s->mb_intra= 0;
2917  motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2918  motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2919  break;
2921  s->mv_dir = MV_DIR_FORWARD;
2922  s->mv_type = MV_TYPE_FIELD;
2923  s->mb_intra= 0;
2924  for(i=0; i<2; i++){
2925  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2926  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2927  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2928  }
2929  break;
2931  s->mv_dir = MV_DIR_BACKWARD;
2932  s->mv_type = MV_TYPE_FIELD;
2933  s->mb_intra= 0;
2934  for(i=0; i<2; i++){
2935  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2936  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2937  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2938  }
2939  break;
2942  s->mv_type = MV_TYPE_FIELD;
2943  s->mb_intra= 0;
2944  for(dir=0; dir<2; dir++){
2945  for(i=0; i<2; i++){
2946  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2947  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2948  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2949  }
2950  }
2951  break;
2952  default:
2953  av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
2954  }
2955 
2956  encode_mb(s, motion_x, motion_y);
2957 
2958  // RAL: Update last macroblock type
2959  s->last_mv_dir = s->mv_dir;
2960 
2961  if (CONFIG_H263_ENCODER &&
2964 
2965  ff_MPV_decode_mb(s, s->block);
2966  }
2967 
2968  /* clean the MV table in IPS frames for direct mode in B frames */
2969  if(s->mb_intra /* && I,P,S_TYPE */){
2970  s->p_mv_table[xy][0]=0;
2971  s->p_mv_table[xy][1]=0;
2972  }
2973 
2974  if(s->flags&CODEC_FLAG_PSNR){
2975  int w= 16;
2976  int h= 16;
2977 
2978  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2979  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2980 
2981  s->current_picture.f.error[0] += sse(
2982  s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
2983  s->dest[0], w, h, s->linesize);
2984  s->current_picture.f.error[1] += sse(
2985  s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
2986  s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
2987  s->current_picture.f.error[2] += sse(
2988  s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
2989  s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
2990  }
2991  if(s->loop_filter){
2994  }
2995  av_dlog(s->avctx, "MB %d %d bits\n",
2996  s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
2997  }
2998  }
2999 
3000  //not beautiful here but we must write it before flushing so it has to be here
3003 
3004  write_slice_end(s);
3005 
3006  /* Send the last GOB if RTP */
3007  if (s->avctx->rtp_callback) {
3008  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3009  pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3010  /* Call the RTP callback to send the last GOB */
3011  emms_c();
3012  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3013  }
3014 
3015  return 0;
3016 }
3017 
3018 #define MERGE(field) dst->field += src->field; src->field=0
3023 }
3024 
3026  int i;
3027 
3028  MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3029  MERGE(dct_count[1]);
3030  MERGE(mv_bits);
3031  MERGE(i_tex_bits);
3032  MERGE(p_tex_bits);
3033  MERGE(i_count);
3034  MERGE(f_count);
3035  MERGE(b_count);
3036  MERGE(skip_count);
3037  MERGE(misc_bits);
3038  MERGE(error_count);
3043 
3044  if(dst->avctx->noise_reduction){
3045  for(i=0; i<64; i++){
3046  MERGE(dct_error_sum[0][i]);
3047  MERGE(dct_error_sum[1][i]);
3048  }
3049  }
3050 
3051  assert(put_bits_count(&src->pb) % 8 ==0);
3052  assert(put_bits_count(&dst->pb) % 8 ==0);
3053  avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3054  flush_put_bits(&dst->pb);
3055 }
3056 
3057 static int estimate_qp(MpegEncContext *s, int dry_run){
3058  if (s->next_lambda){
3061  if(!dry_run) s->next_lambda= 0;
3062  } else if (!s->fixed_qscale) {
3065  if (s->current_picture.f.quality < 0)
3066  return -1;
3067  }
3068 
3069  if(s->adaptive_quant){
3070  switch(s->codec_id){
3071  case AV_CODEC_ID_MPEG4:
3074  break;
3075  case AV_CODEC_ID_H263:
3076  case AV_CODEC_ID_H263P:
3077  case AV_CODEC_ID_FLV1:
3078  if (CONFIG_H263_ENCODER)
3080  break;
3081  default:
3082  ff_init_qscale_tab(s);
3083  }
3084 
3085  s->lambda= s->lambda_table[0];
3086  //FIXME broken
3087  }else
3088  s->lambda = s->current_picture.f.quality;
3089  update_qscale(s);
3090  return 0;
3091 }
3092 
3093 /* must be called before writing the header */
3095  assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3096  s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3097 
3098  if(s->pict_type==AV_PICTURE_TYPE_B){
3099  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3100  assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3101  }else{
3102  s->pp_time= s->time - s->last_non_b_time;
3103  s->last_non_b_time= s->time;
3104  assert(s->picture_number==0 || s->pp_time > 0);
3105  }
3106 }
3107 
3109 {
3110  int i, ret;
3111  int bits;
3112  int context_count = s->slice_context_count;
3113 
3115 
3116  /* Reset the average MB variance */
3117  s->me.mb_var_sum_temp =
3118  s->me.mc_mb_var_sum_temp = 0;
3119 
3120  /* we need to initialize some time vars before we can encode b-frames */
3121  // RAL: Condition added for MPEG1VIDEO
3125  ff_set_mpeg4_time(s);
3126 
3127  s->me.scene_change_score=0;
3128 
3129 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3130 
3131  if(s->pict_type==AV_PICTURE_TYPE_I){
3132  if(s->msmpeg4_version >= 3) s->no_rounding=1;
3133  else s->no_rounding=0;
3134  }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3136  s->no_rounding ^= 1;
3137  }
3138 
3139  if(s->flags & CODEC_FLAG_PASS2){
3140  if (estimate_qp(s,1) < 0)
3141  return -1;
3142  ff_get_2pass_fcode(s);
3143  }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3145  s->lambda= s->last_lambda_for[s->pict_type];
3146  else
3148  update_qscale(s);
3149  }
3150 
3151  s->mb_intra=0; //for the rate distortion & bit compare functions
3152  for(i=1; i<context_count; i++){
3154  if (ret < 0)
3155  return ret;
3156  }
3157 
3158  if(ff_init_me(s)<0)
3159  return -1;
3160 
3161  /* Estimate motion for every MB */
3162  if(s->pict_type != AV_PICTURE_TYPE_I){
3163  s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3164  s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3165  if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3166  if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3167  s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3168  }
3169  }
3170 
3171  s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3172  }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3173  /* I-Frame */
3174  for(i=0; i<s->mb_stride*s->mb_height; i++)
3176 
3177  if(!s->fixed_qscale){
3178  /* finding spatial complexity for I-frame rate control */
3179  s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3180  }
3181  }
3182  for(i=1; i<context_count; i++){
3184  }
3186  s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3187  emms_c();
3188 
3191  for(i=0; i<s->mb_stride*s->mb_height; i++)
3193  av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3195  }
3196 
3197  if(!s->umvplus){
3200 
3202  int a,b;
3203  a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3205  s->f_code= FFMAX3(s->f_code, a, b);
3206  }
3207 
3208  ff_fix_long_p_mvs(s);
3211  int j;
3212  for(i=0; i<2; i++){
3213  for(j=0; j<2; j++)
3216  }
3217  }
3218  }
3219 
3220  if(s->pict_type==AV_PICTURE_TYPE_B){
3221  int a, b;
3222 
3225  s->f_code = FFMAX(a, b);
3226 
3229  s->b_code = FFMAX(a, b);
3230 
3236  int dir, j;
3237  for(dir=0; dir<2; dir++){
3238  for(i=0; i<2; i++){
3239  for(j=0; j<2; j++){
3242  ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3243  s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3244  }
3245  }
3246  }
3247  }
3248  }
3249  }
3250 
3251  if (estimate_qp(s, 0) < 0)
3252  return -1;
3253 
3254  if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3255  s->qscale= 3; //reduce clipping problems
3256 
3257  if (s->out_format == FMT_MJPEG) {
3258  /* for mjpeg, we do include qscale in the matrix */
3259  for(i=1;i<64;i++){
3260  int j= s->dsp.idct_permutation[i];
3261 
3262  s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3263  }
3264  s->y_dc_scale_table=
3268  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3269  s->qscale= 8;
3270  }
3271 
3272  //FIXME var duplication
3274  s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3277 
3278  if (s->current_picture.f.key_frame)
3279  s->picture_in_gop_number=0;
3280 
3281  s->last_bits= put_bits_count(&s->pb);
3282  switch(s->out_format) {
3283  case FMT_MJPEG:
3286  break;
3287  case FMT_H261:
3288  if (CONFIG_H261_ENCODER)
3289  ff_h261_encode_picture_header(s, picture_number);
3290  break;
3291  case FMT_H263:
3293  ff_wmv2_encode_picture_header(s, picture_number);
3294  else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3295  ff_msmpeg4_encode_picture_header(s, picture_number);
3296  else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3297  ff_mpeg4_encode_picture_header(s, picture_number);
3298  else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3299  ff_rv10_encode_picture_header(s, picture_number);
3300  else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3301  ff_rv20_encode_picture_header(s, picture_number);
3302  else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3303  ff_flv_encode_picture_header(s, picture_number);
3304  else if (CONFIG_H263_ENCODER)
3305  ff_h263_encode_picture_header(s, picture_number);
3306  break;
3307  case FMT_MPEG1:
3309  ff_mpeg1_encode_picture_header(s, picture_number);
3310  break;
3311  case FMT_H264:
3312  break;
3313  default:
3314  assert(0);
3315  }
3316  bits= put_bits_count(&s->pb);
3317  s->header_bits= bits - s->last_bits;
3318 
3319  for(i=1; i<context_count; i++){
3321  }
3322  s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3323  for(i=1; i<context_count; i++){
3325  }
3326  emms_c();
3327  return 0;
3328 }
3329 
3331  const int intra= s->mb_intra;
3332  int i;
3333 
3334  s->dct_count[intra]++;
3335 
3336  for(i=0; i<64; i++){
3337  int level= block[i];
3338 
3339  if(level){
3340  if(level>0){
3341  s->dct_error_sum[intra][i] += level;
3342  level -= s->dct_offset[intra][i];
3343  if(level<0) level=0;
3344  }else{
3345  s->dct_error_sum[intra][i] -= level;
3346  level += s->dct_offset[intra][i];
3347  if(level>0) level=0;
3348  }
3349  block[i]= level;
3350  }
3351  }
3352 }
3353 
3355  DCTELEM *block, int n,
3356  int qscale, int *overflow){
3357  const int *qmat;
3358  const uint8_t *scantable= s->intra_scantable.scantable;
3359  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3360  int max=0;
3361  unsigned int threshold1, threshold2;
3362  int bias=0;
3363  int run_tab[65];
3364  int level_tab[65];
3365  int score_tab[65];
3366  int survivor[65];
3367  int survivor_count;
3368  int last_run=0;
3369  int last_level=0;
3370  int last_score= 0;
3371  int last_i;
3372  int coeff[2][64];
3373  int coeff_count[64];
3374  int qmul, qadd, start_i, last_non_zero, i, dc;
3375  const int esc_length= s->ac_esc_length;
3376  uint8_t * length;
3377  uint8_t * last_length;
3378  const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3379 
3380  s->dsp.fdct (block);
3381 
3382  if(s->dct_error_sum)
3383  s->denoise_dct(s, block);
3384  qmul= qscale*16;
3385  qadd= ((qscale-1)|1)*8;
3386 
3387  if (s->mb_intra) {
3388  int q;
3389  if (!s->h263_aic) {
3390  if (n < 4)
3391  q = s->y_dc_scale;
3392  else
3393  q = s->c_dc_scale;
3394  q = q << 3;
3395  } else{
3396  /* For AIC we skip quant/dequant of INTRADC */
3397  q = 1 << 3;
3398  qadd=0;
3399  }
3400 
3401  /* note: block[0] is assumed to be positive */
3402  block[0] = (block[0] + (q >> 1)) / q;
3403  start_i = 1;
3404  last_non_zero = 0;
3405  qmat = s->q_intra_matrix[qscale];
3406  if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3407  bias= 1<<(QMAT_SHIFT-1);
3408  length = s->intra_ac_vlc_length;
3409  last_length= s->intra_ac_vlc_last_length;
3410  } else {
3411  start_i = 0;
3412  last_non_zero = -1;
3413  qmat = s->q_inter_matrix[qscale];
3414  length = s->inter_ac_vlc_length;
3415  last_length= s->inter_ac_vlc_last_length;
3416  }
3417  last_i= start_i;
3418 
3419  threshold1= (1<<QMAT_SHIFT) - bias - 1;
3420  threshold2= (threshold1<<1);
3421 
3422  for(i=63; i>=start_i; i--) {
3423  const int j = scantable[i];
3424  int level = block[j] * qmat[j];
3425 
3426  if(((unsigned)(level+threshold1))>threshold2){
3427  last_non_zero = i;
3428  break;
3429  }
3430  }
3431 
3432  for(i=start_i; i<=last_non_zero; i++) {
3433  const int j = scantable[i];
3434  int level = block[j] * qmat[j];
3435 
3436 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3437 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3438  if(((unsigned)(level+threshold1))>threshold2){
3439  if(level>0){
3440  level= (bias + level)>>QMAT_SHIFT;
3441  coeff[0][i]= level;
3442  coeff[1][i]= level-1;
3443 // coeff[2][k]= level-2;
3444  }else{
3445  level= (bias - level)>>QMAT_SHIFT;
3446  coeff[0][i]= -level;
3447  coeff[1][i]= -level+1;
3448 // coeff[2][k]= -level+2;
3449  }
3450  coeff_count[i]= FFMIN(level, 2);
3451  assert(coeff_count[i]);
3452  max |=level;
3453  }else{
3454  coeff[0][i]= (level>>31)|1;
3455  coeff_count[i]= 1;
3456  }
3457  }
3458 
3459  *overflow= s->max_qcoeff < max; //overflow might have happened
3460 
3461  if(last_non_zero < start_i){
3462  memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3463  return last_non_zero;
3464  }
3465 
3466  score_tab[start_i]= 0;
3467  survivor[0]= start_i;
3468  survivor_count= 1;
3469 
3470  for(i=start_i; i<=last_non_zero; i++){
3471  int level_index, j, zero_distortion;
3472  int dct_coeff= FFABS(block[ scantable[i] ]);
3473  int best_score=256*256*256*120;
3474 
3475  if (s->dsp.fdct == ff_fdct_ifast)
3476  dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3477  zero_distortion= dct_coeff*dct_coeff;
3478 
3479  for(level_index=0; level_index < coeff_count[i]; level_index++){
3480  int distortion;
3481  int level= coeff[level_index][i];
3482  const int alevel= FFABS(level);
3483  int unquant_coeff;
3484 
3485  assert(level);
3486 
3487  if(s->out_format == FMT_H263){
3488  unquant_coeff= alevel*qmul + qadd;
3489  }else{ //MPEG1
3490  j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3491  if(s->mb_intra){
3492  unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3493  unquant_coeff = (unquant_coeff - 1) | 1;
3494  }else{
3495  unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3496  unquant_coeff = (unquant_coeff - 1) | 1;
3497  }
3498  unquant_coeff<<= 3;
3499  }
3500 
3501  distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3502  level+=64;
3503  if((level&(~127)) == 0){
3504  for(j=survivor_count-1; j>=0; j--){
3505  int run= i - survivor[j];
3506  int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3507  score += score_tab[i-run];
3508 
3509  if(score < best_score){
3510  best_score= score;
3511  run_tab[i+1]= run;
3512  level_tab[i+1]= level-64;
3513  }
3514  }
3515 
3516  if(s->out_format == FMT_H263){
3517  for(j=survivor_count-1; j>=0; j--){
3518  int run= i - survivor[j];
3519  int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3520  score += score_tab[i-run];
3521  if(score < last_score){
3522  last_score= score;
3523  last_run= run;
3524  last_level= level-64;
3525  last_i= i+1;
3526  }
3527  }
3528  }
3529  }else{
3530  distortion += esc_length*lambda;
3531  for(j=survivor_count-1; j>=0; j--){
3532  int run= i - survivor[j];
3533  int score= distortion + score_tab[i-run];
3534 
3535  if(score < best_score){
3536  best_score= score;
3537  run_tab[i+1]= run;
3538  level_tab[i+1]= level-64;
3539  }
3540  }
3541 
3542  if(s->out_format == FMT_H263){
3543  for(j=survivor_count-1; j>=0; j--){
3544  int run= i - survivor[j];
3545  int score= distortion + score_tab[i-run];
3546  if(score < last_score){
3547  last_score= score;
3548  last_run= run;
3549  last_level= level-64;
3550  last_i= i+1;
3551  }
3552  }
3553  }
3554  }
3555  }
3556 
3557  score_tab[i+1]= best_score;
3558 
3559  //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3560  if(last_non_zero <= 27){
3561  for(; survivor_count; survivor_count--){
3562  if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3563  break;
3564  }
3565  }else{
3566  for(; survivor_count; survivor_count--){
3567  if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3568  break;
3569  }
3570  }
3571 
3572  survivor[ survivor_count++ ]= i+1;
3573  }
3574 
3575  if(s->out_format != FMT_H263){
3576  last_score= 256*256*256*120;
3577  for(i= survivor[0]; i<=last_non_zero + 1; i++){
3578  int score= score_tab[i];
3579  if(i) score += lambda*2; //FIXME exacter?
3580 
3581  if(score < last_score){
3582  last_score= score;
3583  last_i= i;
3584  last_level= level_tab[i];
3585  last_run= run_tab[i];
3586  }
3587  }
3588  }
3589 
3590  s->coded_score[n] = last_score;
3591 
3592  dc= FFABS(block[0]);
3593  last_non_zero= last_i - 1;
3594  memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3595 
3596  if(last_non_zero < start_i)
3597  return last_non_zero;
3598 
3599  if(last_non_zero == 0 && start_i == 0){
3600  int best_level= 0;
3601  int best_score= dc * dc;
3602 
3603  for(i=0; i<coeff_count[0]; i++){
3604  int level= coeff[i][0];
3605  int alevel= FFABS(level);
3606  int unquant_coeff, score, distortion;
3607 
3608  if(s->out_format == FMT_H263){
3609  unquant_coeff= (alevel*qmul + qadd)>>3;
3610  }else{ //MPEG1
3611  unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3612  unquant_coeff = (unquant_coeff - 1) | 1;
3613  }
3614  unquant_coeff = (unquant_coeff + 4) >> 3;
3615  unquant_coeff<<= 3 + 3;
3616 
3617  distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3618  level+=64;
3619  if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3620  else score= distortion + esc_length*lambda;
3621 
3622  if(score < best_score){
3623  best_score= score;
3624  best_level= level - 64;
3625  }
3626  }
3627  block[0]= best_level;
3628  s->coded_score[n] = best_score - dc*dc;
3629  if(best_level == 0) return -1;
3630  else return last_non_zero;
3631  }
3632 
3633  i= last_i;
3634  assert(last_level);
3635 
3636  block[ perm_scantable[last_non_zero] ]= last_level;
3637  i -= last_run + 1;
3638 
3639  for(; i>start_i; i -= run_tab[i] + 1){
3640  block[ perm_scantable[i-1] ]= level_tab[i];
3641  }
3642 
3643  return last_non_zero;
3644 }
3645 
3646 //#define REFINE_STATS 1
3647 static int16_t basis[64][64];
3648 
3649 static void build_basis(uint8_t *perm){
3650  int i, j, x, y;
3651  emms_c();
3652  for(i=0; i<8; i++){
3653  for(j=0; j<8; j++){
3654  for(y=0; y<8; y++){
3655  for(x=0; x<8; x++){
3656  double s= 0.25*(1<<BASIS_SHIFT);
3657  int index= 8*i + j;
3658  int perm_index= perm[index];
3659  if(i==0) s*= sqrt(0.5);
3660  if(j==0) s*= sqrt(0.5);
3661  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)));
3662  }
3663  }
3664  }
3665  }
3666 }
3667 
3668 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3669  DCTELEM *block, int16_t *weight, DCTELEM *orig,
3670  int n, int qscale){
3671  int16_t rem[64];
3672  LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3673  const uint8_t *scantable= s->intra_scantable.scantable;
3674  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3675 // unsigned int threshold1, threshold2;
3676 // int bias=0;
3677  int run_tab[65];
3678  int prev_run=0;
3679  int prev_level=0;
3680  int qmul, qadd, start_i, last_non_zero, i, dc;
3681  uint8_t * length;
3682  uint8_t * last_length;
3683  int lambda;
3684  int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3685 #ifdef REFINE_STATS
3686 static int count=0;
3687 static int after_last=0;
3688 static int to_zero=0;
3689 static int from_zero=0;
3690 static int raise=0;
3691 static int lower=0;
3692 static int messed_sign=0;
3693 #endif
3694 
3695  if(basis[0][0] == 0)
3697 
3698  qmul= qscale*2;
3699  qadd= (qscale-1)|1;
3700  if (s->mb_intra) {
3701  if (!s->h263_aic) {
3702  if (n < 4)
3703  q = s->y_dc_scale;
3704  else
3705  q = s->c_dc_scale;
3706  } else{
3707  /* For AIC we skip quant/dequant of INTRADC */
3708  q = 1;
3709  qadd=0;
3710  }
3711  q <<= RECON_SHIFT-3;
3712  /* note: block[0] is assumed to be positive */
3713  dc= block[0]*q;
3714 // block[0] = (block[0] + (q >> 1)) / q;
3715  start_i = 1;
3716 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3717 // bias= 1<<(QMAT_SHIFT-1);
3718  length = s->intra_ac_vlc_length;
3719  last_length= s->intra_ac_vlc_last_length;
3720  } else {
3721  dc= 0;
3722  start_i = 0;
3723  length = s->inter_ac_vlc_length;
3724  last_length= s->inter_ac_vlc_last_length;
3725  }
3726  last_non_zero = s->block_last_index[n];
3727 
3728 #ifdef REFINE_STATS
3729 {START_TIMER
3730 #endif
3731  dc += (1<<(RECON_SHIFT-1));
3732  for(i=0; i<64; i++){
3733  rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3734  }
3735 #ifdef REFINE_STATS
3736 STOP_TIMER("memset rem[]")}
3737 #endif
3738  sum=0;
3739  for(i=0; i<64; i++){
3740  int one= 36;
3741  int qns=4;
3742  int w;
3743 
3744  w= FFABS(weight[i]) + qns*one;
3745  w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3746 
3747  weight[i] = w;
3748 // w=weight[i] = (63*qns + (w/2)) / w;
3749 
3750  assert(w>0);
3751  assert(w<(1<<6));
3752  sum += w*w;
3753  }
3754  lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3755 #ifdef REFINE_STATS
3756 {START_TIMER
3757 #endif
3758  run=0;
3759  rle_index=0;
3760  for(i=start_i; i<=last_non_zero; i++){
3761  int j= perm_scantable[i];
3762  const int level= block[j];
3763  int coeff;
3764 
3765  if(level){
3766  if(level<0) coeff= qmul*level - qadd;
3767  else coeff= qmul*level + qadd;
3768  run_tab[rle_index++]=run;
3769  run=0;
3770 
3771  s->dsp.add_8x8basis(rem, basis[j], coeff);
3772  }else{
3773  run++;
3774  }
3775  }
3776 #ifdef REFINE_STATS
3777 if(last_non_zero>0){
3778 STOP_TIMER("init rem[]")
3779 }
3780 }
3781 
3782 {START_TIMER
3783 #endif
3784  for(;;){
3785  int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3786  int best_coeff=0;
3787  int best_change=0;
3788  int run2, best_unquant_change=0, analyze_gradient;
3789 #ifdef REFINE_STATS
3790 {START_TIMER
3791 #endif
3792  analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3793 
3794  if(analyze_gradient){
3795 #ifdef REFINE_STATS
3796 {START_TIMER
3797 #endif
3798  for(i=0; i<64; i++){
3799  int w= weight[i];
3800 
3801  d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3802  }
3803 #ifdef REFINE_STATS
3804 STOP_TIMER("rem*w*w")}
3805 {START_TIMER
3806 #endif
3807  s->dsp.fdct(d1);
3808 #ifdef REFINE_STATS
3809 STOP_TIMER("dct")}
3810 #endif
3811  }
3812 
3813  if(start_i){
3814  const int level= block[0];
3815  int change, old_coeff;
3816 
3817  assert(s->mb_intra);
3818 
3819  old_coeff= q*level;
3820 
3821  for(change=-1; change<=1; change+=2){
3822  int new_level= level + change;
3823  int score, new_coeff;
3824 
3825  new_coeff= q*new_level;
3826  if(new_coeff >= 2048 || new_coeff < 0)
3827  continue;
3828 
3829  score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3830  if(score<best_score){
3831  best_score= score;
3832  best_coeff= 0;
3833  best_change= change;
3834  best_unquant_change= new_coeff - old_coeff;
3835  }
3836  }
3837  }
3838 
3839  run=0;
3840  rle_index=0;
3841  run2= run_tab[rle_index++];
3842  prev_level=0;
3843  prev_run=0;
3844 
3845  for(i=start_i; i<64; i++){
3846  int j= perm_scantable[i];
3847  const int level= block[j];
3848  int change, old_coeff;
3849 
3850  if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3851  break;
3852 
3853  if(level){
3854  if(level<0) old_coeff= qmul*level - qadd;
3855  else old_coeff= qmul*level + qadd;
3856  run2= run_tab[rle_index++]; //FIXME ! maybe after last
3857  }else{
3858  old_coeff=0;
3859  run2--;
3860  assert(run2>=0 || i >= last_non_zero );
3861  }
3862 
3863  for(change=-1; change<=1; change+=2){
3864  int new_level= level + change;
3865  int score, new_coeff, unquant_change;
3866 
3867  score=0;
3868  if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3869  continue;
3870 
3871  if(new_level){
3872  if(new_level<0) new_coeff= qmul*new_level - qadd;
3873  else new_coeff= qmul*new_level + qadd;
3874  if(new_coeff >= 2048 || new_coeff <= -2048)
3875  continue;
3876  //FIXME check for overflow
3877 
3878  if(level){
3879  if(level < 63 && level > -63){
3880  if(i < last_non_zero)
3881  score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3882  - length[UNI_AC_ENC_INDEX(run, level+64)];
3883  else
3884  score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3885  - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3886  }
3887  }else{
3888  assert(FFABS(new_level)==1);
3889 
3890  if(analyze_gradient){
3891  int g= d1[ scantable[i] ];
3892  if(g && (g^new_level) >= 0)
3893  continue;
3894  }
3895 
3896  if(i < last_non_zero){
3897  int next_i= i + run2 + 1;
3898  int next_level= block[ perm_scantable[next_i] ] + 64;
3899 
3900  if(next_level&(~127))
3901  next_level= 0;
3902 
3903  if(next_i < last_non_zero)
3904  score += length[UNI_AC_ENC_INDEX(run, 65)]
3905  + length[UNI_AC_ENC_INDEX(run2, next_level)]
3906  - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3907  else
3908  score += length[UNI_AC_ENC_INDEX(run, 65)]
3909  + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3910  - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3911  }else{
3912  score += last_length[UNI_AC_ENC_INDEX(run, 65)];
3913  if(prev_level){
3914  score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3915  - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3916  }
3917  }
3918  }
3919  }else{
3920  new_coeff=0;
3921  assert(FFABS(level)==1);
3922 
3923  if(i < last_non_zero){
3924  int next_i= i + run2 + 1;
3925  int next_level= block[ perm_scantable[next_i] ] + 64;
3926 
3927  if(next_level&(~127))
3928  next_level= 0;
3929 
3930  if(next_i < last_non_zero)
3931  score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
3932  - length[UNI_AC_ENC_INDEX(run2, next_level)]
3933  - length[UNI_AC_ENC_INDEX(run, 65)];
3934  else
3935  score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
3936  - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3937  - length[UNI_AC_ENC_INDEX(run, 65)];
3938  }else{
3939  score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
3940  if(prev_level){
3941  score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3942  - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3943  }
3944  }
3945  }
3946 
3947  score *= lambda;
3948 
3949  unquant_change= new_coeff - old_coeff;
3950  assert((score < 100*lambda && score > -100*lambda) || lambda==0);
3951 
3952  score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
3953  if(score<best_score){
3954  best_score= score;
3955  best_coeff= i;
3956  best_change= change;
3957  best_unquant_change= unquant_change;
3958  }
3959  }
3960  if(level){
3961  prev_level= level + 64;
3962  if(prev_level&(~127))
3963  prev_level= 0;
3964  prev_run= run;
3965  run=0;
3966  }else{
3967  run++;
3968  }
3969  }
3970 #ifdef REFINE_STATS
3971 STOP_TIMER("iterative step")}
3972 #endif
3973 
3974  if(best_change){
3975  int j= perm_scantable[ best_coeff ];
3976 
3977  block[j] += best_change;
3978 
3979  if(best_coeff > last_non_zero){
3980  last_non_zero= best_coeff;
3981  assert(block[j]);
3982 #ifdef REFINE_STATS
3983 after_last++;
3984 #endif
3985  }else{
3986 #ifdef REFINE_STATS
3987 if(block[j]){
3988  if(block[j] - best_change){
3989  if(FFABS(block[j]) > FFABS(block[j] - best_change)){
3990  raise++;
3991  }else{
3992  lower++;
3993  }
3994  }else{
3995  from_zero++;
3996  }
3997 }else{
3998  to_zero++;
3999 }
4000 #endif
4001  for(; last_non_zero>=start_i; last_non_zero--){
4002  if(block[perm_scantable[last_non_zero]])
4003  break;
4004  }
4005  }
4006 #ifdef REFINE_STATS
4007 count++;
4008 if(256*256*256*64 % count == 0){
4009  printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
4010 }
4011 #endif
4012  run=0;
4013  rle_index=0;
4014  for(i=start_i; i<=last_non_zero; i++){
4015  int j= perm_scantable[i];
4016  const int level= block[j];
4017 
4018  if(level){
4019  run_tab[rle_index++]=run;
4020  run=0;
4021  }else{
4022  run++;
4023  }
4024  }
4025 
4026  s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4027  }else{
4028  break;
4029  }
4030  }
4031 #ifdef REFINE_STATS
4032 if(last_non_zero>0){
4033 STOP_TIMER("iterative search")
4034 }
4035 }
4036 #endif
4037 
4038  return last_non_zero;
4039 }
4040 
4042  DCTELEM *block, int n,
4043  int qscale, int *overflow)
4044 {
4045  int i, j, level, last_non_zero, q, start_i;
4046  const int *qmat;
4047  const uint8_t *scantable= s->intra_scantable.scantable;
4048  int bias;
4049  int max=0;
4050  unsigned int threshold1, threshold2;
4051 
4052  s->dsp.fdct (block);
4053 
4054  if(s->dct_error_sum)
4055  s->denoise_dct(s, block);
4056 
4057  if (s->mb_intra) {
4058  if (!s->h263_aic) {
4059  if (n < 4)
4060  q = s->y_dc_scale;
4061  else
4062  q = s->c_dc_scale;
4063  q = q << 3;
4064  } else
4065  /* For AIC we skip quant/dequant of INTRADC */
4066  q = 1 << 3;
4067 
4068  /* note: block[0] is assumed to be positive */
4069  block[0] = (block[0] + (q >> 1)) / q;
4070  start_i = 1;
4071  last_non_zero = 0;
4072  qmat = s->q_intra_matrix[qscale];
4074  } else {
4075  start_i = 0;
4076  last_non_zero = -1;
4077  qmat = s->q_inter_matrix[qscale];
4079  }
4080  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4081  threshold2= (threshold1<<1);
4082  for(i=63;i>=start_i;i--) {
4083  j = scantable[i];
4084  level = block[j] * qmat[j];
4085 
4086  if(((unsigned)(level+threshold1))>threshold2){
4087  last_non_zero = i;
4088  break;
4089  }else{
4090  block[j]=0;
4091  }
4092  }
4093  for(i=start_i; i<=last_non_zero; i++) {
4094  j = scantable[i];
4095  level = block[j] * qmat[j];
4096 
4097 // if( bias+level >= (1<<QMAT_SHIFT)
4098 // || bias-level >= (1<<QMAT_SHIFT)){
4099  if(((unsigned)(level+threshold1))>threshold2){
4100  if(level>0){
4101  level= (bias + level)>>QMAT_SHIFT;
4102  block[j]= level;
4103  }else{
4104  level= (bias - level)>>QMAT_SHIFT;
4105  block[j]= -level;
4106  }
4107  max |=level;
4108  }else{
4109  block[j]=0;
4110  }
4111  }
4112  *overflow= s->max_qcoeff < max; //overflow might have happened
4113 
4114  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4116  ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4117 
4118  return last_non_zero;
4119 }
4120 
4121 #define OFFSET(x) offsetof(MpegEncContext, x)
4122 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4123 static const AVOption h263_options[] = {
4124  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4125  { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4126  { "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 },
4128  { NULL },
4129 };
4130 
4131 static const AVClass h263_class = {
4132  .class_name = "H.263 encoder",
4133  .item_name = av_default_item_name,
4134  .option = h263_options,
4135  .version = LIBAVUTIL_VERSION_INT,
4136 };
4137 
4139  .name = "h263",
4140  .type = AVMEDIA_TYPE_VIDEO,
4141  .id = AV_CODEC_ID_H263,
4142  .priv_data_size = sizeof(MpegEncContext),
4144  .encode2 = ff_MPV_encode_picture,
4146  .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4147  .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4148  .priv_class = &h263_class,
4149 };
4150 
4151 static const AVOption h263p_options[] = {
4152  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4153  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4154  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4155  { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE},
4157  { NULL },
4158 };
4159 static const AVClass h263p_class = {
4160  .class_name = "H.263p encoder",
4161  .item_name = av_default_item_name,
4162  .option = h263p_options,
4163  .version = LIBAVUTIL_VERSION_INT,
4164 };
4165 
4167  .name = "h263p",
4168  .type = AVMEDIA_TYPE_VIDEO,
4169  .id = AV_CODEC_ID_H263P,
4170  .priv_data_size = sizeof(MpegEncContext),
4172  .encode2 = ff_MPV_encode_picture,
4174  .capabilities = CODEC_CAP_SLICE_THREADS,
4175  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4176  .long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4177  .priv_class = &h263p_class,
4178 };
4179 
4180 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4181 
4183  .name = "msmpeg4v2",
4184  .type = AVMEDIA_TYPE_VIDEO,
4185  .id = AV_CODEC_ID_MSMPEG4V2,
4186  .priv_data_size = sizeof(MpegEncContext),
4188  .encode2 = ff_MPV_encode_picture,
4190  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4191  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4192  .priv_class = &msmpeg4v2_class,
4193 };
4194 
4195 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4196 
4198  .name = "msmpeg4",
4199  .type = AVMEDIA_TYPE_VIDEO,
4200  .id = AV_CODEC_ID_MSMPEG4V3,
4201  .priv_data_size = sizeof(MpegEncContext),
4203  .encode2 = ff_MPV_encode_picture,
4205  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4206  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4207  .priv_class = &msmpeg4v3_class,
4208 };
4209 
4211 
4213  .name = "wmv1",
4214  .type = AVMEDIA_TYPE_VIDEO,
4215  .id = AV_CODEC_ID_WMV1,
4216  .priv_data_size = sizeof(MpegEncContext),
4218  .encode2 = ff_MPV_encode_picture,
4220  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4221  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4222  .priv_class = &wmv1_class,
4223 };
int last_time_base
Definition: mpegvideo.h:534
#define QUANT_BIAS_SHIFT
Definition: mpegvideo.h:444
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:41
void ff_h263_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
Definition: ituh263enc.c:457
int chroma_elim_threshold
Definition: mpegvideo.h:234
static const AVOption h263_options[]
int frame_bits
bits used for the current frame
Definition: mpegvideo.h:475
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
Definition: mpegvideo.h:477
const struct AVCodec * codec
Definition: avcodec.h:1348
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
#define FF_MPV_FLAG_STRICT_GOP
Definition: mpegvideo.h:727
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2458
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: dsputil.h:259
void ff_estimate_b_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:1636
int picture_number
Definition: mpegvideo.h:245
#define MAX_PICTURE_COUNT
Definition: mpegvideo.h:63
int(* dct_quantize)(struct MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:702
rate control context.
Definition: ratecontrol.h:63
S(GMC)-VOP MPEG4.
Definition: avutil.h:248
const uint8_t ff_zigzag_direct[64]
Definition: dsputil.c:59
me_cmp_func frame_skip_cmp[6]
Definition: dsputil.h:244
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:153
int esc3_level_length
Definition: mpegvideo.h:618
static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
int time_increment_bits
number of bits to represent the fractional part of time
Definition: mpegvideo.h:533
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: ituh263enc.c:105
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
struct MpegEncContext MpegEncContext
MpegEncContext.
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1494
int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
Allocate a Picture.
Definition: mpegvideo.c:332
int16_t(* p_mv_table)[2]
MV table (1MV per MB) p-frame encoding.
Definition: mpegvideo.h:373
int mpeg_quant
0-> h263 quant 1-> mpeg quant
Definition: avcodec.h:1641
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
Definition: mpegvideo.h:338
AVOption.
Definition: opt.h:233
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:402
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:286
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:392
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:976
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:324
uint8_t * mb_mean
Table for MB luminance.
Definition: mpegvideo.h:145
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:2641
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG1 & B-frame MPEG4
Definition: mpegvideo.h:401
int pre_pass
= 1 for the pre pass
Definition: mpegvideo.h:179
av_cold int ff_MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:882
#define FF_MPV_FLAG_SKIP_RD
Definition: mpegvideo.h:726
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:2259
#define FF_MPV_GENERIC_CLASS(name)
Definition: mpegvideo.h:747
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:70
void(* shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height)
Definition: dsputil.h:444
RateControlEntry * entry
Definition: ratecontrol.h:66
float border_masking
Border processing masking, raises the quantizer for mbs on the borders of the picture.
Definition: avcodec.h:1973
#define CANDIDATE_MB_TYPE_BACKWARD_I
Definition: mpegvideo.h:428
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:771
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:287
static void denoise_dct_c(MpegEncContext *s, DCTELEM *block)
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
#define OFFSET(x)
uint16_t * mb_var
Table for MB variances.
Definition: mpegvideo.h:143
static int estimate_qp(MpegEncContext *s, int dry_run)
#define CANDIDATE_MB_TYPE_BIDIR
Definition: mpegvideo.h:424
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])
int acc
Definition: yuv2rgb.c:476
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:1588
int16_t(*[3] ac_val)[16]
used for for mpeg4 AC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:330
MJPEG encoder.
void ff_mpeg4_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
int mjpeg_hsample[3]
horizontal sampling factors, default = {2, 1, 1}
Definition: mpegvideo.h:605
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:733
int(* try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale)
Definition: dsputil.h:434
#define CANDIDATE_MB_TYPE_INTRA
Definition: mpegvideo.h:415
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:616
int num
numerator
Definition: rational.h:44
void(* rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb)
Definition: avcodec.h:2471
int size
Definition: avcodec.h:916
enum AVCodecID codec_id
Definition: mpegvideo.h:227
void ff_get_2pass_fcode(MpegEncContext *s)
Definition: ratecontrol.c:632
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:60
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:516
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:45
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:647
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:1724
me_cmp_func sse[6]
Definition: dsputil.h:225
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced p-frame encoding.
Definition: mpegvideo.h:379
static int select_input_picture(MpegEncContext *s)
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:447
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
#define CONFIG_MPEG2VIDEO_ENCODER
Definition: config.h:857
int ildct_cmp
interlaced DCT comparison function
Definition: avcodec.h:1749
mpegvideo header.
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int rtp_payload_size
Definition: avcodec.h:2473
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:47
int scene_change_score
Definition: mpegvideo.h:194
int mpv_flags
flags set by private options
Definition: mpegvideo.h:706
uint8_t permutated[64]
Definition: dsputil.h:183
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: h261enc.c:52
int intra_quant_bias
intra quantizer bias
Definition: avcodec.h:1840
static const AVClass h263_class
uint8_t run
Definition: svq3.c:124
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:450
int padding_bug_score
used to detect the VERY common padding bug in MPEG4
Definition: mpegvideo.h:579
const uint16_t ff_h263_format[8][2]
Definition: h263data.h:239
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:455
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:252
int lmax
maximum Lagrange multipler
Definition: avcodec.h:2409
int frame_skip_cmp
frame skip comparison function
Definition: avcodec.h:2437
An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of structures with info about macroblo...
Definition: avcodec.h:873
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2960
static void write_mb_info(MpegEncContext *s)
int time_base
time in seconds of last I,P,S Frame
Definition: mpegvideo.h:535
int qscale
QP.
Definition: mpegvideo.h:342
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:262
int16_t(* b_back_mv_table)[2]
MV table (1MV per MB) backward mode b-frame encoding.
Definition: mpegvideo.h:375
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:316
#define INPLACE_OFFSET
Definition: mpegvideo.h:71
int encoding
true if we are encoding (vs decoding)
Definition: mpegvideo.h:229
uint64_t vbv_delay
VBV delay coded in the last frame (in periods of a 27 MHz clock).
Definition: avcodec.h:2942
int field_select[2][2]
Definition: mpegvideo.h:400
int scenechange_threshold
scene change detection threshold 0 is default, larger means fewer detected scene changes.
Definition: avcodec.h:1907
int(* pix_sum)(uint8_t *pix, int line_size)
Definition: dsputil.h:220
int quant_precision
Definition: mpegvideo.h:556
void ff_mpeg4_merge_partitions(MpegEncContext *s)
static int mb_var_thread(AVCodecContext *c, void *arg)
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:2107
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1465
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
int modified_quant
Definition: mpegvideo.h:528
#define FF_MPV_FLAG_CBP_RD
Definition: mpegvideo.h:729
int skipdct
skip dct and code zero residual
Definition: mpegvideo.h:355
int b_frame_score
Definition: mpegvideo.h:147
int ff_dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
void ff_mpeg4_clean_buffers(MpegEncContext *s)
Definition: mpeg4video.c:43
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:38
float p_masking
p block masking (0-> disabled)
Definition: avcodec.h:1685
int picture_in_gop_number
0-> first pic in gop, ...
Definition: mpegvideo.h:246
int alt_inter_vlc
alternative inter vlc
Definition: mpegvideo.h:527
uint8_t * ptr_lastgob
Definition: mpegvideo.h:670
int64_t time
time of current frame
Definition: mpegvideo.h:536
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:50
static int encode_picture(MpegEncContext *s, int picture_number)
#define CONFIG_WMV2_ENCODER
Definition: config.h:884
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
Definition: avcodec.h:1412
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (mpeg4) ...
Definition: mpegvideo.h:387
uint8_t bits
Definition: crc.c:31
uint8_t
#define RECON_SHIFT
Definition: dsputil.h:437
void ff_convert_matrix(DSPContext *dsp, 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:72
Picture ** input_picture
next pictures on display order for encoding
Definition: mpegvideo.h:256
AVOptions.
PutBitContext pb2
used for data partitioned VOPs
Definition: mpegvideo.h:576
enum OutputFormat out_format
output format
Definition: mpegvideo.h:219
void(* qpel_mc_func)(uint8_t *dst, uint8_t *src, int stride)
Definition: dsputil.h:144
#define CONFIG_MJPEG_ENCODER
Definition: config.h:855
uint16_t(* dct_offset)[64]
Definition: mpegvideo.h:469
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale)
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
Definition: dsputil.h:201
#define b
Definition: input.c:52
int pre_dia_size
ME prepass diamond size & shape.
Definition: avcodec.h:1800
AVCodec ff_h263_encoder
static const AVOption h263p_options[]
static int get_sae(uint8_t *src, int ref, int stride)
#define emms_c()
Definition: internal.h:145
int64_t pts
presentation timestamp in time_base units (time when frame should be shown to user) If AV_NOPTS_VALUE...
Definition: avcodec.h:1088
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:488
uint8_t motion_subsample_log2
log2 of the size of the block which a single vector in motion_val represents: (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)
Definition: avcodec.h:1302
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:407
int interlaced_dct
Definition: mpegvideo.h:661
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1731
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:313
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:1164
#define CHROMA_420
Definition: mpegvideo.h:653
int intra_dc_precision
Definition: mpegvideo.h:643
int repeat_first_field
Definition: mpegvideo.h:650
op_pixels_func avg_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: dsputil.h:271
const char data[16]
Definition: mxf.c:66
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
int16_t(* b_bidir_forw_mv_table)[2]
MV table (1MV per MB) bidir mode b-frame encoding.
Definition: mpegvideo.h:376
static void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
uint8_t * data
Definition: avcodec.h:915
const uint16_t ff_aanscales[64]
Definition: aandcttab.c:26
uint8_t(* mv_penalty)[MAX_MV *2+1]
amount of bits needed to encode a MV
Definition: mpegvideo.h:200
#define CONFIG_RV20_ENCODER
Definition: config.h:873
void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
Definition: dsputil.c:1741
void ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
int mb_threshold
Macroblock threshold below which the user specified macroblock types will be used.
Definition: avcodec.h:1944
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_...
Definition: pixfmt.h:78
void ff_msmpeg4_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
Definition: msmpeg4enc.c:370
void ff_rv10_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: rv10enc.c:31
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:538
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:425
#define CONFIG_H261_ENCODER
Definition: config.h:849
me_cmp_func ildct_cmp[6]
Definition: dsputil.h:243
const uint8_t * scantable
Definition: dsputil.h:182
int flags2
AVCodecContext.flags2.
Definition: mpegvideo.h:231
int interlaced_frame
The content of the picture is interlaced.
Definition: avcodec.h:1232
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:247
#define LOCAL_ALIGNED_16(t, v,...)
Definition: dsputil.h:602
void ff_MPV_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1573
float lumi_masking
luminance masking (0-> disabled)
Definition: avcodec.h:1664
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:448
void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:238
#define FF_MPV_FLAG_QP_RD
Definition: mpegvideo.h:728
av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:348
int flipflop_rounding
Definition: mpegvideo.h:615
int num_entries
number of RateControlEntries
Definition: ratecontrol.h:65
int gop_picture_number
index of the first picture of a GOP based on fake_pic_num & mpeg1 specific
Definition: mpegvideo.h:629
uint8_t * mb_info_ptr
Definition: mpegvideo.h:520
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:823
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: dsputil.h:312
#define CANDIDATE_MB_TYPE_FORWARD
Definition: mpegvideo.h:422
me_cmp_func nsse[6]
Definition: dsputil.h:233
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2738
int(* q_inter_matrix)[64]
Definition: mpegvideo.h:461
#define r
Definition: input.c:51
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:837
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
Definition: mpegvideo.h:460
int intra_only
if true, only intra pictures are generated
Definition: mpegvideo.h:217
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:1435
const uint16_t ff_mpeg1_default_intra_matrix[64]
Definition: mpeg12data.c:30
int16_t * dc_val[3]
used for mpeg4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:323
enum AVCodecID id
Definition: avcodec.h:2974
int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
int h263_plus
h263 plus headers
Definition: mpegvideo.h:224
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:289
#define CANDIDATE_MB_TYPE_DIRECT
Definition: mpegvideo.h:421
int last_non_b_pict_type
used for mpeg4 gmc b-frames & ratecontrol
Definition: mpegvideo.h:351
int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: wmv2enc.c:70
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:201
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1634
static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:321
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:453
Multithreading support functions.
int64_t total_bits
Definition: mpegvideo.h:474
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:331
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1132
int chroma_y_shift
Definition: mpegvideo.h:657
int strict_std_compliance
strictly follow the std (MPEG4, ...)
Definition: mpegvideo.h:235
int partitioned_frame
is current frame partitioned
Definition: mpegvideo.h:567
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: dsputil.h:313
int frame_skip_threshold
frame skip threshold
Definition: avcodec.h:2416
int me_sub_cmp
subpixel motion estimation comparison function
Definition: avcodec.h:1737
int qmax
maximum quantizer
Definition: avcodec.h:2292
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:1460
static void update_mb_info(MpegEncContext *s, int startcode)
#define MERGE(field)
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:45
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:358
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
int last_lambda_for[5]
last lambda for a specific pict type
Definition: mpegvideo.h:354
static int sse_mb(MpegEncContext *s)
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:96
g
Definition: yuv2rgb.c:540
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegvideo.h:337
int h263_slice_structured
Definition: mpegvideo.h:526
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
uint8_t * buf
Definition: put_bits.h:42
void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: msmpeg4enc.c:214
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2339
void ff_rate_control_uninit(MpegEncContext *s)
Definition: ratecontrol.c:252
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegvideo.h:416
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
Definition: mathematics.c:53
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
int ff_check_alignment(void)
Definition: dsputil.c:2636
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:557
uint16_t * mb_type
Table for candidate MB types for encoding.
Definition: mpegvideo.h:414
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Shrink the already allocated side data buffer.
Definition: avpacket.c:205
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:136
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:570
op_pixels_func put_no_rnd_pixels_tab[4][4]
Halfpel motion compensation with no rounding (a+b)>>1.
Definition: dsputil.h:283
#define CONFIG_LJPEG_ENCODER
Definition: config.h:854
uint8_t *[2][2] b_field_select_table
Definition: mpegvideo.h:382
#define BASIS_SHIFT
Definition: dsputil.h:436
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:921
int off
Definition: dsputil_bfin.c:28
DCTELEM(* blocks)[8][64]
Definition: mpegvideo.h:675
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:70
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:69
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:505
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2317
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
Definition: ituh263enc.c:276
int coded_picture_number
used to set pic->coded_picture_number, should not be used for/by anything else
Definition: mpegvideo.h:244
int * lambda_table
Definition: mpegvideo.h:346
static void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
static int estimate_best_b_count(MpegEncContext *s)
int intra_dc_precision
precision of the intra DC coefficient - 8
Definition: avcodec.h:1951
int me_penalty_compensation
Definition: avcodec.h:1994
#define QMAT_SHIFT
Definition: mpegvideo.h:56
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:451
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:142
#define CHROMA_422
Definition: mpegvideo.h:654
uint32_t ff_squareTbl[512]
Definition: dsputil.c:42
int bit_rate
the average bitrate
Definition: avcodec.h:1404
int progressive_frame
Definition: mpegvideo.h:659
static DCTELEM block[64]
Definition: dct-test.c:169
void ff_mjpeg_encode_picture_header(MpegEncContext *s)
Definition: mjpegenc.c:197
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1065
int ff_h263_get_gob_height(MpegEncContext *s)
Get the GOB height based on picture height.
Definition: h263.c:378
int display_picture_number
picture number in display order
Definition: avcodec.h:1115
uint16_t(* q_inter_matrix16)[2][64]
Definition: mpegvideo.h:464
uint8_t * vbv_delay_ptr
pointer to vbv_delay in the bitstream
Definition: mpegvideo.h:632
int fixed_qscale
fixed qscale if non zero
Definition: mpegvideo.h:228
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is acually possible in mpeg4
#define MAX_MB_BYTES
Definition: mpegvideo.h:69
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
Definition: pixfmt.h:77
int me_method
ME algorithm.
Definition: mpegvideo.h:383
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:126
int umvplus
== H263+ && unrestricted_mv
Definition: mpegvideo.h:524
Picture new_picture
copy of the source picture structure for encoding.
Definition: mpegvideo.h:307
int intra_quant_bias
bias for the quantizer
Definition: mpegvideo.h:445
void ff_fdct_ifast(DCTELEM *data)
Definition: jfdctfst.c:208
int width
picture width / height.
Definition: avcodec.h:1508
int type
type of the buffer (to keep track of who has to deallocate data[*])
Definition: avcodec.h:1217
#define CONFIG_MPEG1VIDEO_ENCODER
Definition: config.h:856
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:317
void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64])
Definition: mjpegenc.c:430
void ff_copy_picture(Picture *dst, Picture *src)
Definition: mpegvideo.c:223
Picture.
Definition: mpegvideo.h:94
int alternate_scan
Definition: mpegvideo.h:649
int coded_score[8]
Definition: mpegvideo.h:457
float rc_max_available_vbv_use
Ratecontrol attempt to use, at maximum, of what can be used without an underflow. ...
Definition: avcodec.h:2362
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegvideo.h:417
void ff_msmpeg4_encode_init(MpegEncContext *s)
Definition: msmpeg4enc.c:115
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:644
int b_frame_strategy
Definition: avcodec.h:1603
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
Definition: mpegvideo.h:463
static av_always_inline av_const long int lrintf(float x)
Definition: libm.h:144
#define FF_NO_IDCT_PERM
Definition: dsputil.h:427
void ff_mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
Definition: mpeg12enc.c:659
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: avcodec.h:1122
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:878
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:261
MotionEstContext me
Definition: mpegvideo.h:405
void ff_wmv2_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
Definition: wmv2enc.c:150
const int16_t ff_mpeg4_default_non_intra_matrix[64]
Definition: mpeg4data.h:348
int mb_decision
macroblock decision mode
Definition: avcodec.h:1882
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride)
uint8_t * mbintra_table
used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding
Definition: mpegvideo.h:334
int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function for encode/decode called after coding/decoding the header and before a frame is code...
Definition: mpegvideo.c:1370
int ac_esc_length
num of bits needed to encode the longest esc
Definition: mpegvideo.h:449
#define CANDIDATE_MB_TYPE_BACKWARD
Definition: mpegvideo.h:423
#define CANDIDATE_MB_TYPE_SKIPPED
Definition: mpegvideo.h:418
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:100
LIBAVUTIL_VERSION_INT
Definition: eval.c:52
#define CONFIG_MPEG4_ENCODER
Definition: config.h:858
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2733
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:433
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:437
int inter_quant_bias
inter quantizer bias
Definition: avcodec.h:1848
static uint8_t default_fcode_tab[MAX_MV *2+1]
Definition: mpegvideo_enc.c:65
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
Definition: dsputil.h:142
int mjpeg_vsample[3]
vertical sampling factors, default = {2, 1, 1}
Definition: mpegvideo.h:604
AVCodec ff_h263p_encoder
static void build_basis(uint8_t *perm)
uint32_t * mb_type
macroblock type table mb_type_base + mb_width + 2
Definition: avcodec.h:1180
void ff_jpeg_fdct_islow_10(DCTELEM *data)
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:389
int frame_skip_factor
frame skip factor
Definition: avcodec.h:2423
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:614
int frame_pred_frame_dct
Definition: mpegvideo.h:644
NULL
Definition: eval.c:52
uint16_t * mc_mb_var
Table for motion compensated MB variances.
Definition: mpegvideo.h:144
void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: flvenc.c:24
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:386
void ff_faandct(DCTELEM *data)
Definition: faandct.c:122
const uint8_t *const ff_mpeg2_dc_scale_table[4]
Definition: mpegvideo.c:121
int coded_picture_number
picture number in bitstream order
Definition: avcodec.h:1109
uint16_t inter_matrix[64]
Definition: mpegvideo.h:442
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1209
int64_t last_non_b_time
Definition: mpegvideo.h:537
int(* fast_dct_quantize)(struct MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:703
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:288
#define CONFIG_MSMPEG4_ENCODER
Definition: msmpeg4.h:65
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Definition: mpegvideo.h:345
double buffer_index
amount of bits in the video/audio buffer
Definition: ratecontrol.h:67
external API header
int me_threshold
Motion estimation threshold below which no motion estimation is performed, but instead the user speci...
Definition: avcodec.h:1937
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:49
int h263_flv
use flv h263 header
Definition: mpegvideo.h:225
static const AVClass h263p_class
enum AVCodecID codec_id
Definition: avcodec.h:1350
static av_const unsigned int ff_sqrt(unsigned int a)
Definition: mathops.h:198
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
int idct_permutation_type
Definition: dsputil.h:426
void(* denoise_dct)(struct MpegEncContext *s, DCTELEM *block)
Definition: mpegvideo.h:704
const uint16_t ff_inv_aanscales[64]
Definition: aandcttab.c:38
av_default_item_name
Definition: dnxhdenc.c:43
#define START_TIMER
Definition: timer.h:74
int frame_bits
number of bits used for the previously encoded frame
Definition: avcodec.h:2495
void ff_mjpeg_encode_close(MpegEncContext *s)
Definition: mjpegenc.c:80
main external API structure.
Definition: avcodec.h:1339
#define CONFIG_H263_ENCODER
Definition: config.h:850
void ff_MPV_encode_init_x86(MpegEncContext *s)
Definition: mpegvideoenc.c:83
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:107
ScanTable intra_scantable
Definition: mpegvideo.h:266
int pre_me
prepass for motion estimation
Definition: avcodec.h:1786
int qmin
minimum quantizer
Definition: avcodec.h:2285
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:215
void(* diff_pixels)(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride)
Definition: dsputil.h:202
void ff_mjpeg_encode_stuffing(PutBitContext *pbc)
Definition: mjpegenc.c:331
static void write_slice_end(MpegEncContext *s)
int64_t dts_delta
pts difference between the first and second input frame, used for calculating dts of the first frame ...
Definition: mpegvideo.h:277
void ff_mjpeg_encode_picture_trailer(MpegEncContext *s)
Definition: mjpegenc.c:338
int16_t(*[2] motion_val)[2]
motion vector table
Definition: avcodec.h:1172
int64_t user_specified_pts
last non zero pts from AVFrame which was passed into avcodec_encode_video()
Definition: mpegvideo.h:273
int ff_h261_get_picture_format(int width, int height)
Definition: h261enc.c:40
uint8_t * buf_end
Definition: put_bits.h:42
float spatial_cplx_masking
spatial complexity masking (0-> disabled)
Definition: avcodec.h:1678
int luma_elim_threshold
Definition: mpegvideo.h:233
void ff_fix_long_p_mvs(MpegEncContext *s)
Definition: motion_est.c:1845
Picture * picture
main picture buffer
Definition: mpegvideo.h:255
int data_partitioning
data partitioning flag from header
Definition: mpegvideo.h:566
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:452
int progressive_sequence
Definition: mpegvideo.h:635
uint16_t * intra_matrix
custom intra quantization matrix
Definition: avcodec.h:1892
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: ituh263enc.c:250
uint8_t * buf_ptr
Definition: put_bits.h:42
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:602
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src)
Describe the class of an AVClass context structure.
Definition: log.h:33
int16_t(*[2][2][2] b_field_mv_table)[2]
MV table (4MV per MB) interlaced b-frame encoding.
Definition: mpegvideo.h:380
int index
Definition: gxfenc.c:72
static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type)
int input_picture_number
used to set pic->display_picture_number, should not be used for/by anything else
Definition: mpegvideo.h:243
AVCodec ff_wmv1_encoder
void(* add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale)
Definition: dsputil.h:435
int mb_info
interval for outputting info about mb offsets as side data
Definition: mpegvideo.h:518
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
void ff_set_mpeg4_time(MpegEncContext *s)
static void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type)
int8_t * ref_index[2]
motion reference frame index the order in which these are stored can depend on the codec...
Definition: avcodec.h:1195
DSPContext dsp
pointers for accelerated dsp functions
Definition: mpegvideo.h:361
int(* pix_norm1)(uint8_t *pix, int line_size)
Definition: dsputil.h:221
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:643
int frame_skip_exp
frame skip exponent
Definition: avcodec.h:2430
#define MAX_MV
Definition: mpegvideo.h:59
av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: mpeg12enc.c:334
const int16_t ff_mpeg4_default_intra_matrix[64]
Definition: mpeg4data.h:337
int f_code
forward MV resolution
Definition: mpegvideo.h:363
int ff_pre_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:1197
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
Definition: mpeg4video.c:121
#define MAX_FCODE
Definition: mpegvideo.h:58
#define CANDIDATE_MB_TYPE_BIDIR_I
Definition: mpegvideo.h:429
static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV *2+1]
Definition: mpegvideo_enc.c:64
#define QMAT_SHIFT_MMX
Definition: mpegvideo.h:55
short DCTELEM
Definition: dsputil.h:39
#define MV_DIR_FORWARD
Definition: mpegvideo.h:385
uint16_t * inter_matrix
custom inter quantization matrix
Definition: avcodec.h:1899
int max_b_frames
max number of b-frames for encoding
Definition: mpegvideo.h:232
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:349
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
int bit_rate
wanted bit rate
Definition: mpegvideo.h:218
DCTELEM(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:674
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
int last_mv_dir
last mv_dir, used for b frame encoding
Definition: mpegvideo.h:630
#define CANDIDATE_MB_TYPE_FORWARD_I
Definition: mpegvideo.h:427
int h263_pred
use mpeg4/h263 ac/dc predictions
Definition: mpegvideo.h:220
int16_t(* b_bidir_back_mv_table)[2]
MV table (1MV per MB) bidir mode b-frame encoding.
Definition: mpegvideo.h:377
float dark_masking
darkness masking (0-> disabled)
Definition: avcodec.h:1692
float temporal_cplx_masking
temporary complexity masking (0-> disabled)
Definition: avcodec.h:1671
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:296
uint8_t *[2] p_field_select_table
Definition: mpegvideo.h:381
int16_t(* b_direct_mv_table)[2]
MV table (1MV per MB) direct mode b-frame encoding.
Definition: mpegvideo.h:378
static const uint16_t scale[4]
AAN (Arai Agui Nakajima) (I)DCT tables.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:325
int8_t * qscale_table
QP table.
Definition: avcodec.h:1139
uint8_t level
Definition: svq3.c:125
int mc_mb_var_sum_temp
Definition: mpegvideo.h:192
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:399
int16_t(* b_forw_mv_table)[2]
MV table (1MV per MB) forward mode b-frame encoding.
Definition: mpegvideo.h:374
int noise_reduction
noise reduction strength
Definition: avcodec.h:1914
static int estimate_motion_thread(AVCodecContext *c, void *arg)
int height
Definition: gxfenc.c:72
void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block.
Definition: dsputil.c:1716
MpegEncContext.
Definition: mpegvideo.h:211
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:316
struct AVCodecContext * avctx
Definition: mpegvideo.h:213
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1524
PutBitContext pb
bit output
Definition: mpegvideo.h:284
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
static void update_qscale(MpegEncContext *s)
int mb_cmp
macroblock comparison function (not supported yet)
Definition: avcodec.h:1743
int quantizer_noise_shaping
Definition: mpegvideo.h:707
int(* dct_error_sum)[64]
Definition: mpegvideo.h:467
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg)
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:248
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:86
void ff_MPV_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding). ...
Definition: mpegvideo.c:689
void ff_jpeg_fdct_islow_8(DCTELEM *data)
#define ARCH_X86
Definition: config.h:33
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.h:262
void(* fdct)(DCTELEM *block)
Definition: dsputil.h:394
uint8_t * dest[3]
Definition: mpegvideo.h:435
#define COPY(a)
int adaptive_quant
use adaptive quantization
Definition: mpegvideo.h:347
static int16_t basis[64][64]
void ff_msmpeg4_encode_ext_header(MpegEncContext *s)
Definition: msmpeg4enc.c:274
static int score_tab[256]
Definition: zmbvenc.c:60
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:295
Bi-dir predicted.
Definition: avutil.h:247
me_cmp_func sad[6]
Definition: dsputil.h:224
int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:66
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_...
Definition: pixfmt.h:79
int64_t reordered_pts
reordered pts to be used as dts for the next output frame when there's a delay
Definition: mpegvideo.h:281
int ff_vbv_update(MpegEncContext *s, int frame_size)
Definition: ratecontrol.c:266
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:42
#define CONFIG_H263P_ENCODER
Definition: config.h:851
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:52
int den
denominator
Definition: rational.h:45
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
Definition: mpegvideo.h:326
AVCodec ff_msmpeg4v3_encoder
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:547
int trellis
trellis RD quantization
Definition: avcodec.h:2444
DSP utils.
#define CANDIDATE_MB_TYPE_DIRECT0
Definition: mpegvideo.h:431
void ff_mpeg4_stuffing(PutBitContext *pbc)
add mpeg4 stuffing bits (01...1)
#define STOP_TIMER(id)
Definition: timer.h:75
void * priv_data
Definition: avcodec.h:1382
const AVOption ff_mpv_generic_options[]
Definition: mpegvideo_enc.c:67
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
Definition: mpeg12enc.c:323
void ff_h261_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y)
Definition: h261enc.c:156
#define CONFIG_FLV_ENCODER
Definition: config.h:847
int last_bits
temp var used for calculating the above vars
Definition: mpegvideo.h:489
void ff_mpeg4_init_partitions(MpegEncContext *s)
int dia_size
ME diamond size & shape.
Definition: avcodec.h:1772
int b_sensitivity
Adjust sensitivity of b_frame_strategy 1.
Definition: avcodec.h:2051
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2773
VideoDSPContext vdsp
Definition: mpegvideo.h:362
void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
Definition: mpegvideo.c:2379
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: avcodec.h:1239
#define VE
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src)
void ff_MPV_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1141
#define av_log2
Definition: intmath.h:85
int error_rate
Simulates errors in the bitstream to test error concealment.
Definition: avcodec.h:2925
int ff_get_best_fcode(MpegEncContext *s, int16_t(*mv_table)[2], int type)
Definition: motion_est.c:1792
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:506
void ff_rv20_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: rv20enc.c:32
PutBitContext tex_pb
used for data partitioned VOPs
Definition: mpegvideo.h:575
Picture next_picture
copy of the next picture structure.
Definition: mpegvideo.h:301
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1058
static void set_frame_distances(MpegEncContext *s)
int linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:253
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:1895
Picture ** reordered_input_picture
pointer to the next pictures in codedorder for encoding
Definition: mpegvideo.h:257
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1441
static const struct twinvq_data tab
void ff_mpeg1_encode_init(MpegEncContext *s)
Definition: mpeg12enc.c:706
struct AVFrame f
Definition: mpegvideo.h:95
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:914
int mb_var_sum
sum of MB variance for current frame
Definition: mpegvideo.h:141
static int encode_thread(AVCodecContext *c, void *arg)
int flags
AVCodecContext.flags (HQ, MV4, ...)
Definition: mpegvideo.h:230
int mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegvideo.h:142
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:440
static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src)
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]
Definition: dsputil.h:314
Floating point AAN DCT
int inter_quant_bias
bias for the quantizer
Definition: mpegvideo.h:446
int me_method
Motion estimation algorithm used for video coding.
Definition: avcodec.h:1542
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:165
int ff_find_unused_picture(MpegEncContext *s, int shared)
Definition: mpegvideo.c:1331
#define MV_TYPE_8X8
4 vectors (h263, mpeg4 4MV)
Definition: mpegvideo.h:390
int rc_min_rate
minimum bitrate
Definition: avcodec.h:2346
int b_code
backward MV resolution for B Frames (mpeg4)
Definition: mpegvideo.h:364
static void MPV_encode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for encoding.
int dct_count[2]
Definition: mpegvideo.h:468
static int encode_frame(AVCodecContext *c, AVFrame *frame)
int uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:254
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:898
int delay
Codec delay.
Definition: avcodec.h:1497
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: avcodec.h:2547
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:908
#define CONFIG_RV10_ENCODER
Definition: config.h:872
#define CANDIDATE_MB_TYPE_INTER_I
Definition: mpegvideo.h:426
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:1998
static void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], int *dmin, int *next_block, int motion_x, int motion_y)
Predicted.
Definition: avutil.h:246
unsigned int lambda
lagrange multipler used in rate distortion
Definition: mpegvideo.h:344
DSPContext.
Definition: dsputil.h:194
AVCodec ff_msmpeg4v2_encoder
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:539
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
int next_lambda
next lambda used for retrying to encode a frame
Definition: mpegvideo.h:476