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