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