a8feeb6fb380761e04c741e06fee025e6b7c0894
[ffmpeg.git] / libavcodec / mpegvideo_enc.c
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "libavutil/intmath.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "avcodec.h"
34 #include "dsputil.h"
35 #include "mpegvideo.h"
36 #include "h263.h"
37 #include "mjpegenc.h"
38 #include "msmpeg4.h"
39 #include "faandct.h"
40 #include "thread.h"
41 #include "aandcttab.h"
42 #include "flv.h"
43 #include "mpeg4video.h"
44 #include "internal.h"
45 #include "bytestream.h"
46 #include <limits.h>
47 #include "sp5x.h"
48
49 //#undef NDEBUG
50 //#include <assert.h>
51
52 static int encode_picture(MpegEncContext *s, int picture_number);
53 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
54 static int sse_mb(MpegEncContext *s);
55 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
56 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
57
58 /* enable all paranoid tests for rounding, overflows, etc... */
59 //#define PARANOID
60
61 //#define DEBUG
62
63 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
64 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
65
66 const AVOption ff_mpv_generic_options[] = {
67     FF_MPV_COMMON_OPTS
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 * quant_matrix[j]));
106             }
107         } else {
108             for (i = 0; i < 64; i++) {
109                 const int j = dsp->idct_permutation[i];
110                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
111                  * Assume x = qscale * quant_matrix[i]
112                  * So             16 <=              x  <= 7905
113                  * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
114                  * so          32768 >= (1 << 19) / (x) >= 67 */
115                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
116                                         (qscale * quant_matrix[j]));
117                 //qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) /
118                 //                    (qscale * quant_matrix[i]);
119                 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) /
120                                        (qscale * quant_matrix[j]);
121
122                 if (qmat16[qscale][0][i] == 0 ||
123                     qmat16[qscale][0][i] == 128 * 256)
124                     qmat16[qscale][0][i] = 128 * 256 - 1;
125                 qmat16[qscale][1][i] =
126                     ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
127                                 qmat16[qscale][0][i]);
128             }
129         }
130
131         for (i = intra; i < 64; i++) {
132             int64_t max = 8191;
133             if (dsp->fdct == ff_fdct_ifast) {
134                 max = (8191LL * ff_aanscales[i]) >> 14;
135             }
136             while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
137                 shift++;
138             }
139         }
140     }
141     if (shift) {
142         av_log(NULL, AV_LOG_INFO,
143                "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
144                QMAT_SHIFT - shift);
145     }
146 }
147
148 static inline void update_qscale(MpegEncContext *s)
149 {
150     s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
151                 (FF_LAMBDA_SHIFT + 7);
152     s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
153
154     s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
155                  FF_LAMBDA_SHIFT;
156 }
157
158 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
159 {
160     int i;
161
162     if (matrix) {
163         put_bits(pb, 1, 1);
164         for (i = 0; i < 64; i++) {
165             put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
166         }
167     } else
168         put_bits(pb, 1, 0);
169 }
170
171 /**
172  * init s->current_picture.qscale_table from s->lambda_table
173  */
174 void ff_init_qscale_tab(MpegEncContext *s)
175 {
176     int8_t * const qscale_table = s->current_picture.f.qscale_table;
177     int i;
178
179     for (i = 0; i < s->mb_num; i++) {
180         unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
181         int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
182         qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
183                                                   s->avctx->qmax);
184     }
185 }
186
187 static void copy_picture_attributes(MpegEncContext *s,
188                                     AVFrame *dst,
189                                     AVFrame *src)
190 {
191     int i;
192
193     dst->pict_type              = src->pict_type;
194     dst->quality                = src->quality;
195     dst->coded_picture_number   = src->coded_picture_number;
196     dst->display_picture_number = src->display_picture_number;
197     //dst->reference              = src->reference;
198     dst->pts                    = src->pts;
199     dst->interlaced_frame       = src->interlaced_frame;
200     dst->top_field_first        = src->top_field_first;
201
202     if (s->avctx->me_threshold) {
203         if (!src->motion_val[0])
204             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
205         if (!src->mb_type)
206             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
207         if (!src->ref_index[0])
208             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
209         if (src->motion_subsample_log2 != dst->motion_subsample_log2)
210             av_log(s->avctx, AV_LOG_ERROR,
211                    "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
212                    src->motion_subsample_log2, dst->motion_subsample_log2);
213
214         memcpy(dst->mb_type, src->mb_type,
215                s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
216
217         for (i = 0; i < 2; i++) {
218             int stride = ((16 * s->mb_width ) >>
219                           src->motion_subsample_log2) + 1;
220             int height = ((16 * s->mb_height) >> src->motion_subsample_log2);
221
222             if (src->motion_val[i] &&
223                 src->motion_val[i] != dst->motion_val[i]) {
224                 memcpy(dst->motion_val[i], src->motion_val[i],
225                        2 * stride * height * sizeof(int16_t));
226             }
227             if (src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]) {
228                 memcpy(dst->ref_index[i], src->ref_index[i],
229                        s->mb_stride * 4 * s->mb_height * sizeof(int8_t));
230             }
231         }
232     }
233 }
234
235 static void update_duplicate_context_after_me(MpegEncContext *dst,
236                                               MpegEncContext *src)
237 {
238 #define COPY(a) dst->a= src->a
239     COPY(pict_type);
240     COPY(current_picture);
241     COPY(f_code);
242     COPY(b_code);
243     COPY(qscale);
244     COPY(lambda);
245     COPY(lambda2);
246     COPY(picture_in_gop_number);
247     COPY(gop_picture_number);
248     COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
249     COPY(progressive_frame);    // FIXME don't set in encode_header
250     COPY(partitioned_frame);    // FIXME don't set in encode_header
251 #undef COPY
252 }
253
254 /**
255  * Set the given MpegEncContext to defaults for encoding.
256  * the changed fields will not depend upon the prior state of the MpegEncContext.
257  */
258 static void MPV_encode_defaults(MpegEncContext *s)
259 {
260     int i;
261     ff_MPV_common_defaults(s);
262
263     for (i = -16; i < 16; i++) {
264         default_fcode_tab[i + MAX_MV] = 1;
265     }
266     s->me.mv_penalty = default_mv_penalty;
267     s->fcode_tab     = default_fcode_tab;
268 }
269
270 /* init video encoder */
271 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
272 {
273     MpegEncContext *s = avctx->priv_data;
274     int i;
275     int chroma_h_shift, chroma_v_shift;
276
277     MPV_encode_defaults(s);
278
279     switch (avctx->codec_id) {
280     case AV_CODEC_ID_MPEG2VIDEO:
281         if (avctx->pix_fmt != PIX_FMT_YUV420P &&
282             avctx->pix_fmt != PIX_FMT_YUV422P) {
283             av_log(avctx, AV_LOG_ERROR,
284                    "only YUV420 and YUV422 are supported\n");
285             return -1;
286         }
287         break;
288     case AV_CODEC_ID_LJPEG:
289         if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
290             avctx->pix_fmt != PIX_FMT_YUVJ422P &&
291             avctx->pix_fmt != PIX_FMT_YUVJ444P &&
292             avctx->pix_fmt != PIX_FMT_BGR0     &&
293             avctx->pix_fmt != PIX_FMT_BGRA     &&
294             avctx->pix_fmt != PIX_FMT_BGR24    &&
295             ((avctx->pix_fmt != PIX_FMT_YUV420P &&
296               avctx->pix_fmt != PIX_FMT_YUV422P &&
297               avctx->pix_fmt != PIX_FMT_YUV444P) ||
298              avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
299             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
300             return -1;
301         }
302         break;
303     case AV_CODEC_ID_MJPEG:
304     case AV_CODEC_ID_AMV:
305         if (avctx->pix_fmt != PIX_FMT_YUVJ420P &&
306             avctx->pix_fmt != PIX_FMT_YUVJ422P &&
307             ((avctx->pix_fmt != PIX_FMT_YUV420P &&
308               avctx->pix_fmt != PIX_FMT_YUV422P) ||
309              avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
310             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
311             return -1;
312         }
313         break;
314     default:
315         if (avctx->pix_fmt != PIX_FMT_YUV420P) {
316             av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
317             return -1;
318         }
319     }
320
321     switch (avctx->pix_fmt) {
322     case PIX_FMT_YUVJ422P:
323     case PIX_FMT_YUV422P:
324         s->chroma_format = CHROMA_422;
325         break;
326     case PIX_FMT_YUVJ420P:
327     case PIX_FMT_YUV420P:
328     default:
329         s->chroma_format = CHROMA_420;
330         break;
331     }
332
333     s->bit_rate = avctx->bit_rate;
334     s->width    = avctx->width;
335     s->height   = avctx->height;
336     if (avctx->gop_size > 600 &&
337         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
338         av_log(avctx, AV_LOG_WARNING,
339                "keyframe interval too large!, reducing it from %d to %d\n",
340                avctx->gop_size, 600);
341         avctx->gop_size = 600;
342     }
343     s->gop_size     = avctx->gop_size;
344     s->avctx        = avctx;
345     s->flags        = avctx->flags;
346     s->flags2       = avctx->flags2;
347     s->max_b_frames = avctx->max_b_frames;
348     s->codec_id     = avctx->codec->id;
349 #if FF_API_MPV_GLOBAL_OPTS
350     if (avctx->luma_elim_threshold)
351         s->luma_elim_threshold   = avctx->luma_elim_threshold;
352     if (avctx->chroma_elim_threshold)
353         s->chroma_elim_threshold = avctx->chroma_elim_threshold;
354 #endif
355     s->strict_std_compliance = avctx->strict_std_compliance;
356     s->quarter_sample     = (avctx->flags & CODEC_FLAG_QPEL) != 0;
357     s->mpeg_quant         = avctx->mpeg_quant;
358     s->rtp_mode           = !!avctx->rtp_payload_size;
359     s->intra_dc_precision = avctx->intra_dc_precision;
360     s->user_specified_pts = AV_NOPTS_VALUE;
361
362     if (s->gop_size <= 1) {
363         s->intra_only = 1;
364         s->gop_size   = 12;
365     } else {
366         s->intra_only = 0;
367     }
368
369     s->me_method = avctx->me_method;
370
371     /* Fixed QSCALE */
372     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
373
374 #if FF_API_MPV_GLOBAL_OPTS
375     if (s->flags & CODEC_FLAG_QP_RD)
376         s->mpv_flags |= FF_MPV_FLAG_QP_RD;
377 #endif
378
379     s->adaptive_quant = (s->avctx->lumi_masking ||
380                          s->avctx->dark_masking ||
381                          s->avctx->temporal_cplx_masking ||
382                          s->avctx->spatial_cplx_masking  ||
383                          s->avctx->p_masking      ||
384                          s->avctx->border_masking ||
385                          (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
386                         !s->fixed_qscale;
387
388     s->loop_filter      = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
389
390     if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
391         av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
392         if (avctx->rc_max_rate && !avctx->rc_buffer_size)
393             return -1;
394     }
395
396     if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
397         av_log(avctx, AV_LOG_INFO,
398                "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
399     }
400
401     if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
402         av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
403         return -1;
404     }
405
406     if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
407         av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
408         return -1;
409     }
410
411     if (avctx->rc_max_rate &&
412         avctx->rc_max_rate == avctx->bit_rate &&
413         avctx->rc_max_rate != avctx->rc_min_rate) {
414         av_log(avctx, AV_LOG_INFO,
415                "impossible bitrate constraints, this will fail\n");
416     }
417
418     if (avctx->rc_buffer_size &&
419         avctx->bit_rate * (int64_t)avctx->time_base.num >
420             avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
421         av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
422         return -1;
423     }
424
425     if (!s->fixed_qscale &&
426         avctx->bit_rate * av_q2d(avctx->time_base) >
427             avctx->bit_rate_tolerance) {
428         av_log(avctx, AV_LOG_ERROR,
429                "bitrate tolerance too small for bitrate\n");
430         return -1;
431     }
432
433     if (s->avctx->rc_max_rate &&
434         s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
435         (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
436          s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
437         90000LL * (avctx->rc_buffer_size - 1) >
438             s->avctx->rc_max_rate * 0xFFFFLL) {
439         av_log(avctx, AV_LOG_INFO,
440                "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
441                "specified vbv buffer is too large for the given bitrate!\n");
442     }
443
444     if ((s->flags & CODEC_FLAG_4MV)  && s->codec_id != AV_CODEC_ID_MPEG4 &&
445         s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
446         s->codec_id != AV_CODEC_ID_FLV1) {
447         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
448         return -1;
449     }
450
451     if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
452         av_log(avctx, AV_LOG_ERROR,
453                "OBMC is only supported with simple mb decision\n");
454         return -1;
455     }
456
457     if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
458         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
459         return -1;
460     }
461
462     if (s->max_b_frames                    &&
463         s->codec_id != AV_CODEC_ID_MPEG4      &&
464         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
465         s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
466         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
467         return -1;
468     }
469
470     if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
471          s->codec_id == AV_CODEC_ID_H263  ||
472          s->codec_id == AV_CODEC_ID_H263P) &&
473         (avctx->sample_aspect_ratio.num > 255 ||
474          avctx->sample_aspect_ratio.den > 255)) {
475         av_log(avctx, AV_LOG_WARNING,
476                "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
477                avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
478         av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
479                    avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
480     }
481
482     if ((s->codec_id == AV_CODEC_ID_H263  ||
483          s->codec_id == AV_CODEC_ID_H263P) &&
484         (avctx->width  > 2048 ||
485          avctx->height > 1152 )) {
486         av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
487         return -1;
488     }
489     if ((s->codec_id == AV_CODEC_ID_H263  ||
490          s->codec_id == AV_CODEC_ID_H263P) &&
491         ((avctx->width &3) ||
492          (avctx->height&3) )) {
493         av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
494         return -1;
495     }
496
497     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
498         (avctx->width  > 4095 ||
499          avctx->height > 4095 )) {
500         av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
501         return -1;
502     }
503
504     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
505         (avctx->width  > 16383 ||
506          avctx->height > 16383 )) {
507         av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
508         return -1;
509     }
510
511     if ((s->codec_id == AV_CODEC_ID_WMV1 ||
512          s->codec_id == AV_CODEC_ID_WMV2) &&
513          avctx->width & 1) {
514          av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
515          return -1;
516     }
517
518     if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
519         s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
520         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
521         return -1;
522     }
523
524     // FIXME mpeg2 uses that too
525     if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
526         av_log(avctx, AV_LOG_ERROR,
527                "mpeg2 style quantization not supported by codec\n");
528         return -1;
529     }
530
531 #if FF_API_MPV_GLOBAL_OPTS
532     if (s->flags & CODEC_FLAG_CBP_RD)
533         s->mpv_flags |= FF_MPV_FLAG_CBP_RD;
534 #endif
535
536     if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
537         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
538         return -1;
539     }
540
541     if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
542         s->avctx->mb_decision != FF_MB_DECISION_RD) {
543         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
544         return -1;
545     }
546
547     if (s->avctx->scenechange_threshold < 1000000000 &&
548         (s->flags & CODEC_FLAG_CLOSED_GOP)) {
549         av_log(avctx, AV_LOG_ERROR,
550                "closed gop with scene change detection are not supported yet, "
551                "set threshold to 1000000000\n");
552         return -1;
553     }
554
555     if (s->flags & CODEC_FLAG_LOW_DELAY) {
556         if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
557             av_log(avctx, AV_LOG_ERROR,
558                   "low delay forcing is only available for mpeg2\n");
559             return -1;
560         }
561         if (s->max_b_frames != 0) {
562             av_log(avctx, AV_LOG_ERROR,
563                    "b frames cannot be used with low delay\n");
564             return -1;
565         }
566     }
567
568     if (s->q_scale_type == 1) {
569         if (avctx->qmax > 12) {
570             av_log(avctx, AV_LOG_ERROR,
571                    "non linear quant only supports qmax <= 12 currently\n");
572             return -1;
573         }
574     }
575
576     if (s->avctx->thread_count > 1         &&
577         s->codec_id != AV_CODEC_ID_MPEG4      &&
578         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
579         s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
580         s->codec_id != AV_CODEC_ID_MJPEG      &&
581         (s->codec_id != AV_CODEC_ID_H263P)) {
582         av_log(avctx, AV_LOG_ERROR,
583                "multi threaded encoding not supported by codec\n");
584         return -1;
585     }
586
587     if (s->avctx->thread_count < 1) {
588         av_log(avctx, AV_LOG_ERROR,
589                "automatic thread number detection not supported by codec, "
590                "patch welcome\n");
591         return -1;
592     }
593
594     if (s->avctx->thread_count > 1)
595         s->rtp_mode = 1;
596
597     if (!avctx->time_base.den || !avctx->time_base.num) {
598         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
599         return -1;
600     }
601
602     i = (INT_MAX / 2 + 128) >> 8;
603     if (avctx->me_threshold >= i) {
604         av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n",
605                i - 1);
606         return -1;
607     }
608     if (avctx->mb_threshold >= i) {
609         av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
610                i - 1);
611         return -1;
612     }
613
614     if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
615         av_log(avctx, AV_LOG_INFO,
616                "notice: b_frame_strategy only affects the first pass\n");
617         avctx->b_frame_strategy = 0;
618     }
619
620     i = av_gcd(avctx->time_base.den, avctx->time_base.num);
621     if (i > 1) {
622         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
623         avctx->time_base.den /= i;
624         avctx->time_base.num /= i;
625         //return -1;
626     }
627
628     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
629         // (a + x * 3 / 8) / x
630         s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
631         s->inter_quant_bias = 0;
632     } else {
633         s->intra_quant_bias = 0;
634         // (a - x / 4) / x
635         s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
636     }
637
638     if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
639         s->intra_quant_bias = avctx->intra_quant_bias;
640     if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
641         s->inter_quant_bias = avctx->inter_quant_bias;
642
643     av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
644
645     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
646                                   &chroma_v_shift);
647
648     if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
649         s->avctx->time_base.den > (1 << 16) - 1) {
650         av_log(avctx, AV_LOG_ERROR,
651                "timebase %d/%d not supported by MPEG 4 standard, "
652                "the maximum admitted value for the timebase denominator "
653                "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
654                (1 << 16) - 1);
655         return -1;
656     }
657     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
658
659 #if FF_API_MPV_GLOBAL_OPTS
660     if (avctx->flags2 & CODEC_FLAG2_SKIP_RD)
661         s->mpv_flags |= FF_MPV_FLAG_SKIP_RD;
662     if (avctx->flags2 & CODEC_FLAG2_STRICT_GOP)
663         s->mpv_flags |= FF_MPV_FLAG_STRICT_GOP;
664     if (avctx->quantizer_noise_shaping)
665         s->quantizer_noise_shaping = avctx->quantizer_noise_shaping;
666 #endif
667
668     switch (avctx->codec->id) {
669     case AV_CODEC_ID_MPEG1VIDEO:
670         s->out_format = FMT_MPEG1;
671         s->low_delay  = !!(s->flags & CODEC_FLAG_LOW_DELAY);
672         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
673         break;
674     case AV_CODEC_ID_MPEG2VIDEO:
675         s->out_format = FMT_MPEG1;
676         s->low_delay  = !!(s->flags & CODEC_FLAG_LOW_DELAY);
677         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
678         s->rtp_mode   = 1;
679         break;
680     case AV_CODEC_ID_LJPEG:
681     case AV_CODEC_ID_MJPEG:
682     case AV_CODEC_ID_AMV:
683         s->out_format = FMT_MJPEG;
684         s->intra_only = 1; /* force intra only for jpeg */
685         if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
686             (avctx->pix_fmt == PIX_FMT_BGR0
687              || s->avctx->pix_fmt == PIX_FMT_BGRA
688              || s->avctx->pix_fmt == PIX_FMT_BGR24)) {
689             s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
690             s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
691             s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
692         } else {
693             s->mjpeg_vsample[0] = 2;
694             s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
695             s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
696             s->mjpeg_hsample[0] = 2;
697             s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
698             s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
699         }
700         if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
701             ff_mjpeg_encode_init(s) < 0)
702             return -1;
703         avctx->delay = 0;
704         s->low_delay = 1;
705         break;
706     case AV_CODEC_ID_H261:
707         if (!CONFIG_H261_ENCODER)
708             return -1;
709         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
710             av_log(avctx, AV_LOG_ERROR,
711                    "The specified picture size of %dx%d is not valid for the "
712                    "H.261 codec.\nValid sizes are 176x144, 352x288\n",
713                     s->width, s->height);
714             return -1;
715         }
716         s->out_format = FMT_H261;
717         avctx->delay  = 0;
718         s->low_delay  = 1;
719         break;
720     case AV_CODEC_ID_H263:
721         if (!CONFIG_H263_ENCODER)
722             return -1;
723         if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
724                              s->width, s->height) == 8) {
725             av_log(avctx, AV_LOG_ERROR,
726                    "The specified picture size of %dx%d is not valid for "
727                    "the H.263 codec.\nValid sizes are 128x96, 176x144, "
728                    "352x288, 704x576, and 1408x1152. "
729                    "Try H.263+.\n", s->width, s->height);
730             return -1;
731         }
732         s->out_format = FMT_H263;
733         avctx->delay  = 0;
734         s->low_delay  = 1;
735         break;
736     case AV_CODEC_ID_H263P:
737         s->out_format = FMT_H263;
738         s->h263_plus  = 1;
739         /* Fx */
740         s->h263_aic        = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
741         s->modified_quant  = s->h263_aic;
742         s->loop_filter     = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
743         s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
744
745         /* /Fx */
746         /* These are just to be sure */
747         avctx->delay = 0;
748         s->low_delay = 1;
749         break;
750     case AV_CODEC_ID_FLV1:
751         s->out_format      = FMT_H263;
752         s->h263_flv        = 2; /* format = 1; 11-bit codes */
753         s->unrestricted_mv = 1;
754         s->rtp_mode  = 0; /* don't allow GOB */
755         avctx->delay = 0;
756         s->low_delay = 1;
757         break;
758     case AV_CODEC_ID_RV10:
759         s->out_format = FMT_H263;
760         avctx->delay  = 0;
761         s->low_delay  = 1;
762         break;
763     case AV_CODEC_ID_RV20:
764         s->out_format      = FMT_H263;
765         avctx->delay       = 0;
766         s->low_delay       = 1;
767         s->modified_quant  = 1;
768         s->h263_aic        = 1;
769         s->h263_plus       = 1;
770         s->loop_filter     = 1;
771         s->unrestricted_mv = 0;
772         break;
773     case AV_CODEC_ID_MPEG4:
774         s->out_format      = FMT_H263;
775         s->h263_pred       = 1;
776         s->unrestricted_mv = 1;
777         s->low_delay       = s->max_b_frames ? 0 : 1;
778         avctx->delay       = s->low_delay ? 0 : (s->max_b_frames + 1);
779         break;
780     case AV_CODEC_ID_MSMPEG4V2:
781         s->out_format      = FMT_H263;
782         s->h263_pred       = 1;
783         s->unrestricted_mv = 1;
784         s->msmpeg4_version = 2;
785         avctx->delay       = 0;
786         s->low_delay       = 1;
787         break;
788     case AV_CODEC_ID_MSMPEG4V3:
789         s->out_format        = FMT_H263;
790         s->h263_pred         = 1;
791         s->unrestricted_mv   = 1;
792         s->msmpeg4_version   = 3;
793         s->flipflop_rounding = 1;
794         avctx->delay         = 0;
795         s->low_delay         = 1;
796         break;
797     case AV_CODEC_ID_WMV1:
798         s->out_format        = FMT_H263;
799         s->h263_pred         = 1;
800         s->unrestricted_mv   = 1;
801         s->msmpeg4_version   = 4;
802         s->flipflop_rounding = 1;
803         avctx->delay         = 0;
804         s->low_delay         = 1;
805         break;
806     case AV_CODEC_ID_WMV2:
807         s->out_format        = FMT_H263;
808         s->h263_pred         = 1;
809         s->unrestricted_mv   = 1;
810         s->msmpeg4_version   = 5;
811         s->flipflop_rounding = 1;
812         avctx->delay         = 0;
813         s->low_delay         = 1;
814         break;
815     default:
816         return -1;
817     }
818
819     avctx->has_b_frames = !s->low_delay;
820
821     s->encoding = 1;
822
823     s->progressive_frame    =
824     s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
825                                                 CODEC_FLAG_INTERLACED_ME) ||
826                                 s->alternate_scan);
827
828     /* init */
829     if (ff_MPV_common_init(s) < 0)
830         return -1;
831
832     if (!s->dct_quantize)
833         s->dct_quantize = ff_dct_quantize_c;
834     if (!s->denoise_dct)
835         s->denoise_dct  = denoise_dct_c;
836     s->fast_dct_quantize = s->dct_quantize;
837     if (avctx->trellis)
838         s->dct_quantize  = dct_quantize_trellis_c;
839
840     if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
841         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
842
843     s->quant_precision = 5;
844
845     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
846     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
847
848     if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
849         ff_h261_encode_init(s);
850     if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
851         ff_h263_encode_init(s);
852     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
853         ff_msmpeg4_encode_init(s);
854     if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
855         && s->out_format == FMT_MPEG1)
856         ff_mpeg1_encode_init(s);
857
858     /* init q matrix */
859     for (i = 0; i < 64; i++) {
860         int j = s->dsp.idct_permutation[i];
861         if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
862             s->mpeg_quant) {
863             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
864             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
865         } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
866             s->intra_matrix[j] =
867             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
868         } else {
869             /* mpeg1/2 */
870             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
871             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
872         }
873         if (s->avctx->intra_matrix)
874             s->intra_matrix[j] = s->avctx->intra_matrix[i];
875         if (s->avctx->inter_matrix)
876             s->inter_matrix[j] = s->avctx->inter_matrix[i];
877     }
878
879     /* precompute matrix */
880     /* for mjpeg, we do include qscale in the matrix */
881     if (s->out_format != FMT_MJPEG) {
882         ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
883                           s->intra_matrix, s->intra_quant_bias, avctx->qmin,
884                           31, 1);
885         ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
886                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
887                           31, 0);
888     }
889
890     if (ff_rate_control_init(s) < 0)
891         return -1;
892
893     return 0;
894 }
895
896 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
897 {
898     MpegEncContext *s = avctx->priv_data;
899
900     ff_rate_control_uninit(s);
901
902     ff_MPV_common_end(s);
903     if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
904         s->out_format == FMT_MJPEG)
905         ff_mjpeg_encode_close(s);
906
907     av_freep(&avctx->extradata);
908
909     return 0;
910 }
911
912 static int get_sae(uint8_t *src, int ref, int stride)
913 {
914     int x,y;
915     int acc = 0;
916
917     for (y = 0; y < 16; y++) {
918         for (x = 0; x < 16; x++) {
919             acc += FFABS(src[x + y * stride] - ref);
920         }
921     }
922
923     return acc;
924 }
925
926 static int get_intra_count(MpegEncContext *s, uint8_t *src,
927                            uint8_t *ref, int stride)
928 {
929     int x, y, w, h;
930     int acc = 0;
931
932     w = s->width  & ~15;
933     h = s->height & ~15;
934
935     for (y = 0; y < h; y += 16) {
936         for (x = 0; x < w; x += 16) {
937             int offset = x + y * stride;
938             int sad  = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
939                                      16);
940             int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
941             int sae  = get_sae(src + offset, mean, stride);
942
943             acc += sae + 500 < sad;
944         }
945     }
946     return acc;
947 }
948
949
950 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg)
951 {
952     AVFrame *pic = NULL;
953     int64_t pts;
954     int i;
955     const int encoding_delay = s->max_b_frames ? s->max_b_frames :
956                                                  (s->low_delay ? 0 : 1);
957     int direct = 1;
958
959     if (pic_arg) {
960         pts = pic_arg->pts;
961         pic_arg->display_picture_number = s->input_picture_number++;
962
963         if (pts != AV_NOPTS_VALUE) {
964             if (s->user_specified_pts != AV_NOPTS_VALUE) {
965                 int64_t time = pts;
966                 int64_t last = s->user_specified_pts;
967
968                 if (time <= last) {
969                     av_log(s->avctx, AV_LOG_ERROR,
970                            "Error, Invalid timestamp=%"PRId64", "
971                            "last=%"PRId64"\n", pts, s->user_specified_pts);
972                     return -1;
973                 }
974
975                 if (!s->low_delay && pic_arg->display_picture_number == 1)
976                     s->dts_delta = time - last;
977             }
978             s->user_specified_pts = pts;
979         } else {
980             if (s->user_specified_pts != AV_NOPTS_VALUE) {
981                 s->user_specified_pts =
982                 pts = s->user_specified_pts + 1;
983                 av_log(s->avctx, AV_LOG_INFO,
984                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
985                        pts);
986             } else {
987                 pts = pic_arg->display_picture_number;
988             }
989         }
990     }
991
992   if (pic_arg) {
993     if (encoding_delay && !(s->flags & CODEC_FLAG_INPUT_PRESERVED))
994         direct = 0;
995     if (pic_arg->linesize[0] != s->linesize)
996         direct = 0;
997     if (pic_arg->linesize[1] != s->uvlinesize)
998         direct = 0;
999     if (pic_arg->linesize[2] != s->uvlinesize)
1000         direct = 0;
1001
1002     //av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0],
1003     //       pic_arg->linesize[1], s->linesize, s->uvlinesize);
1004
1005     if (direct) {
1006         i = ff_find_unused_picture(s, 1);
1007         if (i < 0)
1008             return i;
1009
1010         pic = &s->picture[i].f;
1011         pic->reference = 3;
1012
1013         for (i = 0; i < 4; i++) {
1014             pic->data[i]     = pic_arg->data[i];
1015             pic->linesize[i] = pic_arg->linesize[i];
1016         }
1017         if (ff_alloc_picture(s, (Picture *) pic, 1) < 0) {
1018             return -1;
1019         }
1020     } else {
1021         i = ff_find_unused_picture(s, 0);
1022         if (i < 0)
1023             return i;
1024
1025         pic = &s->picture[i].f;
1026         pic->reference = 3;
1027
1028         if (ff_alloc_picture(s, (Picture *) pic, 0) < 0) {
1029             return -1;
1030         }
1031
1032         if (pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1033             pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1034             pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1035             // empty
1036         } else {
1037             int h_chroma_shift, v_chroma_shift;
1038             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift,
1039                                           &v_chroma_shift);
1040
1041             for (i = 0; i < 3; i++) {
1042                 int src_stride = pic_arg->linesize[i];
1043                 int dst_stride = i ? s->uvlinesize : s->linesize;
1044                 int h_shift = i ? h_chroma_shift : 0;
1045                 int v_shift = i ? v_chroma_shift : 0;
1046                 int w = s->width  >> h_shift;
1047                 int h = s->height >> v_shift;
1048                 uint8_t *src = pic_arg->data[i];
1049                 uint8_t *dst = pic->data[i];
1050
1051                 if(s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)){
1052                     h= ((s->height+15)/16*16)>>v_shift;
1053                 }
1054
1055                 if (!s->avctx->rc_buffer_size)
1056                     dst += INPLACE_OFFSET;
1057
1058                 if (src_stride == dst_stride)
1059                     memcpy(dst, src, src_stride * h);
1060                 else {
1061                     while (h--) {
1062                         memcpy(dst, src, w);
1063                         dst += dst_stride;
1064                         src += src_stride;
1065                     }
1066                 }
1067             }
1068         }
1069     }
1070     copy_picture_attributes(s, pic, pic_arg);
1071     pic->pts = pts; // we set this here to avoid modifiying pic_arg
1072   }
1073
1074     /* shift buffer entries */
1075     for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1076         s->input_picture[i - 1] = s->input_picture[i];
1077
1078     s->input_picture[encoding_delay] = (Picture*) pic;
1079
1080     return 0;
1081 }
1082
1083 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1084 {
1085     int x, y, plane;
1086     int score = 0;
1087     int64_t score64 = 0;
1088
1089     for (plane = 0; plane < 3; plane++) {
1090         const int stride = p->f.linesize[plane];
1091         const int bw = plane ? 1 : 2;
1092         for (y = 0; y < s->mb_height * bw; y++) {
1093             for (x = 0; x < s->mb_width * bw; x++) {
1094                 int off = p->f.type == FF_BUFFER_TYPE_SHARED ? 0 : 16;
1095                 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1096                 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1097                 int v   = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1098
1099                 switch (s->avctx->frame_skip_exp) {
1100                 case 0: score    =  FFMAX(score, v);          break;
1101                 case 1: score   += FFABS(v);                  break;
1102                 case 2: score   += v * v;                     break;
1103                 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1104                 case 4: score64 += v * v * (int64_t)(v * v);  break;
1105                 }
1106             }
1107         }
1108     }
1109
1110     if (score)
1111         score64 = score;
1112
1113     if (score64 < s->avctx->frame_skip_threshold)
1114         return 1;
1115     if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1116         return 1;
1117     return 0;
1118 }
1119
1120 static int estimate_best_b_count(MpegEncContext *s)
1121 {
1122     AVCodec *codec    = avcodec_find_encoder(s->avctx->codec_id);
1123     AVCodecContext *c = avcodec_alloc_context3(NULL);
1124     AVFrame input[FF_MAX_B_FRAMES + 2];
1125     const int scale = s->avctx->brd_scale;
1126     int i, j, out_size, p_lambda, b_lambda, lambda2;
1127     int outbuf_size  = s->width * s->height; // FIXME
1128     uint8_t *outbuf  = av_malloc(outbuf_size);
1129     int64_t best_rd  = INT64_MAX;
1130     int best_b_count = -1;
1131
1132     av_assert0(scale >= 0 && scale <= 3);
1133
1134     //emms_c();
1135     //s->next_picture_ptr->quality;
1136     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1137     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1138     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1139     if (!b_lambda) // FIXME we should do this somewhere else
1140         b_lambda = p_lambda;
1141     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1142                FF_LAMBDA_SHIFT;
1143
1144     c->width        = s->width  >> scale;
1145     c->height       = s->height >> scale;
1146     c->flags        = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1147                       CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1148     c->flags       |= s->avctx->flags & CODEC_FLAG_QPEL;
1149     c->mb_decision  = s->avctx->mb_decision;
1150     c->me_cmp       = s->avctx->me_cmp;
1151     c->mb_cmp       = s->avctx->mb_cmp;
1152     c->me_sub_cmp   = s->avctx->me_sub_cmp;
1153     c->pix_fmt      = PIX_FMT_YUV420P;
1154     c->time_base    = s->avctx->time_base;
1155     c->max_b_frames = s->max_b_frames;
1156
1157     if (avcodec_open2(c, codec, NULL) < 0)
1158         return -1;
1159
1160     for (i = 0; i < s->max_b_frames + 2; i++) {
1161         int ysize = c->width * c->height;
1162         int csize = (c->width / 2) * (c->height / 2);
1163         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1164                                                 s->next_picture_ptr;
1165
1166         avcodec_get_frame_defaults(&input[i]);
1167         input[i].data[0]     = av_malloc(ysize + 2 * csize);
1168         input[i].data[1]     = input[i].data[0] + ysize;
1169         input[i].data[2]     = input[i].data[1] + csize;
1170         input[i].linesize[0] = c->width;
1171         input[i].linesize[1] =
1172         input[i].linesize[2] = c->width / 2;
1173
1174         if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1175             pre_input = *pre_input_ptr;
1176
1177             if (pre_input.f.type != FF_BUFFER_TYPE_SHARED && i) {
1178                 pre_input.f.data[0] += INPLACE_OFFSET;
1179                 pre_input.f.data[1] += INPLACE_OFFSET;
1180                 pre_input.f.data[2] += INPLACE_OFFSET;
1181             }
1182
1183             s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1184                                  pre_input.f.data[0], pre_input.f.linesize[0],
1185                                  c->width,      c->height);
1186             s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1187                                  pre_input.f.data[1], pre_input.f.linesize[1],
1188                                  c->width >> 1, c->height >> 1);
1189             s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1190                                  pre_input.f.data[2], pre_input.f.linesize[2],
1191                                  c->width >> 1, c->height >> 1);
1192         }
1193     }
1194
1195     for (j = 0; j < s->max_b_frames + 1; j++) {
1196         int64_t rd = 0;
1197
1198         if (!s->input_picture[j])
1199             break;
1200
1201         c->error[0] = c->error[1] = c->error[2] = 0;
1202
1203         input[0].pict_type = AV_PICTURE_TYPE_I;
1204         input[0].quality   = 1 * FF_QP2LAMBDA;
1205         out_size           = avcodec_encode_video(c, outbuf,
1206                                                   outbuf_size, &input[0]);
1207         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1208
1209         for (i = 0; i < s->max_b_frames + 1; i++) {
1210             int is_p = i % (j + 1) == j || i == s->max_b_frames;
1211
1212             input[i + 1].pict_type = is_p ?
1213                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1214             input[i + 1].quality   = is_p ? p_lambda : b_lambda;
1215             out_size = avcodec_encode_video(c, outbuf, outbuf_size,
1216                                             &input[i + 1]);
1217             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1218         }
1219
1220         /* get the delayed frames */
1221         while (out_size) {
1222             out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
1223             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1224         }
1225
1226         rd += c->error[0] + c->error[1] + c->error[2];
1227
1228         if (rd < best_rd) {
1229             best_rd = rd;
1230             best_b_count = j;
1231         }
1232     }
1233
1234     av_freep(&outbuf);
1235     avcodec_close(c);
1236     av_freep(&c);
1237
1238     for (i = 0; i < s->max_b_frames + 2; i++) {
1239         av_freep(&input[i].data[0]);
1240     }
1241
1242     return best_b_count;
1243 }
1244
1245 static int select_input_picture(MpegEncContext *s)
1246 {
1247     int i;
1248
1249     for (i = 1; i < MAX_PICTURE_COUNT; i++)
1250         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1251     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1252
1253     /* set next picture type & ordering */
1254     if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1255         if (/*s->picture_in_gop_number >= s->gop_size ||*/
1256             s->next_picture_ptr == NULL || s->intra_only) {
1257             s->reordered_input_picture[0] = s->input_picture[0];
1258             s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1259             s->reordered_input_picture[0]->f.coded_picture_number =
1260                 s->coded_picture_number++;
1261         } else {
1262             int b_frames;
1263
1264             if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1265                 if (s->picture_in_gop_number < s->gop_size &&
1266                     skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1267                     // FIXME check that te gop check above is +-1 correct
1268                     //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n",
1269                     //       s->input_picture[0]->f.data[0],
1270                     //       s->input_picture[0]->pts);
1271
1272                     if (s->input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED) {
1273                         for (i = 0; i < 4; i++)
1274                             s->input_picture[0]->f.data[i] = NULL;
1275                         s->input_picture[0]->f.type = 0;
1276                     } else {
1277                         assert(s->input_picture[0]->f.type == FF_BUFFER_TYPE_USER ||
1278                                s->input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL);
1279
1280                         s->avctx->release_buffer(s->avctx,
1281                                                  &s->input_picture[0]->f);
1282                     }
1283
1284                     emms_c();
1285                     ff_vbv_update(s, 0);
1286
1287                     goto no_output_pic;
1288                 }
1289             }
1290
1291             if (s->flags & CODEC_FLAG_PASS2) {
1292                 for (i = 0; i < s->max_b_frames + 1; i++) {
1293                     int pict_num = s->input_picture[0]->f.display_picture_number + i;
1294
1295                     if (pict_num >= s->rc_context.num_entries)
1296                         break;
1297                     if (!s->input_picture[i]) {
1298                         s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1299                         break;
1300                     }
1301
1302                     s->input_picture[i]->f.pict_type =
1303                         s->rc_context.entry[pict_num].new_pict_type;
1304                 }
1305             }
1306
1307             if (s->avctx->b_frame_strategy == 0) {
1308                 b_frames = s->max_b_frames;
1309                 while (b_frames && !s->input_picture[b_frames])
1310                     b_frames--;
1311             } else if (s->avctx->b_frame_strategy == 1) {
1312                 for (i = 1; i < s->max_b_frames + 1; i++) {
1313                     if (s->input_picture[i] &&
1314                         s->input_picture[i]->b_frame_score == 0) {
1315                         s->input_picture[i]->b_frame_score =
1316                             get_intra_count(s,
1317                                             s->input_picture[i    ]->f.data[0],
1318                                             s->input_picture[i - 1]->f.data[0],
1319                                             s->linesize) + 1;
1320                     }
1321                 }
1322                 for (i = 0; i < s->max_b_frames + 1; i++) {
1323                     if (s->input_picture[i] == NULL ||
1324                         s->input_picture[i]->b_frame_score - 1 >
1325                             s->mb_num / s->avctx->b_sensitivity)
1326                         break;
1327                 }
1328
1329                 b_frames = FFMAX(0, i - 1);
1330
1331                 /* reset scores */
1332                 for (i = 0; i < b_frames + 1; i++) {
1333                     s->input_picture[i]->b_frame_score = 0;
1334                 }
1335             } else if (s->avctx->b_frame_strategy == 2) {
1336                 b_frames = estimate_best_b_count(s);
1337             } else {
1338                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1339                 b_frames = 0;
1340             }
1341
1342             emms_c();
1343             //static int b_count = 0;
1344             //b_count += b_frames;
1345             //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1346
1347             for (i = b_frames - 1; i >= 0; i--) {
1348                 int type = s->input_picture[i]->f.pict_type;
1349                 if (type && type != AV_PICTURE_TYPE_B)
1350                     b_frames = i;
1351             }
1352             if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1353                 b_frames == s->max_b_frames) {
1354                 av_log(s->avctx, AV_LOG_ERROR,
1355                        "warning, too many b frames in a row\n");
1356             }
1357
1358             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1359                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1360                     s->gop_size > s->picture_in_gop_number) {
1361                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
1362                 } else {
1363                     if (s->flags & CODEC_FLAG_CLOSED_GOP)
1364                         b_frames = 0;
1365                     s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1366                 }
1367             }
1368
1369             if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1370                 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1371                 b_frames--;
1372
1373             s->reordered_input_picture[0] = s->input_picture[b_frames];
1374             if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1375                 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1376             s->reordered_input_picture[0]->f.coded_picture_number =
1377                 s->coded_picture_number++;
1378             for (i = 0; i < b_frames; i++) {
1379                 s->reordered_input_picture[i + 1] = s->input_picture[i];
1380                 s->reordered_input_picture[i + 1]->f.pict_type =
1381                     AV_PICTURE_TYPE_B;
1382                 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1383                     s->coded_picture_number++;
1384             }
1385         }
1386     }
1387 no_output_pic:
1388     if (s->reordered_input_picture[0]) {
1389         s->reordered_input_picture[0]->f.reference =
1390            s->reordered_input_picture[0]->f.pict_type !=
1391                AV_PICTURE_TYPE_B ? 3 : 0;
1392
1393         ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1394
1395         if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_SHARED ||
1396             s->avctx->rc_buffer_size) {
1397             // input is a shared pix, so we can't modifiy it -> alloc a new
1398             // one & ensure that the shared one is reuseable
1399
1400             Picture *pic;
1401             int i = ff_find_unused_picture(s, 0);
1402             if (i < 0)
1403                 return i;
1404             pic = &s->picture[i];
1405
1406             pic->f.reference = s->reordered_input_picture[0]->f.reference;
1407             if (ff_alloc_picture(s, pic, 0) < 0) {
1408                 return -1;
1409             }
1410
1411             /* mark us unused / free shared pic */
1412             if (s->reordered_input_picture[0]->f.type == FF_BUFFER_TYPE_INTERNAL)
1413                 s->avctx->release_buffer(s->avctx,
1414                                          &s->reordered_input_picture[0]->f);
1415             for (i = 0; i < 4; i++)
1416                 s->reordered_input_picture[0]->f.data[i] = NULL;
1417             s->reordered_input_picture[0]->f.type = 0;
1418
1419             copy_picture_attributes(s, &pic->f,
1420                                     &s->reordered_input_picture[0]->f);
1421
1422             s->current_picture_ptr = pic;
1423         } else {
1424             // input is not a shared pix -> reuse buffer for current_pix
1425
1426             assert(s->reordered_input_picture[0]->f.type ==
1427                        FF_BUFFER_TYPE_USER ||
1428                    s->reordered_input_picture[0]->f.type ==
1429                        FF_BUFFER_TYPE_INTERNAL);
1430
1431             s->current_picture_ptr = s->reordered_input_picture[0];
1432             for (i = 0; i < 4; i++) {
1433                 s->new_picture.f.data[i] += INPLACE_OFFSET;
1434             }
1435         }
1436         ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1437
1438         s->picture_number = s->new_picture.f.display_picture_number;
1439         //printf("dpn:%d\n", s->picture_number);
1440     } else {
1441         memset(&s->new_picture, 0, sizeof(Picture));
1442     }
1443     return 0;
1444 }
1445
1446 int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1447                           AVFrame *pic_arg, int *got_packet)
1448 {
1449     MpegEncContext *s = avctx->priv_data;
1450     int i, stuffing_count, ret;
1451     int context_count = s->slice_context_count;
1452
1453     s->picture_in_gop_number++;
1454
1455     if (load_input_picture(s, pic_arg) < 0)
1456         return -1;
1457
1458     if (select_input_picture(s) < 0) {
1459         return -1;
1460     }
1461
1462     /* output? */
1463     if (s->new_picture.f.data[0]) {
1464         if ((ret = ff_alloc_packet2(avctx, pkt, s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000)) < 0)
1465             return ret;
1466         if (s->mb_info) {
1467             s->mb_info_ptr = av_packet_new_side_data(pkt,
1468                                  AV_PKT_DATA_H263_MB_INFO,
1469                                  s->mb_width*s->mb_height*12);
1470             s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1471         }
1472
1473         for (i = 0; i < context_count; i++) {
1474             int start_y = s->thread_context[i]->start_mb_y;
1475             int   end_y = s->thread_context[i]->  end_mb_y;
1476             int h       = s->mb_height;
1477             uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1478             uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);
1479
1480             init_put_bits(&s->thread_context[i]->pb, start, end - start);
1481         }
1482
1483         s->pict_type = s->new_picture.f.pict_type;
1484         //emms_c();
1485         //printf("qs:%f %f %d\n", s->new_picture.quality,
1486         //       s->current_picture.quality, s->qscale);
1487         ff_MPV_frame_start(s, avctx);
1488 vbv_retry:
1489         if (encode_picture(s, s->picture_number) < 0)
1490             return -1;
1491
1492         avctx->header_bits = s->header_bits;
1493         avctx->mv_bits     = s->mv_bits;
1494         avctx->misc_bits   = s->misc_bits;
1495         avctx->i_tex_bits  = s->i_tex_bits;
1496         avctx->p_tex_bits  = s->p_tex_bits;
1497         avctx->i_count     = s->i_count;
1498         // FIXME f/b_count in avctx
1499         avctx->p_count     = s->mb_num - s->i_count - s->skip_count;
1500         avctx->skip_count  = s->skip_count;
1501
1502         ff_MPV_frame_end(s);
1503
1504         if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1505             ff_mjpeg_encode_picture_trailer(s);
1506
1507         if (avctx->rc_buffer_size) {
1508             RateControlContext *rcc = &s->rc_context;
1509             int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1510
1511             if (put_bits_count(&s->pb) > max_size &&
1512                 s->lambda < s->avctx->lmax) {
1513                 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1514                                        (s->qscale + 1) / s->qscale);
1515                 if (s->adaptive_quant) {
1516                     int i;
1517                     for (i = 0; i < s->mb_height * s->mb_stride; i++)
1518                         s->lambda_table[i] =
1519                             FFMAX(s->lambda_table[i] + 1,
1520                                   s->lambda_table[i] * (s->qscale + 1) /
1521                                   s->qscale);
1522                 }
1523                 s->mb_skipped = 0;        // done in MPV_frame_start()
1524                 // done in encode_picture() so we must undo it
1525                 if (s->pict_type == AV_PICTURE_TYPE_P) {
1526                     if (s->flipflop_rounding          ||
1527                         s->codec_id == AV_CODEC_ID_H263P ||
1528                         s->codec_id == AV_CODEC_ID_MPEG4)
1529                         s->no_rounding ^= 1;
1530                 }
1531                 if (s->pict_type != AV_PICTURE_TYPE_B) {
1532                     s->time_base       = s->last_time_base;
1533                     s->last_non_b_time = s->time - s->pp_time;
1534                 }
1535                 //av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
1536                 for (i = 0; i < context_count; i++) {
1537                     PutBitContext *pb = &s->thread_context[i]->pb;
1538                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1539                 }
1540                 goto vbv_retry;
1541             }
1542
1543             assert(s->avctx->rc_max_rate);
1544         }
1545
1546         if (s->flags & CODEC_FLAG_PASS1)
1547             ff_write_pass1_stats(s);
1548
1549         for (i = 0; i < 4; i++) {
1550             s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
1551             avctx->error[i] += s->current_picture_ptr->f.error[i];
1552         }
1553
1554         if (s->flags & CODEC_FLAG_PASS1)
1555             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1556                    avctx->i_tex_bits + avctx->p_tex_bits ==
1557                        put_bits_count(&s->pb));
1558         flush_put_bits(&s->pb);
1559         s->frame_bits  = put_bits_count(&s->pb);
1560
1561         stuffing_count = ff_vbv_update(s, s->frame_bits);
1562         if (stuffing_count) {
1563             if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1564                     stuffing_count + 50) {
1565                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1566                 return -1;
1567             }
1568
1569             switch (s->codec_id) {
1570             case AV_CODEC_ID_MPEG1VIDEO:
1571             case AV_CODEC_ID_MPEG2VIDEO:
1572                 while (stuffing_count--) {
1573                     put_bits(&s->pb, 8, 0);
1574                 }
1575             break;
1576             case AV_CODEC_ID_MPEG4:
1577                 put_bits(&s->pb, 16, 0);
1578                 put_bits(&s->pb, 16, 0x1C3);
1579                 stuffing_count -= 4;
1580                 while (stuffing_count--) {
1581                     put_bits(&s->pb, 8, 0xFF);
1582                 }
1583             break;
1584             default:
1585                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1586             }
1587             flush_put_bits(&s->pb);
1588             s->frame_bits  = put_bits_count(&s->pb);
1589         }
1590
1591         /* update mpeg1/2 vbv_delay for CBR */
1592         if (s->avctx->rc_max_rate                          &&
1593             s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1594             s->out_format == FMT_MPEG1                     &&
1595             90000LL * (avctx->rc_buffer_size - 1) <=
1596                 s->avctx->rc_max_rate * 0xFFFFLL) {
1597             int vbv_delay, min_delay;
1598             double inbits  = s->avctx->rc_max_rate *
1599                              av_q2d(s->avctx->time_base);
1600             int    minbits = s->frame_bits - 8 *
1601                              (s->vbv_delay_ptr - s->pb.buf - 1);
1602             double bits    = s->rc_context.buffer_index + minbits - inbits;
1603
1604             if (bits < 0)
1605                 av_log(s->avctx, AV_LOG_ERROR,
1606                        "Internal error, negative bits\n");
1607
1608             assert(s->repeat_first_field == 0);
1609
1610             vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1611             min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1612                         s->avctx->rc_max_rate;
1613
1614             vbv_delay = FFMAX(vbv_delay, min_delay);
1615
1616             av_assert0(vbv_delay < 0xFFFF);
1617
1618             s->vbv_delay_ptr[0] &= 0xF8;
1619             s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1620             s->vbv_delay_ptr[1]  = vbv_delay >> 5;
1621             s->vbv_delay_ptr[2] &= 0x07;
1622             s->vbv_delay_ptr[2] |= vbv_delay << 3;
1623             avctx->vbv_delay     = vbv_delay * 300;
1624         }
1625         s->total_bits     += s->frame_bits;
1626         avctx->frame_bits  = s->frame_bits;
1627
1628         pkt->pts = s->current_picture.f.pts;
1629         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1630             if (!s->current_picture.f.coded_picture_number)
1631                 pkt->dts = pkt->pts - s->dts_delta;
1632             else
1633                 pkt->dts = s->reordered_pts;
1634             s->reordered_pts = pkt->pts;
1635         } else
1636             pkt->dts = pkt->pts;
1637         if (s->current_picture.f.key_frame)
1638             pkt->flags |= AV_PKT_FLAG_KEY;
1639         if (s->mb_info)
1640             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1641     } else {
1642         s->frame_bits = 0;
1643     }
1644     assert((s->frame_bits & 7) == 0);
1645
1646     pkt->size = s->frame_bits / 8;
1647     *got_packet = !!pkt->size;
1648     return 0;
1649 }
1650
1651 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1652                                                 int n, int threshold)
1653 {
1654     static const char tab[64] = {
1655         3, 2, 2, 1, 1, 1, 1, 1,
1656         1, 1, 1, 1, 1, 1, 1, 1,
1657         1, 1, 1, 1, 1, 1, 1, 1,
1658         0, 0, 0, 0, 0, 0, 0, 0,
1659         0, 0, 0, 0, 0, 0, 0, 0,
1660         0, 0, 0, 0, 0, 0, 0, 0,
1661         0, 0, 0, 0, 0, 0, 0, 0,
1662         0, 0, 0, 0, 0, 0, 0, 0
1663     };
1664     int score = 0;
1665     int run = 0;
1666     int i;
1667     DCTELEM *block = s->block[n];
1668     const int last_index = s->block_last_index[n];
1669     int skip_dc;
1670
1671     if (threshold < 0) {
1672         skip_dc = 0;
1673         threshold = -threshold;
1674     } else
1675         skip_dc = 1;
1676
1677     /* Are all we could set to zero already zero? */
1678     if (last_index <= skip_dc - 1)
1679         return;
1680
1681     for (i = 0; i <= last_index; i++) {
1682         const int j = s->intra_scantable.permutated[i];
1683         const int level = FFABS(block[j]);
1684         if (level == 1) {
1685             if (skip_dc && i == 0)
1686                 continue;
1687             score += tab[run];
1688             run = 0;
1689         } else if (level > 1) {
1690             return;
1691         } else {
1692             run++;
1693         }
1694     }
1695     if (score >= threshold)
1696         return;
1697     for (i = skip_dc; i <= last_index; i++) {
1698         const int j = s->intra_scantable.permutated[i];
1699         block[j] = 0;
1700     }
1701     if (block[0])
1702         s->block_last_index[n] = 0;
1703     else
1704         s->block_last_index[n] = -1;
1705 }
1706
1707 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block,
1708                                int last_index)
1709 {
1710     int i;
1711     const int maxlevel = s->max_qcoeff;
1712     const int minlevel = s->min_qcoeff;
1713     int overflow = 0;
1714
1715     if (s->mb_intra) {
1716         i = 1; // skip clipping of intra dc
1717     } else
1718         i = 0;
1719
1720     for (; i <= last_index; i++) {
1721         const int j = s->intra_scantable.permutated[i];
1722         int level = block[j];
1723
1724         if (level > maxlevel) {
1725             level = maxlevel;
1726             overflow++;
1727         } else if (level < minlevel) {
1728             level = minlevel;
1729             overflow++;
1730         }
1731
1732         block[j] = level;
1733     }
1734
1735     if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1736         av_log(s->avctx, AV_LOG_INFO,
1737                "warning, clipping %d dct coefficients to %d..%d\n",
1738                overflow, minlevel, maxlevel);
1739 }
1740
1741 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1742 {
1743     int x, y;
1744     // FIXME optimize
1745     for (y = 0; y < 8; y++) {
1746         for (x = 0; x < 8; x++) {
1747             int x2, y2;
1748             int sum = 0;
1749             int sqr = 0;
1750             int count = 0;
1751
1752             for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1753                 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1754                     int v = ptr[x2 + y2 * stride];
1755                     sum += v;
1756                     sqr += v * v;
1757                     count++;
1758                 }
1759             }
1760             weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1761         }
1762     }
1763 }
1764
1765 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1766                                                 int motion_x, int motion_y,
1767                                                 int mb_block_height,
1768                                                 int mb_block_count)
1769 {
1770     int16_t weight[8][64];
1771     DCTELEM orig[8][64];
1772     const int mb_x = s->mb_x;
1773     const int mb_y = s->mb_y;
1774     int i;
1775     int skip_dct[8];
1776     int dct_offset = s->linesize * 8; // default for progressive frames
1777     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1778     int wrap_y, wrap_c;
1779
1780     for (i = 0; i < mb_block_count; i++)
1781         skip_dct[i] = s->skipdct;
1782
1783     if (s->adaptive_quant) {
1784         const int last_qp = s->qscale;
1785         const int mb_xy = mb_x + mb_y * s->mb_stride;
1786
1787         s->lambda = s->lambda_table[mb_xy];
1788         update_qscale(s);
1789
1790         if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1791             s->qscale = s->current_picture_ptr->f.qscale_table[mb_xy];
1792             s->dquant = s->qscale - last_qp;
1793
1794             if (s->out_format == FMT_H263) {
1795                 s->dquant = av_clip(s->dquant, -2, 2);
1796
1797                 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1798                     if (!s->mb_intra) {
1799                         if (s->pict_type == AV_PICTURE_TYPE_B) {
1800                             if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1801                                 s->dquant = 0;
1802                         }
1803                         if (s->mv_type == MV_TYPE_8X8)
1804                             s->dquant = 0;
1805                     }
1806                 }
1807             }
1808         }
1809         ff_set_qscale(s, last_qp + s->dquant);
1810     } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1811         ff_set_qscale(s, s->qscale + s->dquant);
1812
1813     wrap_y = s->linesize;
1814     wrap_c = s->uvlinesize;
1815     ptr_y  = s->new_picture.f.data[0] +
1816              (mb_y * 16 * wrap_y)              + mb_x * 16;
1817     ptr_cb = s->new_picture.f.data[1] +
1818              (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1819     ptr_cr = s->new_picture.f.data[2] +
1820              (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1821
1822     if((mb_x*16+16 > s->width || mb_y*16+16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
1823         uint8_t *ebuf = s->edge_emu_buffer + 32;
1824         s->dsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,
1825                                 mb_y * 16, s->width, s->height);
1826         ptr_y = ebuf;
1827         s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, 8,
1828                                 mb_block_height, mb_x * 8, mb_y * 8,
1829                                 (s->width+1) >> 1, (s->height+1) >> 1);
1830         ptr_cb = ebuf + 18 * wrap_y;
1831         s->dsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr, wrap_c, 8,
1832                                 mb_block_height, mb_x * 8, mb_y * 8,
1833                                 (s->width+1) >> 1, (s->height+1) >> 1);
1834         ptr_cr = ebuf + 18 * wrap_y + 8;
1835     }
1836
1837     if (s->mb_intra) {
1838         if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1839             int progressive_score, interlaced_score;
1840
1841             s->interlaced_dct = 0;
1842             progressive_score = s->dsp.ildct_cmp[4](s, ptr_y,
1843                                                     NULL, wrap_y, 8) +
1844                                 s->dsp.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1845                                                     NULL, wrap_y, 8) - 400;
1846
1847             if (progressive_score > 0) {
1848                 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y,
1849                                                        NULL, wrap_y * 2, 8) +
1850                                    s->dsp.ildct_cmp[4](s, ptr_y + wrap_y,
1851                                                        NULL, wrap_y * 2, 8);
1852                 if (progressive_score > interlaced_score) {
1853                     s->interlaced_dct = 1;
1854
1855                     dct_offset = wrap_y;
1856                     wrap_y <<= 1;
1857                     if (s->chroma_format == CHROMA_422)
1858                         wrap_c <<= 1;
1859                 }
1860             }
1861         }
1862
1863         s->dsp.get_pixels(s->block[0], ptr_y                  , wrap_y);
1864         s->dsp.get_pixels(s->block[1], ptr_y              + 8 , wrap_y);
1865         s->dsp.get_pixels(s->block[2], ptr_y + dct_offset     , wrap_y);
1866         s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8 , wrap_y);
1867
1868         if (s->flags & CODEC_FLAG_GRAY) {
1869             skip_dct[4] = 1;
1870             skip_dct[5] = 1;
1871         } else {
1872             s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1873             s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
1874             if (!s->chroma_y_shift) { /* 422 */
1875                 s->dsp.get_pixels(s->block[6],
1876                                   ptr_cb + (dct_offset >> 1), wrap_c);
1877                 s->dsp.get_pixels(s->block[7],
1878                                   ptr_cr + (dct_offset >> 1), wrap_c);
1879             }
1880         }
1881     } else {
1882         op_pixels_func (*op_pix)[4];
1883         qpel_mc_func (*op_qpix)[16];
1884         uint8_t *dest_y, *dest_cb, *dest_cr;
1885
1886         dest_y  = s->dest[0];
1887         dest_cb = s->dest[1];
1888         dest_cr = s->dest[2];
1889
1890         if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
1891             op_pix  = s->dsp.put_pixels_tab;
1892             op_qpix = s->dsp.put_qpel_pixels_tab;
1893         } else {
1894             op_pix  = s->dsp.put_no_rnd_pixels_tab;
1895             op_qpix = s->dsp.put_no_rnd_qpel_pixels_tab;
1896         }
1897
1898         if (s->mv_dir & MV_DIR_FORWARD) {
1899             ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0,
1900                           s->last_picture.f.data,
1901                           op_pix, op_qpix);
1902             op_pix  = s->dsp.avg_pixels_tab;
1903             op_qpix = s->dsp.avg_qpel_pixels_tab;
1904         }
1905         if (s->mv_dir & MV_DIR_BACKWARD) {
1906             ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1,
1907                           s->next_picture.f.data,
1908                           op_pix, op_qpix);
1909         }
1910
1911         if (s->flags & CODEC_FLAG_INTERLACED_DCT) {
1912             int progressive_score, interlaced_score;
1913
1914             s->interlaced_dct = 0;
1915             progressive_score = s->dsp.ildct_cmp[0](s, dest_y,
1916                                                     ptr_y,              wrap_y,
1917                                                     8) +
1918                                 s->dsp.ildct_cmp[0](s, dest_y + wrap_y * 8,
1919                                                     ptr_y + wrap_y * 8, wrap_y,
1920                                                     8) - 400;
1921
1922             if (s->avctx->ildct_cmp == FF_CMP_VSSE)
1923                 progressive_score -= 400;
1924
1925             if (progressive_score > 0) {
1926                 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y,
1927                                                        ptr_y,
1928                                                        wrap_y * 2, 8) +
1929                                    s->dsp.ildct_cmp[0](s, dest_y + wrap_y,
1930                                                        ptr_y + wrap_y,
1931                                                        wrap_y * 2, 8);
1932
1933                 if (progressive_score > interlaced_score) {
1934                     s->interlaced_dct = 1;
1935
1936                     dct_offset = wrap_y;
1937                     wrap_y <<= 1;
1938                     if (s->chroma_format == CHROMA_422)
1939                         wrap_c <<= 1;
1940                 }
1941             }
1942         }
1943
1944         s->dsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
1945         s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
1946         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset,
1947                            dest_y + dct_offset, wrap_y);
1948         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
1949                            dest_y + dct_offset + 8, wrap_y);
1950
1951         if (s->flags & CODEC_FLAG_GRAY) {
1952             skip_dct[4] = 1;
1953             skip_dct[5] = 1;
1954         } else {
1955             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
1956             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
1957             if (!s->chroma_y_shift) { /* 422 */
1958                 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
1959                                    dest_cb + (dct_offset >> 1), wrap_c);
1960                 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
1961                                    dest_cr + (dct_offset >> 1), wrap_c);
1962             }
1963         }
1964         /* pre quantization */
1965         if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
1966                 2 * s->qscale * s->qscale) {
1967             // FIXME optimize
1968             if (s->dsp.sad[1](NULL, ptr_y , dest_y,
1969                               wrap_y, 8) < 20 * s->qscale)
1970                 skip_dct[0] = 1;
1971             if (s->dsp.sad[1](NULL, ptr_y + 8,
1972                               dest_y + 8, wrap_y, 8) < 20 * s->qscale)
1973                 skip_dct[1] = 1;
1974             if (s->dsp.sad[1](NULL, ptr_y + dct_offset,
1975                               dest_y + dct_offset, wrap_y, 8) < 20 * s->qscale)
1976                 skip_dct[2] = 1;
1977             if (s->dsp.sad[1](NULL, ptr_y + dct_offset + 8,
1978                               dest_y + dct_offset + 8,
1979                               wrap_y, 8) < 20 * s->qscale)
1980                 skip_dct[3] = 1;
1981             if (s->dsp.sad[1](NULL, ptr_cb, dest_cb,
1982                               wrap_c, 8) < 20 * s->qscale)
1983                 skip_dct[4] = 1;
1984             if (s->dsp.sad[1](NULL, ptr_cr, dest_cr,
1985                               wrap_c, 8) < 20 * s->qscale)
1986                 skip_dct[5] = 1;
1987             if (!s->chroma_y_shift) { /* 422 */
1988                 if (s->dsp.sad[1](NULL, ptr_cb + (dct_offset >> 1),
1989                                   dest_cb + (dct_offset >> 1),
1990                                   wrap_c, 8) < 20 * s->qscale)
1991                     skip_dct[6] = 1;
1992                 if (s->dsp.sad[1](NULL, ptr_cr + (dct_offset >> 1),
1993                                   dest_cr + (dct_offset >> 1),
1994                                   wrap_c, 8) < 20 * s->qscale)
1995                     skip_dct[7] = 1;
1996             }
1997         }
1998     }
1999
2000     if (s->quantizer_noise_shaping) {
2001         if (!skip_dct[0])
2002             get_visual_weight(weight[0], ptr_y                 , wrap_y);
2003         if (!skip_dct[1])
2004             get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
2005         if (!skip_dct[2])
2006             get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
2007         if (!skip_dct[3])
2008             get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2009         if (!skip_dct[4])
2010             get_visual_weight(weight[4], ptr_cb                , wrap_c);
2011         if (!skip_dct[5])
2012             get_visual_weight(weight[5], ptr_cr                , wrap_c);
2013         if (!s->chroma_y_shift) { /* 422 */
2014             if (!skip_dct[6])
2015                 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2016                                   wrap_c);
2017             if (!skip_dct[7])
2018                 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2019                                   wrap_c);
2020         }
2021         memcpy(orig[0], s->block[0], sizeof(DCTELEM) * 64 * mb_block_count);
2022     }
2023
2024     /* DCT & quantize */
2025     av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2026     {
2027         for (i = 0; i < mb_block_count; i++) {
2028             if (!skip_dct[i]) {
2029                 int overflow;
2030                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2031                 // FIXME we could decide to change to quantizer instead of
2032                 // clipping
2033                 // JS: I don't think that would be a good idea it could lower
2034                 //     quality instead of improve it. Just INTRADC clipping
2035                 //     deserves changes in quantizer
2036                 if (overflow)
2037                     clip_coeffs(s, s->block[i], s->block_last_index[i]);
2038             } else
2039                 s->block_last_index[i] = -1;
2040         }
2041         if (s->quantizer_noise_shaping) {
2042             for (i = 0; i < mb_block_count; i++) {
2043                 if (!skip_dct[i]) {
2044                     s->block_last_index[i] =
2045                         dct_quantize_refine(s, s->block[i], weight[i],
2046                                             orig[i], i, s->qscale);
2047                 }
2048             }
2049         }
2050
2051         if (s->luma_elim_threshold && !s->mb_intra)
2052             for (i = 0; i < 4; i++)
2053                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2054         if (s->chroma_elim_threshold && !s->mb_intra)
2055             for (i = 4; i < mb_block_count; i++)
2056                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2057
2058         if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2059             for (i = 0; i < mb_block_count; i++) {
2060                 if (s->block_last_index[i] == -1)
2061                     s->coded_score[i] = INT_MAX / 256;
2062             }
2063         }
2064     }
2065
2066     if ((s->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2067         s->block_last_index[4] =
2068         s->block_last_index[5] = 0;
2069         s->block[4][0] =
2070         s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2071     }
2072
2073     // non c quantize code returns incorrect block_last_index FIXME
2074     if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2075         for (i = 0; i < mb_block_count; i++) {
2076             int j;
2077             if (s->block_last_index[i] > 0) {
2078                 for (j = 63; j > 0; j--) {
2079                     if (s->block[i][s->intra_scantable.permutated[j]])
2080                         break;
2081                 }
2082                 s->block_last_index[i] = j;
2083             }
2084         }
2085     }
2086
2087     /* huffman encode */
2088     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2089     case AV_CODEC_ID_MPEG1VIDEO:
2090     case AV_CODEC_ID_MPEG2VIDEO:
2091         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2092             ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2093         break;
2094     case AV_CODEC_ID_MPEG4:
2095         if (CONFIG_MPEG4_ENCODER)
2096             ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2097         break;
2098     case AV_CODEC_ID_MSMPEG4V2:
2099     case AV_CODEC_ID_MSMPEG4V3:
2100     case AV_CODEC_ID_WMV1:
2101         if (CONFIG_MSMPEG4_ENCODER)
2102             ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2103         break;
2104     case AV_CODEC_ID_WMV2:
2105         if (CONFIG_WMV2_ENCODER)
2106             ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2107         break;
2108     case AV_CODEC_ID_H261:
2109         if (CONFIG_H261_ENCODER)
2110             ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2111         break;
2112     case AV_CODEC_ID_H263:
2113     case AV_CODEC_ID_H263P:
2114     case AV_CODEC_ID_FLV1:
2115     case AV_CODEC_ID_RV10:
2116     case AV_CODEC_ID_RV20:
2117         if (CONFIG_H263_ENCODER)
2118             ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2119         break;
2120     case AV_CODEC_ID_MJPEG:
2121     case AV_CODEC_ID_AMV:
2122         if (CONFIG_MJPEG_ENCODER)
2123             ff_mjpeg_encode_mb(s, s->block);
2124         break;
2125     default:
2126         av_assert1(0);
2127     }
2128 }
2129
2130 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2131 {
2132     if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
2133     else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
2134 }
2135
2136 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2137     int i;
2138
2139     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2140
2141     /* mpeg1 */
2142     d->mb_skip_run= s->mb_skip_run;
2143     for(i=0; i<3; i++)
2144         d->last_dc[i] = s->last_dc[i];
2145
2146     /* statistics */
2147     d->mv_bits= s->mv_bits;
2148     d->i_tex_bits= s->i_tex_bits;
2149     d->p_tex_bits= s->p_tex_bits;
2150     d->i_count= s->i_count;
2151     d->f_count= s->f_count;
2152     d->b_count= s->b_count;
2153     d->skip_count= s->skip_count;
2154     d->misc_bits= s->misc_bits;
2155     d->last_bits= 0;
2156
2157     d->mb_skipped= 0;
2158     d->qscale= s->qscale;
2159     d->dquant= s->dquant;
2160
2161     d->esc3_level_length= s->esc3_level_length;
2162 }
2163
2164 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2165     int i;
2166
2167     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2168     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2169
2170     /* mpeg1 */
2171     d->mb_skip_run= s->mb_skip_run;
2172     for(i=0; i<3; i++)
2173         d->last_dc[i] = s->last_dc[i];
2174
2175     /* statistics */
2176     d->mv_bits= s->mv_bits;
2177     d->i_tex_bits= s->i_tex_bits;
2178     d->p_tex_bits= s->p_tex_bits;
2179     d->i_count= s->i_count;
2180     d->f_count= s->f_count;
2181     d->b_count= s->b_count;
2182     d->skip_count= s->skip_count;
2183     d->misc_bits= s->misc_bits;
2184
2185     d->mb_intra= s->mb_intra;
2186     d->mb_skipped= s->mb_skipped;
2187     d->mv_type= s->mv_type;
2188     d->mv_dir= s->mv_dir;
2189     d->pb= s->pb;
2190     if(s->data_partitioning){
2191         d->pb2= s->pb2;
2192         d->tex_pb= s->tex_pb;
2193     }
2194     d->block= s->block;
2195     for(i=0; i<8; i++)
2196         d->block_last_index[i]= s->block_last_index[i];
2197     d->interlaced_dct= s->interlaced_dct;
2198     d->qscale= s->qscale;
2199
2200     d->esc3_level_length= s->esc3_level_length;
2201 }
2202
2203 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2204                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2205                            int *dmin, int *next_block, int motion_x, int motion_y)
2206 {
2207     int score;
2208     uint8_t *dest_backup[3];
2209
2210     copy_context_before_encode(s, backup, type);
2211
2212     s->block= s->blocks[*next_block];
2213     s->pb= pb[*next_block];
2214     if(s->data_partitioning){
2215         s->pb2   = pb2   [*next_block];
2216         s->tex_pb= tex_pb[*next_block];
2217     }
2218
2219     if(*next_block){
2220         memcpy(dest_backup, s->dest, sizeof(s->dest));
2221         s->dest[0] = s->rd_scratchpad;
2222         s->dest[1] = s->rd_scratchpad + 16*s->linesize;
2223         s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
2224         assert(s->linesize >= 32); //FIXME
2225     }
2226
2227     encode_mb(s, motion_x, motion_y);
2228
2229     score= put_bits_count(&s->pb);
2230     if(s->data_partitioning){
2231         score+= put_bits_count(&s->pb2);
2232         score+= put_bits_count(&s->tex_pb);
2233     }
2234
2235     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2236         ff_MPV_decode_mb(s, s->block);
2237
2238         score *= s->lambda2;
2239         score += sse_mb(s) << FF_LAMBDA_SHIFT;
2240     }
2241
2242     if(*next_block){
2243         memcpy(s->dest, dest_backup, sizeof(s->dest));
2244     }
2245
2246     if(score<*dmin){
2247         *dmin= score;
2248         *next_block^=1;
2249
2250         copy_context_after_encode(best, s, type);
2251     }
2252 }
2253
2254 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2255     uint32_t *sq = ff_squareTbl + 256;
2256     int acc=0;
2257     int x,y;
2258
2259     if(w==16 && h==16)
2260         return s->dsp.sse[0](NULL, src1, src2, stride, 16);
2261     else if(w==8 && h==8)
2262         return s->dsp.sse[1](NULL, src1, src2, stride, 8);
2263
2264     for(y=0; y<h; y++){
2265         for(x=0; x<w; x++){
2266             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2267         }
2268     }
2269
2270     av_assert2(acc>=0);
2271
2272     return acc;
2273 }
2274
2275 static int sse_mb(MpegEncContext *s){
2276     int w= 16;
2277     int h= 16;
2278
2279     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2280     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2281
2282     if(w==16 && h==16)
2283       if(s->avctx->mb_cmp == FF_CMP_NSSE){
2284         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)
2285                +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)
2286                +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);
2287       }else{
2288         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)
2289                +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)
2290                +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);
2291       }
2292     else
2293         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)
2294                +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)
2295                +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);
2296 }
2297
2298 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2299     MpegEncContext *s= *(void**)arg;
2300
2301
2302     s->me.pre_pass=1;
2303     s->me.dia_size= s->avctx->pre_dia_size;
2304     s->first_slice_line=1;
2305     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2306         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2307             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2308         }
2309         s->first_slice_line=0;
2310     }
2311
2312     s->me.pre_pass=0;
2313
2314     return 0;
2315 }
2316
2317 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2318     MpegEncContext *s= *(void**)arg;
2319
2320     ff_check_alignment();
2321
2322     s->me.dia_size= s->avctx->dia_size;
2323     s->first_slice_line=1;
2324     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2325         s->mb_x=0; //for block init below
2326         ff_init_block_index(s);
2327         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2328             s->block_index[0]+=2;
2329             s->block_index[1]+=2;
2330             s->block_index[2]+=2;
2331             s->block_index[3]+=2;
2332
2333             /* compute motion vector & mb_type and store in context */
2334             if(s->pict_type==AV_PICTURE_TYPE_B)
2335                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2336             else
2337                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2338         }
2339         s->first_slice_line=0;
2340     }
2341     return 0;
2342 }
2343
2344 static int mb_var_thread(AVCodecContext *c, void *arg){
2345     MpegEncContext *s= *(void**)arg;
2346     int mb_x, mb_y;
2347
2348     ff_check_alignment();
2349
2350     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2351         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2352             int xx = mb_x * 16;
2353             int yy = mb_y * 16;
2354             uint8_t *pix = s->new_picture.f.data[0] + (yy * s->linesize) + xx;
2355             int varc;
2356             int sum = s->dsp.pix_sum(pix, s->linesize);
2357
2358             varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)sum*sum)>>8) + 500 + 128)>>8;
2359
2360             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2361             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2362             s->me.mb_var_sum_temp    += varc;
2363         }
2364     }
2365     return 0;
2366 }
2367
2368 static void write_slice_end(MpegEncContext *s){
2369     if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2370         if(s->partitioned_frame){
2371             ff_mpeg4_merge_partitions(s);
2372         }
2373
2374         ff_mpeg4_stuffing(&s->pb);
2375     }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2376         ff_mjpeg_encode_stuffing(s);
2377     }
2378
2379     avpriv_align_put_bits(&s->pb);
2380     flush_put_bits(&s->pb);
2381
2382     if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
2383         s->misc_bits+= get_bits_diff(s);
2384 }
2385
2386 static void write_mb_info(MpegEncContext *s)
2387 {
2388     uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2389     int offset = put_bits_count(&s->pb);
2390     int mba  = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2391     int gobn = s->mb_y / s->gob_index;
2392     int pred_x, pred_y;
2393     if (CONFIG_H263_ENCODER)
2394         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2395     bytestream_put_le32(&ptr, offset);
2396     bytestream_put_byte(&ptr, s->qscale);
2397     bytestream_put_byte(&ptr, gobn);
2398     bytestream_put_le16(&ptr, mba);
2399     bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2400     bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2401     /* 4MV not implemented */
2402     bytestream_put_byte(&ptr, 0); /* hmv2 */
2403     bytestream_put_byte(&ptr, 0); /* vmv2 */
2404 }
2405
2406 static void update_mb_info(MpegEncContext *s, int startcode)
2407 {
2408     if (!s->mb_info)
2409         return;
2410     if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2411         s->mb_info_size += 12;
2412         s->prev_mb_info = s->last_mb_info;
2413     }
2414     if (startcode) {
2415         s->prev_mb_info = put_bits_count(&s->pb)/8;
2416         /* This might have incremented mb_info_size above, and we return without
2417          * actually writing any info into that slot yet. But in that case,
2418          * this will be called again at the start of the after writing the
2419          * start code, actually writing the mb info. */
2420         return;
2421     }
2422
2423     s->last_mb_info = put_bits_count(&s->pb)/8;
2424     if (!s->mb_info_size)
2425         s->mb_info_size += 12;
2426     write_mb_info(s);
2427 }
2428
2429 static int encode_thread(AVCodecContext *c, void *arg){
2430     MpegEncContext *s= *(void**)arg;
2431     int mb_x, mb_y, pdif = 0;
2432     int chr_h= 16>>s->chroma_y_shift;
2433     int i, j;
2434     MpegEncContext best_s, backup_s;
2435     uint8_t bit_buf[2][MAX_MB_BYTES];
2436     uint8_t bit_buf2[2][MAX_MB_BYTES];
2437     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2438     PutBitContext pb[2], pb2[2], tex_pb[2];
2439 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
2440
2441     ff_check_alignment();
2442
2443     for(i=0; i<2; i++){
2444         init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
2445         init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
2446         init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2447     }
2448
2449     s->last_bits= put_bits_count(&s->pb);
2450     s->mv_bits=0;
2451     s->misc_bits=0;
2452     s->i_tex_bits=0;
2453     s->p_tex_bits=0;
2454     s->i_count=0;
2455     s->f_count=0;
2456     s->b_count=0;
2457     s->skip_count=0;
2458
2459     for(i=0; i<3; i++){
2460         /* init last dc values */
2461         /* note: quant matrix value (8) is implied here */
2462         s->last_dc[i] = 128 << s->intra_dc_precision;
2463
2464         s->current_picture.f.error[i] = 0;
2465     }
2466     if(s->codec_id==AV_CODEC_ID_AMV){
2467         s->last_dc[0] = 128*8/13;
2468         s->last_dc[1] = 128*8/14;
2469         s->last_dc[2] = 128*8/14;
2470     }
2471     s->mb_skip_run = 0;
2472     memset(s->last_mv, 0, sizeof(s->last_mv));
2473
2474     s->last_mv_dir = 0;
2475
2476     switch(s->codec_id){
2477     case AV_CODEC_ID_H263:
2478     case AV_CODEC_ID_H263P:
2479     case AV_CODEC_ID_FLV1:
2480         if (CONFIG_H263_ENCODER)
2481             s->gob_index = ff_h263_get_gob_height(s);
2482         break;
2483     case AV_CODEC_ID_MPEG4:
2484         if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2485             ff_mpeg4_init_partitions(s);
2486         break;
2487     }
2488
2489     s->resync_mb_x=0;
2490     s->resync_mb_y=0;
2491     s->first_slice_line = 1;
2492     s->ptr_lastgob = s->pb.buf;
2493     for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2494 //    printf("row %d at %X\n", s->mb_y, (int)s);
2495         s->mb_x=0;
2496         s->mb_y= mb_y;
2497
2498         ff_set_qscale(s, s->qscale);
2499         ff_init_block_index(s);
2500
2501         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2502             int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2503             int mb_type= s->mb_type[xy];
2504 //            int d;
2505             int dmin= INT_MAX;
2506             int dir;
2507
2508             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2509                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2510                 return -1;
2511             }
2512             if(s->data_partitioning){
2513                 if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
2514                    || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2515                     av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2516                     return -1;
2517                 }
2518             }
2519
2520             s->mb_x = mb_x;
2521             s->mb_y = mb_y;  // moved into loop, can get changed by H.261
2522             ff_update_block_index(s);
2523
2524             if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2525                 ff_h261_reorder_mb_index(s);
2526                 xy= s->mb_y*s->mb_stride + s->mb_x;
2527                 mb_type= s->mb_type[xy];
2528             }
2529
2530             /* write gob / video packet header  */
2531             if(s->rtp_mode){
2532                 int current_packet_size, is_gob_start;
2533
2534                 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2535
2536                 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2537
2538                 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2539
2540                 switch(s->codec_id){
2541                 case AV_CODEC_ID_H263:
2542                 case AV_CODEC_ID_H263P:
2543                     if(!s->h263_slice_structured)
2544                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2545                     break;
2546                 case AV_CODEC_ID_MPEG2VIDEO:
2547                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2548                 case AV_CODEC_ID_MPEG1VIDEO:
2549                     if(s->mb_skip_run) is_gob_start=0;
2550                     break;
2551                 case AV_CODEC_ID_MJPEG:
2552                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2553                     break;
2554                 }
2555
2556                 if(is_gob_start){
2557                     if(s->start_mb_y != mb_y || mb_x!=0){
2558                         write_slice_end(s);
2559                         if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2560                             ff_mpeg4_init_partitions(s);
2561                         }
2562                     }
2563
2564                     av_assert2((put_bits_count(&s->pb)&7) == 0);
2565                     current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2566
2567                     if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2568                         int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2569                         int d= 100 / s->avctx->error_rate;
2570                         if(r % d == 0){
2571                             current_packet_size=0;
2572                             s->pb.buf_ptr= s->ptr_lastgob;
2573                             assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2574                         }
2575                     }
2576
2577                     if (s->avctx->rtp_callback){
2578                         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2579                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2580                     }
2581                     update_mb_info(s, 1);
2582
2583                     switch(s->codec_id){
2584                     case AV_CODEC_ID_MPEG4:
2585                         if (CONFIG_MPEG4_ENCODER) {
2586                             ff_mpeg4_encode_video_packet_header(s);
2587                             ff_mpeg4_clean_buffers(s);
2588                         }
2589                     break;
2590                     case AV_CODEC_ID_MPEG1VIDEO:
2591                     case AV_CODEC_ID_MPEG2VIDEO:
2592                         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2593                             ff_mpeg1_encode_slice_header(s);
2594                             ff_mpeg1_clean_buffers(s);
2595                         }
2596                     break;
2597                     case AV_CODEC_ID_H263:
2598                     case AV_CODEC_ID_H263P:
2599                         if (CONFIG_H263_ENCODER)
2600                             ff_h263_encode_gob_header(s, mb_y);
2601                     break;
2602                     }
2603
2604                     if(s->flags&CODEC_FLAG_PASS1){
2605                         int bits= put_bits_count(&s->pb);
2606                         s->misc_bits+= bits - s->last_bits;
2607                         s->last_bits= bits;
2608                     }
2609
2610                     s->ptr_lastgob += current_packet_size;
2611                     s->first_slice_line=1;
2612                     s->resync_mb_x=mb_x;
2613                     s->resync_mb_y=mb_y;
2614                 }
2615             }
2616
2617             if(  (s->resync_mb_x   == s->mb_x)
2618                && s->resync_mb_y+1 == s->mb_y){
2619                 s->first_slice_line=0;
2620             }
2621
2622             s->mb_skipped=0;
2623             s->dquant=0; //only for QP_RD
2624
2625             update_mb_info(s, 0);
2626
2627             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
2628                 int next_block=0;
2629                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2630
2631                 copy_context_before_encode(&backup_s, s, -1);
2632                 backup_s.pb= s->pb;
2633                 best_s.data_partitioning= s->data_partitioning;
2634                 best_s.partitioned_frame= s->partitioned_frame;
2635                 if(s->data_partitioning){
2636                     backup_s.pb2= s->pb2;
2637                     backup_s.tex_pb= s->tex_pb;
2638                 }
2639
2640                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2641                     s->mv_dir = MV_DIR_FORWARD;
2642                     s->mv_type = MV_TYPE_16X16;
2643                     s->mb_intra= 0;
2644                     s->mv[0][0][0] = s->p_mv_table[xy][0];
2645                     s->mv[0][0][1] = s->p_mv_table[xy][1];
2646                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2647                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2648                 }
2649                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2650                     s->mv_dir = MV_DIR_FORWARD;
2651                     s->mv_type = MV_TYPE_FIELD;
2652                     s->mb_intra= 0;
2653                     for(i=0; i<2; i++){
2654                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2655                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2656                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2657                     }
2658                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2659                                  &dmin, &next_block, 0, 0);
2660                 }
2661                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2662                     s->mv_dir = MV_DIR_FORWARD;
2663                     s->mv_type = MV_TYPE_16X16;
2664                     s->mb_intra= 0;
2665                     s->mv[0][0][0] = 0;
2666                     s->mv[0][0][1] = 0;
2667                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2668                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2669                 }
2670                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2671                     s->mv_dir = MV_DIR_FORWARD;
2672                     s->mv_type = MV_TYPE_8X8;
2673                     s->mb_intra= 0;
2674                     for(i=0; i<4; i++){
2675                         s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2676                         s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2677                     }
2678                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2679                                  &dmin, &next_block, 0, 0);
2680                 }
2681                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2682                     s->mv_dir = MV_DIR_FORWARD;
2683                     s->mv_type = MV_TYPE_16X16;
2684                     s->mb_intra= 0;
2685                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2686                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2687                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2688                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2689                 }
2690                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2691                     s->mv_dir = MV_DIR_BACKWARD;
2692                     s->mv_type = MV_TYPE_16X16;
2693                     s->mb_intra= 0;
2694                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2695                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2696                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2697                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2698                 }
2699                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2700                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2701                     s->mv_type = MV_TYPE_16X16;
2702                     s->mb_intra= 0;
2703                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2704                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2705                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2706                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2707                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2708                                  &dmin, &next_block, 0, 0);
2709                 }
2710                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2711                     s->mv_dir = MV_DIR_FORWARD;
2712                     s->mv_type = MV_TYPE_FIELD;
2713                     s->mb_intra= 0;
2714                     for(i=0; i<2; i++){
2715                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2716                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2717                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2718                     }
2719                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2720                                  &dmin, &next_block, 0, 0);
2721                 }
2722                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2723                     s->mv_dir = MV_DIR_BACKWARD;
2724                     s->mv_type = MV_TYPE_FIELD;
2725                     s->mb_intra= 0;
2726                     for(i=0; i<2; i++){
2727                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2728                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2729                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2730                     }
2731                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2732                                  &dmin, &next_block, 0, 0);
2733                 }
2734                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2735                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2736                     s->mv_type = MV_TYPE_FIELD;
2737                     s->mb_intra= 0;
2738                     for(dir=0; dir<2; dir++){
2739                         for(i=0; i<2; i++){
2740                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2741                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2742                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2743                         }
2744                     }
2745                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2746                                  &dmin, &next_block, 0, 0);
2747                 }
2748                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2749                     s->mv_dir = 0;
2750                     s->mv_type = MV_TYPE_16X16;
2751                     s->mb_intra= 1;
2752                     s->mv[0][0][0] = 0;
2753                     s->mv[0][0][1] = 0;
2754                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2755                                  &dmin, &next_block, 0, 0);
2756                     if(s->h263_pred || s->h263_aic){
2757                         if(best_s.mb_intra)
2758                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2759                         else
2760                             ff_clean_intra_table_entries(s); //old mode?
2761                     }
2762                 }
2763
2764                 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2765                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2766                         const int last_qp= backup_s.qscale;
2767                         int qpi, qp, dc[6];
2768                         DCTELEM ac[6][16];
2769                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2770                         static const int dquant_tab[4]={-1,1,-2,2};
2771
2772                         av_assert2(backup_s.dquant == 0);
2773
2774                         //FIXME intra
2775                         s->mv_dir= best_s.mv_dir;
2776                         s->mv_type = MV_TYPE_16X16;
2777                         s->mb_intra= best_s.mb_intra;
2778                         s->mv[0][0][0] = best_s.mv[0][0][0];
2779                         s->mv[0][0][1] = best_s.mv[0][0][1];
2780                         s->mv[1][0][0] = best_s.mv[1][0][0];
2781                         s->mv[1][0][1] = best_s.mv[1][0][1];
2782
2783                         qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2784                         for(; qpi<4; qpi++){
2785                             int dquant= dquant_tab[qpi];
2786                             qp= last_qp + dquant;
2787                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2788                                 continue;
2789                             backup_s.dquant= dquant;
2790                             if(s->mb_intra && s->dc_val[0]){
2791                                 for(i=0; i<6; i++){
2792                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
2793                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
2794                                 }
2795                             }
2796
2797                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2798                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2799                             if(best_s.qscale != qp){
2800                                 if(s->mb_intra && s->dc_val[0]){
2801                                     for(i=0; i<6; i++){
2802                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
2803                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
2804                                     }
2805                                 }
2806                             }
2807                         }
2808                     }
2809                 }
2810                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2811                     int mx= s->b_direct_mv_table[xy][0];
2812                     int my= s->b_direct_mv_table[xy][1];
2813
2814                     backup_s.dquant = 0;
2815                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2816                     s->mb_intra= 0;
2817                     ff_mpeg4_set_direct_mv(s, mx, my);
2818                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2819                                  &dmin, &next_block, mx, my);
2820                 }
2821                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2822                     backup_s.dquant = 0;
2823                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2824                     s->mb_intra= 0;
2825                     ff_mpeg4_set_direct_mv(s, 0, 0);
2826                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2827                                  &dmin, &next_block, 0, 0);
2828                 }
2829                 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2830                     int coded=0;
2831                     for(i=0; i<6; i++)
2832                         coded |= s->block_last_index[i];
2833                     if(coded){
2834                         int mx,my;
2835                         memcpy(s->mv, best_s.mv, sizeof(s->mv));
2836                         if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2837                             mx=my=0; //FIXME find the one we actually used
2838                             ff_mpeg4_set_direct_mv(s, mx, my);
2839                         }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2840                             mx= s->mv[1][0][0];
2841                             my= s->mv[1][0][1];
2842                         }else{
2843                             mx= s->mv[0][0][0];
2844                             my= s->mv[0][0][1];
2845                         }
2846
2847                         s->mv_dir= best_s.mv_dir;
2848                         s->mv_type = best_s.mv_type;
2849                         s->mb_intra= 0;
2850 /*                        s->mv[0][0][0] = best_s.mv[0][0][0];
2851                         s->mv[0][0][1] = best_s.mv[0][0][1];
2852                         s->mv[1][0][0] = best_s.mv[1][0][0];
2853                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
2854                         backup_s.dquant= 0;
2855                         s->skipdct=1;
2856                         encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2857                                         &dmin, &next_block, mx, my);
2858                         s->skipdct=0;
2859                     }
2860                 }
2861
2862                 s->current_picture.f.qscale_table[xy] = best_s.qscale;
2863
2864                 copy_context_after_encode(s, &best_s, -1);
2865
2866                 pb_bits_count= put_bits_count(&s->pb);
2867                 flush_put_bits(&s->pb);
2868                 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2869                 s->pb= backup_s.pb;
2870
2871                 if(s->data_partitioning){
2872                     pb2_bits_count= put_bits_count(&s->pb2);
2873                     flush_put_bits(&s->pb2);
2874                     avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2875                     s->pb2= backup_s.pb2;
2876
2877                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
2878                     flush_put_bits(&s->tex_pb);
2879                     avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2880                     s->tex_pb= backup_s.tex_pb;
2881                 }
2882                 s->last_bits= put_bits_count(&s->pb);
2883
2884                 if (CONFIG_H263_ENCODER &&
2885                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2886                     ff_h263_update_motion_val(s);
2887
2888                 if(next_block==0){ //FIXME 16 vs linesize16
2889                     s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
2890                     s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
2891                     s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2892                 }
2893
2894                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2895                     ff_MPV_decode_mb(s, s->block);
2896             } else {
2897                 int motion_x = 0, motion_y = 0;
2898                 s->mv_type=MV_TYPE_16X16;
2899                 // only one MB-Type possible
2900
2901                 switch(mb_type){
2902                 case CANDIDATE_MB_TYPE_INTRA:
2903                     s->mv_dir = 0;
2904                     s->mb_intra= 1;
2905                     motion_x= s->mv[0][0][0] = 0;
2906                     motion_y= s->mv[0][0][1] = 0;
2907                     break;
2908                 case CANDIDATE_MB_TYPE_INTER:
2909                     s->mv_dir = MV_DIR_FORWARD;
2910                     s->mb_intra= 0;
2911                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2912                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2913                     break;
2914                 case CANDIDATE_MB_TYPE_INTER_I:
2915                     s->mv_dir = MV_DIR_FORWARD;
2916                     s->mv_type = MV_TYPE_FIELD;
2917                     s->mb_intra= 0;
2918                     for(i=0; i<2; i++){
2919                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2920                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2921                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2922                     }
2923                     break;
2924                 case CANDIDATE_MB_TYPE_INTER4V:
2925                     s->mv_dir = MV_DIR_FORWARD;
2926                     s->mv_type = MV_TYPE_8X8;
2927                     s->mb_intra= 0;
2928                     for(i=0; i<4; i++){
2929                         s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
2930                         s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
2931                     }
2932                     break;
2933                 case CANDIDATE_MB_TYPE_DIRECT:
2934                     if (CONFIG_MPEG4_ENCODER) {
2935                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2936                         s->mb_intra= 0;
2937                         motion_x=s->b_direct_mv_table[xy][0];
2938                         motion_y=s->b_direct_mv_table[xy][1];
2939                         ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2940                     }
2941                     break;
2942                 case CANDIDATE_MB_TYPE_DIRECT0:
2943                     if (CONFIG_MPEG4_ENCODER) {
2944                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2945                         s->mb_intra= 0;
2946                         ff_mpeg4_set_direct_mv(s, 0, 0);
2947                     }
2948                     break;
2949                 case CANDIDATE_MB_TYPE_BIDIR:
2950                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2951                     s->mb_intra= 0;
2952                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2953                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2954                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2955                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2956                     break;
2957                 case CANDIDATE_MB_TYPE_BACKWARD:
2958                     s->mv_dir = MV_DIR_BACKWARD;
2959                     s->mb_intra= 0;
2960                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2961                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2962                     break;
2963                 case CANDIDATE_MB_TYPE_FORWARD:
2964                     s->mv_dir = MV_DIR_FORWARD;
2965                     s->mb_intra= 0;
2966                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2967                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2968 //                    printf(" %d %d ", motion_x, motion_y);
2969                     break;
2970                 case CANDIDATE_MB_TYPE_FORWARD_I:
2971                     s->mv_dir = MV_DIR_FORWARD;
2972                     s->mv_type = MV_TYPE_FIELD;
2973                     s->mb_intra= 0;
2974                     for(i=0; i<2; i++){
2975                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2976                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2977                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2978                     }
2979                     break;
2980                 case CANDIDATE_MB_TYPE_BACKWARD_I:
2981                     s->mv_dir = MV_DIR_BACKWARD;
2982                     s->mv_type = MV_TYPE_FIELD;
2983                     s->mb_intra= 0;
2984                     for(i=0; i<2; i++){
2985                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2986                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2987                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2988                     }
2989                     break;
2990                 case CANDIDATE_MB_TYPE_BIDIR_I:
2991                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2992                     s->mv_type = MV_TYPE_FIELD;
2993                     s->mb_intra= 0;
2994                     for(dir=0; dir<2; dir++){
2995                         for(i=0; i<2; i++){
2996                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2997                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2998                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2999                         }
3000                     }
3001                     break;
3002                 default:
3003                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3004                 }
3005
3006                 encode_mb(s, motion_x, motion_y);
3007
3008                 // RAL: Update last macroblock type
3009                 s->last_mv_dir = s->mv_dir;
3010
3011                 if (CONFIG_H263_ENCODER &&
3012                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3013                     ff_h263_update_motion_val(s);
3014
3015                 ff_MPV_decode_mb(s, s->block);
3016             }
3017
3018             /* clean the MV table in IPS frames for direct mode in B frames */
3019             if(s->mb_intra /* && I,P,S_TYPE */){
3020                 s->p_mv_table[xy][0]=0;
3021                 s->p_mv_table[xy][1]=0;
3022             }
3023
3024             if(s->flags&CODEC_FLAG_PSNR){
3025                 int w= 16;
3026                 int h= 16;
3027
3028                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3029                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3030
3031                 s->current_picture.f.error[0] += sse(
3032                     s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3033                     s->dest[0], w, h, s->linesize);
3034                 s->current_picture.f.error[1] += sse(
3035                     s, s->new_picture.f.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3036                     s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3037                 s->current_picture.f.error[2] += sse(
3038                     s, s->new_picture.f.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3039                     s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3040             }
3041             if(s->loop_filter){
3042                 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3043                     ff_h263_loop_filter(s);
3044             }
3045 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
3046         }
3047     }
3048
3049     //not beautiful here but we must write it before flushing so it has to be here
3050     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3051         ff_msmpeg4_encode_ext_header(s);
3052
3053     write_slice_end(s);
3054
3055     /* Send the last GOB if RTP */
3056     if (s->avctx->rtp_callback) {
3057         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3058         pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3059         /* Call the RTP callback to send the last GOB */
3060         emms_c();
3061         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3062     }
3063
3064     return 0;
3065 }
3066
3067 #define MERGE(field) dst->field += src->field; src->field=0
3068 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3069     MERGE(me.scene_change_score);
3070     MERGE(me.mc_mb_var_sum_temp);
3071     MERGE(me.mb_var_sum_temp);
3072 }
3073
3074 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3075     int i;
3076
3077     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3078     MERGE(dct_count[1]);
3079     MERGE(mv_bits);
3080     MERGE(i_tex_bits);
3081     MERGE(p_tex_bits);
3082     MERGE(i_count);
3083     MERGE(f_count);
3084     MERGE(b_count);
3085     MERGE(skip_count);
3086     MERGE(misc_bits);
3087     MERGE(error_count);
3088     MERGE(padding_bug_score);
3089     MERGE(current_picture.f.error[0]);
3090     MERGE(current_picture.f.error[1]);
3091     MERGE(current_picture.f.error[2]);
3092
3093     if(dst->avctx->noise_reduction){
3094         for(i=0; i<64; i++){
3095             MERGE(dct_error_sum[0][i]);
3096             MERGE(dct_error_sum[1][i]);
3097         }
3098     }
3099
3100     assert(put_bits_count(&src->pb) % 8 ==0);
3101     assert(put_bits_count(&dst->pb) % 8 ==0);
3102     avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3103     flush_put_bits(&dst->pb);
3104 }
3105
3106 static int estimate_qp(MpegEncContext *s, int dry_run){
3107     if (s->next_lambda){
3108         s->current_picture_ptr->f.quality =
3109         s->current_picture.f.quality = s->next_lambda;
3110         if(!dry_run) s->next_lambda= 0;
3111     } else if (!s->fixed_qscale) {
3112         s->current_picture_ptr->f.quality =
3113         s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3114         if (s->current_picture.f.quality < 0)
3115             return -1;
3116     }
3117
3118     if(s->adaptive_quant){
3119         switch(s->codec_id){
3120         case AV_CODEC_ID_MPEG4:
3121             if (CONFIG_MPEG4_ENCODER)
3122                 ff_clean_mpeg4_qscales(s);
3123             break;
3124         case AV_CODEC_ID_H263:
3125         case AV_CODEC_ID_H263P:
3126         case AV_CODEC_ID_FLV1:
3127             if (CONFIG_H263_ENCODER)
3128                 ff_clean_h263_qscales(s);
3129             break;
3130         default:
3131             ff_init_qscale_tab(s);
3132         }
3133
3134         s->lambda= s->lambda_table[0];
3135         //FIXME broken
3136     }else
3137         s->lambda = s->current_picture.f.quality;
3138 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3139     update_qscale(s);
3140     return 0;
3141 }
3142
3143 /* must be called before writing the header */
3144 static void set_frame_distances(MpegEncContext * s){
3145     assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3146     s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3147
3148     if(s->pict_type==AV_PICTURE_TYPE_B){
3149         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3150         assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3151     }else{
3152         s->pp_time= s->time - s->last_non_b_time;
3153         s->last_non_b_time= s->time;
3154         assert(s->picture_number==0 || s->pp_time > 0);
3155     }
3156 }
3157
3158 static int encode_picture(MpegEncContext *s, int picture_number)
3159 {
3160     int i;
3161     int bits;
3162     int context_count = s->slice_context_count;
3163
3164     s->picture_number = picture_number;
3165
3166     /* Reset the average MB variance */
3167     s->me.mb_var_sum_temp    =
3168     s->me.mc_mb_var_sum_temp = 0;
3169
3170     /* we need to initialize some time vars before we can encode b-frames */
3171     // RAL: Condition added for MPEG1VIDEO
3172     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3173         set_frame_distances(s);
3174     if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3175         ff_set_mpeg4_time(s);
3176
3177     s->me.scene_change_score=0;
3178
3179 //    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3180
3181     if(s->pict_type==AV_PICTURE_TYPE_I){
3182         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3183         else                        s->no_rounding=0;
3184     }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3185         if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3186             s->no_rounding ^= 1;
3187     }
3188
3189     if(s->flags & CODEC_FLAG_PASS2){
3190         if (estimate_qp(s,1) < 0)
3191             return -1;
3192         ff_get_2pass_fcode(s);
3193     }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3194         if(s->pict_type==AV_PICTURE_TYPE_B)
3195             s->lambda= s->last_lambda_for[s->pict_type];
3196         else
3197             s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3198         update_qscale(s);
3199     }
3200
3201     if(s->codec_id != AV_CODEC_ID_AMV){
3202         if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
3203         if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3204         s->q_chroma_intra_matrix   = s->q_intra_matrix;
3205         s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3206     }
3207
3208     s->mb_intra=0; //for the rate distortion & bit compare functions
3209     for(i=1; i<context_count; i++){
3210         ff_update_duplicate_context(s->thread_context[i], s);
3211     }
3212
3213     if(ff_init_me(s)<0)
3214         return -1;
3215
3216     /* Estimate motion for every MB */
3217     if(s->pict_type != AV_PICTURE_TYPE_I){
3218         s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3219         s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3220         if(s->pict_type != AV_PICTURE_TYPE_B && s->avctx->me_threshold==0){
3221             if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3222                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3223             }
3224         }
3225
3226         s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3227     }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3228         /* I-Frame */
3229         for(i=0; i<s->mb_stride*s->mb_height; i++)
3230             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3231
3232         if(!s->fixed_qscale){
3233             /* finding spatial complexity for I-frame rate control */
3234             s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3235         }
3236     }
3237     for(i=1; i<context_count; i++){
3238         merge_context_after_me(s, s->thread_context[i]);
3239     }
3240     s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3241     s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
3242     emms_c();
3243
3244     if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3245         s->pict_type= AV_PICTURE_TYPE_I;
3246         for(i=0; i<s->mb_stride*s->mb_height; i++)
3247             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3248 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3249         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3250     }
3251
3252     if(!s->umvplus){
3253         if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3254             s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3255
3256             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3257                 int a,b;
3258                 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3259                 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3260                 s->f_code= FFMAX3(s->f_code, a, b);
3261             }
3262
3263             ff_fix_long_p_mvs(s);
3264             ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3265             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3266                 int j;
3267                 for(i=0; i<2; i++){
3268                     for(j=0; j<2; j++)
3269                         ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3270                                         s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3271                 }
3272             }
3273         }
3274
3275         if(s->pict_type==AV_PICTURE_TYPE_B){
3276             int a, b;
3277
3278             a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3279             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3280             s->f_code = FFMAX(a, b);
3281
3282             a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3283             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3284             s->b_code = FFMAX(a, b);
3285
3286             ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3287             ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3288             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3289             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3290             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3291                 int dir, j;
3292                 for(dir=0; dir<2; dir++){
3293                     for(i=0; i<2; i++){
3294                         for(j=0; j<2; j++){
3295                             int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3296                                           : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);