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