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