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