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