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/opt.h"
33 #include "avcodec.h"
34 #include "dsputil.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
37 #include "h263.h"
38 #include "mjpegenc.h"
39 #include "msmpeg4.h"
40 #include "faandct.h"
41 #include "thread.h"
42 #include "aandcttab.h"
43 #include "flv.h"
44 #include "mpeg4video.h"
45 #include "internal.h"
46 #include <limits.h>
47 
48 //#undef NDEBUG
49 //#include <assert.h>
50 
51 static int encode_picture(MpegEncContext *s, int picture_number);
52 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
53 static int sse_mb(MpegEncContext *s);
54 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
55 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
56 
57 /* enable all paranoid tests for rounding, overflows, etc... */
58 //#define PARANOID
59 
60 //#define DEBUG
61 
62 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
63 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
64 
65 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64],
66  uint16_t (*qmat16)[2][64],
67  const uint16_t *quant_matrix,
68  int bias, int qmin, int qmax, int intra)
69 {
70  int qscale;
71  int shift = 0;
72 
73  for (qscale = qmin; qscale <= qmax; qscale++) {
74  int i;
75  if (dsp->fdct == ff_jpeg_fdct_islow_8 ||
77 #ifdef FAAN_POSTSCALE
78  || dsp->fdct == ff_faandct
79 #endif
80  ) {
81  for (i = 0; i < 64; i++) {
82  const int j = dsp->idct_permutation[i];
83  /* 16 <= qscale * quant_matrix[i] <= 7905
84  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
85  * 19952 <= x <= 249205026
86  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
87  * 3444240 >= (1 << 36) / (x) >= 275 */
88 
89  qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
90  (qscale * quant_matrix[j]));
91  }
92  } else if (dsp->fdct == fdct_ifast
93 #ifndef FAAN_POSTSCALE
94  || dsp->fdct == ff_faandct
95 #endif
96  ) {
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 == fdct_ifast
136 #ifndef FAAN_POSTSCALE
137  || dsp->fdct == ff_faandct
138 #endif
139  ) {
140  max = (8191LL * ff_aanscales[i]) >> 14;
141  }
142  while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
143  shift++;
144  }
145  }
146  }
147  if (shift) {
149  "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
150  QMAT_SHIFT - shift);
151  }
152 }
153 
154 static inline void update_qscale(MpegEncContext *s)
155 {
156  s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
157  (FF_LAMBDA_SHIFT + 7);
158  s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
159 
160  s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
162 }
163 
164 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
165 {
166  int i;
167 
168  if (matrix) {
169  put_bits(pb, 1, 1);
170  for (i = 0; i < 64; i++) {
171  put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
172  }
173  } else
174  put_bits(pb, 1, 0);
175 }
176 
181 {
182  int8_t * const qscale_table = s->current_picture.f.qscale_table;
183  int i;
184 
185  for (i = 0; i < s->mb_num; i++) {
186  unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
187  int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
188  qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
189  s->avctx->qmax);
190  }
191 }
192 
194  AVFrame *dst,
195  AVFrame *src)
196 {
197  int i;
198 
199  dst->pict_type = src->pict_type;
200  dst->quality = src->quality;
203  //dst->reference = src->reference;
204  dst->pts = src->pts;
206  dst->top_field_first = src->top_field_first;
207 
208  if (s->avctx->me_threshold) {
209  if (!src->motion_val[0])
210  av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
211  if (!src->mb_type)
212  av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
213  if (!src->ref_index[0])
214  av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
217  "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
219 
220  memcpy(dst->mb_type, src->mb_type,
221  s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
222 
223  for (i = 0; i < 2; i++) {
224  int stride = ((16 * s->mb_width ) >>
225  src->motion_subsample_log2) + 1;
226  int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
227 
228  if (src->motion_val[i] &&
229  src->motion_val[i] != dst->motion_val[i]) {
230  memcpy(dst->motion_val[i], src->motion_val[i],
231  2 * stride * height * sizeof(int16_t));
232  }
233  if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
234  memcpy(dst->ref_index[i], src->ref_index[i],
235  s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
236  }
237  }
238  }
239 }
240 
242  MpegEncContext *src)
243 {
244 #define COPY(a) dst->a= src->a
245  COPY(pict_type);
247  COPY(f_code);
248  COPY(b_code);
249  COPY(qscale);
250  COPY(lambda);
251  COPY(lambda2);
254  COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
255  COPY(progressive_frame); // FIXME don't set in encode_header
256  COPY(partitioned_frame); // FIXME don't set in encode_header
257 #undef COPY
258 }
259 
265 {
266  int i;
268 
269  for (i = -16; i < 16; i++) {
270  default_fcode_tab[i + MAX_MV] = 1;
271  }
274 }
275 
276 /* init video encoder */
278 {
279  MpegEncContext *s = avctx->priv_data;
280  int i;
281  int chroma_h_shift, chroma_v_shift;
282 
284 
285  switch (avctx->codec_id) {
286  case CODEC_ID_MPEG2VIDEO:
287  if (avctx->pix_fmt != PIX_FMT_YUV420P &&
288  avctx->pix_fmt != PIX_FMT_YUV422P) {
289  av_log(avctx, AV_LOG_ERROR,
290  "only YUV420 and YUV422 are supported\n");
291  return -1;
292  }
293  break;
294  case CODEC_ID_LJPEG:
295  if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
296  avctx->pix_fmt != PIX_FMT_YUVJ422P &&
297  avctx->pix_fmt != PIX_FMT_YUVJ444P &&
298  avctx->pix_fmt != PIX_FMT_BGRA &&
299  ((avctx->pix_fmt != PIX_FMT_YUV420P &&
300  avctx->pix_fmt != PIX_FMT_YUV422P &&
301  avctx->pix_fmt != PIX_FMT_YUV444P) ||
303  av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
304  return -1;
305  }
306  break;
307  case CODEC_ID_MJPEG:
308  if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
309  avctx->pix_fmt != PIX_FMT_YUVJ422P &&
310  ((avctx->pix_fmt != PIX_FMT_YUV420P &&
311  avctx->pix_fmt != PIX_FMT_YUV422P) ||
313  av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
314  return -1;
315  }
316  break;
317  default:
318  if (avctx->pix_fmt != PIX_FMT_YUV420P) {
319  av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
320  return -1;
321  }
322  }
323 
324  switch (avctx->pix_fmt) {
325  case PIX_FMT_YUVJ422P:
326  case PIX_FMT_YUV422P:
328  break;
329  case PIX_FMT_YUVJ420P:
330  case PIX_FMT_YUV420P:
331  default:
333  break;
334  }
335 
336  s->bit_rate = avctx->bit_rate;
337  s->width = avctx->width;
338  s->height = avctx->height;
339  if (avctx->gop_size > 600 &&
341  av_log(avctx, AV_LOG_ERROR,
342  "Warning keyframe interval too large! reducing it ...\n");
343  avctx->gop_size = 600;
344  }
345  s->gop_size = avctx->gop_size;
346  s->avctx = avctx;
347  s->flags = avctx->flags;
348  s->flags2 = avctx->flags2;
349  s->max_b_frames = avctx->max_b_frames;
350  s->codec_id = avctx->codec->id;
354 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
355  if (avctx->flags & CODEC_FLAG_PART)
356  s->data_partitioning = 1;
357 #endif
358  s->quarter_sample = (avctx->flags & CODEC_FLAG_QPEL) != 0;
359  s->mpeg_quant = avctx->mpeg_quant;
360  s->rtp_mode = !!avctx->rtp_payload_size;
363 
364  if (s->gop_size <= 1) {
365  s->intra_only = 1;
366  s->gop_size = 12;
367  } else {
368  s->intra_only = 0;
369  }
370 
371  s->me_method = avctx->me_method;
372 
373  /* Fixed QSCALE */
374  s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
375 
376  s->adaptive_quant = (s->avctx->lumi_masking ||
377  s->avctx->dark_masking ||
380  s->avctx->p_masking ||
381  s->avctx->border_masking ||
382  (s->flags & CODEC_FLAG_QP_RD)) &&
383  !s->fixed_qscale;
384 
386 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
387  s->alternate_scan = !!(s->flags & CODEC_FLAG_ALT_SCAN);
388  s->intra_vlc_format = !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
389  s->q_scale_type = !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
390  s->obmc = !!(s->flags & CODEC_FLAG_OBMC);
391 #endif
392 
393  if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
394  av_log(avctx, AV_LOG_ERROR,
395  "a vbv buffer size is needed, "
396  "for encoding with a maximum bitrate\n");
397  return -1;
398  }
399 
400  if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
401  av_log(avctx, AV_LOG_INFO,
402  "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
403  }
404 
405  if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
406  av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
407  return -1;
408  }
409 
410  if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
411  av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
412  return -1;
413  }
414 
415  if (avctx->rc_max_rate &&
416  avctx->rc_max_rate == avctx->bit_rate &&
417  avctx->rc_max_rate != avctx->rc_min_rate) {
418  av_log(avctx, AV_LOG_INFO,
419  "impossible bitrate constraints, this will fail\n");
420  }
421 
422  if (avctx->rc_buffer_size &&
423  avctx->bit_rate * (int64_t)avctx->time_base.num >
424  avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
425  av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
426  return -1;
427  }
428 
429  if (!s->fixed_qscale &&
430  avctx->bit_rate * av_q2d(avctx->time_base) >
431  avctx->bit_rate_tolerance) {
432  av_log(avctx, AV_LOG_ERROR,
433  "bitrate tolerance too small for bitrate\n");
434  return -1;
435  }
436 
437  if (s->avctx->rc_max_rate &&
438  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
439  (s->codec_id == CODEC_ID_MPEG1VIDEO ||
440  s->codec_id == CODEC_ID_MPEG2VIDEO) &&
441  90000LL * (avctx->rc_buffer_size - 1) >
442  s->avctx->rc_max_rate * 0xFFFFLL) {
443  av_log(avctx, AV_LOG_INFO,
444  "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
445  "specified vbv buffer is too large for the given bitrate!\n");
446  }
447 
448  if ((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 &&
450  s->codec_id != CODEC_ID_FLV1) {
451  av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
452  return -1;
453  }
454 
455  if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
456  av_log(avctx, AV_LOG_ERROR,
457  "OBMC is only supported with simple mb decision\n");
458  return -1;
459  }
460 
461 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
462  if (s->obmc && s->codec_id != CODEC_ID_H263 &&
463  s->codec_id != CODEC_ID_H263P) {
464  av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
465  return -1;
466  }
467 #endif
468 
469  if (s->quarter_sample && s->codec_id != CODEC_ID_MPEG4) {
470  av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
471  return -1;
472  }
473 
474 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
475  if (s->data_partitioning && s->codec_id != CODEC_ID_MPEG4) {
476  av_log(avctx, AV_LOG_ERROR,
477  "data partitioning not supported by codec\n");
478  return -1;
479  }
480 #endif
481 
482  if (s->max_b_frames &&
483  s->codec_id != CODEC_ID_MPEG4 &&
486  av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
487  return -1;
488  }
489 
490  if ((s->codec_id == CODEC_ID_MPEG4 ||
491  s->codec_id == CODEC_ID_H263 ||
492  s->codec_id == CODEC_ID_H263P) &&
493  (avctx->sample_aspect_ratio.num > 255 ||
494  avctx->sample_aspect_ratio.den > 255)) {
495  av_log(avctx, AV_LOG_ERROR,
496  "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
498  return -1;
499  }
500 
503  | CODEC_FLAG_ALT_SCAN
504 #endif
505  )) &&
507  av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
508  return -1;
509  }
510 
511  // FIXME mpeg2 uses that too
512  if (s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4) {
513  av_log(avctx, AV_LOG_ERROR,
514  "mpeg2 style quantization not supported by codec\n");
515  return -1;
516  }
517 
518  if ((s->flags & CODEC_FLAG_CBP_RD) && !avctx->trellis) {
519  av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
520  return -1;
521  }
522 
523  if ((s->flags & CODEC_FLAG_QP_RD) &&
525  av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
526  return -1;
527  }
528 
529  if (s->avctx->scenechange_threshold < 1000000000 &&
530  (s->flags & CODEC_FLAG_CLOSED_GOP)) {
531  av_log(avctx, AV_LOG_ERROR,
532  "closed gop with scene change detection are not supported yet, "
533  "set threshold to 1000000000\n");
534  return -1;
535  }
536 
537 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
538  if ((s->flags2 & CODEC_FLAG2_INTRA_VLC) &&
540  av_log(avctx, AV_LOG_ERROR,
541  "intra vlc table not supported by codec\n");
542  return -1;
543  }
544 #endif
545 
546  if (s->flags & CODEC_FLAG_LOW_DELAY) {
547  if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
548  av_log(avctx, AV_LOG_ERROR,
549  "low delay forcing is only available for mpeg2\n");
550  return -1;
551  }
552  if (s->max_b_frames != 0) {
553  av_log(avctx, AV_LOG_ERROR,
554  "b frames cannot be used with low delay\n");
555  return -1;
556  }
557  }
558 
559  if (s->q_scale_type == 1) {
560 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
561  if (s->codec_id != CODEC_ID_MPEG2VIDEO) {
562  av_log(avctx, AV_LOG_ERROR,
563  "non linear quant is only available for mpeg2\n");
564  return -1;
565  }
566 #endif
567  if (avctx->qmax > 12) {
568  av_log(avctx, AV_LOG_ERROR,
569  "non linear quant only supports qmax <= 12 currently\n");
570  return -1;
571  }
572  }
573 
574  if (s->avctx->thread_count > 1 &&
575  s->codec_id != CODEC_ID_MPEG4 &&
578  (s->codec_id != CODEC_ID_H263P
580  || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT)
581 #endif
582  )) {
583  av_log(avctx, AV_LOG_ERROR,
584  "multi threaded encoding not supported by codec\n");
585  return -1;
586  }
587 
588  if (s->avctx->thread_count < 1) {
589  av_log(avctx, AV_LOG_ERROR,
590  "automatic thread number detection not supported by codec,"
591  "patch welcome\n");
592  return -1;
593  }
594 
595  if (s->avctx->thread_count > 1)
596  s->rtp_mode = 1;
597 
598  if (!avctx->time_base.den || !avctx->time_base.num) {
599  av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
600  return -1;
601  }
602 
603  i = (INT_MAX / 2 + 128) >> 8;
604  if (avctx->me_threshold >= i) {
605  av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
606  i - 1);
607  return -1;
608  }
609  if (avctx->mb_threshold >= i) {
610  av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
611  i - 1);
612  return -1;
613  }
614 
615  if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
616  av_log(avctx, AV_LOG_INFO,
617  "notice: b_frame_strategy only affects the first pass\n");
618  avctx->b_frame_strategy = 0;
619  }
620 
621  i = av_gcd(avctx->time_base.den, avctx->time_base.num);
622  if (i > 1) {
623  av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
624  avctx->time_base.den /= i;
625  avctx->time_base.num /= i;
626  //return -1;
627  }
628 
629  if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG1VIDEO ||
631  // (a + x * 3 / 8) / x
632  s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
633  s->inter_quant_bias = 0;
634  } else {
635  s->intra_quant_bias = 0;
636  // (a - x / 4) / x
637  s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
638  }
639 
644 
645  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
646  &chroma_v_shift);
647 
648  if (avctx->codec_id == CODEC_ID_MPEG4 &&
649  s->avctx->time_base.den > (1 << 16) - 1) {
650  av_log(avctx, AV_LOG_ERROR,
651  "timebase %d/%d not supported by MPEG 4 standard, "
652  "the maximum admitted value for the timebase denominator "
653  "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
654  (1 << 16) - 1);
655  return -1;
656  }
657  s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
658 
659  switch (avctx->codec->id) {
660  case CODEC_ID_MPEG1VIDEO:
661  s->out_format = FMT_MPEG1;
662  s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
663  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
664  break;
665  case CODEC_ID_MPEG2VIDEO:
666  s->out_format = FMT_MPEG1;
667  s->low_delay = !!(s->flags & CODEC_FLAG_LOW_DELAY);
668  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
669  s->rtp_mode = 1;
670  break;
671  case CODEC_ID_LJPEG:
672  case CODEC_ID_MJPEG:
673  s->out_format = FMT_MJPEG;
674  s->intra_only = 1; /* force intra only for jpeg */
675  if (avctx->codec->id == CODEC_ID_LJPEG &&
676  avctx->pix_fmt == PIX_FMT_BGRA) {
677  s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
678  s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
679  s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
680  } else {
681  s->mjpeg_vsample[0] = 2;
682  s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
683  s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
684  s->mjpeg_hsample[0] = 2;
685  s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
686  s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
687  }
689  ff_mjpeg_encode_init(s) < 0)
690  return -1;
691  avctx->delay = 0;
692  s->low_delay = 1;
693  break;
694  case CODEC_ID_H261:
695  if (!CONFIG_H261_ENCODER)
696  return -1;
697  if (ff_h261_get_picture_format(s->width, s->height) < 0) {
698  av_log(avctx, AV_LOG_ERROR,
699  "The specified picture size of %dx%d is not valid for the "
700  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
701  s->width, s->height);
702  return -1;
703  }
704  s->out_format = FMT_H261;
705  avctx->delay = 0;
706  s->low_delay = 1;
707  break;
708  case CODEC_ID_H263:
709  if (!CONFIG_H263_ENCODER)
710  return -1;
712  s->width, s->height) == 8) {
713  av_log(avctx, AV_LOG_INFO,
714  "The specified picture size of %dx%d is not valid for "
715  "the H.263 codec.\nValid sizes are 128x96, 176x144, "
716  "352x288, 704x576, and 1408x1152."
717  "Try H.263+.\n", s->width, s->height);
718  return -1;
719  }
720  s->out_format = FMT_H263;
721  avctx->delay = 0;
722  s->low_delay = 1;
723  break;
724  case CODEC_ID_H263P:
725  s->out_format = FMT_H263;
726  s->h263_plus = 1;
727  /* Fx */
728 #if FF_API_MPEGVIDEO_GLOBAL_OPTS
729  if (avctx->flags & CODEC_FLAG_H263P_UMV)
730  s->umvplus = 1;
731  if (avctx->flags & CODEC_FLAG_H263P_AIV)
732  s->alt_inter_vlc = 1;
733  if (avctx->flags & CODEC_FLAG_H263P_SLICE_STRUCT)
734  s->h263_slice_structured = 1;
735 #endif
736  s->h263_aic = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
737  s->modified_quant = s->h263_aic;
738  s->loop_filter = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
739  s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
740 
741  /* /Fx */
742  /* These are just to be sure */
743  avctx->delay = 0;
744  s->low_delay = 1;
745  break;
746  case CODEC_ID_FLV1:
747  s->out_format = FMT_H263;
748  s->h263_flv = 2; /* format = 1; 11-bit codes */
749  s->unrestricted_mv = 1;
750  s->rtp_mode = 0; /* don't allow GOB */
751  avctx->delay = 0;
752  s->low_delay = 1;
753  break;
754  case CODEC_ID_RV10:
755  s->out_format = FMT_H263;
756  avctx->delay = 0;
757  s->low_delay = 1;
758  break;
759  case CODEC_ID_RV20:
760  s->out_format = FMT_H263;
761  avctx->delay = 0;
762  s->low_delay = 1;
763  s->modified_quant = 1;
764  s->h263_aic = 1;
765  s->h263_plus = 1;
766  s->loop_filter = 1;
767  s->unrestricted_mv = 0;
768  break;
769  case CODEC_ID_MPEG4:
770  s->out_format = FMT_H263;
771  s->h263_pred = 1;
772  s->unrestricted_mv = 1;
773  s->low_delay = s->max_b_frames ? 0 : 1;
774  avctx->delay = s->low_delay ? 0 : (s->max_b_frames + 1);
775  break;
776  case CODEC_ID_MSMPEG4V2:
777  s->out_format = FMT_H263;
778  s->h263_pred = 1;
779  s->unrestricted_mv = 1;
780  s->msmpeg4_version = 2;
781  avctx->delay = 0;
782  s->low_delay = 1;
783  break;
784  case CODEC_ID_MSMPEG4V3:
785  s->out_format = FMT_H263;
786  s->h263_pred = 1;
787  s->unrestricted_mv = 1;
788  s->msmpeg4_version = 3;
789  s->flipflop_rounding = 1;
790  avctx->delay = 0;
791  s->low_delay = 1;
792  break;
793  case CODEC_ID_WMV1:
794  s->out_format = FMT_H263;
795  s->h263_pred = 1;
796  s->unrestricted_mv = 1;
797  s->msmpeg4_version = 4;
798  s->flipflop_rounding = 1;
799  avctx->delay = 0;
800  s->low_delay = 1;
801  break;
802  case CODEC_ID_WMV2:
803  s->out_format = FMT_H263;
804  s->h263_pred = 1;
805  s->unrestricted_mv = 1;
806  s->msmpeg4_version = 5;
807  s->flipflop_rounding = 1;
808  avctx->delay = 0;
809  s->low_delay = 1;
810  break;
811  default:
812  return -1;
813  }
814 
815  avctx->has_b_frames = !s->low_delay;
816 
817  s->encoding = 1;
818 
819  s->progressive_frame =
822  s->alternate_scan);
823 
824  /* init */
825  if (MPV_common_init(s) < 0)
826  return -1;
827 
828  if (!s->dct_quantize)
830  if (!s->denoise_dct)
833  if (avctx->trellis)
835 
838 
839  s->quant_precision = 5;
840 
841  ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
843 
851  && s->out_format == FMT_MPEG1)
853 
854  /* init q matrix */
855  for (i = 0; i < 64; i++) {
856  int j = s->dsp.idct_permutation[i];
858  s->mpeg_quant) {
861  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
862  s->intra_matrix[j] =
864  } else {
865  /* mpeg1/2 */
868  }
869  if (s->avctx->intra_matrix)
870  s->intra_matrix[j] = s->avctx->intra_matrix[i];
871  if (s->avctx->inter_matrix)
872  s->inter_matrix[j] = s->avctx->inter_matrix[i];
873  }
874 
875  /* precompute matrix */
876  /* for mjpeg, we do include qscale in the matrix */
877  if (s->out_format != FMT_MJPEG) {
879  s->intra_matrix, s->intra_quant_bias, avctx->qmin,
880  31, 1);
882  s->inter_matrix, s->inter_quant_bias, avctx->qmin,
883  31, 0);
884  }
885 
886  if (ff_rate_control_init(s) < 0)
887  return -1;
888 
889  return 0;
890 }
891 
893 {
894  MpegEncContext *s = avctx->priv_data;
895 
897 
898  MPV_common_end(s);
900  s->out_format == FMT_MJPEG)
902 
903  av_freep(&avctx->extradata);
904 
905  return 0;
906 }
907 
908 static int get_sae(uint8_t *src, int ref, int stride)
909 {
910  int x,y;
911  int acc = 0;
912 
913  for (y = 0; y < 16; y++) {
914  for (x = 0; x < 16; x++) {
915  acc += FFABS(src[x + y * stride] - ref);
916  }
917  }
918 
919  return acc;
920 }
921 
922 static int get_intra_count(MpegEncContext *s, uint8_t *src,
923  uint8_t *ref, int stride)
924 {
925  int x, y, w, h;
926  int acc = 0;
927 
928  w = s->width & ~15;
929  h = s->height & ~15;
930 
931  for (y = 0; y < h; y += 16) {
932  for (x = 0; x < w; x += 16) {
933  int offset = x + y * stride;
934  int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
935  16);
936  int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
937  int sae = get_sae(src + offset, mean, stride);
938 
939  acc += sae + 500 < sad;
940  }
941  }
942  return acc;
943 }
944 
945 
946 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
947 {
948  AVFrame *pic = NULL;
949  int64_t pts;
950  int i;
951  const int encoding_delay = s->max_b_frames;
952  int direct = 1;
953 
954  if (pic_arg) {
955  pts = pic_arg->pts;
957 
958  if (pts != AV_NOPTS_VALUE) {
960  int64_t time = pts;
961  int64_t last = s->user_specified_pts;
962 
963  if (time <= last) {
965  "Error, Invalid timestamp=%"PRId64", "
966  "last=%"PRId64"\n", pts, s->user_specified_pts);
967  return -1;
968  }
969  }
970  s->user_specified_pts = pts;
971  } else {
973  s->user_specified_pts =
974  pts = s->user_specified_pts + 1;
976  "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
977  pts);
978  } else {
979  pts = pic_arg->display_picture_number;
980  }
981  }
982  }
983 
984  if (pic_arg) {
985  if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
986  direct = 0;
987  if (pic_arg->linesize[0] != s->linesize)
988  direct = 0;
989  if (pic_arg->linesize[1] != s->uvlinesize)
990  direct = 0;
991  if (pic_arg->linesize[2] != s->uvlinesize)
992  direct = 0;
993 
994  //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
995  // pic_arg->linesize[1], s->linesize, s->uvlinesize);
996 
997  if (direct) {
998  i = ff_find_unused_picture(s, 1);
999  if (i < 0)
1000  return i;
1001 
1002  pic = (AVFrame *) &s->picture[i];
1003  pic->reference = 3;
1004 
1005  for (i = 0; i < 4; i++) {
1006  pic->data[i] = pic_arg->data[i];
1007  pic->linesize[i] = pic_arg->linesize[i];
1008  }
1009  if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1010  return -1;
1011  }
1012  } else {
1013  i = ff_find_unused_picture(s, 0);
1014  if (i < 0)
1015  return i;
1016 
1017  pic = (AVFrame *) &s->picture[i];
1018  pic->reference = 3;
1019 
1020  if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1021  return -1;
1022  }
1023 
1024  if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1025  pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1026  pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1027  // empty
1028  } else {
1029  int h_chroma_shift, v_chroma_shift;
1030  avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1031  &v_chroma_shift);
1032 
1033  for (i = 0; i < 3; i++) {
1034  int src_stride = pic_arg->linesize[i];
1035  int dst_stride = i ? s->uvlinesize : s->linesize;
1036  int h_shift = i ? h_chroma_shift : 0;
1037  int v_shift = i ? v_chroma_shift : 0;
1038  int w = s->width >> h_shift;
1039  int h = s->height >> v_shift;
1040  uint8_t *src = pic_arg->data[i];
1041  uint8_t *dst = pic->data[i];
1042 
1043  if (!s->avctx->rc_buffer_size)
1044  dst += INPLACE_OFFSET;
1045 
1046  if (src_stride == dst_stride)
1047  memcpy(dst, src, src_stride * h);
1048  else {
1049  while (h--) {
1050  memcpy(dst, src, w);
1051  dst += dst_stride;
1052  src += src_stride;
1053  }
1054  }
1055  }
1056  }
1057  }
1058  copy_picture_attributes(s, pic, pic_arg);
1059  pic->pts = pts; // we set this here to avoid modifiying pic_arg
1060  }
1061 
1062  /* shift buffer entries */
1063  for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1064  s->input_picture[i - 1] = s->input_picture[i];
1065 
1066  s->input_picture[encoding_delay] = (Picture*) pic;
1067 
1068  return 0;
1069 }
1070 
1071 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1072 {
1073  int x, y, plane;
1074  int score = 0;
1075  int64_t score64 = 0;
1076 
1077  for (plane = 0; plane < 3; plane++) {
1078  const int stride = p->f.linesize[plane];
1079  const int bw = plane ? 1 : 2;
1080  for (y = 0; y < s->mb_height * bw; y++) {
1081  for (x = 0; x < s->mb_width * bw; x++) {
1082  int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1083  uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1084  uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1085  int v = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1086 
1087  switch (s->avctx->frame_skip_exp) {
1088  case 0: score = FFMAX(score, v); break;
1089  case 1: score += FFABS(v); break;
1090  case 2: score += v * v; break;
1091  case 3: score64 += FFABS(v * v * (int64_t)v); break;
1092  case 4: score64 += v * v * (int64_t)(v * v); break;
1093  }
1094  }
1095  }
1096  }
1097 
1098  if (score)
1099  score64 = score;
1100 
1101  if (score64 < s->avctx->frame_skip_threshold)
1102  return 1;
1103  if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1104  return 1;
1105  return 0;
1106 }
1107 
1109 {
1112  AVFrame input[FF_MAX_B_FRAMES + 2];
1113  const int scale = s->avctx->brd_scale;
1114  int i, j, out_size, p_lambda, b_lambda, lambda2;
1115  int outbuf_size = s->width * s->height; // FIXME
1116  uint8_t *outbuf = av_malloc(outbuf_size);
1117  int64_t best_rd = INT64_MAX;
1118  int best_b_count = -1;
1119 
1120  assert(scale >= 0 && scale <= 3);
1121 
1122  //emms_c();
1123  //s->next_picture_ptr->quality;
1124  p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1125  //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1126  b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1127  if (!b_lambda) // FIXME we should do this somewhere else
1128  b_lambda = p_lambda;
1129  lambda2 = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1131 
1132  c->width = s->width >> scale;
1133  c->height = s->height >> scale;
1135  CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1136  c->flags |= s->avctx->flags & CODEC_FLAG_QPEL;
1137  c->mb_decision = s->avctx->mb_decision;
1138  c->me_cmp = s->avctx->me_cmp;
1139  c->mb_cmp = s->avctx->mb_cmp;
1140  c->me_sub_cmp = s->avctx->me_sub_cmp;
1141  c->pix_fmt = PIX_FMT_YUV420P;
1142  c->time_base = s->avctx->time_base;
1143  c->max_b_frames = s->max_b_frames;
1144 
1145  if (avcodec_open2(c, codec, NULL) < 0)
1146  return -1;
1147 
1148  for (i = 0; i < s->max_b_frames + 2; i++) {
1149  int ysize = c->width * c->height;
1150  int csize = (c->width / 2) * (c->height / 2);
1151  Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1152  s->next_picture_ptr;
1153 
1154  avcodec_get_frame_defaults(&input[i]);
1155  input[i].data[0] = av_malloc(ysize + 2 * csize);
1156  input[i].data[1] = input[i].data[0] + ysize;
1157  input[i].data[2] = input[i].data[1] + csize;
1158  input[i].linesize[0] = c->width;
1159  input[i].linesize[1] =
1160  input[i].linesize[2] = c->width / 2;
1161 
1162  if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1163  pre_input = *pre_input_ptr;
1164 
1165  if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1166  pre_input.f.data[0] += INPLACE_OFFSET;
1167  pre_input.f.data[1] += INPLACE_OFFSET;
1168  pre_input.f.data[2] += INPLACE_OFFSET;
1169  }
1170 
1171  s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1172  pre_input.f.data[0], pre_input.f.linesize[0],
1173  c->width, c->height);
1174  s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1175  pre_input.f.data[1], pre_input.f.linesize[1],
1176  c->width >> 1, c->height >> 1);
1177  s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1178  pre_input.f.data[2], pre_input.f.linesize[2],
1179  c->width >> 1, c->height >> 1);
1180  }
1181  }
1182 
1183  for (j = 0; j < s->max_b_frames + 1; j++) {
1184  int64_t rd = 0;
1185 
1186  if (!s->input_picture[j])
1187  break;
1188 
1189  c->error[0] = c->error[1] = c->error[2] = 0;
1190 
1191  input[0].pict_type = AV_PICTURE_TYPE_I;
1192  input[0].quality = 1 * FF_QP2LAMBDA;
1193  out_size = avcodec_encode_video(c, outbuf,
1194  outbuf_size, &input[0]);
1195  //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1196 
1197  for (i = 0; i < s->max_b_frames + 1; i++) {
1198  int is_p = i % (j + 1) == j || i == s->max_b_frames;
1199 
1200  input[i + 1].pict_type = is_p ?
1202  input[i + 1].quality = is_p ? p_lambda : b_lambda;
1203  out_size = avcodec_encode_video(c, outbuf, outbuf_size,
1204  &input[i + 1]);
1205  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1206  }
1207 
1208  /* get the delayed frames */
1209  while (out_size) {
1210  out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
1211  rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1212  }
1213 
1214  rd += c->error[0] + c->error[1] + c->error[2];
1215 
1216  if (rd < best_rd) {
1217  best_rd = rd;
1218  best_b_count = j;
1219  }
1220  }
1221 
1222  av_freep(&outbuf);
1223  avcodec_close(c);
1224  av_freep(&c);
1225 
1226  for (i = 0; i < s->max_b_frames + 2; i++) {
1227  av_freep(&input[i].data[0]);
1228  }
1229 
1230  return best_b_count;
1231 }
1232 
1234 {
1235  int i;
1236 
1237  for (i = 1; i < MAX_PICTURE_COUNT; i++)
1239  s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1240 
1241  /* set next picture type & ordering */
1242  if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1243  if (/*s->picture_in_gop_number >= s->gop_size ||*/
1244  s->next_picture_ptr == NULL || s->intra_only) {
1245  s->reordered_input_picture[0] = s->input_picture[0];
1248  s->coded_picture_number++;
1249  } else {
1250  int b_frames;
1251 
1253  if (s->picture_in_gop_number < s->gop_size &&
1254  skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1255  // FIXME check that te gop check above is +-1 correct
1256  //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1257  // s->input_picture[0]->f.data[0],
1258  // s->input_picture[0]->pts);
1259 
1260  if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1261  for (i = 0; i < 4; i++)
1262  s->input_picture[0]->f.data[i] = NULL;
1263  s->input_picture[0]->f.type = 0;
1264  } else {
1265  assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1267 
1268  s->avctx->release_buffer(s->avctx,
1269  (AVFrame *) s->input_picture[0]);
1270  }
1271 
1272  emms_c();
1273  ff_vbv_update(s, 0);
1274 
1275  goto no_output_pic;
1276  }
1277  }
1278 
1279  if (s->flags & CODEC_FLAG_PASS2) {
1280  for (i = 0; i < s->max_b_frames + 1; i++) {
1281  int pict_num = s->input_picture[0]->f.display_picture_number + i;
1282 
1283  if (pict_num >= s->rc_context.num_entries)
1284  break;
1285  if (!s->input_picture[i]) {
1286  s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1287  break;
1288  }
1289 
1290  s->input_picture[i]->f.pict_type =
1291  s->rc_context.entry[pict_num].new_pict_type;
1292  }
1293  }
1294 
1295  if (s->avctx->b_frame_strategy == 0) {
1296  b_frames = s->max_b_frames;
1297  while (b_frames && !s->input_picture[b_frames])
1298  b_frames--;
1299  } else if (s->avctx->b_frame_strategy == 1) {
1300  for (i = 1; i < s->max_b_frames + 1; i++) {
1301  if (s->input_picture[i] &&
1302  s->input_picture[i]->b_frame_score == 0) {
1303  s->input_picture[i]->b_frame_score =
1304  get_intra_count(s,
1305  s->input_picture[i ]->f.data[0],
1306  s->input_picture[i - 1]->f.data[0],
1307  s->linesize) + 1;
1308  }
1309  }
1310  for (i = 0; i < s->max_b_frames + 1; i++) {
1311  if (s->input_picture[i] == NULL ||
1312  s->input_picture[i]->b_frame_score - 1 >
1313  s->mb_num / s->avctx->b_sensitivity)
1314  break;
1315  }
1316 
1317  b_frames = FFMAX(0, i - 1);
1318 
1319  /* reset scores */
1320  for (i = 0; i < b_frames + 1; i++) {
1321  s->input_picture[i]->b_frame_score = 0;
1322  }
1323  } else if (s->avctx->b_frame_strategy == 2) {
1324  b_frames = estimate_best_b_count(s);
1325  } else {
1326  av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1327  b_frames = 0;
1328  }
1329 
1330  emms_c();
1331  //static int b_count = 0;
1332  //b_count += b_frames;
1333  //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1334 
1335  for (i = b_frames - 1; i >= 0; i--) {
1336  int type = s->input_picture[i]->f.pict_type;
1337  if (type && type != AV_PICTURE_TYPE_B)
1338  b_frames = i;
1339  }
1340  if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1341  b_frames == s->max_b_frames) {
1343  "warning, too many b frames in a row\n");
1344  }
1345 
1346  if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1347  if ((s->flags2 & CODEC_FLAG2_STRICT_GOP) &&
1348  s->gop_size > s->picture_in_gop_number) {
1349  b_frames = s->gop_size - s->picture_in_gop_number - 1;
1350  } else {
1351  if (s->flags & CODEC_FLAG_CLOSED_GOP)
1352  b_frames = 0;
1353  s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1354  }
1355  }
1356 
1357  if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1358  s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1359  b_frames--;
1360 
1361  s->reordered_input_picture[0] = s->input_picture[b_frames];
1365  s->coded_picture_number++;
1366  for (i = 0; i < b_frames; i++) {
1367  s->reordered_input_picture[i + 1] = s->input_picture[i];
1368  s->reordered_input_picture[i + 1]->f.pict_type =
1371  s->coded_picture_number++;
1372  }
1373  }
1374  }
1375 no_output_pic:
1376  if (s->reordered_input_picture[0]) {
1379  AV_PICTURE_TYPE_B ? 3 : 0;
1380 
1382 
1384  s->avctx->rc_buffer_size) {
1385  // input is a shared pix, so we can't modifiy it -> alloc a new
1386  // one & ensure that the shared one is reuseable
1387 
1388  Picture *pic;
1389  int i = ff_find_unused_picture(s, 0);
1390  if (i < 0)
1391  return i;
1392  pic = &s->picture[i];
1393 
1395  if (ff_alloc_picture(s, pic, 0) < 0) {
1396  return -1;
1397  }
1398 
1399  /* mark us unused / free shared pic */
1401  s->avctx->release_buffer(s->avctx,
1402  (AVFrame *) s->reordered_input_picture[0]);
1403  for (i = 0; i < 4; i++)
1404  s->reordered_input_picture[0]->f.data[i] = NULL;
1405  s->reordered_input_picture[0]->f.type = 0;
1406 
1407  copy_picture_attributes(s, (AVFrame *) pic,
1408  (AVFrame *) s->reordered_input_picture[0]);
1409 
1410  s->current_picture_ptr = pic;
1411  } else {
1412  // input is not a shared pix -> reuse buffer for current_pix
1413 
1414  assert(s->reordered_input_picture[0]->f.type ==
1416  s->reordered_input_picture[0]->f.type ==
1418 
1420  for (i = 0; i < 4; i++) {
1421  s->new_picture.f.data[i] += INPLACE_OFFSET;
1422  }
1423  }
1425 
1427  //printf("dpn:%d\n", s->picture_number);
1428  } else {
1429  memset(&s->new_picture, 0, sizeof(Picture));
1430  }
1431  return 0;
1432 }
1433 
1435  unsigned char *buf, int buf_size, void *data)
1436 {
1437  MpegEncContext *s = avctx->priv_data;
1438  AVFrame *pic_arg = data;
1439  int i, stuffing_count;
1440  int context_count = s->slice_context_count;
1441 
1442  for (i = 0; i < context_count; i++) {
1443  int start_y = s->thread_context[i]->start_mb_y;
1444  int end_y = s->thread_context[i]-> end_mb_y;
1445  int h = s->mb_height;
1446  uint8_t *start = buf + (size_t)(((int64_t) buf_size) * start_y / h);
1447  uint8_t *end = buf + (size_t)(((int64_t) buf_size) * end_y / h);
1448 
1449  init_put_bits(&s->thread_context[i]->pb, start, end - start);
1450  }
1451 
1452  s->picture_in_gop_number++;
1453 
1454  if (load_input_picture(s, pic_arg) < 0)
1455  return -1;
1456 
1457  if (select_input_picture(s) < 0) {
1458  return -1;
1459  }
1460 
1461  /* output? */
1462  if (s->new_picture.f.data[0]) {
1463  s->pict_type = s->new_picture.f.pict_type;
1464  //emms_c();
1465  //printf("qs:%f %f %d\n", s->new_picture.quality,
1466  // s->current_picture.quality, s->qscale);
1467  MPV_frame_start(s, avctx);
1468 vbv_retry:
1469  if (encode_picture(s, s->picture_number) < 0)
1470  return -1;
1471 
1472  avctx->header_bits = s->header_bits;
1473  avctx->mv_bits = s->mv_bits;
1474  avctx->misc_bits = s->misc_bits;
1475  avctx->i_tex_bits = s->i_tex_bits;
1476  avctx->p_tex_bits = s->p_tex_bits;
1477  avctx->i_count = s->i_count;
1478  // FIXME f/b_count in avctx
1479  avctx->p_count = s->mb_num - s->i_count - s->skip_count;
1480  avctx->skip_count = s->skip_count;
1481 
1482  MPV_frame_end(s);
1483 
1486 
1487  if (avctx->rc_buffer_size) {
1488  RateControlContext *rcc = &s->rc_context;
1489  int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1490 
1491  if (put_bits_count(&s->pb) > max_size &&
1492  s->lambda < s->avctx->lmax) {
1493  s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1494  (s->qscale + 1) / s->qscale);
1495  if (s->adaptive_quant) {
1496  int i;
1497  for (i = 0; i < s->mb_height * s->mb_stride; i++)
1498  s->lambda_table[i] =
1499  FFMAX(s->lambda_table[i] + 1,
1500  s->lambda_table[i] * (s->qscale + 1) /
1501  s->qscale);
1502  }
1503  s->mb_skipped = 0; // done in MPV_frame_start()
1504  // done in encode_picture() so we must undo it
1505  if (s->pict_type == AV_PICTURE_TYPE_P) {
1506  if (s->flipflop_rounding ||
1507  s->codec_id == CODEC_ID_H263P ||
1508  s->codec_id == CODEC_ID_MPEG4)
1509  s->no_rounding ^= 1;
1510  }
1511  if (s->pict_type != AV_PICTURE_TYPE_B) {
1512  s->time_base = s->last_time_base;
1513  s->last_non_b_time = s->time - s->pp_time;
1514  }
1515  //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1516  for (i = 0; i < context_count; i++) {
1517  PutBitContext *pb = &s->thread_context[i]->pb;
1518  init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1519  }
1520  goto vbv_retry;
1521  }
1522 
1523  assert(s->avctx->rc_max_rate);
1524  }
1525 
1526  if (s->flags & CODEC_FLAG_PASS1)
1528 
1529  for (i = 0; i < 4; i++) {
1531  avctx->error[i] += s->current_picture_ptr->f.error[i];
1532  }
1533 
1534  if (s->flags & CODEC_FLAG_PASS1)
1535  assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1536  avctx->i_tex_bits + avctx->p_tex_bits ==
1537  put_bits_count(&s->pb));
1538  flush_put_bits(&s->pb);
1539  s->frame_bits = put_bits_count(&s->pb);
1540 
1541  stuffing_count = ff_vbv_update(s, s->frame_bits);
1542  if (stuffing_count) {
1543  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1544  stuffing_count + 50) {
1545  av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1546  return -1;
1547  }
1548 
1549  switch (s->codec_id) {
1550  case CODEC_ID_MPEG1VIDEO:
1551  case CODEC_ID_MPEG2VIDEO:
1552  while (stuffing_count--) {
1553  put_bits(&s->pb, 8, 0);
1554  }
1555  break;
1556  case CODEC_ID_MPEG4:
1557  put_bits(&s->pb, 16, 0);
1558  put_bits(&s->pb, 16, 0x1C3);
1559  stuffing_count -= 4;
1560  while (stuffing_count--) {
1561  put_bits(&s->pb, 8, 0xFF);
1562  }
1563  break;
1564  default:
1565  av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1566  }
1567  flush_put_bits(&s->pb);
1568  s->frame_bits = put_bits_count(&s->pb);
1569  }
1570 
1571  /* update mpeg1/2 vbv_delay for CBR */
1572  if (s->avctx->rc_max_rate &&
1573  s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1574  s->out_format == FMT_MPEG1 &&
1575  90000LL * (avctx->rc_buffer_size - 1) <=
1576  s->avctx->rc_max_rate * 0xFFFFLL) {
1577  int vbv_delay, min_delay;
1578  double inbits = s->avctx->rc_max_rate *
1579  av_q2d(s->avctx->time_base);
1580  int minbits = s->frame_bits - 8 *
1581  (s->vbv_delay_ptr - s->pb.buf - 1);
1582  double bits = s->rc_context.buffer_index + minbits - inbits;
1583 
1584  if (bits < 0)
1586  "Internal error, negative bits\n");
1587 
1588  assert(s->repeat_first_field == 0);
1589 
1590  vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1591  min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1592  s->avctx->rc_max_rate;
1593 
1594  vbv_delay = FFMAX(vbv_delay, min_delay);
1595 
1596  assert(vbv_delay < 0xFFFF);
1597 
1598  s->vbv_delay_ptr[0] &= 0xF8;
1599  s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1600  s->vbv_delay_ptr[1] = vbv_delay >> 5;
1601  s->vbv_delay_ptr[2] &= 0x07;
1602  s->vbv_delay_ptr[2] |= vbv_delay << 3;
1603  avctx->vbv_delay = vbv_delay * 300;
1604  }
1605  s->total_bits += s->frame_bits;
1606  avctx->frame_bits = s->frame_bits;
1607  } else {
1608  assert((put_bits_ptr(&s->pb) == s->pb.buf));
1609  s->frame_bits = 0;
1610  }
1611  assert((s->frame_bits & 7) == 0);
1612 
1613  return s->frame_bits / 8;
1614 }
1615 
1617  int n, int threshold)
1618 {
1619  static const char tab[64] = {
1620  3, 2, 2, 1, 1, 1, 1, 1,
1621  1, 1, 1, 1, 1, 1, 1, 1,
1622  1, 1, 1, 1, 1, 1, 1, 1,
1623  0, 0, 0, 0, 0, 0, 0, 0,
1624  0, 0, 0, 0, 0, 0, 0, 0,
1625  0, 0, 0, 0, 0, 0, 0, 0,
1626  0, 0, 0, 0, 0, 0, 0, 0,
1627  0, 0, 0, 0, 0, 0, 0, 0
1628  };
1629  int score = 0;
1630  int run = 0;
1631  int i;
1632  DCTELEM *block = s->block[n];
1633  const int last_index = s->block_last_index[n];
1634  int skip_dc;
1635 
1636  if (threshold < 0) {
1637  skip_dc = 0;
1638  threshold = -threshold;
1639  } else
1640  skip_dc = 1;
1641 
1642  /* Are all we could set to zero already zero? */
1643  if (last_index <= skip_dc - 1)
1644  return;
1645 
1646  for (i = 0; i <= last_index; i++) {
1647  const int j = s->intra_scantable.permutated[i];
1648  const int level = FFABS(block[j]);
1649  if (level == 1) {
1650  if (skip_dc && i == 0)
1651  continue;
1652  score += tab[run];
1653  run = 0;
1654  } else if (level > 1) {
1655  return;
1656  } else {
1657  run++;
1658  }
1659  }
1660  if (score >= threshold)
1661  return;
1662  for (i = skip_dc; i <= last_index; i++) {
1663  const int j = s->intra_scantable.permutated[i];
1664  block[j] = 0;
1665  }
1666  if (block[0])
1667  s->block_last_index[n] = 0;
1668  else
1669  s->block_last_index[n] = -1;
1670 }
1671 
1672 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1673  int last_index)
1674 {
1675  int i;
1676  const int maxlevel = s->max_qcoeff;
1677  const int minlevel = s->min_qcoeff;
1678  int overflow = 0;
1679 
1680  if (s->mb_intra) {
1681  i = 1; // skip clipping of intra dc
1682  } else
1683  i = 0;
1684 
1685  for (; i <= last_index; i++) {
1686  const int j = s->intra_scantable.permutated[i];
1687  int level = block[j];
1688 
1689  if (level > maxlevel) {
1690  level = maxlevel;
1691  overflow++;
1692  } else if (level < minlevel) {
1693  level = minlevel;
1694  overflow++;
1695  }
1696 
1697  block[j] = level;
1698  }
1699 
1700  if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1701  av_log(s->avctx, AV_LOG_INFO,
1702  "warning, clipping %d dct coefficients to %d..%d\n",
1703  overflow, minlevel, maxlevel);
1704 }
1705 
1706 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1707 {
1708  int x, y;
1709  // FIXME optimize
1710  for (y = 0; y < 8; y++) {
1711  for (x = 0; x < 8; x++) {
1712  int x2, y2;
1713  int sum = 0;
1714  int sqr = 0;
1715  int count = 0;
1716 
1717  for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1718  for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1719  int v = ptr[x2 + y2 * stride];
1720  sum += v;
1721  sqr += v * v;
1722  count++;
1723  }
1724  }
1725  weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1726  }
1727  }
1728 }
1729 
1731  int motion_x, int motion_y,
1732  int mb_block_height,
1733  int mb_block_count)
1734 {
1735  int16_t weight[8][64];
1736  DCTELEM orig[8][64];
1737  const int mb_x = s->mb_x;
1738  const int mb_y = s->mb_y;
1739  int i;
1740  int skip_dct[8];
1741  int dct_offset = s->linesize * 8; // default for progressive frames
1742  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1743  int wrap_y, wrap_c;
1744 
1745  for (i = 0; i < mb_block_count; i++)
1746  skip_dct[i] = s->skipdct;
1747 
1748  if (s->adaptive_quant) {
1749  const int last_qp = s->qscale;
1750  const int mb_xy = mb_x + mb_y * s->mb_stride;
1751 
1752  s->lambda = s->lambda_table[mb_xy];
1753  update_qscale(s);
1754 
1755  if (!(s->flags & CODEC_FLAG_QP_RD)) {
1756  s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1757  s->dquant = s->qscale - last_qp;
1758 
1759  if (s->out_format == FMT_H263) {
1760  s->dquant = av_clip(s->dquant, -2, 2);
1761 
1762  if (s->codec_id == CODEC_ID_MPEG4) {
1763  if (!s->mb_intra) {
1764  if (s->pict_type == AV_PICTURE_TYPE_B) {
1765  if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1766  s->dquant = 0;
1767  }
1768  if (s->mv_type == MV_TYPE_8X8)
1769  s->dquant = 0;
1770  }
1771  }
1772  }
1773  }
1774  ff_set_qscale(s, last_qp + s->dquant);
1775  } else if (s->flags & CODEC_FLAG_QP_RD)
1776  ff_set_qscale(s, s->qscale + s->dquant);
1777 
1778  wrap_y = s->linesize;
1779  wrap_c = s->uvlinesize;
1780  ptr_y = s->new_picture.f.data[0] +
1781  (mb_y * 16 * wrap_y) + mb_x * 16;
1782  ptr_cb = s->new_picture.f.data[1] +
1783  (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1784  ptr_cr = s->new_picture.f.data[2] +
1785  (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1786 
1787  if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1788  uint8_t *ebuf = s->edge_emu_buffer + 32;
1789  s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1790  mb_y * 16, s->width, s->height);
1791  ptr_y = ebuf;
1792  s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1793  mb_block_height, mb_x * 8, mb_y * 8,
1794  s->width >> 1, s->height >> 1);
1795  ptr_cb = ebuf + 18 * wrap_y;
1796  s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1797  mb_block_height, mb_x * 8, mb_y * 8,
1798  s->width >> 1, s->height >> 1);
1799  ptr_cr = ebuf + 18 * wrap_y + 8;
1800  }
1801 
1802  if (s->mb_intra) {
1803  if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1804  int progressive_score, interlaced_score;
1805 
1806  s->interlaced_dct = 0;
1807  progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1808  NULL, wrap_y, 8) +
1809  s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1810  NULL, wrap_y, 8) - 400;
1811 
1812  if (progressive_score > 0) {
1813  interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1814  NULL, wrap_y * 2, 8) +
1815  s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1816  NULL, wrap_y * 2, 8);
1817  if (progressive_score > interlaced_score) {
1818  s->interlaced_dct = 1;
1819 
1820  dct_offset = wrap_y;
1821  wrap_y <<= 1;
1822  if (s->chroma_format == CHROMA_422)
1823  wrap_c <<= 1;
1824  }
1825  }
1826  }
1827 
1828  s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
1829  s->dsp.get_pixels(s->block[1], ptr_y + 8 , wrap_y);
1830  s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
1831  s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1832 
1833  if (s->flags & CODEC_FLAG_GRAY) {
1834  skip_dct[4] = 1;
1835  skip_dct[5] = 1;
1836  } else {
1837  s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1838  s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1839  if (!s->chroma_y_shift) { /* 422 */
1840  s->dsp.get_pixels(s->block[6],
1841  ptr_cb + (dct_offset >> 1), wrap_c);
1842  s->dsp.get_pixels(s->block[7],
1843  ptr_cr + (dct_offset >> 1), wrap_c);
1844  }
1845  }
1846  } else {
1847  op_pixels_func (*op_pix)[4];
1848  qpel_mc_func (*op_qpix)[16];
1849  uint8_t *dest_y, *dest_cb, *dest_cr;
1850 
1851  dest_y = s->dest[0];
1852  dest_cb = s->dest[1];
1853  dest_cr = s->dest[2];
1854 
1855  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1856  op_pix = s->dsp.put_pixels_tab;
1857  op_qpix = s->dsp.put_qpel_pixels_tab;
1858  } else {
1859  op_pix = s->dsp.put_no_rnd_pixels_tab;
1860  op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1861  }
1862 
1863  if (s->mv_dir & MV_DIR_FORWARD) {
1864  MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data,
1865  op_pix, op_qpix);
1866  op_pix = s->dsp.avg_pixels_tab;
1867  op_qpix = s->dsp.avg_qpel_pixels_tab;
1868  }
1869  if (s->mv_dir & MV_DIR_BACKWARD) {
1870  MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data,
1871  op_pix, op_qpix);
1872  }
1873 
1874  if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1875  int progressive_score, interlaced_score;
1876 
1877  s->interlaced_dct = 0;
1878  progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1879  ptr_y, wrap_y,
1880  8) +
1881  s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1882  ptr_y + wrap_y * 8, wrap_y,
1883  8) - 400;
1884 
1885  if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1886  progressive_score -= 400;
1887 
1888  if (progressive_score > 0) {
1889  interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1890  ptr_y,
1891  wrap_y * 2, 8) +
1892  s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1893  ptr_y + wrap_y,
1894  wrap_y * 2, 8);
1895 
1896  if (progressive_score > interlaced_score) {
1897  s->interlaced_dct = 1;
1898 
1899  dct_offset = wrap_y;
1900  wrap_y <<= 1;
1901  if (s->chroma_format == CHROMA_422)
1902  wrap_c <<= 1;
1903  }
1904  }
1905  }
1906 
1907  s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1908  s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1909  s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1910  dest_y + dct_offset, wrap_y);
1911  s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1912  dest_y + dct_offset + 8, wrap_y);
1913 
1914  if (s->flags & CODEC_FLAG_GRAY) {
1915  skip_dct[4] = 1;
1916  skip_dct[5] = 1;
1917  } else {
1918  s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1919  s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1920  if (!s->chroma_y_shift) { /* 422 */
1921  s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1922  dest_cb + (dct_offset >> 1), wrap_c);
1923  s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1924  dest_cr + (dct_offset >> 1), wrap_c);
1925  }
1926  }
1927  /* pre quantization */
1928  if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1929  2 * s->qscale * s->qscale) {
1930  // FIXME optimize
1931  if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1932  wrap_y, 8) < 20 * s->qscale)
1933  skip_dct[0] = 1;
1934  if (s->dsp.sad[1](NULL, ptr_y + 8,
1935  dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1936  skip_dct[1] = 1;
1937  if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1938  dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1939  skip_dct[2] = 1;
1940  if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1941  dest_y + dct_offset + 8,
1942  wrap_y, 8) < 20 * s->qscale)
1943  skip_dct[3] = 1;
1944  if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1945  wrap_c, 8) < 20 * s->qscale)
1946  skip_dct[4] = 1;
1947  if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1948  wrap_c, 8) < 20 * s->qscale)
1949  skip_dct[5] = 1;
1950  if (!s->chroma_y_shift) { /* 422 */
1951  if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1952  dest_cb + (dct_offset >> 1),
1953  wrap_c, 8) < 20 * s->qscale)
1954  skip_dct[6] = 1;
1955  if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1956  dest_cr + (dct_offset >> 1),
1957  wrap_c, 8) < 20 * s->qscale)
1958  skip_dct[7] = 1;
1959  }
1960  }
1961  }
1962 
1963  if (s->avctx->quantizer_noise_shaping) {
1964  if (!skip_dct[0])
1965  get_visual_weight(weight[0], ptr_y , wrap_y);
1966  if (!skip_dct[1])
1967  get_visual_weight(weight[1], ptr_y + 8, wrap_y);
1968  if (!skip_dct[2])
1969  get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
1970  if (!skip_dct[3])
1971  get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
1972  if (!skip_dct[4])
1973  get_visual_weight(weight[4], ptr_cb , wrap_c);
1974  if (!skip_dct[5])
1975  get_visual_weight(weight[5], ptr_cr , wrap_c);
1976  if (!s->chroma_y_shift) { /* 422 */
1977  if (!skip_dct[6])
1978  get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
1979  wrap_c);
1980  if (!skip_dct[7])
1981  get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
1982  wrap_c);
1983  }
1984  memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
1985  }
1986 
1987  /* DCT & quantize */
1988  assert(s->out_format != FMT_MJPEG || s->qscale == 8);
1989  {
1990  for (i = 0; i < mb_block_count; i++) {
1991  if (!skip_dct[i]) {
1992  int overflow;
1993  s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
1994  // FIXME we could decide to change to quantizer instead of
1995  // clipping
1996  // JS: I don't think that would be a good idea it could lower
1997  // quality instead of improve it. Just INTRADC clipping
1998  // deserves changes in quantizer
1999  if (overflow)
2000  clip_coeffs(s, s->block[i], s->block_last_index[i]);
2001  } else
2002  s->block_last_index[i] = -1;
2003  }
2004  if (s->avctx->quantizer_noise_shaping) {
2005  for (i = 0; i < mb_block_count; i++) {
2006  if (!skip_dct[i]) {
2007  s->block_last_index[i] =
2008  dct_quantize_refine(s, s->block[i], weight[i],
2009  orig[i], i, s->qscale);
2010  }
2011  }
2012  }
2013 
2014  if (s->luma_elim_threshold && !s->mb_intra)
2015  for (i = 0; i < 4; i++)
2017  if (s->chroma_elim_threshold && !s->mb_intra)
2018  for (i = 4; i < mb_block_count; i++)
2020 
2021  if (s->flags & CODEC_FLAG_CBP_RD) {
2022  for (i = 0; i < mb_block_count; i++) {
2023  if (s->block_last_index[i] == -1)
2024  s->coded_score[i] = INT_MAX / 256;
2025  }
2026  }
2027  }
2028 
2029  if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2030  s->block_last_index[4] =
2031  s->block_last_index[5] = 0;
2032  s->block[4][0] =
2033  s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2034  }
2035 
2036  // non c quantize code returns incorrect block_last_index FIXME
2037  if (s->alternate_scan && s->dct_quantize != dct_quantize_c) {
2038  for (i = 0; i < mb_block_count; i++) {
2039  int j;
2040  if (s->block_last_index[i] > 0) {
2041  for (j = 63; j > 0; j--) {
2042  if (s->block[i][s->intra_scantable.permutated[j]])
2043  break;
2044  }
2045  s->block_last_index[i] = j;
2046  }
2047  }
2048  }
2049 
2050  /* huffman encode */
2051  switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2052  case CODEC_ID_MPEG1VIDEO:
2053  case CODEC_ID_MPEG2VIDEO:
2055  mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2056  break;
2057  case CODEC_ID_MPEG4:
2059  mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2060  break;
2061  case CODEC_ID_MSMPEG4V2:
2062  case CODEC_ID_MSMPEG4V3:
2063  case CODEC_ID_WMV1:
2065  msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2066  break;
2067  case CODEC_ID_WMV2:
2068  if (CONFIG_WMV2_ENCODER)
2069  ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2070  break;
2071  case CODEC_ID_H261:
2072  if (CONFIG_H261_ENCODER)
2073  ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2074  break;
2075  case CODEC_ID_H263:
2076  case CODEC_ID_H263P:
2077  case CODEC_ID_FLV1:
2078  case CODEC_ID_RV10:
2079  case CODEC_ID_RV20:
2080  if (CONFIG_H263_ENCODER)
2081  ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2082  break;
2083  case CODEC_ID_MJPEG:
2085  ff_mjpeg_encode_mb(s, s->block);
2086  break;
2087  default:
2088  assert(0);
2089  }
2090 }
2091 
2092 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2093 {
2094  if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
2095  else encode_mb_internal(s, motion_x, motion_y, 16, 8);
2096 }
2097 
2098 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2099  int i;
2100 
2101  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2102 
2103  /* mpeg1 */
2104  d->mb_skip_run= s->mb_skip_run;
2105  for(i=0; i<3; i++)
2106  d->last_dc[i] = s->last_dc[i];
2107 
2108  /* statistics */
2109  d->mv_bits= s->mv_bits;
2110  d->i_tex_bits= s->i_tex_bits;
2111  d->p_tex_bits= s->p_tex_bits;
2112  d->i_count= s->i_count;
2113  d->f_count= s->f_count;
2114  d->b_count= s->b_count;
2115  d->skip_count= s->skip_count;
2116  d->misc_bits= s->misc_bits;
2117  d->last_bits= 0;
2118 
2119  d->mb_skipped= 0;
2120  d->qscale= s->qscale;
2121  d->dquant= s->dquant;
2122 
2124 }
2125 
2126 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2127  int i;
2128 
2129  memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2130  memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2131 
2132  /* mpeg1 */
2133  d->mb_skip_run= s->mb_skip_run;
2134  for(i=0; i<3; i++)
2135  d->last_dc[i] = s->last_dc[i];
2136 
2137  /* statistics */
2138  d->mv_bits= s->mv_bits;
2139  d->i_tex_bits= s->i_tex_bits;
2140  d->p_tex_bits= s->p_tex_bits;
2141  d->i_count= s->i_count;
2142  d->f_count= s->f_count;
2143  d->b_count= s->b_count;
2144  d->skip_count= s->skip_count;
2145  d->misc_bits= s->misc_bits;
2146 
2147  d->mb_intra= s->mb_intra;
2148  d->mb_skipped= s->mb_skipped;
2149  d->mv_type= s->mv_type;
2150  d->mv_dir= s->mv_dir;
2151  d->pb= s->pb;
2152  if(s->data_partitioning){
2153  d->pb2= s->pb2;
2154  d->tex_pb= s->tex_pb;
2155  }
2156  d->block= s->block;
2157  for(i=0; i<8; i++)
2158  d->block_last_index[i]= s->block_last_index[i];
2160  d->qscale= s->qscale;
2161 
2163 }
2164 
2165 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2167  int *dmin, int *next_block, int motion_x, int motion_y)
2168 {
2169  int score;
2170  uint8_t *dest_backup[3];
2171 
2172  copy_context_before_encode(s, backup, type);
2173 
2174  s->block= s->blocks[*next_block];
2175  s->pb= pb[*next_block];
2176  if(s->data_partitioning){
2177  s->pb2 = pb2 [*next_block];
2178  s->tex_pb= tex_pb[*next_block];
2179  }
2180 
2181  if(*next_block){
2182  memcpy(dest_backup, s->dest, sizeof(s->dest));
2183  s->dest[0] = s->rd_scratchpad;
2184  s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2185  s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2186  assert(s->linesize >= 32); //FIXME
2187  }
2188 
2189  encode_mb(s, motion_x, motion_y);
2190 
2191  score= put_bits_count(&s->pb);
2192  if(s->data_partitioning){
2193  score+= put_bits_count(&s->pb2);
2194  score+= put_bits_count(&s->tex_pb);
2195  }
2196 
2197  if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2198  MPV_decode_mb(s, s->block);
2199 
2200  score *= s->lambda2;
2201  score += sse_mb(s) << FF_LAMBDA_SHIFT;
2202  }
2203 
2204  if(*next_block){
2205  memcpy(s->dest, dest_backup, sizeof(s->dest));
2206  }
2207 
2208  if(score<*dmin){
2209  *dmin= score;
2210  *next_block^=1;
2211 
2212  copy_context_after_encode(best, s, type);
2213  }
2214 }
2215 
2216 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2217  uint32_t *sq = ff_squareTbl + 256;
2218  int acc=0;
2219  int x,y;
2220 
2221  if(w==16 && h==16)
2222  return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2223  else if(w==8 && h==8)
2224  return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2225 
2226  for(y=0; y<h; y++){
2227  for(x=0; x<w; x++){
2228  acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2229  }
2230  }
2231 
2232  assert(acc>=0);
2233 
2234  return acc;
2235 }
2236 
2237 static int sse_mb(MpegEncContext *s){
2238  int w= 16;
2239  int h= 16;
2240 
2241  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2242  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2243 
2244  if(w==16 && h==16)
2245  if(s->avctx->mb_cmp == FF_CMP_NSSE){
2246  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)
2247  +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)
2248  +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);
2249  }else{
2250  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)
2251  +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)
2252  +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);
2253  }
2254  else
2255  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)
2256  +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)
2257  +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);
2258 }
2259 
2260 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2261  MpegEncContext *s= *(void**)arg;
2262 
2263 
2264  s->me.pre_pass=1;
2265  s->me.dia_size= s->avctx->pre_dia_size;
2266  s->first_slice_line=1;
2267  for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2268  for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2270  }
2271  s->first_slice_line=0;
2272  }
2273 
2274  s->me.pre_pass=0;
2275 
2276  return 0;
2277 }
2278 
2279 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2280  MpegEncContext *s= *(void**)arg;
2281 
2283 
2284  s->me.dia_size= s->avctx->dia_size;
2285  s->first_slice_line=1;
2286  for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2287  s->mb_x=0; //for block init below
2289  for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2290  s->block_index[0]+=2;
2291  s->block_index[1]+=2;
2292  s->block_index[2]+=2;
2293  s->block_index[3]+=2;
2294 
2295  /* compute motion vector & mb_type and store in context */
2298  else
2300  }
2301  s->first_slice_line=0;
2302  }
2303  return 0;
2304 }
2305 
2306 static int mb_var_thread(AVCodecContext *c, void *arg){
2307  MpegEncContext *s= *(void**)arg;
2308  int mb_x, mb_y;
2309 
2311 
2312  for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2313  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2314  int xx = mb_x * 16;
2315  int yy = mb_y * 16;
2316  uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2317  int varc;
2318  int sum = s->dsp.pix_sum(pix, s->linesize);
2319 
2320  varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2321 
2322  s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2323  s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2324  s->me.mb_var_sum_temp += varc;
2325  }
2326  }
2327  return 0;
2328 }
2329 
2332  if(s->partitioned_frame){
2334  }
2335 
2336  ff_mpeg4_stuffing(&s->pb);
2337  }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2339  }
2340 
2342  flush_put_bits(&s->pb);
2343 
2344  if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2345  s->misc_bits+= get_bits_diff(s);
2346 }
2347 
2348 static int encode_thread(AVCodecContext *c, void *arg){
2349  MpegEncContext *s= *(void**)arg;
2350  int mb_x, mb_y, pdif = 0;
2351  int chr_h= 16>>s->chroma_y_shift;
2352  int i, j;
2353  MpegEncContext best_s, backup_s;
2354  uint8_t bit_buf[2][MAX_MB_BYTES];
2355  uint8_t bit_buf2[2][MAX_MB_BYTES];
2356  uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2357  PutBitContext pb[2], pb2[2], tex_pb[2];
2358 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2359 
2361 
2362  for(i=0; i<2; i++){
2363  init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
2364  init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
2365  init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2366  }
2367 
2368  s->last_bits= put_bits_count(&s->pb);
2369  s->mv_bits=0;
2370  s->misc_bits=0;
2371  s->i_tex_bits=0;
2372  s->p_tex_bits=0;
2373  s->i_count=0;
2374  s->f_count=0;
2375  s->b_count=0;
2376  s->skip_count=0;
2377 
2378  for(i=0; i<3; i++){
2379  /* init last dc values */
2380  /* note: quant matrix value (8) is implied here */
2381  s->last_dc[i] = 128 << s->intra_dc_precision;
2382 
2383  s->current_picture.f.error[i] = 0;
2384  }
2385  s->mb_skip_run = 0;
2386  memset(s->last_mv, 0, sizeof(s->last_mv));
2387 
2388  s->last_mv_dir = 0;
2389 
2390  switch(s->codec_id){
2391  case CODEC_ID_H263:
2392  case CODEC_ID_H263P:
2393  case CODEC_ID_FLV1:
2394  if (CONFIG_H263_ENCODER)
2396  break;
2397  case CODEC_ID_MPEG4:
2400  break;
2401  }
2402 
2403  s->resync_mb_x=0;
2404  s->resync_mb_y=0;
2405  s->first_slice_line = 1;
2406  s->ptr_lastgob = s->pb.buf;
2407  for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2408 // printf("row %d at %X\n", s->mb_y, (int)s);
2409  s->mb_x=0;
2410  s->mb_y= mb_y;
2411 
2412  ff_set_qscale(s, s->qscale);
2414 
2415  for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2416  int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2417  int mb_type= s->mb_type[xy];
2418 // int d;
2419  int dmin= INT_MAX;
2420  int dir;
2421 
2422  if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2423  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2424  return -1;
2425  }
2426  if(s->data_partitioning){
2427  if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
2428  || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2429  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2430  return -1;
2431  }
2432  }
2433 
2434  s->mb_x = mb_x;
2435  s->mb_y = mb_y; // moved into loop, can get changed by H.261
2437 
2440  xy= s->mb_y*s->mb_stride + s->mb_x;
2441  mb_type= s->mb_type[xy];
2442  }
2443 
2444  /* write gob / video packet header */
2445  if(s->rtp_mode){
2446  int current_packet_size, is_gob_start;
2447 
2448  current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2449 
2450  is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2451 
2452  if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2453 
2454  switch(s->codec_id){
2455  case CODEC_ID_H263:
2456  case CODEC_ID_H263P:
2457  if(!s->h263_slice_structured)
2458  if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2459  break;
2460  case CODEC_ID_MPEG2VIDEO:
2461  if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2462  case CODEC_ID_MPEG1VIDEO:
2463  if(s->mb_skip_run) is_gob_start=0;
2464  break;
2465  }
2466 
2467  if(is_gob_start){
2468  if(s->start_mb_y != mb_y || mb_x!=0){
2469  write_slice_end(s);
2470 
2473  }
2474  }
2475 
2476  assert((put_bits_count(&s->pb)&7) == 0);
2477  current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2478 
2479  if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2480  int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2481  int d= 100 / s->avctx->error_rate;
2482  if(r % d == 0){
2483  current_packet_size=0;
2484  s->pb.buf_ptr= s->ptr_lastgob;
2485  assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2486  }
2487  }
2488 
2489  if (s->avctx->rtp_callback){
2490  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2491  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2492  }
2493 
2494  switch(s->codec_id){
2495  case CODEC_ID_MPEG4:
2496  if (CONFIG_MPEG4_ENCODER) {
2499  }
2500  break;
2501  case CODEC_ID_MPEG1VIDEO:
2502  case CODEC_ID_MPEG2VIDEO:
2506  }
2507  break;
2508  case CODEC_ID_H263:
2509  case CODEC_ID_H263P:
2510  if (CONFIG_H263_ENCODER)
2511  ff_h263_encode_gob_header(s, mb_y);
2512  break;
2513  }
2514 
2515  if(s->flags&CODEC_FLAG_PASS1){
2516  int bits= put_bits_count(&s->pb);
2517  s->misc_bits+= bits - s->last_bits;
2518  s->last_bits= bits;
2519  }
2520 
2521  s->ptr_lastgob += current_packet_size;
2522  s->first_slice_line=1;
2523  s->resync_mb_x=mb_x;
2524  s->resync_mb_y=mb_y;
2525  }
2526  }
2527 
2528  if( (s->resync_mb_x == s->mb_x)
2529  && s->resync_mb_y+1 == s->mb_y){
2530  s->first_slice_line=0;
2531  }
2532 
2533  s->mb_skipped=0;
2534  s->dquant=0; //only for QP_RD
2535 
2536  if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
2537  int next_block=0;
2538  int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2539 
2540  copy_context_before_encode(&backup_s, s, -1);
2541  backup_s.pb= s->pb;
2544  if(s->data_partitioning){
2545  backup_s.pb2= s->pb2;
2546  backup_s.tex_pb= s->tex_pb;
2547  }
2548 
2549  if(mb_type&CANDIDATE_MB_TYPE_INTER){
2550  s->mv_dir = MV_DIR_FORWARD;
2551  s->mv_type = MV_TYPE_16X16;
2552  s->mb_intra= 0;
2553  s->mv[0][0][0] = s->p_mv_table[xy][0];
2554  s->mv[0][0][1] = s->p_mv_table[xy][1];
2555  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2556  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2557  }
2558  if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2559  s->mv_dir = MV_DIR_FORWARD;
2560  s->mv_type = MV_TYPE_FIELD;
2561  s->mb_intra= 0;
2562  for(i=0; i<2; i++){
2563  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2564  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2565  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2566  }
2567  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2568  &dmin, &next_block, 0, 0);
2569  }
2570  if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2571  s->mv_dir = MV_DIR_FORWARD;
2572  s->mv_type = MV_TYPE_16X16;
2573  s->mb_intra= 0;
2574  s->mv[0][0][0] = 0;
2575  s->mv[0][0][1] = 0;
2576  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2577  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2578  }
2579  if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2580  s->mv_dir = MV_DIR_FORWARD;
2581  s->mv_type = MV_TYPE_8X8;
2582  s->mb_intra= 0;
2583  for(i=0; i<4; i++){
2584  s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2585  s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2586  }
2587  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2588  &dmin, &next_block, 0, 0);
2589  }
2590  if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2591  s->mv_dir = MV_DIR_FORWARD;
2592  s->mv_type = MV_TYPE_16X16;
2593  s->mb_intra= 0;
2594  s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2595  s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2596  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2597  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2598  }
2599  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2600  s->mv_dir = MV_DIR_BACKWARD;
2601  s->mv_type = MV_TYPE_16X16;
2602  s->mb_intra= 0;
2603  s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2604  s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2605  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2606  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2607  }
2608  if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2610  s->mv_type = MV_TYPE_16X16;
2611  s->mb_intra= 0;
2612  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2613  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2614  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2615  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2616  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2617  &dmin, &next_block, 0, 0);
2618  }
2619  if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2620  s->mv_dir = MV_DIR_FORWARD;
2621  s->mv_type = MV_TYPE_FIELD;
2622  s->mb_intra= 0;
2623  for(i=0; i<2; i++){
2624  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2625  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2626  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2627  }
2628  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2629  &dmin, &next_block, 0, 0);
2630  }
2631  if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2632  s->mv_dir = MV_DIR_BACKWARD;
2633  s->mv_type = MV_TYPE_FIELD;
2634  s->mb_intra= 0;
2635  for(i=0; i<2; i++){
2636  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2637  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2638  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2639  }
2640  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2641  &dmin, &next_block, 0, 0);
2642  }
2643  if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2645  s->mv_type = MV_TYPE_FIELD;
2646  s->mb_intra= 0;
2647  for(dir=0; dir<2; dir++){
2648  for(i=0; i<2; i++){
2649  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2650  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2651  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2652  }
2653  }
2654  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2655  &dmin, &next_block, 0, 0);
2656  }
2657  if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2658  s->mv_dir = 0;
2659  s->mv_type = MV_TYPE_16X16;
2660  s->mb_intra= 1;
2661  s->mv[0][0][0] = 0;
2662  s->mv[0][0][1] = 0;
2663  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2664  &dmin, &next_block, 0, 0);
2665  if(s->h263_pred || s->h263_aic){
2666  if(best_s.mb_intra)
2667  s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2668  else
2669  ff_clean_intra_table_entries(s); //old mode?
2670  }
2671  }
2672 
2673  if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
2674  if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2675  const int last_qp= backup_s.qscale;
2676  int qpi, qp, dc[6];
2677  DCTELEM ac[6][16];
2678  const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2679  static const int dquant_tab[4]={-1,1,-2,2};
2680 
2681  assert(backup_s.dquant == 0);
2682 
2683  //FIXME intra
2684  s->mv_dir= best_s.mv_dir;
2685  s->mv_type = MV_TYPE_16X16;
2686  s->mb_intra= best_s.mb_intra;
2687  s->mv[0][0][0] = best_s.mv[0][0][0];
2688  s->mv[0][0][1] = best_s.mv[0][0][1];
2689  s->mv[1][0][0] = best_s.mv[1][0][0];
2690  s->mv[1][0][1] = best_s.mv[1][0][1];
2691 
2692  qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2693  for(; qpi<4; qpi++){
2694  int dquant= dquant_tab[qpi];
2695  qp= last_qp + dquant;
2696  if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2697  continue;
2698  backup_s.dquant= dquant;
2699  if(s->mb_intra && s->dc_val[0]){
2700  for(i=0; i<6; i++){
2701  dc[i]= s->dc_val[0][ s->block_index[i] ];
2702  memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2703  }
2704  }
2705 
2706  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2707  &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2708  if(best_s.qscale != qp){
2709  if(s->mb_intra && s->dc_val[0]){
2710  for(i=0; i<6; i++){
2711  s->dc_val[0][ s->block_index[i] ]= dc[i];
2712  memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2713  }
2714  }
2715  }
2716  }
2717  }
2718  }
2720  int mx= s->b_direct_mv_table[xy][0];
2721  int my= s->b_direct_mv_table[xy][1];
2722 
2723  backup_s.dquant = 0;
2725  s->mb_intra= 0;
2726  ff_mpeg4_set_direct_mv(s, mx, my);
2727  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2728  &dmin, &next_block, mx, my);
2729  }
2731  backup_s.dquant = 0;
2733  s->mb_intra= 0;
2734  ff_mpeg4_set_direct_mv(s, 0, 0);
2735  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2736  &dmin, &next_block, 0, 0);
2737  }
2738  if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
2739  int coded=0;
2740  for(i=0; i<6; i++)
2741  coded |= s->block_last_index[i];
2742  if(coded){
2743  int mx,my;
2744  memcpy(s->mv, best_s.mv, sizeof(s->mv));
2745  if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2746  mx=my=0; //FIXME find the one we actually used
2747  ff_mpeg4_set_direct_mv(s, mx, my);
2748  }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2749  mx= s->mv[1][0][0];
2750  my= s->mv[1][0][1];
2751  }else{
2752  mx= s->mv[0][0][0];
2753  my= s->mv[0][0][1];
2754  }
2755 
2756  s->mv_dir= best_s.mv_dir;
2757  s->mv_type = best_s.mv_type;
2758  s->mb_intra= 0;
2759 /* s->mv[0][0][0] = best_s.mv[0][0][0];
2760  s->mv[0][0][1] = best_s.mv[0][0][1];
2761  s->mv[1][0][0] = best_s.mv[1][0][0];
2762  s->mv[1][0][1] = best_s.mv[1][0][1];*/
2763  backup_s.dquant= 0;
2764  s->skipdct=1;
2765  encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2766  &dmin, &next_block, mx, my);
2767  s->skipdct=0;
2768  }
2769  }
2770 
2771  s->current_picture.f.qscale_table[xy] = best_s.qscale;
2772 
2773  copy_context_after_encode(s, &best_s, -1);
2774 
2775  pb_bits_count= put_bits_count(&s->pb);
2776  flush_put_bits(&s->pb);
2777  avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2778  s->pb= backup_s.pb;
2779 
2780  if(s->data_partitioning){
2781  pb2_bits_count= put_bits_count(&s->pb2);
2782  flush_put_bits(&s->pb2);
2783  avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2784  s->pb2= backup_s.pb2;
2785 
2786  tex_pb_bits_count= put_bits_count(&s->tex_pb);
2787  flush_put_bits(&s->tex_pb);
2788  avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2789  s->tex_pb= backup_s.tex_pb;
2790  }
2791  s->last_bits= put_bits_count(&s->pb);
2792 
2793  if (CONFIG_H263_ENCODER &&
2796 
2797  if(next_block==0){ //FIXME 16 vs linesize16
2798  s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
2799  s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
2800  s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2801  }
2802 
2804  MPV_decode_mb(s, s->block);
2805  } else {
2806  int motion_x = 0, motion_y = 0;
2808  // only one MB-Type possible
2809 
2810  switch(mb_type){
2812  s->mv_dir = 0;
2813  s->mb_intra= 1;
2814  motion_x= s->mv[0][0][0] = 0;
2815  motion_y= s->mv[0][0][1] = 0;
2816  break;
2818  s->mv_dir = MV_DIR_FORWARD;
2819  s->mb_intra= 0;
2820  motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2821  motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2822  break;
2824  s->mv_dir = MV_DIR_FORWARD;
2825  s->mv_type = MV_TYPE_FIELD;
2826  s->mb_intra= 0;
2827  for(i=0; i<2; i++){
2828  j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2829  s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2830  s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2831  }
2832  break;
2834  s->mv_dir = MV_DIR_FORWARD;
2835  s->mv_type = MV_TYPE_8X8;
2836  s->mb_intra= 0;
2837  for(i=0; i<4; i++){
2838  s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2839  s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2840  }
2841  break;
2843  if (CONFIG_MPEG4_ENCODER) {
2845  s->mb_intra= 0;
2846  motion_x=s->b_direct_mv_table[xy][0];
2847  motion_y=s->b_direct_mv_table[xy][1];
2848  ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2849  }
2850  break;
2852  if (CONFIG_MPEG4_ENCODER) {
2854  s->mb_intra= 0;
2855  ff_mpeg4_set_direct_mv(s, 0, 0);
2856  }
2857  break;
2860  s->mb_intra= 0;
2861  s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2862  s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2863  s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2864  s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2865  break;
2867  s->mv_dir = MV_DIR_BACKWARD;
2868  s->mb_intra= 0;
2869  motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2870  motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2871  break;
2873  s->mv_dir = MV_DIR_FORWARD;
2874  s->mb_intra= 0;
2875  motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2876  motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2877 // printf(" %d %d ", motion_x, motion_y);
2878  break;
2880  s->mv_dir = MV_DIR_FORWARD;
2881  s->mv_type = MV_TYPE_FIELD;
2882  s->mb_intra= 0;
2883  for(i=0; i<2; i++){
2884  j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2885  s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2886  s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2887  }
2888  break;
2890  s->mv_dir = MV_DIR_BACKWARD;
2891  s->mv_type = MV_TYPE_FIELD;
2892  s->mb_intra= 0;
2893  for(i=0; i<2; i++){
2894  j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2895  s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2896  s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2897  }
2898  break;
2901  s->mv_type = MV_TYPE_FIELD;
2902  s->mb_intra= 0;
2903  for(dir=0; dir<2; dir++){
2904  for(i=0; i<2; i++){
2905  j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2906  s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2907  s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2908  }
2909  }
2910  break;
2911  default:
2912  av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
2913  }
2914 
2915  encode_mb(s, motion_x, motion_y);
2916 
2917  // RAL: Update last macroblock type
2918  s->last_mv_dir = s->mv_dir;
2919 
2920  if (CONFIG_H263_ENCODER &&
2923 
2924  MPV_decode_mb(s, s->block);
2925  }
2926 
2927  /* clean the MV table in IPS frames for direct mode in B frames */
2928  if(s->mb_intra /* && I,P,S_TYPE */){
2929  s->p_mv_table[xy][0]=0;
2930  s->p_mv_table[xy][1]=0;
2931  }
2932 
2933  if(s->flags&CODEC_FLAG_PSNR){
2934  int w= 16;
2935  int h= 16;
2936 
2937  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2938  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2939 
2940  s->current_picture.f.error[0] += sse(
2941  s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
2942  s->dest[0], w, h, s->linesize);
2943  s->current_picture.f.error[1] += sse(
2944  s, s->new_picture.f.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
2945  s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
2946  s->current_picture.f.error[2] += sse(
2947  s, s->new_picture.f.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h,
2948  s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
2949  }
2950  if(s->loop_filter){
2953  }
2954 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
2955  }
2956  }
2957 
2958  //not beautiful here but we must write it before flushing so it has to be here
2961 
2962  write_slice_end(s);
2963 
2964  /* Send the last GOB if RTP */
2965  if (s->avctx->rtp_callback) {
2966  int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
2967  pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
2968  /* Call the RTP callback to send the last GOB */
2969  emms_c();
2970  s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
2971  }
2972 
2973  return 0;
2974 }
2975 
2976 #define MERGE(field) dst->field += src->field; src->field=0
2981 }
2982 
2984  int i;
2985 
2986  MERGE(dct_count[0]); //note, the other dct vars are not part of the context
2987  MERGE(dct_count[1]);
2988  MERGE(mv_bits);
2989  MERGE(i_tex_bits);
2990  MERGE(p_tex_bits);
2991  MERGE(i_count);
2992  MERGE(f_count);
2993  MERGE(b_count);
2994  MERGE(skip_count);
2995  MERGE(misc_bits);
2996  MERGE(error_count);
3001 
3002  if(dst->avctx->noise_reduction){
3003  for(i=0; i<64; i++){
3004  MERGE(dct_error_sum[0][i]);
3005  MERGE(dct_error_sum[1][i]);
3006  }
3007  }
3008 
3009  assert(put_bits_count(&src->pb) % 8 ==0);
3010  assert(put_bits_count(&dst->pb) % 8 ==0);
3011  avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3012  flush_put_bits(&dst->pb);
3013 }
3014 
3015 static int estimate_qp(MpegEncContext *s, int dry_run){
3016  if (s->next_lambda){
3019  if(!dry_run) s->next_lambda= 0;
3020  } else if (!s->fixed_qscale) {
3023  if (s->current_picture.f.quality < 0)
3024  return -1;
3025  }
3026 
3027  if(s->adaptive_quant){
3028  switch(s->codec_id){
3029  case CODEC_ID_MPEG4:
3032  break;
3033  case CODEC_ID_H263:
3034  case CODEC_ID_H263P:
3035  case CODEC_ID_FLV1:
3036  if (CONFIG_H263_ENCODER)
3038  break;
3039  default:
3040  ff_init_qscale_tab(s);
3041  }
3042 
3043  s->lambda= s->lambda_table[0];
3044  //FIXME broken
3045  }else
3046  s->lambda = s->current_picture.f.quality;
3047 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3048  update_qscale(s);
3049  return 0;
3050 }
3051 
3052 /* must be called before writing the header */
3054  assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3055  s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3056 
3057  if(s->pict_type==AV_PICTURE_TYPE_B){
3058  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3059  assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3060  }else{
3061  s->pp_time= s->time - s->last_non_b_time;
3062  s->last_non_b_time= s->time;
3063  assert(s->picture_number==0 || s->pp_time > 0);
3064  }
3065 }
3066 
3068 {
3069  int i;
3070  int bits;
3071  int context_count = s->slice_context_count;
3072 
3074 
3075  /* Reset the average MB variance */
3076  s->me.mb_var_sum_temp =
3077  s->me.mc_mb_var_sum_temp = 0;
3078 
3079  /* we need to initialize some time vars before we can encode b-frames */
3080  // RAL: Condition added for MPEG1VIDEO
3084  ff_set_mpeg4_time(s);
3085 
3086  s->me.scene_change_score=0;
3087 
3088 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3089 
3090  if(s->pict_type==AV_PICTURE_TYPE_I){
3091  if(s->msmpeg4_version >= 3) s->no_rounding=1;
3092  else s->no_rounding=0;
3093  }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3095  s->no_rounding ^= 1;
3096  }
3097 
3098  if(s->flags & CODEC_FLAG_PASS2){
3099  if (estimate_qp(s,1) < 0)
3100  return -1;
3101  ff_get_2pass_fcode(s);
3102  }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3104  s->lambda= s->last_lambda_for[s->pict_type];
3105  else
3107  update_qscale(s);
3108  }
3109 
3110  s->mb_intra=0; //for the rate distortion & bit compare functions
3111  for(i=1; i<context_count; i++){
3113  }
3114 
3115  if(ff_init_me(s)<0)
3116  return -1;
3117 
3118  /* Estimate motion for every MB */
3119  if(s->pict_type != AV_PICTURE_TYPE_I){
3120  s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3121  s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3122  if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3123  if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3124  s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3125  }
3126  }
3127 
3128  s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3129  }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3130  /* I-Frame */
3131  for(i=0; i<s->mb_stride*s->mb_height; i++)
3133 
3134  if(!s->fixed_qscale){
3135  /* finding spatial complexity for I-frame rate control */
3136  s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3137  }
3138  }
3139  for(i=1; i<context_count; i++){
3141  }
3143  s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
3144  emms_c();
3145 
3148  for(i=0; i<s->mb_stride*s->mb_height; i++)
3150 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3151  }
3152 
3153  if(!s->umvplus){
3156 
3158  int a,b;
3159  a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3161  s->f_code= FFMAX3(s->f_code, a, b);
3162  }
3163 
3164  ff_fix_long_p_mvs(s);
3167  int j;
3168  for(i=0; i<2; i++){
3169  for(j=0; j<2; j++)
3172  }
3173  }
3174  }
3175 
3176  if(s->pict_type==AV_PICTURE_TYPE_B){
3177  int a, b;
3178 
3181  s->f_code = FFMAX(a, b);
3182 
3185  s->b_code = FFMAX(a, b);
3186 
3192  int dir, j;
3193  for(dir=0; dir<2; dir++){
3194  for(i=0; i<2; i++){
3195  for(j=0; j<2; j++){
3198  ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3199  s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3200  }
3201  }
3202  }
3203  }
3204  }
3205  }
3206 
3207  if (estimate_qp(s, 0) < 0)
3208  return -1;
3209 
3210  if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3211  s->qscale= 3; //reduce clipping problems
3212 
3213  if (s->out_format == FMT_MJPEG) {
3214  /* for mjpeg, we do include qscale in the matrix */
3215  for(i=1;i<64;i++){
3216  int j= s->dsp.idct_permutation[i];
3217 
3218  s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3219  }
3220  s->y_dc_scale_table=
3224  s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3225  s->qscale= 8;
3226  }
3227 
3228  //FIXME var duplication
3230  s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3233 
3234  if (s->current_picture.f.key_frame)
3235  s->picture_in_gop_number=0;
3236 
3237  s->last_bits= put_bits_count(&s->pb);
3238  switch(s->out_format) {
3239  case FMT_MJPEG:
3242  break;
3243  case FMT_H261:
3244  if (CONFIG_H261_ENCODER)
3245  ff_h261_encode_picture_header(s, picture_number);
3246  break;
3247  case FMT_H263:
3249  ff_wmv2_encode_picture_header(s, picture_number);
3250  else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3251  msmpeg4_encode_picture_header(s, picture_number);
3252  else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3253  mpeg4_encode_picture_header(s, picture_number);
3254  else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
3255  rv10_encode_picture_header(s, picture_number);
3256  else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
3257  rv20_encode_picture_header(s, picture_number);
3258  else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
3259  ff_flv_encode_picture_header(s, picture_number);
3260  else if (CONFIG_H263_ENCODER)
3261  ff_h263_encode_picture_header(s, picture_number);
3262  break;
3263  case FMT_MPEG1:
3265  mpeg1_encode_picture_header(s, picture_number);
3266  break;
3267  case FMT_H264:
3268  break;
3269  default:
3270  assert(0);
3271  }
3272  bits= put_bits_count(&s->pb);
3273  s->header_bits= bits - s->last_bits;
3274 
3275  for(i=1; i<context_count; i++){
3277  }
3278  s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3279  for(i=1; i<context_count; i++){
3281  }
3282  emms_c();
3283  return 0;
3284 }
3285 
3287  const int intra= s->mb_intra;
3288  int i;
3289 
3290  s->dct_count[intra]++;
3291 
3292  for(i=0; i<64; i++){
3293  int level= block[i];
3294 
3295  if(level){
3296  if(level>0){
3297  s->dct_error_sum[intra][i] += level;
3298  level -= s->dct_offset[intra][i];
3299  if(level<0) level=0;
3300  }else{
3301  s->dct_error_sum[intra][i] -= level;
3302  level += s->dct_offset[intra][i];
3303  if(level>0) level=0;
3304  }
3305  block[i]= level;
3306  }
3307  }
3308 }
3309 
3311  DCTELEM *block, int n,
3312  int qscale, int *overflow){
3313  const int *qmat;
3314  const uint8_t *scantable= s->intra_scantable.scantable;
3315  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3316  int max=0;
3317  unsigned int threshold1, threshold2;
3318  int bias=0;
3319  int run_tab[65];
3320  int level_tab[65];
3321  int score_tab[65];
3322  int survivor[65];
3323  int survivor_count;
3324  int last_run=0;
3325  int last_level=0;
3326  int last_score= 0;
3327  int last_i;
3328  int coeff[2][64];
3329  int coeff_count[64];
3330  int qmul, qadd, start_i, last_non_zero, i, dc;
3331  const int esc_length= s->ac_esc_length;
3332  uint8_t * length;
3333  uint8_t * last_length;
3334  const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3335 
3336  s->dsp.fdct (block);
3337 
3338  if(s->dct_error_sum)
3339  s->denoise_dct(s, block);
3340  qmul= qscale*16;
3341  qadd= ((qscale-1)|1)*8;
3342 
3343  if (s->mb_intra) {
3344  int q;
3345  if (!s->h263_aic) {
3346  if (n < 4)
3347  q = s->y_dc_scale;
3348  else
3349  q = s->c_dc_scale;
3350  q = q << 3;
3351  } else{
3352  /* For AIC we skip quant/dequant of INTRADC */
3353  q = 1 << 3;
3354  qadd=0;
3355  }
3356 
3357  /* note: block[0] is assumed to be positive */
3358  block[0] = (block[0] + (q >> 1)) / q;
3359  start_i = 1;
3360  last_non_zero = 0;
3361  qmat = s->q_intra_matrix[qscale];
3362  if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3363  bias= 1<<(QMAT_SHIFT-1);
3364  length = s->intra_ac_vlc_length;
3365  last_length= s->intra_ac_vlc_last_length;
3366  } else {
3367  start_i = 0;
3368  last_non_zero = -1;
3369  qmat = s->q_inter_matrix[qscale];
3370  length = s->inter_ac_vlc_length;
3371  last_length= s->inter_ac_vlc_last_length;
3372  }
3373  last_i= start_i;
3374 
3375  threshold1= (1<<QMAT_SHIFT) - bias - 1;
3376  threshold2= (threshold1<<1);
3377 
3378  for(i=63; i>=start_i; i--) {
3379  const int j = scantable[i];
3380  int level = block[j] * qmat[j];
3381 
3382  if(((unsigned)(level+threshold1))>threshold2){
3383  last_non_zero = i;
3384  break;
3385  }
3386  }
3387 
3388  for(i=start_i; i<=last_non_zero; i++) {
3389  const int j = scantable[i];
3390  int level = block[j] * qmat[j];
3391 
3392 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3393 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3394  if(((unsigned)(level+threshold1))>threshold2){
3395  if(level>0){
3396  level= (bias + level)>>QMAT_SHIFT;
3397  coeff[0][i]= level;
3398  coeff[1][i]= level-1;
3399 // coeff[2][k]= level-2;
3400  }else{
3401  level= (bias - level)>>QMAT_SHIFT;
3402  coeff[0][i]= -level;
3403  coeff[1][i]= -level+1;
3404 // coeff[2][k]= -level+2;
3405  }
3406  coeff_count[i]= FFMIN(level, 2);
3407  assert(coeff_count[i]);
3408  max |=level;
3409  }else{
3410  coeff[0][i]= (level>>31)|1;
3411  coeff_count[i]= 1;
3412  }
3413  }
3414 
3415  *overflow= s->max_qcoeff < max; //overflow might have happened
3416 
3417  if(last_non_zero < start_i){
3418  memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3419  return last_non_zero;
3420  }
3421 
3422  score_tab[start_i]= 0;
3423  survivor[0]= start_i;
3424  survivor_count= 1;
3425 
3426  for(i=start_i; i<=last_non_zero; i++){
3427  int level_index, j, zero_distortion;
3428  int dct_coeff= FFABS(block[ scantable[i] ]);
3429  int best_score=256*256*256*120;
3430 
3431  if ( s->dsp.fdct == fdct_ifast
3432 #ifndef FAAN_POSTSCALE
3433  || s->dsp.fdct == ff_faandct
3434 #endif
3435  )
3436  dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3437  zero_distortion= dct_coeff*dct_coeff;
3438 
3439  for(level_index=0; level_index < coeff_count[i]; level_index++){
3440  int distortion;
3441  int level= coeff[level_index][i];
3442  const int alevel= FFABS(level);
3443  int unquant_coeff;
3444 
3445  assert(level);
3446 
3447  if(s->out_format == FMT_H263){
3448  unquant_coeff= alevel*qmul + qadd;
3449  }else{ //MPEG1
3450  j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3451  if(s->mb_intra){
3452  unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
3453  unquant_coeff = (unquant_coeff - 1) | 1;
3454  }else{
3455  unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3456  unquant_coeff = (unquant_coeff - 1) | 1;
3457  }
3458  unquant_coeff<<= 3;
3459  }
3460 
3461  distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3462  level+=64;
3463  if((level&(~127)) == 0){
3464  for(j=survivor_count-1; j>=0; j--){
3465  int run= i - survivor[j];
3466  int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3467  score += score_tab[i-run];
3468 
3469  if(score < best_score){
3470  best_score= score;
3471  run_tab[i+1]= run;
3472  level_tab[i+1]= level-64;
3473  }
3474  }
3475 
3476  if(s->out_format == FMT_H263){
3477  for(j=survivor_count-1; j>=0; j--){
3478  int run= i - survivor[j];
3479  int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3480  score += score_tab[i-run];
3481  if(score < last_score){
3482  last_score= score;
3483  last_run= run;
3484  last_level= level-64;
3485  last_i= i+1;
3486  }
3487  }
3488  }
3489  }else{
3490  distortion += esc_length*lambda;
3491  for(j=survivor_count-1; j>=0; j--){
3492  int run= i - survivor[j];
3493  int score= distortion + score_tab[i-run];
3494 
3495  if(score < best_score){
3496  best_score= score;
3497  run_tab[i+1]= run;
3498  level_tab[i+1]= level-64;
3499  }
3500  }
3501 
3502  if(s->out_format == FMT_H263){
3503  for(j=survivor_count-1; j>=0; j--){
3504  int run= i - survivor[j];
3505  int score= distortion + score_tab[i-run];
3506  if(score < last_score){
3507  last_score= score;
3508  last_run= run;
3509  last_level= level-64;
3510  last_i= i+1;
3511  }
3512  }
3513  }
3514  }
3515  }
3516 
3517  score_tab[i+1]= best_score;
3518 
3519  //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3520  if(last_non_zero <= 27){
3521  for(; survivor_count; survivor_count--){
3522  if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3523  break;
3524  }
3525  }else{
3526  for(; survivor_count; survivor_count--){
3527  if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3528  break;
3529  }
3530  }
3531 
3532  survivor[ survivor_count++ ]= i+1;
3533  }
3534 
3535  if(s->out_format != FMT_H263){
3536  last_score= 256*256*256*120;
3537  for(i= survivor[0]; i<=last_non_zero + 1; i++){
3538  int score= score_tab[i];
3539  if(i) score += lambda*2; //FIXME exacter?
3540 
3541  if(score < last_score){
3542  last_score= score;
3543  last_i= i;
3544  last_level= level_tab[i];
3545  last_run= run_tab[i];
3546  }
3547  }
3548  }
3549 
3550  s->coded_score[n] = last_score;
3551 
3552  dc= FFABS(block[0]);
3553  last_non_zero= last_i - 1;
3554  memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3555 
3556  if(last_non_zero < start_i)
3557  return last_non_zero;
3558 
3559  if(last_non_zero == 0 && start_i == 0){
3560  int best_level= 0;
3561  int best_score= dc * dc;
3562 
3563  for(i=0; i<coeff_count[0]; i++){
3564  int level= coeff[i][0];
3565  int alevel= FFABS(level);
3566  int unquant_coeff, score, distortion;
3567 
3568  if(s->out_format == FMT_H263){
3569  unquant_coeff= (alevel*qmul + qadd)>>3;
3570  }else{ //MPEG1
3571  unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3572  unquant_coeff = (unquant_coeff - 1) | 1;
3573  }
3574  unquant_coeff = (unquant_coeff + 4) >> 3;
3575  unquant_coeff<<= 3 + 3;
3576 
3577  distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3578  level+=64;
3579  if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3580  else score= distortion + esc_length*lambda;
3581 
3582  if(score < best_score){
3583  best_score= score;
3584  best_level= level - 64;
3585  }
3586  }
3587  block[0]= best_level;
3588  s->coded_score[n] = best_score - dc*dc;
3589  if(best_level == 0) return -1;
3590  else return last_non_zero;
3591  }
3592 
3593  i= last_i;
3594  assert(last_level);
3595 
3596  block[ perm_scantable[last_non_zero] ]= last_level;
3597  i -= last_run + 1;
3598 
3599  for(; i>start_i; i -= run_tab[i] + 1){
3600  block[ perm_scantable[i-1] ]= level_tab[i];
3601  }
3602 
3603  return last_non_zero;
3604 }
3605 
3606 //#define REFINE_STATS 1
3607 static int16_t basis[64][64];
3608 
3609 static void build_basis(uint8_t *perm){
3610  int i, j, x, y;
3611  emms_c();
3612  for(i=0; i<8; i++){
3613  for(j=0; j<8; j++){
3614  for(y=0; y<8; y++){
3615  for(x=0; x<8; x++){
3616  double s= 0.25*(1<<BASIS_SHIFT);
3617  int index= 8*i + j;
3618  int perm_index= perm[index];
3619  if(i==0) s*= sqrt(0.5);
3620  if(j==0) s*= sqrt(0.5);
3621  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)));
3622  }
3623  }
3624  }
3625  }
3626 }
3627 
3628 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3629  DCTELEM *block, int16_t *weight, DCTELEM *orig,
3630  int n, int qscale){
3631  int16_t rem[64];
3632  LOCAL_ALIGNED_16(DCTELEM, d1, [64]);
3633  const uint8_t *scantable= s->intra_scantable.scantable;
3634  const uint8_t *perm_scantable= s->intra_scantable.permutated;
3635 // unsigned int threshold1, threshold2;
3636 // int bias=0;
3637  int run_tab[65];
3638  int prev_run=0;
3639  int prev_level=0;
3640  int qmul, qadd, start_i, last_non_zero, i, dc;
3641  uint8_t * length;
3642  uint8_t * last_length;
3643  int lambda;
3644  int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3645 #ifdef REFINE_STATS
3646 static int count=0;
3647 static int after_last=0;
3648 static int to_zero=0;
3649 static int from_zero=0;
3650 static int raise=0;
3651 static int lower=0;
3652 static int messed_sign=0;
3653 #endif
3654 
3655  if(basis[0][0] == 0)
3657 
3658  qmul= qscale*2;
3659  qadd= (qscale-1)|1;
3660  if (s->mb_intra) {
3661  if (!s->h263_aic) {
3662  if (n < 4)
3663  q = s->y_dc_scale;
3664  else
3665  q = s->c_dc_scale;
3666  } else{
3667  /* For AIC we skip quant/dequant of INTRADC */
3668  q = 1;
3669  qadd=0;
3670  }
3671  q <<= RECON_SHIFT-3;
3672  /* note: block[0] is assumed to be positive */
3673  dc= block[0]*q;
3674 // block[0] = (block[0] + (q >> 1)) / q;
3675  start_i = 1;
3676 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3677 // bias= 1<<(QMAT_SHIFT-1);
3678  length = s->intra_ac_vlc_length;
3679  last_length= s->intra_ac_vlc_last_length;
3680  } else {
3681  dc= 0;
3682  start_i = 0;
3683  length = s->inter_ac_vlc_length;
3684  last_length= s->inter_ac_vlc_last_length;
3685  }
3686  last_non_zero = s->block_last_index[n];
3687 
3688 #ifdef REFINE_STATS
3689 {START_TIMER
3690 #endif
3691  dc += (1<<(RECON_SHIFT-1));
3692  for(i=0; i<64; i++){
3693  rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
3694  }
3695 #ifdef REFINE_STATS
3696 STOP_TIMER("memset rem[]")}
3697 #endif
3698  sum=0;
3699  for(i=0; i<64; i++){
3700  int one= 36;
3701  int qns=4;
3702  int w;
3703 
3704  w= FFABS(weight[i]) + qns*one;
3705  w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3706 
3707  weight[i] = w;
3708 // w=weight[i] = (63*qns + (w/2)) / w;
3709 
3710  assert(w>0);
3711  assert(w<(1<<6));
3712  sum += w*w;
3713  }
3714  lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3715 #ifdef REFINE_STATS
3716 {START_TIMER
3717 #endif
3718  run=0;
3719  rle_index=0;
3720  for(i=start_i; i<=last_non_zero; i++){
3721  int j= perm_scantable[i];
3722  const int level= block[j];
3723  int coeff;
3724 
3725  if(level){
3726  if(level<0) coeff= qmul*level - qadd;
3727  else coeff= qmul*level + qadd;
3728  run_tab[rle_index++]=run;
3729  run=0;
3730 
3731  s->dsp.add_8x8basis(rem, basis[j], coeff);
3732  }else{
3733  run++;
3734  }
3735  }
3736 #ifdef REFINE_STATS
3737 if(last_non_zero>0){
3738 STOP_TIMER("init rem[]")
3739 }
3740 }
3741 
3742 {START_TIMER
3743 #endif
3744  for(;;){
3745  int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3746  int best_coeff=0;
3747  int best_change=0;
3748  int run2, best_unquant_change=0, analyze_gradient;
3749 #ifdef REFINE_STATS
3750 {START_TIMER
3751 #endif
3752  analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
3753 
3754  if(analyze_gradient){
3755 #ifdef REFINE_STATS
3756 {START_TIMER
3757 #endif
3758  for(i=0; i<64; i++){
3759  int w= weight[i];
3760 
3761  d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3762  }
3763 #ifdef REFINE_STATS
3764 STOP_TIMER("rem*w*w")}
3765 {START_TIMER
3766 #endif
3767  s->dsp.fdct(d1);
3768 #ifdef REFINE_STATS
3769 STOP_TIMER("dct")}
3770 #endif
3771  }
3772 
3773  if(start_i){
3774  const int level= block[0];
3775  int change, old_coeff;
3776 
3777  assert(s->mb_intra);
3778 
3779  old_coeff= q*level;
3780 
3781  for(change=-1; change<=1; change+=2){
3782  int new_level= level + change;
3783  int score, new_coeff;
3784 
3785  new_coeff= q*new_level;
3786  if(new_coeff >= 2048 || new_coeff < 0)
3787  continue;
3788 
3789  score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3790  if(score<best_score){
3791  best_score= score;
3792  best_coeff= 0;
3793  best_change= change;
3794  best_unquant_change= new_coeff - old_coeff;
3795  }
3796  }
3797  }
3798 
3799  run=0;
3800  rle_index=0;
3801  run2= run_tab[rle_index++];
3802  prev_level=0;
3803  prev_run=0;
3804 
3805  for(i=start_i; i<64; i++){
3806  int j= perm_scantable[i];
3807  const int level= block[j];
3808  int change, old_coeff;
3809 
3810  if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3811  break;
3812 
3813  if(level){
3814  if(level<0) old_coeff= qmul*level - qadd;
3815  else old_coeff= qmul*level + qadd;
3816  run2= run_tab[rle_index++]; //FIXME ! maybe after last
3817  }else{
3818  old_coeff=0;
3819  run2--;
3820  assert(run2>=0 || i >= last_non_zero );
3821  }
3822 
3823  for(change=-1; change<=1; change+=2){
3824  int new_level= level + change;
3825  int score, new_coeff, unquant_change;
3826 
3827  score=0;
3828  if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3829  continue;
3830 
3831  if(new_level){
3832  if(new_level<0) new_coeff= qmul*new_level - qadd;
3833  else new_coeff= qmul*new_level + qadd;
3834  if(new_coeff >= 2048 || new_coeff <= -2048)
3835  continue;
3836  //FIXME check for overflow
3837 
3838  if(level){
3839  if(level < 63 && level > -63){
3840  if(i < last_non_zero)
3841  score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
3842  - length[UNI_AC_ENC_INDEX(run, level+64)];
3843  else
3844  score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3845  - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3846  }
3847  }else{
3848  assert(FFABS(new_level)==1);
3849 
3850  if(analyze_gradient){
3851  int g= d1[ scantable[i] ];
3852  if(g && (g^new_level) >= 0)
3853  continue;
3854  }
3855 
3856  if(i < last_non_zero){
3857  int next_i= i + run2 + 1;
3858  int next_level= block[ perm_scantable[next_i] ] + 64;
3859 
3860  if(next_level&(~127))
3861  next_level= 0;
3862 
3863  if(next_i < last_non_zero)
3864  score += length[UNI_AC_ENC_INDEX(run, 65)]
3865  + length[UNI_AC_ENC_INDEX(run2, next_level)]
3866  - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3867  else
3868  score += length[UNI_AC_ENC_INDEX(run, 65)]
3869  + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3870  - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
3871  }else{
3872  score += last_length[UNI_AC_ENC_INDEX(run, 65)];
3873  if(prev_level){
3874  score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3875  - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3876  }
3877  }
3878  }
3879  }else{
3880  new_coeff=0;
3881  assert(FFABS(level)==1);
3882 
3883  if(i < last_non_zero){
3884  int next_i= i + run2 + 1;
3885  int next_level= block[ perm_scantable[next_i] ] + 64;
3886 
3887  if(next_level&(~127))
3888  next_level= 0;
3889 
3890  if(next_i < last_non_zero)
3891  score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
3892  - length[UNI_AC_ENC_INDEX(run2, next_level)]
3893  - length[UNI_AC_ENC_INDEX(run, 65)];
3894  else
3895  score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
3896  - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
3897  - length[UNI_AC_ENC_INDEX(run, 65)];
3898  }else{
3899  score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
3900  if(prev_level){
3901  score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
3902  - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
3903  }
3904  }
3905  }
3906 
3907  score *= lambda;
3908 
3909  unquant_change= new_coeff - old_coeff;
3910  assert((score < 100*lambda && score > -100*lambda) || lambda==0);
3911 
3912  score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
3913  if(score<best_score){
3914  best_score= score;
3915  best_coeff= i;
3916  best_change= change;
3917  best_unquant_change= unquant_change;
3918  }
3919  }
3920  if(level){
3921  prev_level= level + 64;
3922  if(prev_level&(~127))
3923  prev_level= 0;
3924  prev_run= run;
3925  run=0;
3926  }else{
3927  run++;
3928  }
3929  }
3930 #ifdef REFINE_STATS
3931 STOP_TIMER("iterative step")}
3932 #endif
3933 
3934  if(best_change){
3935  int j= perm_scantable[ best_coeff ];
3936 
3937  block[j] += best_change;
3938 
3939  if(best_coeff > last_non_zero){
3940  last_non_zero= best_coeff;
3941  assert(block[j]);
3942 #ifdef REFINE_STATS
3943 after_last++;
3944 #endif
3945  }else{
3946 #ifdef REFINE_STATS
3947 if(block[j]){
3948  if(block[j] - best_change){
3949  if(FFABS(block[j]) > FFABS(block[j] - best_change)){
3950  raise++;
3951  }else{
3952  lower++;
3953  }
3954  }else{
3955  from_zero++;
3956  }
3957 }else{
3958  to_zero++;
3959 }
3960 #endif
3961  for(; last_non_zero>=start_i; last_non_zero--){
3962  if(block[perm_scantable[last_non_zero]])
3963  break;
3964  }
3965  }
3966 #ifdef REFINE_STATS
3967 count++;
3968 if(256*256*256*64 % count == 0){
3969  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);
3970 }
3971 #endif
3972  run=0;
3973  rle_index=0;
3974  for(i=start_i; i<=last_non_zero; i++){
3975  int j= perm_scantable[i];
3976  const int level= block[j];
3977 
3978  if(level){
3979  run_tab[rle_index++]=run;
3980  run=0;
3981  }else{
3982  run++;
3983  }
3984  }
3985 
3986  s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
3987  }else{
3988  break;
3989  }
3990  }
3991 #ifdef REFINE_STATS
3992 if(last_non_zero>0){
3993 STOP_TIMER("iterative search")
3994 }
3995 }
3996 #endif
3997 
3998  return last_non_zero;
3999 }
4000 
4002  DCTELEM *block, int n,
4003  int qscale, int *overflow)
4004 {
4005  int i, j, level, last_non_zero, q, start_i;
4006  const int *qmat;
4007  const uint8_t *scantable= s->intra_scantable.scantable;
4008  int bias;
4009  int max=0;
4010  unsigned int threshold1, threshold2;
4011 
4012  s->dsp.fdct (block);
4013 
4014  if(s->dct_error_sum)
4015  s->denoise_dct(s, block);
4016 
4017  if (s->mb_intra) {
4018  if (!s->h263_aic) {
4019  if (n < 4)
4020  q = s->y_dc_scale;
4021  else
4022  q = s->c_dc_scale;
4023  q = q << 3;
4024  } else
4025  /* For AIC we skip quant/dequant of INTRADC */
4026  q = 1 << 3;
4027 
4028  /* note: block[0] is assumed to be positive */
4029  block[0] = (block[0] + (q >> 1)) / q;
4030  start_i = 1;
4031  last_non_zero = 0;
4032  qmat = s->q_intra_matrix[qscale];
4034  } else {
4035  start_i = 0;
4036  last_non_zero = -1;
4037  qmat = s->q_inter_matrix[qscale];
4039  }
4040  threshold1= (1<<QMAT_SHIFT) - bias - 1;
4041  threshold2= (threshold1<<1);
4042  for(i=63;i>=start_i;i--) {
4043  j = scantable[i];
4044  level = block[j] * qmat[j];
4045 
4046  if(((unsigned)(level+threshold1))>threshold2){
4047  last_non_zero = i;
4048  break;
4049  }else{
4050  block[j]=0;
4051  }
4052  }
4053  for(i=start_i; i<=last_non_zero; i++) {
4054  j = scantable[i];
4055  level = block[j] * qmat[j];
4056 
4057 // if( bias+level >= (1<<QMAT_SHIFT)
4058 // || bias-level >= (1<<QMAT_SHIFT)){
4059  if(((unsigned)(level+threshold1))>threshold2){
4060  if(level>0){
4061  level= (bias + level)>>QMAT_SHIFT;
4062  block[j]= level;
4063  }else{
4064  level= (bias - level)>>QMAT_SHIFT;
4065  block[j]= -level;
4066  }
4067  max |=level;
4068  }else{
4069  block[j]=0;
4070  }
4071  }
4072  *overflow= s->max_qcoeff < max; //overflow might have happened
4073 
4074  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4076  ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4077 
4078  return last_non_zero;
4079 }
4080 
4081 #define OFFSET(x) offsetof(MpegEncContext, x)
4082 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4083 static const AVOption h263_options[] = {
4084  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4085  { "structured_slices","Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4086  { NULL },
4087 };
4088 
4089 static const AVClass h263_class = {
4090  .class_name = "H.263 encoder",
4091  .item_name = av_default_item_name,
4092  .option = h263_options,
4093  .version = LIBAVUTIL_VERSION_INT,
4094 };
4095 
4097  .name = "h263",
4098  .type = AVMEDIA_TYPE_VIDEO,
4099  .id = CODEC_ID_H263,
4100  .priv_data_size = sizeof(MpegEncContext),
4101  .init = MPV_encode_init,
4102  .encode = MPV_encode_picture,
4103  .close = MPV_encode_end,
4104  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4105  .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4106  .priv_class = &h263_class,
4107 };
4108 
4109 static const AVOption h263p_options[] = {
4110  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4111  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4112  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
4113  { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE},
4114  { NULL },
4115 };
4116 static const AVClass h263p_class = {
4117  .class_name = "H.263p encoder",
4118  .item_name = av_default_item_name,
4119  .option = h263p_options,
4120  .version = LIBAVUTIL_VERSION_INT,
4121 };
4122 
4124  .name = "h263p",
4125  .type = AVMEDIA_TYPE_VIDEO,
4126  .id = CODEC_ID_H263P,
4127  .priv_data_size = sizeof(MpegEncContext),
4128  .init = MPV_encode_init,
4129  .encode = MPV_encode_picture,
4130  .close = MPV_encode_end,
4131  .capabilities = CODEC_CAP_SLICE_THREADS,
4132  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4133  .long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4134  .priv_class = &h263p_class,
4135 };
4136 
4138  .name = "msmpeg4v2",
4139  .type = AVMEDIA_TYPE_VIDEO,
4140  .id = CODEC_ID_MSMPEG4V2,
4141  .priv_data_size = sizeof(MpegEncContext),
4142  .init = MPV_encode_init,
4143  .encode = MPV_encode_picture,
4144  .close = MPV_encode_end,
4145  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4146  .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4147 };
4148 
4150  .name = "msmpeg4",
4151  .type = AVMEDIA_TYPE_VIDEO,
4152  .id = CODEC_ID_MSMPEG4V3,
4153  .priv_data_size = sizeof(MpegEncContext),
4154  .init = MPV_encode_init,
4155  .encode = MPV_encode_picture,
4156  .close = MPV_encode_end,
4157  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4158  .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4159 };
4160 
4162  .name = "wmv1",
4163  .type = AVMEDIA_TYPE_VIDEO,
4164  .id = CODEC_ID_WMV1,
4165  .priv_data_size = sizeof(MpegEncContext),
4166  .init = MPV_encode_init,
4167  .encode = MPV_encode_picture,
4168  .close = MPV_encode_end,
4169  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
4170  .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4171 };