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