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