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