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