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