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