3f21349385ae24c509152afd2965030c88a111df
[ffmpeg.git] / libavcodec / mpegvideo.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  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21  */
22  
23 /**
24  * @file mpegvideo.c
25  * The simplest mpeg encoder (well, it was the simplest!).
26  */ 
27  
28 #include <limits.h>
29 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "mpegvideo.h"
32 #include "faandct.h"
33
34 #ifdef USE_FASTMEMCPY
35 #include "fastmemcpy.h"
36 #endif
37
38 //#undef NDEBUG
39 //#include <assert.h>
40
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 
45                                    DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 
47                                    DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49                                    DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51                                    DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s, 
53                                   DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s, 
55                                   DCTELEM *block, int n, int qscale);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int sse_mb(MpegEncContext *s);
61 static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
62 #endif //CONFIG_ENCODERS
63
64 #ifdef HAVE_XVMC
65 extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
66 extern void XVMC_field_end(MpegEncContext *s);
67 extern void XVMC_decode_mb(MpegEncContext *s);
68 #endif
69
70 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
71
72
73 /* enable all paranoid tests for rounding, overflows, etc... */
74 //#define PARANOID
75
76 //#define DEBUG
77
78
79 /* for jpeg fast DCT */
80 #define CONST_BITS 14
81
82 static const uint16_t aanscales[64] = {
83     /* precomputed values scaled up by 14 bits */
84     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
85     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
86     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
87     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
88     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
89     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
90     8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
91     4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
92 };
93
94 static const uint8_t h263_chroma_roundtab[16] = {
95 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
96     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
97 };
98
99 static const uint8_t ff_default_chroma_qscale_table[32]={
100 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
101     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
102 };
103
104 #ifdef CONFIG_ENCODERS
105 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
106 static uint8_t default_fcode_tab[MAX_MV*2+1];
107
108 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
109
110 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
111                            const uint16_t *quant_matrix, int bias, int qmin, int qmax)
112 {
113     int qscale;
114
115     for(qscale=qmin; qscale<=qmax; qscale++){
116         int i;
117         if (dsp->fdct == ff_jpeg_fdct_islow 
118 #ifdef FAAN_POSTSCALE
119             || dsp->fdct == ff_faandct
120 #endif
121             ) {
122             for(i=0;i<64;i++) {
123                 const int j= dsp->idct_permutation[i];
124                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
125                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
126                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
127                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
128                 
129                 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
130                                 (qscale * quant_matrix[j]));
131             }
132         } else if (dsp->fdct == fdct_ifast
133 #ifndef FAAN_POSTSCALE
134                    || dsp->fdct == ff_faandct
135 #endif
136                    ) {
137             for(i=0;i<64;i++) {
138                 const int j= dsp->idct_permutation[i];
139                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
140                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
141                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
142                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
143                 
144                 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
145                                 (aanscales[i] * qscale * quant_matrix[j]));
146             }
147         } else {
148             for(i=0;i<64;i++) {
149                 const int j= dsp->idct_permutation[i];
150                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
151                    So 16           <= qscale * quant_matrix[i]             <= 7905
152                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
153                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
154                 */
155                 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
156 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
157                 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
158
159                 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
160                 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
161             }
162         }
163     }
164 }
165
166 static inline void update_qscale(MpegEncContext *s){
167     s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
168     s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
169     
170     s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
171 }
172 #endif //CONFIG_ENCODERS
173
174 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
175     int i;
176     int end;
177     
178     st->scantable= src_scantable;
179
180     for(i=0; i<64; i++){
181         int j;
182         j = src_scantable[i];
183         st->permutated[i] = permutation[j];
184 #ifdef ARCH_POWERPC
185         st->inverse[j] = i;
186 #endif
187     }
188     
189     end=-1;
190     for(i=0; i<64; i++){
191         int j;
192         j = st->permutated[i];
193         if(j>end) end=j;
194         st->raster_end[i]= end;
195     }
196 }
197
198 #ifdef CONFIG_ENCODERS
199 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
200     int i;
201
202     if(matrix){
203         put_bits(pb, 1, 1);
204         for(i=0;i<64;i++) {
205             put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
206         }
207     }else
208         put_bits(pb, 1, 0);
209 }
210 #endif //CONFIG_ENCODERS
211
212 /* init common dct for both encoder and decoder */
213 int DCT_common_init(MpegEncContext *s)
214 {
215     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
216     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
217     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
218     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
219     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
220     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
221
222 #ifdef CONFIG_ENCODERS
223     s->dct_quantize= dct_quantize_c;
224     s->denoise_dct= denoise_dct_c;
225 #endif
226         
227 #ifdef HAVE_MMX
228     MPV_common_init_mmx(s);
229 #endif
230 #ifdef ARCH_ALPHA
231     MPV_common_init_axp(s);
232 #endif
233 #ifdef HAVE_MLIB
234     MPV_common_init_mlib(s);
235 #endif
236 #ifdef HAVE_MMI
237     MPV_common_init_mmi(s);
238 #endif
239 #ifdef ARCH_ARMV4L
240     MPV_common_init_armv4l(s);
241 #endif
242 #ifdef ARCH_POWERPC
243     MPV_common_init_ppc(s);
244 #endif
245
246 #ifdef CONFIG_ENCODERS
247     s->fast_dct_quantize= s->dct_quantize;
248
249     if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
250         s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
251     }
252
253 #endif //CONFIG_ENCODERS
254
255     /* load & permutate scantables
256        note: only wmv uses differnt ones 
257     */
258     if(s->alternate_scan){
259         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
260         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
261     }else{
262         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
263         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
264     }
265     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
266     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
267
268     s->picture_structure= PICT_FRAME;
269     
270     return 0;
271 }
272
273 static void copy_picture(Picture *dst, Picture *src){
274     *dst = *src;
275     dst->type= FF_BUFFER_TYPE_COPY;
276 }
277
278 static void copy_picture_attributes(AVFrame *dst, AVFrame *src){
279     dst->pict_type              = src->pict_type;
280     dst->quality                = src->quality;
281     dst->coded_picture_number   = src->coded_picture_number;
282     dst->display_picture_number = src->display_picture_number;
283 //    dst->reference              = src->reference;
284     dst->pts                    = src->pts;
285     dst->interlaced_frame       = src->interlaced_frame;
286     dst->top_field_first        = src->top_field_first;
287 }
288
289 /**
290  * allocates a Picture
291  * The pixels are allocated/set by calling get_buffer() if shared=0
292  */
293 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
294     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
295     const int mb_array_size= s->mb_stride*s->mb_height;
296     const int b8_array_size= s->b8_stride*s->mb_height*2;
297     const int b4_array_size= s->b4_stride*s->mb_height*4;
298     int i;
299     
300     if(shared){
301         assert(pic->data[0]);
302         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
303         pic->type= FF_BUFFER_TYPE_SHARED;
304     }else{
305         int r;
306         
307         assert(!pic->data[0]);
308         
309         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
310         
311         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
312             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
313             return -1;
314         }
315
316         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
317             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
318             return -1;
319         }
320
321         if(pic->linesize[1] != pic->linesize[2]){
322             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
323             return -1;
324         }
325
326         s->linesize  = pic->linesize[0];
327         s->uvlinesize= pic->linesize[1];
328     }
329     
330     if(pic->qscale_table==NULL){
331         if (s->encoding) {        
332             CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
333             CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
334             CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
335         }
336
337         CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
338         CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
339         CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
340         pic->mb_type= pic->mb_type_base + s->mb_stride+1;
341         if(s->out_format == FMT_H264){
342             for(i=0; i<2; i++){
343                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+1)  * sizeof(int16_t))
344                 pic->motion_val[i]= pic->motion_val_base[i]+1;
345                 CHECKED_ALLOCZ(pic->ref_index[i] , b8_array_size * sizeof(uint8_t))
346             }
347             pic->motion_subsample_log2= 2;
348         }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
349             for(i=0; i<2; i++){
350                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+1) * sizeof(int16_t)*2) //FIXME
351                 pic->motion_val[i]= pic->motion_val_base[i]+1;
352             }
353             pic->motion_subsample_log2= 3;
354         }
355         pic->qstride= s->mb_stride;
356         CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
357     }
358
359     //it might be nicer if the application would keep track of these but it would require a API change
360     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
361     s->prev_pict_types[0]= s->pict_type;
362     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
363         pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
364     
365     return 0;
366 fail: //for the CHECKED_ALLOCZ macro
367     return -1;
368 }
369
370 /**
371  * deallocates a picture
372  */
373 static void free_picture(MpegEncContext *s, Picture *pic){
374     int i;
375
376     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
377         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
378     }
379
380     av_freep(&pic->mb_var);
381     av_freep(&pic->mc_mb_var);
382     av_freep(&pic->mb_mean);
383     av_freep(&pic->mbskip_table);
384     av_freep(&pic->qscale_table);
385     av_freep(&pic->mb_type_base);
386     av_freep(&pic->pan_scan);
387     pic->mb_type= NULL;
388     for(i=0; i<2; i++){
389         av_freep(&pic->motion_val_base[i]);
390         av_freep(&pic->ref_index[i]);
391     }
392     
393     if(pic->type == FF_BUFFER_TYPE_SHARED){
394         for(i=0; i<4; i++){
395             pic->base[i]=
396             pic->data[i]= NULL;
397         }
398         pic->type= 0;        
399     }
400 }
401
402 /* init common structure for both encoder and decoder */
403 int MPV_common_init(MpegEncContext *s)
404 {
405     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
406
407     dsputil_init(&s->dsp, s->avctx);
408     DCT_common_init(s);
409
410     s->flags= s->avctx->flags;
411
412     s->mb_width  = (s->width  + 15) / 16;
413     s->mb_height = (s->height + 15) / 16;
414     s->mb_stride = s->mb_width + 1;
415     s->b8_stride = s->mb_width*2 + 1;
416     s->b4_stride = s->mb_width*4 + 1;
417     mb_array_size= s->mb_height * s->mb_stride;
418     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
419
420     /* set default edge pos, will be overriden in decode_header if needed */
421     s->h_edge_pos= s->mb_width*16;
422     s->v_edge_pos= s->mb_height*16;
423
424     s->mb_num = s->mb_width * s->mb_height;
425     
426     s->block_wrap[0]=
427     s->block_wrap[1]=
428     s->block_wrap[2]=
429     s->block_wrap[3]= s->mb_width*2 + 2;
430     s->block_wrap[4]=
431     s->block_wrap[5]= s->mb_width + 2;
432
433     s->y_dc_scale_table=
434     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
435     s->chroma_qscale_table= ff_default_chroma_qscale_table;
436     if (!s->encoding)
437         s->progressive_sequence= 1;
438     s->progressive_frame= 1;
439     s->coded_picture_number = 0;
440
441     y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
442     c_size = (s->mb_width + 2) * (s->mb_height + 2);
443     yc_size = y_size + 2 * c_size;
444
445     /* convert fourcc to upper case */
446     s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
447                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
448                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
449                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
450
451     s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
452                                + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
453                                + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
454                                + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
455
456     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458
459     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
460
461     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
462     for(y=0; y<s->mb_height; y++){
463         for(x=0; x<s->mb_width; x++){
464             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
465         }
466     }
467     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
468     
469     if (s->encoding) {
470         /* Allocate MV tables */
471         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
472         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
473         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
474         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
477         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
478         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
479         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
480         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
481         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
482         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
483
484         //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
485         CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
486         
487         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
488         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
489
490         if(s->codec_id==CODEC_ID_MPEG4){
491             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
492             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
493         }
494         
495         if(s->msmpeg4_version){
496             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
497         }
498         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
499
500         /* Allocate MB type table */
501         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
502         
503         CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
504         
505         CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
506         CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
507         CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
508         CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
509         CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
510         CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
511         
512         if(s->avctx->noise_reduction){
513             CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
514             CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
515         }
516     }
517     CHECKED_ALLOCZ(s->blocks, 64*6*2 * sizeof(DCTELEM))
518         
519     CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
520
521     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
522     
523     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
524         /* interlaced direct mode decoding tables */
525             for(i=0; i<2; i++){
526                 int j, k;
527                 for(j=0; j<2; j++){
528                     for(k=0; k<2; k++){
529                         CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
530                         s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
531                     }
532                     CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
533                     CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
534                     s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
535                 }
536                 CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
537             }
538     }
539     if (s->out_format == FMT_H263) {
540         /* ac values */
541         CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
542         s->ac_val[1] = s->ac_val[0] + y_size;
543         s->ac_val[2] = s->ac_val[1] + c_size;
544         
545         /* cbp values */
546         CHECKED_ALLOCZ(s->coded_block, y_size);
547         
548         /* divx501 bitstream reorder buffer */
549         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
550
551         /* cbp, ac_pred, pred_dir */
552         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
553         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
554     }
555     
556     if (s->h263_pred || s->h263_plus || !s->encoding) {
557         /* dc values */
558         //MN: we need these for error resilience of intra-frames
559         CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
560         s->dc_val[1] = s->dc_val[0] + y_size;
561         s->dc_val[2] = s->dc_val[1] + c_size;
562         for(i=0;i<yc_size;i++)
563             s->dc_val[0][i] = 1024;
564     }
565
566     /* which mb is a intra block */
567     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
568     memset(s->mbintra_table, 1, mb_array_size);
569     
570     /* default structure is frame */
571     s->picture_structure = PICT_FRAME;
572     
573     /* init macroblock skip table */
574     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
575     //Note the +1 is for a quicker mpeg4 slice_end detection
576     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
577     
578     s->block= s->blocks[0];
579
580     for(i=0;i<12;i++){
581         s->pblocks[i] = (short *)(&s->block[i]);
582     }
583
584     s->parse_context.state= -1;
585     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
586        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
587        s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
588        s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
589     }
590
591     s->context_initialized = 1;
592     return 0;
593  fail:
594     MPV_common_end(s);
595     return -1;
596 }
597
598
599 //extern int sads;
600
601 /* init common structure for both encoder and decoder */
602 void MPV_common_end(MpegEncContext *s)
603 {
604     int i, j, k;
605
606     av_freep(&s->parse_context.buffer);
607     s->parse_context.buffer_size=0;
608
609     av_freep(&s->mb_type);
610     av_freep(&s->p_mv_table_base);
611     av_freep(&s->b_forw_mv_table_base);
612     av_freep(&s->b_back_mv_table_base);
613     av_freep(&s->b_bidir_forw_mv_table_base);
614     av_freep(&s->b_bidir_back_mv_table_base);
615     av_freep(&s->b_direct_mv_table_base);
616     s->p_mv_table= NULL;
617     s->b_forw_mv_table= NULL;
618     s->b_back_mv_table= NULL;
619     s->b_bidir_forw_mv_table= NULL;
620     s->b_bidir_back_mv_table= NULL;
621     s->b_direct_mv_table= NULL;
622     for(i=0; i<2; i++){
623         for(j=0; j<2; j++){
624             for(k=0; k<2; k++){
625                 av_freep(&s->b_field_mv_table_base[i][j][k]);
626                 s->b_field_mv_table[i][j][k]=NULL;
627             }
628             av_freep(&s->b_field_select_table[i][j]);
629             av_freep(&s->p_field_mv_table_base[i][j]);
630             s->p_field_mv_table[i][j]=NULL;
631         }
632         av_freep(&s->p_field_select_table[i]);
633     }
634     
635     av_freep(&s->dc_val[0]);
636     av_freep(&s->ac_val[0]);
637     av_freep(&s->coded_block);
638     av_freep(&s->mbintra_table);
639     av_freep(&s->cbp_table);
640     av_freep(&s->pred_dir_table);
641     av_freep(&s->me.scratchpad);
642     av_freep(&s->me.map);
643     av_freep(&s->me.score_map);
644     
645     av_freep(&s->mbskip_table);
646     av_freep(&s->prev_pict_types);
647     av_freep(&s->bitstream_buffer);
648     av_freep(&s->tex_pb_buffer);
649     av_freep(&s->pb2_buffer);
650     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
651     av_freep(&s->avctx->stats_out);
652     av_freep(&s->ac_stats);
653     av_freep(&s->error_status_table);
654     av_freep(&s->mb_index2xy);
655     av_freep(&s->lambda_table);
656     av_freep(&s->q_intra_matrix);
657     av_freep(&s->q_inter_matrix);
658     av_freep(&s->q_intra_matrix16);
659     av_freep(&s->q_inter_matrix16);
660     av_freep(&s->blocks);
661     av_freep(&s->input_picture);
662     av_freep(&s->reordered_input_picture);
663     av_freep(&s->dct_error_sum);
664     av_freep(&s->dct_offset);
665
666     if(s->picture){
667         for(i=0; i<MAX_PICTURE_COUNT; i++){
668             free_picture(s, &s->picture[i]);
669         }
670     }
671     av_freep(&s->picture);
672     avcodec_default_free_buffers(s->avctx);
673     s->context_initialized = 0;
674     s->last_picture_ptr=
675     s->next_picture_ptr=
676     s->current_picture_ptr= NULL;
677     for(i=0; i<3; i++)
678         if (s->visualization_buffer[i])
679             av_free(s->visualization_buffer[i]);
680 }
681
682 #ifdef CONFIG_ENCODERS
683
684 /* init video encoder */
685 int MPV_encode_init(AVCodecContext *avctx)
686 {
687     MpegEncContext *s = avctx->priv_data;
688     int i, dummy;
689     int chroma_h_shift, chroma_v_shift;
690
691     avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
692
693     s->bit_rate = avctx->bit_rate;
694     s->width = avctx->width;
695     s->height = avctx->height;
696     if(avctx->gop_size > 600){
697         av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
698         avctx->gop_size=600;
699     }
700     s->gop_size = avctx->gop_size;
701     s->avctx = avctx;
702     s->flags= avctx->flags;
703     s->max_b_frames= avctx->max_b_frames;
704     s->codec_id= avctx->codec->id;
705     s->luma_elim_threshold  = avctx->luma_elim_threshold;
706     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
707     s->strict_std_compliance= avctx->strict_std_compliance;
708     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
709     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
710     s->mpeg_quant= avctx->mpeg_quant;
711     s->rtp_mode= !!avctx->rtp_payload_size;
712
713     if (s->gop_size <= 1) {
714         s->intra_only = 1;
715         s->gop_size = 12;
716     } else {
717         s->intra_only = 0;
718     }
719
720     s->me_method = avctx->me_method;
721
722     /* Fixed QSCALE */
723     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
724     
725     s->adaptive_quant= (   s->avctx->lumi_masking
726                         || s->avctx->dark_masking
727                         || s->avctx->temporal_cplx_masking 
728                         || s->avctx->spatial_cplx_masking
729                         || s->avctx->p_masking
730                         || (s->flags&CODEC_FLAG_QP_RD))
731                        && !s->fixed_qscale;
732     
733     s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
734     s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
735     s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
736
737     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
738         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
739         return -1;
740     }    
741
742     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
743         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
744     }    
745         
746     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
747        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
748         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
749         return -1;
750     }
751         
752     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
753         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
754         return -1;
755     }
756     
757     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
758         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
759         return -1;
760     }
761     
762     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
763         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
764         return -1;
765     }
766
767     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
768         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
769         return -1;
770     }
771     
772     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
773         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
774         return -1;
775     }
776     
777     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
778         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
779         return -1;
780     }
781         
782     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
783         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
784         return -1;
785     }
786
787     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
788         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
789         return -1;
790     }
791     
792     if(s->codec_id==CODEC_ID_MJPEG){
793         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
794         s->inter_quant_bias= 0;
795     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
796         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
797         s->inter_quant_bias= 0;
798     }else{
799         s->intra_quant_bias=0;
800         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
801     }
802     
803     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
804         s->intra_quant_bias= avctx->intra_quant_bias;
805     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
806         s->inter_quant_bias= avctx->inter_quant_bias;
807         
808     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
809
810     av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
811     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
812
813     switch(avctx->codec->id) {
814     case CODEC_ID_MPEG1VIDEO:
815         s->out_format = FMT_MPEG1;
816         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
817         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
818         break;
819     case CODEC_ID_MPEG2VIDEO:
820         s->out_format = FMT_MPEG1;
821         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
822         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
823         s->rtp_mode= 1;
824         break;
825     case CODEC_ID_LJPEG:
826     case CODEC_ID_MJPEG:
827         s->out_format = FMT_MJPEG;
828         s->intra_only = 1; /* force intra only for jpeg */
829         s->mjpeg_write_tables = 1; /* write all tables */
830         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
831         s->mjpeg_vsample[0] = 1<<chroma_v_shift;
832         s->mjpeg_vsample[1] = 1;
833         s->mjpeg_vsample[2] = 1; 
834         s->mjpeg_hsample[0] = 1<<chroma_h_shift;
835         s->mjpeg_hsample[1] = 1; 
836         s->mjpeg_hsample[2] = 1; 
837         if (mjpeg_init(s) < 0)
838             return -1;
839         avctx->delay=0;
840         s->low_delay=1;
841         break;
842 #ifdef CONFIG_RISKY
843     case CODEC_ID_H263:
844         if (h263_get_picture_format(s->width, s->height) == 7) {
845             av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
846             return -1;
847         }
848         s->out_format = FMT_H263;
849         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
850         avctx->delay=0;
851         s->low_delay=1;
852         break;
853     case CODEC_ID_H263P:
854         s->out_format = FMT_H263;
855         s->h263_plus = 1;
856         /* Fx */
857         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
858         s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
859         s->modified_quant= s->h263_aic;
860         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
861         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
862         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
863         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
864         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
865
866         /* /Fx */
867         /* These are just to be sure */
868         avctx->delay=0;
869         s->low_delay=1;
870         break;
871     case CODEC_ID_FLV1:
872         s->out_format = FMT_H263;
873         s->h263_flv = 2; /* format = 1; 11-bit codes */
874         s->unrestricted_mv = 1;
875         s->rtp_mode=0; /* don't allow GOB */
876         avctx->delay=0;
877         s->low_delay=1;
878         break;
879     case CODEC_ID_RV10:
880         s->out_format = FMT_H263;
881         avctx->delay=0;
882         s->low_delay=1;
883         break;
884     case CODEC_ID_MPEG4:
885         s->out_format = FMT_H263;
886         s->h263_pred = 1;
887         s->unrestricted_mv = 1;
888         s->low_delay= s->max_b_frames ? 0 : 1;
889         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
890         break;
891     case CODEC_ID_MSMPEG4V1:
892         s->out_format = FMT_H263;
893         s->h263_msmpeg4 = 1;
894         s->h263_pred = 1;
895         s->unrestricted_mv = 1;
896         s->msmpeg4_version= 1;
897         avctx->delay=0;
898         s->low_delay=1;
899         break;
900     case CODEC_ID_MSMPEG4V2:
901         s->out_format = FMT_H263;
902         s->h263_msmpeg4 = 1;
903         s->h263_pred = 1;
904         s->unrestricted_mv = 1;
905         s->msmpeg4_version= 2;
906         avctx->delay=0;
907         s->low_delay=1;
908         break;
909     case CODEC_ID_MSMPEG4V3:
910         s->out_format = FMT_H263;
911         s->h263_msmpeg4 = 1;
912         s->h263_pred = 1;
913         s->unrestricted_mv = 1;
914         s->msmpeg4_version= 3;
915         s->flipflop_rounding=1;
916         avctx->delay=0;
917         s->low_delay=1;
918         break;
919     case CODEC_ID_WMV1:
920         s->out_format = FMT_H263;
921         s->h263_msmpeg4 = 1;
922         s->h263_pred = 1;
923         s->unrestricted_mv = 1;
924         s->msmpeg4_version= 4;
925         s->flipflop_rounding=1;
926         avctx->delay=0;
927         s->low_delay=1;
928         break;
929     case CODEC_ID_WMV2:
930         s->out_format = FMT_H263;
931         s->h263_msmpeg4 = 1;
932         s->h263_pred = 1;
933         s->unrestricted_mv = 1;
934         s->msmpeg4_version= 5;
935         s->flipflop_rounding=1;
936         avctx->delay=0;
937         s->low_delay=1;
938         break;
939 #endif
940     default:
941         return -1;
942     }
943
944     { /* set up some save defaults, some codecs might override them later */
945         static int done=0;
946         if(!done){
947             int i;
948             done=1;
949
950             default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
951             memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
952             memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
953
954             for(i=-16; i<16; i++){
955                 default_fcode_tab[i + MAX_MV]= 1;
956             }
957         }
958     }
959     s->me.mv_penalty= default_mv_penalty;
960     s->fcode_tab= default_fcode_tab;
961  
962     /* dont use mv_penalty table for crap MV as it would be confused */
963     //FIXME remove after fixing / removing old ME
964     if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
965
966     s->encoding = 1;
967
968     /* init */
969     if (MPV_common_init(s) < 0)
970         return -1;
971
972     if(s->modified_quant)
973         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
974     s->progressive_frame= 
975     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
976     
977     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
978     
979     ff_init_me(s);
980
981 #ifdef CONFIG_ENCODERS
982 #ifdef CONFIG_RISKY
983     if (s->out_format == FMT_H263)
984         h263_encode_init(s);
985     if(s->msmpeg4_version)
986         ff_msmpeg4_encode_init(s);
987 #endif
988     if (s->out_format == FMT_MPEG1)
989         ff_mpeg1_encode_init(s);
990 #endif
991
992     /* init default q matrix */
993     for(i=0;i<64;i++) {
994         int j= s->dsp.idct_permutation[i];
995 #ifdef CONFIG_RISKY
996         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
997             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
998             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
999         }else if(s->out_format == FMT_H263){
1000             s->intra_matrix[j] =
1001             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1002         }else
1003 #endif
1004         { /* mpeg1/2 */
1005             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1006             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1007         }
1008         if(s->avctx->intra_matrix)
1009             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1010         if(s->avctx->inter_matrix)
1011             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1012     }
1013
1014     /* precompute matrix */
1015     /* for mjpeg, we do include qscale in the matrix */
1016     if (s->out_format != FMT_MJPEG) {
1017         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1018                        s->intra_matrix, s->intra_quant_bias, 1, 31);
1019         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1020                        s->inter_matrix, s->inter_quant_bias, 1, 31);
1021     }
1022
1023     if(ff_rate_control_init(s) < 0)
1024         return -1;
1025
1026     s->picture_number = 0;
1027     s->input_picture_number = 0;
1028     s->picture_in_gop_number = 0;
1029     /* motion detector init */
1030     s->f_code = 1;
1031     s->b_code = 1;
1032
1033     return 0;
1034 }
1035
1036 int MPV_encode_end(AVCodecContext *avctx)
1037 {
1038     MpegEncContext *s = avctx->priv_data;
1039
1040 #ifdef STATS
1041     print_stats();
1042 #endif
1043
1044     ff_rate_control_uninit(s);
1045
1046     MPV_common_end(s);
1047     if (s->out_format == FMT_MJPEG)
1048         mjpeg_close(s);
1049
1050     av_freep(&avctx->extradata);
1051       
1052     return 0;
1053 }
1054
1055 #endif //CONFIG_ENCODERS
1056
1057 void init_rl(RLTable *rl)
1058 {
1059     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1060     uint8_t index_run[MAX_RUN+1];
1061     int last, run, level, start, end, i;
1062
1063     /* compute max_level[], max_run[] and index_run[] */
1064     for(last=0;last<2;last++) {
1065         if (last == 0) {
1066             start = 0;
1067             end = rl->last;
1068         } else {
1069             start = rl->last;
1070             end = rl->n;
1071         }
1072
1073         memset(max_level, 0, MAX_RUN + 1);
1074         memset(max_run, 0, MAX_LEVEL + 1);
1075         memset(index_run, rl->n, MAX_RUN + 1);
1076         for(i=start;i<end;i++) {
1077             run = rl->table_run[i];
1078             level = rl->table_level[i];
1079             if (index_run[run] == rl->n)
1080                 index_run[run] = i;
1081             if (level > max_level[run])
1082                 max_level[run] = level;
1083             if (run > max_run[level])
1084                 max_run[level] = run;
1085         }
1086         rl->max_level[last] = av_malloc(MAX_RUN + 1);
1087         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1088         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1089         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1090         rl->index_run[last] = av_malloc(MAX_RUN + 1);
1091         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1092     }
1093 }
1094
1095 /* draw the edges of width 'w' of an image of size width, height */
1096 //FIXME check that this is ok for mpeg4 interlaced
1097 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1098 {
1099     uint8_t *ptr, *last_line;
1100     int i;
1101
1102     last_line = buf + (height - 1) * wrap;
1103     for(i=0;i<w;i++) {
1104         /* top and bottom */
1105         memcpy(buf - (i + 1) * wrap, buf, width);
1106         memcpy(last_line + (i + 1) * wrap, last_line, width);
1107     }
1108     /* left and right */
1109     ptr = buf;
1110     for(i=0;i<height;i++) {
1111         memset(ptr - w, ptr[0], w);
1112         memset(ptr + width, ptr[width-1], w);
1113         ptr += wrap;
1114     }
1115     /* corners */
1116     for(i=0;i<w;i++) {
1117         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1118         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1119         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1120         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1121     }
1122 }
1123
1124 int ff_find_unused_picture(MpegEncContext *s, int shared){
1125     int i;
1126     
1127     if(shared){
1128         for(i=0; i<MAX_PICTURE_COUNT; i++){
1129             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1130         }
1131     }else{
1132         for(i=0; i<MAX_PICTURE_COUNT; i++){
1133             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1134         }
1135         for(i=0; i<MAX_PICTURE_COUNT; i++){
1136             if(s->picture[i].data[0]==NULL) return i;
1137         }
1138     }
1139
1140     assert(0);
1141     return -1;
1142 }
1143
1144 static void update_noise_reduction(MpegEncContext *s){
1145     int intra, i;
1146
1147     for(intra=0; intra<2; intra++){
1148         if(s->dct_count[intra] > (1<<16)){
1149             for(i=0; i<64; i++){
1150                 s->dct_error_sum[intra][i] >>=1;
1151             }
1152             s->dct_count[intra] >>= 1;
1153         }
1154         
1155         for(i=0; i<64; i++){
1156             s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1157         }
1158     }
1159 }
1160
1161 /**
1162  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1163  */
1164 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1165 {
1166     int i;
1167     AVFrame *pic;
1168     s->mb_skiped = 0;
1169
1170     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1171
1172     /* mark&release old frames */
1173     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1174         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1175
1176         /* release forgotten pictures */
1177         /* if(mpeg124/h263) */
1178         if(!s->encoding){
1179             for(i=0; i<MAX_PICTURE_COUNT; i++){
1180                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1181                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1182                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1183                 }
1184             }
1185         }
1186     }
1187 alloc:
1188     if(!s->encoding){
1189         /* release non refernce frames */
1190         for(i=0; i<MAX_PICTURE_COUNT; i++){
1191             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1192                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1193             }
1194         }
1195
1196         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1197             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1198         else{
1199             i= ff_find_unused_picture(s, 0);
1200             pic= (AVFrame*)&s->picture[i];
1201         }
1202
1203         pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1204
1205         pic->coded_picture_number= s->coded_picture_number++;
1206         
1207         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1208             return -1;
1209
1210         s->current_picture_ptr= (Picture*)pic;
1211         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1212         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1213     }
1214
1215     s->current_picture_ptr->pict_type= s->pict_type;
1216 //    if(s->flags && CODEC_FLAG_QSCALE) 
1217   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1218     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1219
1220     copy_picture(&s->current_picture, s->current_picture_ptr);
1221   
1222   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1223     if (s->pict_type != B_TYPE) {
1224         s->last_picture_ptr= s->next_picture_ptr;
1225         s->next_picture_ptr= s->current_picture_ptr;
1226     }
1227     
1228     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1229     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1230     
1231     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1232         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1233         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1234         goto alloc;
1235     }
1236
1237     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1238
1239     if(s->picture_structure!=PICT_FRAME){
1240         int i;
1241         for(i=0; i<4; i++){
1242             if(s->picture_structure == PICT_BOTTOM_FIELD){
1243                  s->current_picture.data[i] += s->current_picture.linesize[i];
1244             } 
1245             s->current_picture.linesize[i] *= 2;
1246             s->last_picture.linesize[i] *=2;
1247             s->next_picture.linesize[i] *=2;
1248         }
1249     }
1250   }
1251    
1252     s->hurry_up= s->avctx->hurry_up;
1253     s->error_resilience= avctx->error_resilience;
1254
1255     /* set dequantizer, we cant do it during init as it might change for mpeg4
1256        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1257     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1258         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1259         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1260     }else if(s->out_format == FMT_H263){
1261         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1262         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1263     }else{
1264         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1265         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1266     }
1267
1268     if(s->dct_error_sum){
1269         assert(s->avctx->noise_reduction && s->encoding);
1270
1271         update_noise_reduction(s);
1272     }
1273         
1274 #ifdef HAVE_XVMC
1275     if(s->avctx->xvmc_acceleration)
1276         return XVMC_field_start(s, avctx);
1277 #endif
1278     return 0;
1279 }
1280
1281 /* generic function for encode/decode called after a frame has been coded/decoded */
1282 void MPV_frame_end(MpegEncContext *s)
1283 {
1284     int i;
1285     /* draw edge for correct motion prediction if outside */
1286 #ifdef HAVE_XVMC
1287 //just to make sure that all data is rendered.
1288     if(s->avctx->xvmc_acceleration){
1289         XVMC_field_end(s);
1290     }else
1291 #endif
1292     if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1293             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1294             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1295             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1296     }
1297     emms_c();
1298     
1299     s->last_pict_type    = s->pict_type;
1300     if(s->pict_type!=B_TYPE){
1301         s->last_non_b_pict_type= s->pict_type;
1302     }
1303 #if 0
1304         /* copy back current_picture variables */
1305     for(i=0; i<MAX_PICTURE_COUNT; i++){
1306         if(s->picture[i].data[0] == s->current_picture.data[0]){
1307             s->picture[i]= s->current_picture;
1308             break;
1309         }    
1310     }
1311     assert(i<MAX_PICTURE_COUNT);
1312 #endif    
1313
1314     if(s->encoding){
1315         /* release non refernce frames */
1316         for(i=0; i<MAX_PICTURE_COUNT; i++){
1317             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1318                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1319             }
1320         }
1321     }
1322     // clear copies, to avoid confusion
1323 #if 0
1324     memset(&s->last_picture, 0, sizeof(Picture));
1325     memset(&s->next_picture, 0, sizeof(Picture));
1326     memset(&s->current_picture, 0, sizeof(Picture));
1327 #endif
1328 }
1329
1330 /**
1331  * draws an line from (ex, ey) -> (sx, sy).
1332  * @param w width of the image
1333  * @param h height of the image
1334  * @param stride stride/linesize of the image
1335  * @param color color of the arrow
1336  */
1337 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1338     int t, x, y, f;
1339     
1340     sx= clip(sx, 0, w-1);
1341     sy= clip(sy, 0, h-1);
1342     ex= clip(ex, 0, w-1);
1343     ey= clip(ey, 0, h-1);
1344     
1345     buf[sy*stride + sx]+= color;
1346     
1347     if(ABS(ex - sx) > ABS(ey - sy)){
1348         if(sx > ex){
1349             t=sx; sx=ex; ex=t;
1350             t=sy; sy=ey; ey=t;
1351         }
1352         buf+= sx + sy*stride;
1353         ex-= sx;
1354         f= ((ey-sy)<<16)/ex;
1355         for(x= 0; x <= ex; x++){
1356             y= ((x*f) + (1<<15))>>16;
1357             buf[y*stride + x]+= color;
1358         }
1359     }else{
1360         if(sy > ey){
1361             t=sx; sx=ex; ex=t;
1362             t=sy; sy=ey; ey=t;
1363         }
1364         buf+= sx + sy*stride;
1365         ey-= sy;
1366         if(ey) f= ((ex-sx)<<16)/ey;
1367         else   f= 0;
1368         for(y= 0; y <= ey; y++){
1369             x= ((y*f) + (1<<15))>>16;
1370             buf[y*stride + x]+= color;
1371         }
1372     }
1373 }
1374
1375 /**
1376  * draws an arrow from (ex, ey) -> (sx, sy).
1377  * @param w width of the image
1378  * @param h height of the image
1379  * @param stride stride/linesize of the image
1380  * @param color color of the arrow
1381  */
1382 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1383     int dx,dy;
1384
1385     sx= clip(sx, -100, w+100);
1386     sy= clip(sy, -100, h+100);
1387     ex= clip(ex, -100, w+100);
1388     ey= clip(ey, -100, h+100);
1389     
1390     dx= ex - sx;
1391     dy= ey - sy;
1392     
1393     if(dx*dx + dy*dy > 3*3){
1394         int rx=  dx + dy;
1395         int ry= -dx + dy;
1396         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1397         
1398         //FIXME subpixel accuracy
1399         rx= ROUNDED_DIV(rx*3<<4, length);
1400         ry= ROUNDED_DIV(ry*3<<4, length);
1401         
1402         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1403         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1404     }
1405     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1406 }
1407
1408 /**
1409  * prints debuging info for the given picture.
1410  */
1411 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1412
1413     if(!pict || !pict->mb_type) return;
1414
1415     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1416         int x,y;
1417         
1418         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1419         switch (pict->pict_type) {
1420             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1421             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1422             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1423             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1424             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1425             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1426         }
1427         for(y=0; y<s->mb_height; y++){
1428             for(x=0; x<s->mb_width; x++){
1429                 if(s->avctx->debug&FF_DEBUG_SKIP){
1430                     int count= s->mbskip_table[x + y*s->mb_stride];
1431                     if(count>9) count=9;
1432                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1433                 }
1434                 if(s->avctx->debug&FF_DEBUG_QP){
1435                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1436                 }
1437                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1438                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1439                     //Type & MV direction
1440                     if(IS_PCM(mb_type))
1441                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1442                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1443                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1444                     else if(IS_INTRA4x4(mb_type))
1445                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1446                     else if(IS_INTRA16x16(mb_type))
1447                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1448                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1449                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1450                     else if(IS_DIRECT(mb_type))
1451                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1452                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1453                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1454                     else if(IS_GMC(mb_type))
1455                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1456                     else if(IS_SKIP(mb_type))
1457                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1458                     else if(!USES_LIST(mb_type, 1))
1459                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1460                     else if(!USES_LIST(mb_type, 0))
1461                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1462                     else{
1463                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1464                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1465                     }
1466                     
1467                     //segmentation
1468                     if(IS_8X8(mb_type))
1469                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1470                     else if(IS_16X8(mb_type))
1471                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1472                     else if(IS_8X16(mb_type))
1473                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1474                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1475                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1476                     else
1477                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1478                     
1479                         
1480                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1481                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1482                     else
1483                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1484                 }
1485 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1486             }
1487             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1488         }
1489     }
1490
1491     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1492         const int shift= 1 + s->quarter_sample;
1493         int mb_y;
1494         uint8_t *ptr;
1495         int i;
1496         int h_chroma_shift, v_chroma_shift;
1497         s->low_delay=0; //needed to see the vectors without trashing the buffers
1498
1499         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1500         for(i=0; i<3; i++){
1501             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1502             pict->data[i]= s->visualization_buffer[i];
1503         }
1504         pict->type= FF_BUFFER_TYPE_COPY;
1505         ptr= pict->data[0];
1506
1507         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1508             int mb_x;
1509             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1510                 const int mb_index= mb_x + mb_y*s->mb_stride;
1511                 if((s->avctx->debug_mv) && pict->motion_val){
1512                   int type;
1513                   for(type=0; type<3; type++){
1514                     int direction;
1515                     switch (type) {
1516                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1517                                 continue;
1518                               direction = 0;
1519                               break;
1520                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1521                                 continue;
1522                               direction = 0;
1523                               break;
1524                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1525                                 continue;
1526                               direction = 1;
1527                               break;
1528                     }
1529                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1530                         continue;
1531
1532                     if(IS_8X8(pict->mb_type[mb_index])){
1533                       int i;
1534                       for(i=0; i<4; i++){
1535                         int sx= mb_x*16 + 4 + 8*(i&1);
1536                         int sy= mb_y*16 + 4 + 8*(i>>1);
1537                         int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1538                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1539                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1540                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1541                       }
1542                     }else if(IS_16X8(pict->mb_type[mb_index])){
1543                       int i;
1544                       for(i=0; i<2; i++){
1545                         int sx=mb_x*16 + 8;
1546                         int sy=mb_y*16 + 4 + 8*i;
1547                         int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2);
1548                         int mx=(pict->motion_val[direction][xy][0]>>shift) + sx;
1549                         int my=(pict->motion_val[direction][xy][1]>>shift) + sy;
1550                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1551                       }
1552                     }else{
1553                       int sx= mb_x*16 + 8;
1554                       int sy= mb_y*16 + 8;
1555                       int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1556                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1557                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1558                       draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1559                     }
1560                   }                  
1561                 }
1562                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1563                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1564                     int y;
1565                     for(y=0; y<8; y++){
1566                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1567                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1568                     }
1569                 }
1570                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1571                     int mb_type= pict->mb_type[mb_index];
1572                     uint64_t u,v;
1573                     int y;
1574 #define COLOR(theta, r)\
1575 u= (int)(128 + r*cos(theta*3.141592/180));\
1576 v= (int)(128 + r*sin(theta*3.141592/180));
1577
1578                     
1579                     u=v=128;
1580                     if(IS_PCM(mb_type)){
1581                         COLOR(120,48)
1582                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1583                         COLOR(30,48)
1584                     }else if(IS_INTRA4x4(mb_type)){
1585                         COLOR(90,48)
1586                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1587 //                        COLOR(120,48)
1588                     }else if(IS_DIRECT(mb_type)){
1589                         COLOR(150,48)
1590                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1591                         COLOR(170,48)
1592                     }else if(IS_GMC(mb_type)){
1593                         COLOR(190,48)
1594                     }else if(IS_SKIP(mb_type)){
1595 //                        COLOR(180,48)
1596                     }else if(!USES_LIST(mb_type, 1)){
1597                         COLOR(240,48)
1598                     }else if(!USES_LIST(mb_type, 0)){
1599                         COLOR(0,48)
1600                     }else{
1601                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1602                         COLOR(300,48)
1603                     }
1604
1605                     u*= 0x0101010101010101ULL;
1606                     v*= 0x0101010101010101ULL;
1607                     for(y=0; y<8; y++){
1608                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1609                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1610                     }
1611
1612                     //segmentation
1613                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1614                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1615                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1616                     }
1617                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1618                         for(y=0; y<16; y++)
1619                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1620                     }
1621                         
1622                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1623                         // hmm
1624                     }
1625                 }
1626                 s->mbskip_table[mb_index]=0;
1627             }
1628         }
1629     }
1630 }
1631
1632 #ifdef CONFIG_ENCODERS
1633
1634 static int get_sae(uint8_t *src, int ref, int stride){
1635     int x,y;
1636     int acc=0;
1637     
1638     for(y=0; y<16; y++){
1639         for(x=0; x<16; x++){
1640             acc+= ABS(src[x+y*stride] - ref);
1641         }
1642     }
1643     
1644     return acc;
1645 }
1646
1647 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1648     int x, y, w, h;
1649     int acc=0;
1650     
1651     w= s->width &~15;
1652     h= s->height&~15;
1653     
1654     for(y=0; y<h; y+=16){
1655         for(x=0; x<w; x+=16){
1656             int offset= x + y*stride;
1657             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1658             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1659             int sae = get_sae(src + offset, mean, stride);
1660             
1661             acc+= sae + 500 < sad;
1662         }
1663     }
1664     return acc;
1665 }
1666
1667
1668 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1669     AVFrame *pic=NULL;
1670     int i;
1671     const int encoding_delay= s->max_b_frames;
1672     int direct=1;
1673     
1674   if(pic_arg){
1675     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1676     if(pic_arg->linesize[0] != s->linesize) direct=0;
1677     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1678     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1679   
1680 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1681     
1682     if(direct){
1683         i= ff_find_unused_picture(s, 1);
1684
1685         pic= (AVFrame*)&s->picture[i];
1686         pic->reference= 3;
1687     
1688         for(i=0; i<4; i++){
1689             pic->data[i]= pic_arg->data[i];
1690             pic->linesize[i]= pic_arg->linesize[i];
1691         }
1692         alloc_picture(s, (Picture*)pic, 1);
1693     }else{
1694         int offset= 16;
1695         i= ff_find_unused_picture(s, 0);
1696
1697         pic= (AVFrame*)&s->picture[i];
1698         pic->reference= 3;
1699
1700         alloc_picture(s, (Picture*)pic, 0);
1701
1702         if(   pic->data[0] + offset == pic_arg->data[0] 
1703            && pic->data[1] + offset == pic_arg->data[1]
1704            && pic->data[2] + offset == pic_arg->data[2]){
1705        // empty
1706         }else{
1707             int h_chroma_shift, v_chroma_shift;
1708             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1709         
1710             for(i=0; i<3; i++){
1711                 int src_stride= pic_arg->linesize[i];
1712                 int dst_stride= i ? s->uvlinesize : s->linesize;
1713                 int h_shift= i ? h_chroma_shift : 0;
1714                 int v_shift= i ? v_chroma_shift : 0;
1715                 int w= s->width >>h_shift;
1716                 int h= s->height>>v_shift;
1717                 uint8_t *src= pic_arg->data[i];
1718                 uint8_t *dst= pic->data[i] + offset;
1719             
1720                 if(src_stride==dst_stride)
1721                     memcpy(dst, src, src_stride*h);
1722                 else{
1723                     while(h--){
1724                         memcpy(dst, src, w);
1725                         dst += dst_stride;
1726                         src += src_stride;
1727                     }
1728                 }
1729             }
1730         }
1731     }
1732     copy_picture_attributes(pic, pic_arg);
1733     
1734     pic->display_picture_number= s->input_picture_number++;
1735   }
1736
1737     /* shift buffer entries */
1738     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1739         s->input_picture[i-1]= s->input_picture[i];
1740         
1741     s->input_picture[encoding_delay]= (Picture*)pic;
1742
1743     return 0;
1744 }
1745
1746 static void select_input_picture(MpegEncContext *s){
1747     int i;
1748
1749     for(i=1; i<MAX_PICTURE_COUNT; i++)
1750         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1751     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1752
1753     /* set next picture types & ordering */
1754     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1755         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1756             s->reordered_input_picture[0]= s->input_picture[0];
1757             s->reordered_input_picture[0]->pict_type= I_TYPE;
1758             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1759         }else{
1760             int b_frames;
1761             
1762             if(s->flags&CODEC_FLAG_PASS2){
1763                 for(i=0; i<s->max_b_frames+1; i++){
1764                     int pict_num= s->input_picture[0]->display_picture_number + i;
1765                     int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1766                     s->input_picture[i]->pict_type= pict_type;
1767                     
1768                     if(i + 1 >= s->rc_context.num_entries) break;
1769                 }
1770             }
1771
1772             if(s->input_picture[0]->pict_type){
1773                 /* user selected pict_type */
1774                 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1775                     if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1776                 }
1777             
1778                 if(b_frames > s->max_b_frames){
1779                     av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1780                     b_frames = s->max_b_frames;
1781                 }
1782             }else if(s->avctx->b_frame_strategy==0){
1783                 b_frames= s->max_b_frames;
1784                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
1785             }else if(s->avctx->b_frame_strategy==1){
1786                 for(i=1; i<s->max_b_frames+1; i++){
1787                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1788                         s->input_picture[i]->b_frame_score= 
1789                             get_intra_count(s, s->input_picture[i  ]->data[0], 
1790                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
1791                     }
1792                 }
1793                 for(i=0; i<s->max_b_frames; i++){
1794                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1795                 }
1796                                 
1797                 b_frames= FFMAX(0, i-1);
1798                 
1799                 /* reset scores */
1800                 for(i=0; i<b_frames+1; i++){
1801                     s->input_picture[i]->b_frame_score=0;
1802                 }
1803             }else{
1804                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1805                 b_frames=0;
1806             }
1807
1808             emms_c();
1809 //static int b_count=0;
1810 //b_count+= b_frames;
1811 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1812                         
1813             s->reordered_input_picture[0]= s->input_picture[b_frames];
1814             if(   s->picture_in_gop_number + b_frames >= s->gop_size 
1815                || s->reordered_input_picture[0]->pict_type== I_TYPE)
1816                 s->reordered_input_picture[0]->pict_type= I_TYPE;
1817             else
1818                 s->reordered_input_picture[0]->pict_type= P_TYPE;
1819             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1820             for(i=0; i<b_frames; i++){
1821                 s->reordered_input_picture[i+1]= s->input_picture[i];
1822                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1823                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
1824             }
1825         }
1826     }
1827     
1828     if(s->reordered_input_picture[0]){
1829         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1830
1831         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1832
1833         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1834             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1835         
1836             int i= ff_find_unused_picture(s, 0);
1837             Picture *pic= &s->picture[i];
1838
1839             /* mark us unused / free shared pic */
1840             for(i=0; i<4; i++)
1841                 s->reordered_input_picture[0]->data[i]= NULL;
1842             s->reordered_input_picture[0]->type= 0;
1843             
1844             copy_picture_attributes((AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
1845             pic->reference              = s->reordered_input_picture[0]->reference;
1846             
1847             alloc_picture(s, pic, 0);
1848
1849             s->current_picture_ptr= pic;
1850         }else{
1851             // input is not a shared pix -> reuse buffer for current_pix
1852
1853             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1854                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1855             
1856             s->current_picture_ptr= s->reordered_input_picture[0];
1857             for(i=0; i<4; i++){
1858                 s->new_picture.data[i]+=16;
1859             }
1860         }
1861         copy_picture(&s->current_picture, s->current_picture_ptr);
1862     
1863         s->picture_number= s->new_picture.display_picture_number;
1864 //printf("dpn:%d\n", s->picture_number);
1865     }else{
1866        memset(&s->new_picture, 0, sizeof(Picture));
1867     }
1868 }
1869
1870 int MPV_encode_picture(AVCodecContext *avctx,
1871                        unsigned char *buf, int buf_size, void *data)
1872 {
1873     MpegEncContext *s = avctx->priv_data;
1874     AVFrame *pic_arg = data;
1875     int i, stuffing_count;
1876
1877     if(avctx->pix_fmt != PIX_FMT_YUV420P){
1878         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1879         return -1;
1880     }
1881     
1882     init_put_bits(&s->pb, buf, buf_size);
1883
1884     s->picture_in_gop_number++;
1885
1886     load_input_picture(s, pic_arg);
1887     
1888     select_input_picture(s);
1889     
1890     /* output? */
1891     if(s->new_picture.data[0]){
1892         s->pict_type= s->new_picture.pict_type;
1893 //emms_c();
1894 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1895         MPV_frame_start(s, avctx);
1896
1897         encode_picture(s, s->picture_number);
1898         
1899         avctx->real_pict_num  = s->picture_number;
1900         avctx->header_bits = s->header_bits;
1901         avctx->mv_bits     = s->mv_bits;
1902         avctx->misc_bits   = s->misc_bits;
1903         avctx->i_tex_bits  = s->i_tex_bits;
1904         avctx->p_tex_bits  = s->p_tex_bits;
1905         avctx->i_count     = s->i_count;
1906         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1907         avctx->skip_count  = s->skip_count;
1908
1909         MPV_frame_end(s);
1910
1911         if (s->out_format == FMT_MJPEG)
1912             mjpeg_picture_trailer(s);
1913         
1914         if(s->flags&CODEC_FLAG_PASS1)
1915             ff_write_pass1_stats(s);
1916
1917         for(i=0; i<4; i++){
1918             avctx->error[i] += s->current_picture_ptr->error[i];
1919         }
1920     }
1921
1922     flush_put_bits(&s->pb);
1923     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1924
1925     stuffing_count= ff_vbv_update(s, s->frame_bits);
1926     if(stuffing_count){
1927         switch(s->codec_id){
1928         case CODEC_ID_MPEG1VIDEO:
1929         case CODEC_ID_MPEG2VIDEO:
1930             while(stuffing_count--){
1931                 put_bits(&s->pb, 8, 0);
1932             }
1933         break;
1934         case CODEC_ID_MPEG4:
1935             put_bits(&s->pb, 16, 0);
1936             put_bits(&s->pb, 16, 0x1C3);
1937             stuffing_count -= 4;
1938             while(stuffing_count--){
1939                 put_bits(&s->pb, 8, 0xFF);
1940             }
1941         break;
1942         default:
1943             av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1944         }
1945         flush_put_bits(&s->pb);
1946         s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1947     }
1948
1949     /* update mpeg1/2 vbv_delay for CBR */    
1950     if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){
1951         int vbv_delay;
1952
1953         assert(s->repeat_first_field==0);
1954         
1955         vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
1956         assert(vbv_delay < 0xFFFF);
1957
1958         s->vbv_delay_ptr[0] &= 0xF8;
1959         s->vbv_delay_ptr[0] |= vbv_delay>>13;
1960         s->vbv_delay_ptr[1]  = vbv_delay>>5;
1961         s->vbv_delay_ptr[2] &= 0x07;
1962         s->vbv_delay_ptr[2] |= vbv_delay<<3;
1963     }
1964
1965     s->total_bits += s->frame_bits;
1966     avctx->frame_bits  = s->frame_bits;
1967     
1968     return s->frame_bits/8;
1969 }
1970
1971 #endif //CONFIG_ENCODERS
1972
1973 static inline void gmc1_motion(MpegEncContext *s,
1974                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1975                                int dest_offset,
1976                                uint8_t **ref_picture, int src_offset)
1977 {
1978     uint8_t *ptr;
1979     int offset, src_x, src_y, linesize, uvlinesize;
1980     int motion_x, motion_y;
1981     int emu=0;
1982
1983     motion_x= s->sprite_offset[0][0];
1984     motion_y= s->sprite_offset[0][1];
1985     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1986     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1987     motion_x<<=(3-s->sprite_warping_accuracy);
1988     motion_y<<=(3-s->sprite_warping_accuracy);
1989     src_x = clip(src_x, -16, s->width);
1990     if (src_x == s->width)
1991         motion_x =0;
1992     src_y = clip(src_y, -16, s->height);
1993     if (src_y == s->height)
1994         motion_y =0;
1995
1996     linesize = s->linesize;
1997     uvlinesize = s->uvlinesize;
1998     
1999     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2000
2001     dest_y+=dest_offset;
2002     if(s->flags&CODEC_FLAG_EMU_EDGE){
2003         if(   (unsigned)src_x >= s->h_edge_pos - 17
2004            || (unsigned)src_y >= s->v_edge_pos - 17){
2005             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2006             ptr= s->edge_emu_buffer;
2007         }
2008     }
2009     
2010     if((motion_x|motion_y)&7){
2011         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2012         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2013     }else{
2014         int dxy;
2015         
2016         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2017         if (s->no_rounding){
2018             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2019         }else{
2020             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2021         }
2022     }
2023     
2024     if(s->flags&CODEC_FLAG_GRAY) return;
2025
2026     motion_x= s->sprite_offset[1][0];
2027     motion_y= s->sprite_offset[1][1];
2028     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2029     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2030     motion_x<<=(3-s->sprite_warping_accuracy);
2031     motion_y<<=(3-s->sprite_warping_accuracy);
2032     src_x = clip(src_x, -8, s->width>>1);
2033     if (src_x == s->width>>1)
2034         motion_x =0;
2035     src_y = clip(src_y, -8, s->height>>1);
2036     if (src_y == s->height>>1)
2037         motion_y =0;
2038
2039     offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
2040     ptr = ref_picture[1] + offset;
2041     if(s->flags&CODEC_FLAG_EMU_EDGE){
2042         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2043            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2044             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2045             ptr= s->edge_emu_buffer;
2046             emu=1;
2047         }
2048     }
2049     s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2050     
2051     ptr = ref_picture[2] + offset;
2052     if(emu){
2053         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2054         ptr= s->edge_emu_buffer;
2055     }
2056     s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2057     
2058     return;
2059 }
2060
2061 static inline void gmc_motion(MpegEncContext *s,
2062                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2063                                int dest_offset,
2064                                uint8_t **ref_picture, int src_offset)
2065 {
2066     uint8_t *ptr;
2067     int linesize, uvlinesize;
2068     const int a= s->sprite_warping_accuracy;
2069     int ox, oy;
2070
2071     linesize = s->linesize;
2072     uvlinesize = s->uvlinesize;
2073
2074     ptr = ref_picture[0] + src_offset;
2075
2076     dest_y+=dest_offset;
2077     
2078     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2079     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2080
2081     s->dsp.gmc(dest_y, ptr, linesize, 16,
2082            ox, 
2083            oy, 
2084            s->sprite_delta[0][0], s->sprite_delta[0][1],
2085            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2086            a+1, (1<<(2*a+1)) - s->no_rounding,
2087            s->h_edge_pos, s->v_edge_pos);
2088     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2089            ox + s->sprite_delta[0][0]*8, 
2090            oy + s->sprite_delta[1][0]*8, 
2091            s->sprite_delta[0][0], s->sprite_delta[0][1],
2092            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2093            a+1, (1<<(2*a+1)) - s->no_rounding,
2094            s->h_edge_pos, s->v_edge_pos);
2095
2096     if(s->flags&CODEC_FLAG_GRAY) return;
2097
2098
2099     dest_cb+=dest_offset>>1;
2100     dest_cr+=dest_offset>>1;
2101     
2102     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2103     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2104
2105     ptr = ref_picture[1] + (src_offset>>1);
2106     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2107            ox, 
2108            oy, 
2109            s->sprite_delta[0][0], s->sprite_delta[0][1],
2110            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2111            a+1, (1<<(2*a+1)) - s->no_rounding,
2112            s->h_edge_pos>>1, s->v_edge_pos>>1);
2113     
2114     ptr = ref_picture[2] + (src_offset>>1);
2115     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2116            ox, 
2117            oy, 
2118            s->sprite_delta[0][0], s->sprite_delta[0][1],
2119            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2120            a+1, (1<<(2*a+1)) - s->no_rounding,
2121            s->h_edge_pos>>1, s->v_edge_pos>>1);
2122 }
2123
2124 /**
2125  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2126  * @param buf destination buffer
2127  * @param src source buffer
2128  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2129  * @param block_w width of block
2130  * @param block_h height of block
2131  * @param src_x x coordinate of the top left sample of the block in the source buffer
2132  * @param src_y y coordinate of the top left sample of the block in the source buffer
2133  * @param w width of the source buffer
2134  * @param h height of the source buffer
2135  */
2136 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2137                                     int src_x, int src_y, int w, int h){
2138     int x, y;
2139     int start_y, start_x, end_y, end_x;
2140
2141     if(src_y>= h){
2142         src+= (h-1-src_y)*linesize;
2143         src_y=h-1;
2144     }else if(src_y<=-block_h){
2145         src+= (1-block_h-src_y)*linesize;
2146         src_y=1-block_h;
2147     }
2148     if(src_x>= w){
2149         src+= (w-1-src_x);
2150         src_x=w-1;
2151     }else if(src_x<=-block_w){
2152         src+= (1-block_w-src_x);
2153         src_x=1-block_w;
2154     }
2155
2156     start_y= FFMAX(0, -src_y);
2157     start_x= FFMAX(0, -src_x);
2158     end_y= FFMIN(block_h, h-src_y);
2159     end_x= FFMIN(block_w, w-src_x);
2160
2161     // copy existing part
2162     for(y=start_y; y<end_y; y++){
2163         for(x=start_x; x<end_x; x++){
2164             buf[x + y*linesize]= src[x + y*linesize];
2165         }
2166     }
2167
2168     //top
2169     for(y=0; y<start_y; y++){
2170         for(x=start_x; x<end_x; x++){
2171             buf[x + y*linesize]= buf[x + start_y*linesize];
2172         }
2173     }
2174
2175     //bottom
2176     for(y=end_y; y<block_h; y++){
2177         for(x=start_x; x<end_x; x++){
2178             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2179         }
2180     }
2181                                     
2182     for(y=0; y<block_h; y++){
2183        //left
2184         for(x=0; x<start_x; x++){
2185             buf[x + y*linesize]= buf[start_x + y*linesize];
2186         }
2187        
2188        //right
2189         for(x=end_x; x<block_w; x++){
2190             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2191         }
2192     }
2193 }
2194
2195 static inline int hpel_motion(MpegEncContext *s, 
2196                                   uint8_t *dest, uint8_t *src, 
2197                                   int src_x, int src_y,
2198                                   int width, int height, int stride,
2199                                   int h_edge_pos, int v_edge_pos,
2200                                   int w, int h, op_pixels_func *pix_op,
2201                                   int motion_x, int motion_y)
2202 {
2203     int dxy;
2204     int emu=0;
2205
2206     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2207     src_x += motion_x >> 1;
2208     src_y += motion_y >> 1;
2209                 
2210     /* WARNING: do no forget half pels */
2211     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2212     if (src_x == width)
2213         dxy &= ~1;
2214     src_y = clip(src_y, -16, height);
2215     if (src_y == height)
2216         dxy &= ~2;
2217     src += src_y * stride + src_x;
2218
2219     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2220         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2221            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2222             ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1,
2223                              src_x, src_y, h_edge_pos, v_edge_pos);
2224             src= s->edge_emu_buffer;
2225             emu=1;
2226         }
2227     }
2228     pix_op[dxy](dest, src, stride, h);
2229     return emu;
2230 }
2231
2232 /* apply one mpeg motion vector to the three components */
2233 static inline void mpeg_motion(MpegEncContext *s,
2234                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2235                                int dest_offset,
2236                                uint8_t **ref_picture, int src_offset,
2237                                int field_based, op_pixels_func (*pix_op)[4],
2238                                int motion_x, int motion_y, int h)
2239 {
2240     uint8_t *ptr;
2241     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize;
2242     int emu=0;
2243 #if 0    
2244 if(s->quarter_sample)
2245 {
2246     motion_x>>=1;
2247     motion_y>>=1;
2248 }
2249 #endif
2250
2251     height = s->height >> field_based;
2252     v_edge_pos = s->v_edge_pos >> field_based;
2253     uvlinesize = s->current_picture.linesize[1] << field_based;
2254
2255     emu= hpel_motion(s, 
2256                 dest_y + dest_offset, ref_picture[0] + src_offset,
2257                 s->mb_x * 16, s->mb_y * (16 >> field_based),
2258                 s->width, height, s->current_picture.linesize[0] << field_based,
2259                 s->h_edge_pos, v_edge_pos,
2260                 16, h, pix_op[0],
2261                 motion_x, motion_y);
2262
2263
2264     if(s->flags&CODEC_FLAG_GRAY) return;
2265
2266     if (s->out_format == FMT_H263) {
2267         dxy = 0;
2268         if ((motion_x & 3) != 0)
2269             dxy |= 1;
2270         if ((motion_y & 3) != 0)
2271             dxy |= 2;
2272         mx = motion_x >> 2;
2273         my = motion_y >> 2;
2274     } else {
2275         mx = motion_x / 2;
2276         my = motion_y / 2;
2277         dxy = ((my & 1) << 1) | (mx & 1);
2278         mx >>= 1;
2279         my >>= 1;
2280     }
2281     
2282     src_x = s->mb_x * 8 + mx;
2283     src_y = s->mb_y * (8 >> field_based) + my;
2284     src_x = clip(src_x, -8, s->width >> 1);
2285     if (src_x == (s->width >> 1))
2286         dxy &= ~1;
2287     src_y = clip(src_y, -8, height >> 1);
2288     if (src_y == (height >> 1))
2289         dxy &= ~2;
2290     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2291     ptr = ref_picture[1] + offset;
2292     if(emu){
2293         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2294                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2295         ptr= s->edge_emu_buffer + (src_offset >> 1);
2296     }
2297     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2298
2299     ptr = ref_picture[2] + offset;
2300     if(emu){
2301         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2302                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2303         ptr= s->edge_emu_buffer + (src_offset >> 1);
2304     }
2305     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2306 }
2307 //FIXME move to dsputil, avg variant, 16x16 version
2308 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2309     int x;
2310     uint8_t * const top   = src[1];
2311     uint8_t * const left  = src[2];
2312     uint8_t * const mid   = src[0];
2313     uint8_t * const right = src[3];
2314     uint8_t * const bottom= src[4];
2315 #define OBMC_FILTER(x, t, l, m, r, b)\
2316     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2317 #define OBMC_FILTER4(x, t, l, m, r, b)\
2318     OBMC_FILTER(x         , t, l, m, r, b);\
2319     OBMC_FILTER(x+1       , t, l, m, r, b);\
2320     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2321     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2322     
2323     x=0;
2324     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2325     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2326     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2327     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2328     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2329     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2330     x+= stride;
2331     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2332     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2333     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2334     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2335     x+= stride;
2336     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2337     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2338     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2339     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2340     x+= 2*stride;
2341     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2342     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2343     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2344     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2345     x+= 2*stride;
2346     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2347     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2348     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2349     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2350     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2351     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2352     x+= stride;
2353     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2354     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2355     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2356     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2357 }
2358
2359 /* obmc for 1 8x8 luma block */
2360 static inline void obmc_motion(MpegEncContext *s,
2361                                uint8_t *dest, uint8_t *src,
2362                                int src_x, int src_y,
2363                                op_pixels_func *pix_op,
2364                                int16_t mv[5][2]/* mid top left right bottom*/)
2365 #define MID    0
2366 {
2367     int i;
2368     uint8_t *ptr[5];
2369     
2370     assert(s->quarter_sample==0);
2371     
2372     for(i=0; i<5; i++){
2373         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2374             ptr[i]= ptr[MID];
2375         }else{
2376             ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1);
2377             hpel_motion(s, ptr[i], src,
2378                         src_x, src_y,
2379                         s->width, s->height, s->linesize,
2380                         s->h_edge_pos, s->v_edge_pos,
2381                         8, 8, pix_op,
2382                         mv[i][0], mv[i][1]);
2383         }
2384     }
2385
2386     put_obmc(dest, ptr, s->linesize);                
2387 }
2388
2389 static inline void qpel_motion(MpegEncContext *s,
2390                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2391                                int dest_offset,
2392                                uint8_t **ref_picture, int src_offset,
2393                                int field_based, op_pixels_func (*pix_op)[4],
2394                                qpel_mc_func (*qpix_op)[16],
2395                                int motion_x, int motion_y, int h)
2396 {
2397     uint8_t *ptr;
2398     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
2399     int emu=0;
2400
2401     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2402     src_x = s->mb_x * 16 + (motion_x >> 2);
2403     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2404
2405     height = s->height >> field_based;
2406     v_edge_pos = s->v_edge_pos >> field_based;
2407     src_x = clip(src_x, -16, s->width);
2408     if (src_x == s->width)
2409         dxy &= ~3;
2410     src_y = clip(src_y, -16, height);
2411     if (src_y == height)
2412         dxy &= ~12;
2413     linesize = s->linesize << field_based;
2414     uvlinesize = s->uvlinesize << field_based;
2415     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2416     dest_y += dest_offset;
2417 //printf("%d %d %d\n", src_x, src_y, dxy);
2418     
2419     if(s->flags&CODEC_FLAG_EMU_EDGE){
2420         if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2421            || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2422             ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
2423                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2424             ptr= s->edge_emu_buffer + src_offset;
2425             emu=1;
2426         }
2427     }
2428     if(!field_based)
2429         qpix_op[0][dxy](dest_y, ptr, linesize);
2430     else{
2431         //damn interlaced mode
2432         //FIXME boundary mirroring is not exactly correct here
2433         qpix_op[1][dxy](dest_y  , ptr  , linesize);
2434         qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2435     }
2436
2437     if(s->flags&CODEC_FLAG_GRAY) return;
2438
2439     if(field_based){
2440         mx= motion_x/2;
2441         my= motion_y>>1;
2442     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2443         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2444         mx= (motion_x>>1) + rtab[motion_x&7];
2445         my= (motion_y>>1) + rtab[motion_y&7];
2446     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2447         mx= (motion_x>>1)|(motion_x&1);
2448         my= (motion_y>>1)|(motion_y&1);
2449     }else{
2450         mx= motion_x/2;
2451         my= motion_y/2;
2452     }
2453     mx= (mx>>1)|(mx&1);
2454     my= (my>>1)|(my&1);
2455
2456     dxy= (mx&1) | ((my&1)<<1);
2457     mx>>=1;
2458     my>>=1;
2459
2460     src_x = s->mb_x * 8 + mx;
2461     src_y = s->mb_y * (8 >> field_based) + my;
2462     src_x = clip(src_x, -8, s->width >> 1);
2463     if (src_x == (s->width >> 1))
2464         dxy &= ~1;
2465     src_y = clip(src_y, -8, height >> 1);
2466     if (src_y == (height >> 1))
2467         dxy &= ~2;
2468
2469     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2470     ptr = ref_picture[1] + offset;
2471     if(emu){
2472         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2473                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2474         ptr= s->edge_emu_buffer + (src_offset >> 1);
2475     }
2476     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2477     
2478     ptr = ref_picture[2] + offset;
2479     if(emu){
2480         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2481                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2482         ptr= s->edge_emu_buffer + (src_offset >> 1);
2483     }
2484     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2485 }
2486
2487 inline int ff_h263_round_chroma(int x){
2488     if (x >= 0)
2489         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2490     else {
2491         x = -x;
2492         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2493     }
2494 }
2495
2496 /**
2497  * h263 chorma 4mv motion compensation.
2498  */
2499 static inline void chroma_4mv_motion(MpegEncContext *s,
2500                                      uint8_t *dest_cb, uint8_t *dest_cr,
2501                                      uint8_t **ref_picture,
2502                                      op_pixels_func *pix_op,
2503                                      int mx, int my){
2504     int dxy, emu=0, src_x, src_y, offset;
2505     uint8_t *ptr;
2506     
2507     /* In case of 8X8, we construct a single chroma motion vector
2508        with a special rounding */
2509     mx= ff_h263_round_chroma(mx);
2510     my= ff_h263_round_chroma(my);
2511     
2512     dxy = ((my & 1) << 1) | (mx & 1);
2513     mx >>= 1;
2514     my >>= 1;
2515
2516     src_x = s->mb_x * 8 + mx;
2517     src_y = s->mb_y * 8 + my;
2518     src_x = clip(src_x, -8, s->width/2);
2519     if (src_x == s->width/2)
2520         dxy &= ~1;
2521     src_y = clip(src_y, -8, s->height/2);
2522     if (src_y == s->height/2)
2523         dxy &= ~2;
2524     
2525     offset = (src_y * (s->uvlinesize)) + src_x;
2526     ptr = ref_picture[1] + offset;
2527     if(s->flags&CODEC_FLAG_EMU_EDGE){
2528         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2529            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2530             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2531             ptr= s->edge_emu_buffer;
2532             emu=1;
2533         }
2534     }
2535     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2536
2537     ptr = ref_picture[2] + offset;
2538     if(emu){
2539         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2540         ptr= s->edge_emu_buffer;
2541     }
2542     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2543 }
2544
2545 /**
2546  * motion compesation of a single macroblock
2547  * @param s context
2548  * @param dest_y luma destination pointer
2549  * @param dest_cb chroma cb/u destination pointer
2550  * @param dest_cr chroma cr/v destination pointer
2551  * @param dir direction (0->forward, 1->backward)
2552  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2553  * @param pic_op halfpel motion compensation function (average or put normally)
2554  * @param pic_op qpel motion compensation function (average or put normally)
2555  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2556  */
2557 static inline void MPV_motion(MpegEncContext *s, 
2558                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2559                               int dir, uint8_t **ref_picture, 
2560                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2561 {
2562     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2563     int mb_x, mb_y, i;
2564     uint8_t *ptr, *dest;
2565
2566     mb_x = s->mb_x;
2567     mb_y = s->mb_y;
2568
2569     if(s->obmc && s->pict_type != B_TYPE){
2570         int16_t mv_cache[4][4][2];
2571         const int xy= s->mb_x + s->mb_y*s->mb_stride;
2572         const int mot_stride= s->mb_width*2 + 2;
2573         const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride;
2574
2575         assert(!s->mb_skiped);
2576                 
2577         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2578         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2579         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2580
2581         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2582             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2583         }else{
2584             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2585         }
2586
2587         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2588             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2589             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2590         }else{
2591             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2592             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2593         }
2594
2595         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2596             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2597             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2598         }else{
2599             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2600             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2601         }
2602         
2603         mx = 0;
2604         my = 0;
2605         for(i=0;i<4;i++) {
2606             const int x= (i&1)+1;
2607             const int y= (i>>1)+1;
2608             int16_t mv[5][2]= {
2609                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2610                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2611                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2612                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2613                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2614             //FIXME cleanup
2615             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2616                         ref_picture[0],
2617                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2618                         pix_op[1],
2619                         mv);
2620
2621             mx += mv[0][0];
2622             my += mv[0][1];
2623         }
2624         if(!(s->flags&CODEC_FLAG_GRAY))
2625             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2626
2627         return;
2628     }
2629    
2630     switch(s->mv_type) {
2631     case MV_TYPE_16X16:
2632 #ifdef CONFIG_RISKY
2633         if(s->mcsel){
2634             if(s->real_sprite_warping_points==1){
2635                 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2636                             ref_picture, 0);
2637             }else{
2638                 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2639                             ref_picture, 0);
2640             }
2641         }else if(s->quarter_sample){
2642             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2643                         ref_picture, 0,
2644                         0, pix_op, qpix_op,
2645                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2646         }else if(s->mspel){
2647             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2648                         ref_picture, pix_op,
2649                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2650         }else
2651 #endif
2652         {
2653             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2654                         ref_picture, 0,
2655                         0, pix_op,
2656                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2657         }           
2658         break;
2659     case MV_TYPE_8X8:
2660         mx = 0;
2661         my = 0;
2662         if(s->quarter_sample){
2663             for(i=0;i<4;i++) {
2664                 motion_x = s->mv[dir][i][0];
2665                 motion_y = s->mv[dir][i][1];
2666
2667                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2668                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2669                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2670                     
2671                 /* WARNING: do no forget half pels */
2672                 src_x = clip(src_x, -16, s->width);
2673                 if (src_x == s->width)
2674                     dxy &= ~3;
2675                 src_y = clip(src_y, -16, s->height);
2676                 if (src_y == s->height)
2677                     dxy &= ~12;
2678                     
2679                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2680                 if(s->flags&CODEC_FLAG_EMU_EDGE){
2681                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2682                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2683                         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2684                         ptr= s->edge_emu_buffer;
2685                     }
2686                 }
2687                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2688                 qpix_op[1][dxy](dest, ptr, s->linesize);
2689
2690                 mx += s->mv[dir][i][0]/2;
2691                 my += s->mv[dir][i][1]/2;
2692             }
2693         }else{
2694             for(i=0;i<4;i++) {
2695                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2696                             ref_picture[0],
2697                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2698                             s->width, s->height, s->linesize,
2699                             s->h_edge_pos, s->v_edge_pos,
2700                             8, 8, pix_op[1],
2701                             s->mv[dir][i][0], s->mv[dir][i][1]);
2702
2703                 mx += s->mv[dir][i][0];
2704                 my += s->mv[dir][i][1];
2705             }
2706         }
2707
2708         if(!(s->flags&CODEC_FLAG_GRAY))
2709             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2710         break;
2711     case MV_TYPE_FIELD:
2712         if (s->picture_structure == PICT_FRAME) {
2713             if(s->quarter_sample){
2714                 /* top field */
2715                 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2716                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2717                             1, pix_op, qpix_op,
2718                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
2719                 /* bottom field */
2720                 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2721                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2722                             1, pix_op, qpix_op,
2723                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
2724             }else{
2725                 /* top field */       
2726                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2727                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2728                             1, pix_op,
2729                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
2730                 /* bottom field */
2731                 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2732                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2733                             1, pix_op,
2734                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
2735             }
2736         } else {
2737             int offset;
2738             if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2739                 offset= s->field_select[dir][0] ? s->linesize : 0;
2740             }else{
2741                 ref_picture= s->current_picture.data;
2742                 offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2743             } 
2744
2745             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2746                         ref_picture, offset,
2747                         0, pix_op,
2748                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2749         }
2750         break;
2751     case MV_TYPE_16X8:{
2752         int offset;
2753          uint8_t ** ref2picture;
2754
2755             if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2756                 ref2picture= ref_picture;
2757                 offset= s->field_select[dir][0] ? s->linesize : 0;
2758             }else{
2759                 ref2picture= s->current_picture.data;
2760                 offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2761             } 
2762
2763             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2764                         ref2picture, offset,
2765                         0, pix_op,
2766                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
2767
2768
2769             if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2770                 ref2picture= ref_picture;
2771                 offset= s->field_select[dir][1] ? s->linesize : 0;
2772             }else{
2773                 ref2picture= s->current_picture.data;
2774                 offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2775             } 
2776             // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2777             mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2778                         0,
2779                         ref2picture, offset,
2780                         0, pix_op,
2781                         s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2782         }
2783         
2784         break;
2785     case MV_TYPE_DMV:
2786     {
2787     op_pixels_func (*dmv_pix_op)[4];
2788     int offset;
2789
2790         dmv_pix_op = s->dsp.put_pixels_tab;
2791
2792         if(s->picture_structure == PICT_FRAME){
2793             //put top field from top field
2794             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2795                         ref_picture, 0,
2796                         1, dmv_pix_op,
2797                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
2798             //put bottom field from bottom field
2799             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2800                         ref_picture, s->linesize,
2801                         1, dmv_pix_op,
2802                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
2803
2804             dmv_pix_op = s->dsp.avg_pixels_tab; 
2805         
2806             //avg top field from bottom field
2807             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2808                         ref_picture, s->linesize,
2809                         1, dmv_pix_op,
2810                         s->mv[dir][2][0], s->mv[dir][2][1], 8);
2811             //avg bottom field from top field
2812             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2813                         ref_picture, 0,
2814                         1, dmv_pix_op,
2815                         s->mv[dir][3][0], s->mv[dir][3][1], 8);
2816
2817         }else{
2818             offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2819                          s->linesize : 0;
2820
2821             //put field from the same parity
2822             //same parity is never in the same frame
2823             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2824                         ref_picture,offset,
2825                         0,dmv_pix_op,
2826                         s->mv[dir][0][0],s->mv[dir][0][1],16);
2827
2828             // after put we make avg of the same block
2829             dmv_pix_op=s->dsp.avg_pixels_tab; 
2830
2831             //opposite parity is always in the same frame if this is second field
2832             if(!s->first_field){
2833                 ref_picture = s->current_picture.data;    
2834                 //top field is one linesize from frame beginig
2835                 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2836                         -s->linesize : s->linesize;
2837             }else 
2838                 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2839                         0 : s->linesize;
2840
2841             //avg field from the opposite parity
2842             mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2843                         ref_picture, offset,
2844                         0,dmv_pix_op,
2845                         s->mv[dir][2][0],s->mv[dir][2][1],16);
2846         }
2847     }
2848     break;
2849     default: assert(0);
2850     }
2851 }
2852
2853
2854 /* put block[] to dest[] */
2855 static inline void put_dct(MpegEncContext *s, 
2856                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2857 {
2858     s->dct_unquantize_intra(s, block, i, qscale);
2859     s->dsp.idct_put (dest, line_size, block);
2860 }
2861
2862 /* add block[] to dest[] */
2863 static inline void add_dct(MpegEncContext *s, 
2864                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2865 {
2866     if (s->block_last_index[i] >= 0) {
2867         s->dsp.idct_add (dest, line_size, block);
2868     }
2869 }
2870
2871 static inline void add_dequant_dct(MpegEncContext *s, 
2872                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2873 {
2874     if (s->block_last_index[i] >= 0) {
2875         s->dct_unquantize_inter(s, block, i, qscale);
2876
2877         s->dsp.idct_add (dest, line_size, block);
2878     }
2879 }
2880
2881 /**
2882  * cleans dc, ac, coded_block for the current non intra MB
2883  */
2884 void ff_clean_intra_table_entries(MpegEncContext *s)
2885 {
2886     int wrap = s->block_wrap[0];
2887     int xy = s->block_index[0];
2888     
2889     s->dc_val[0][xy           ] = 
2890     s->dc_val[0][xy + 1       ] = 
2891     s->dc_val[0][xy     + wrap] =
2892     s->dc_val[0][xy + 1 + wrap] = 1024;
2893     /* ac pred */
2894     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2895     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2896     if (s->msmpeg4_version>=3) {
2897         s->coded_block[xy           ] =
2898         s->coded_block[xy + 1       ] =
2899         s->coded_block[xy     + wrap] =
2900         s->coded_block[xy + 1 + wrap] = 0;
2901     }
2902     /* chroma */
2903     wrap = s->block_wrap[4];
2904     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2905     s->dc_val[1][xy] =
2906     s->dc_val[2][xy] = 1024;
2907     /* ac pred */
2908     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2909     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2910     
2911     s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2912 }
2913
2914 /* generic function called after a macroblock has been parsed by the
2915    decoder or after it has been encoded by the encoder.
2916
2917    Important variables used:
2918    s->mb_intra : true if intra macroblock
2919    s->mv_dir   : motion vector direction
2920    s->mv_type  : motion vector type
2921    s->mv       : motion vector
2922    s->interlaced_dct : true if interlaced dct used (mpeg2)
2923  */
2924 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2925 {
2926     int mb_x, mb_y;
2927     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2928 #ifdef HAVE_XVMC
2929     if(s->avctx->xvmc_acceleration){
2930         XVMC_decode_mb(s);//xvmc uses pblocks
2931         return;
2932     }
2933 #endif
2934
2935     mb_x = s->mb_x;
2936     mb_y = s->mb_y;
2937
2938     s->current_picture.qscale_table[mb_xy]= s->qscale;
2939
2940     /* update DC predictors for P macroblocks */
2941     if (!s->mb_intra) {
2942         if (s->h263_pred || s->h263_aic) {
2943             if(s->mbintra_table[mb_xy])
2944                 ff_clean_intra_table_entries(s);
2945         } else {
2946             s->last_dc[0] =
2947             s->last_dc[1] =
2948             s->last_dc[2] = 128 << s->intra_dc_precision;
2949         }
2950     }
2951     else if (s->h263_pred || s->h263_aic)
2952         s->mbintra_table[mb_xy]=1;
2953
2954     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2955         uint8_t *dest_y, *dest_cb, *dest_cr;
2956         int dct_linesize, dct_offset;
2957         op_pixels_func (*op_pix)[4];
2958         qpel_mc_func (*op_qpix)[16];
2959         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2960         const int uvlinesize= s->current_picture.linesize[1];
2961         const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
2962
2963         /* avoid copy if macroblock skipped in last frame too */
2964         /* skip only during decoding as we might trash the buffers during encoding a bit */
2965         if(!s->encoding){
2966             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2967             const int age= s->current_picture.age;
2968
2969             assert(age);
2970
2971             if (s->mb_skiped) {
2972                 s->mb_skiped= 0;
2973                 assert(s->pict_type!=I_TYPE);
2974  
2975                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2976                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2977
2978                 /* if previous was skipped too, then nothing to do !  */
2979                 if (*mbskip_ptr >= age && s->current_picture.reference){
2980                     return;
2981                 }
2982             } else if(!s->current_picture.reference){
2983                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2984                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2985             } else{
2986                 *mbskip_ptr = 0; /* not skipped */
2987             }
2988         }
2989
2990         if (s->interlaced_dct) {
2991             dct_linesize = linesize * 2;
2992             dct_offset = linesize;
2993         } else {
2994             dct_linesize = linesize;
2995             dct_offset = linesize * 8;
2996         }
2997         if(readable){
2998             dest_y=  s->dest[0];
2999             dest_cb= s->dest[1];
3000             dest_cr= s->dest[2];
3001         }else{
3002             dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers
3003             dest_cb= s->edge_emu_buffer+48;
3004             dest_cr= s->edge_emu_buffer+56;
3005         }
3006         if (!s->mb_intra) {
3007             /* motion handling */
3008             /* decoding or more than one mb_type (MC was allready done otherwise) */
3009             if(!s->encoding){
3010                 if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3011                     op_pix = s->dsp.put_pixels_tab;
3012                     op_qpix= s->dsp.put_qpel_pixels_tab;
3013                 }else{
3014                     op_pix = s->dsp.put_no_rnd_pixels_tab;
3015                     op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3016                 }
3017
3018                 if (s->mv_dir & MV_DIR_FORWARD) {
3019                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3020                     op_pix = s->dsp.avg_pixels_tab;
3021                     op_qpix= s->dsp.avg_qpel_pixels_tab;
3022                 }
3023                 if (s->mv_dir & MV_DIR_BACKWARD) {
3024                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3025                 }
3026             }
3027
3028             /* skip dequant / idct if we are really late ;) */
3029             if(s->hurry_up>1) return;
3030
3031             /* add dct residue */
3032             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3033                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3034                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3035                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3036                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3037                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3038
3039                 if(!(s->flags&CODEC_FLAG_GRAY)){
3040                     add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3041                     add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3042                 }
3043             } else if(s->codec_id != CODEC_ID_WMV2){
3044                 add_dct(s, block[0], 0, dest_y, dct_linesize);
3045                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3046                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3047                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3048
3049                 if(!(s->flags&CODEC_FLAG_GRAY)){
3050                     add_dct(s, block[4], 4, dest_cb, uvlinesize);
3051                     add_dct(s, block[5], 5, dest_cr, uvlinesize);
3052                 }
3053             } 
3054 #ifdef CONFIG_RISKY
3055             else{
3056                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3057             }
3058 #endif
3059         } else {
3060             /* dct only in intra block */
3061             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3062                 put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3063                 put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3064                 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3065                 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3066
3067                 if(!(s->flags&CODEC_FLAG_GRAY)){
3068                     put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3069                     put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3070                 }
3071             }else{
3072                 s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3073                 s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3074                 s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3075                 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3076
3077                 if(!(s->flags&CODEC_FLAG_GRAY)){
3078                     s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3079                     s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3080                 }
3081             }
3082         }
3083         if(!readable){
3084             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3085             s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3086             s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3087         }
3088     }
3089 }
3090
3091 #ifdef CONFIG_ENCODERS
3092
3093 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3094 {
3095     static const char tab[64]=
3096         {3,2,2,1,1,1,1,1,
3097          1,1,1,1,1,1,1,1,
3098          1,1,1,1,1,1,1,1,
3099          0,0,0,0,0,0,0,0,
3100          0,0,0,0,0,0,0,0,
3101          0,0,0,0,0,0,0,0,
3102          0,0,0,0,0,0,0,0,
3103          0,0,0,0,0,0,0,0};
3104     int score=0;
3105     int run=0;
3106     int i;
3107     DCTELEM *block= s->block[n];
3108     const int last_index= s->block_last_index[n];
3109     int skip_dc;
3110
3111     if(threshold<0){
3112         skip_dc=0;
3113         threshold= -threshold;
3114     }else
3115         skip_dc=1;
3116
3117     /* are all which we could set to zero are allready zero? */
3118     if(last_index<=skip_dc - 1) return;
3119
3120     for(i=0; i<=last_index; i++){
3121         const int j = s->intra_scantable.permutated[i];
3122         const int level = ABS(block[j]);
3123         if(level==1){
3124             if(skip_dc && i==0) continue;
3125             score+= tab[run];
3126             run=0;
3127         }else if(level>1){
3128             return;
3129         }else{
3130             run++;
3131         }
3132     }
3133     if(score >= threshold) return;
3134     for(i=skip_dc; i<=last_index; i++){
3135         const int j = s->intra_scantable.permutated[i];
3136         block[j]=0;
3137     }
3138     if(block[0]) s->block_last_index[n]= 0;
3139     else         s->block_last_index[n]= -1;
3140 }
3141
3142 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3143 {
3144     int i;
3145     const int maxlevel= s->max_qcoeff;
3146     const int minlevel= s->min_qcoeff;
3147     int overflow=0;
3148     
3149     if(s->mb_intra){
3150         i=1; //skip clipping of intra dc
3151     }else
3152         i=0;
3153     
3154     for(;i<=last_index; i++){
3155         const int j= s->intra_scantable.permutated[i];
3156         int level = block[j];
3157        
3158         if     (level>maxlevel){
3159             level=maxlevel;
3160             overflow++;
3161         }else if(level<minlevel){
3162             level=minlevel;
3163             overflow++;
3164         }
3165         
3166         block[j]= level;
3167     }
3168     
3169     if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3170         av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3171 }
3172
3173 #endif //CONFIG_ENCODERS
3174
3175 /**
3176  *
3177  * @param h is the normal height, this will be reduced automatically if needed for the last row
3178  */
3179 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3180     if (s->avctx->draw_horiz_band) {
3181         AVFrame *src;
3182         int offset[4];
3183         
3184         if(s->picture_structure != PICT_FRAME){
3185             h <<= 1;
3186             y <<= 1;
3187             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3188         }
3189
3190         h= FFMIN(h, s->height - y);
3191
3192         if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3193             src= (AVFrame*)s->current_picture_ptr;
3194         else if(s->last_picture_ptr)
3195             src= (AVFrame*)s->last_picture_ptr;
3196         else
3197             return;
3198             
3199         if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3200             offset[0]=
3201             offset[1]=
3202             offset[2]=
3203             offset[3]= 0;
3204         }else{
3205             offset[0]= y * s->linesize;;
3206             offset[1]= 
3207             offset[2]= (y>>1) * s->uvlinesize;;
3208             offset[3]= 0;
3209         }
3210
3211         emms_c();
3212
3213         s->avctx->draw_horiz_band(s->avctx, src, offset,
3214                                   y, s->picture_structure, h);
3215     }
3216 }
3217
3218 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3219     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3220     const int uvlinesize= s->current_picture.linesize[1];
3221         
3222     s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3223     s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
3224     s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
3225     s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
3226     s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3227     s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3228     
3229     if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3230         s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3231         s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3232         s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3233     }else{
3234         s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3235         s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3236         s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3237     }    
3238 }
3239
3240 #ifdef CONFIG_ENCODERS
3241
3242 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3243 {
3244     const int mb_x= s->mb_x;
3245     const int mb_y= s->mb_y;
3246     int i;
3247     int skip_dct[6];
3248     int dct_offset   = s->linesize*8; //default for progressive frames
3249     
3250     for(i=0; i<6; i++) skip_dct[i]=0;
3251     
3252     if(s->adaptive_quant){
3253         const int last_qp= s->qscale;
3254         const int mb_xy= mb_x + mb_y*s->mb_stride;
3255
3256         s->lambda= s->lambda_table[mb_xy];
3257         update_qscale(s);
3258     
3259         if(!(s->flags&CODEC_FLAG_QP_RD)){
3260             s->dquant= s->qscale - last_qp;
3261
3262             if(s->out_format==FMT_H263)
3263                 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3264             
3265             if(s->codec_id==CODEC_ID_MPEG4){        
3266                 if(!s->mb_intra){
3267                     if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8)
3268                         s->dquant=0;
3269                 }
3270             }
3271         }
3272         ff_set_qscale(s, last_qp + s->dquant);
3273     }
3274
3275     if (s->mb_intra) {
3276         uint8_t *ptr;
3277         int wrap_y;
3278         int emu=0;
3279
3280         wrap_y = s->linesize;
3281         ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3282
3283         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3284             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3285             ptr= s->edge_emu_buffer;
3286             emu=1;
3287         }
3288         
3289         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3290             int progressive_score, interlaced_score;
3291
3292             s->interlaced_dct=0;
3293             progressive_score= s->dsp.ildct_cmp[4](s, ptr           , NULL, wrap_y, 8) 
3294                               +s->dsp.ildct_cmp[4](s, ptr + wrap_y*8, NULL, wrap_y, 8) - 400;
3295
3296             if(progressive_score > 0){
3297                 interlaced_score = s->dsp.ildct_cmp[4](s, ptr           , NULL, wrap_y*2, 8) 
3298                                   +s->dsp.ildct_cmp[4](s, ptr + wrap_y  , NULL, wrap_y*2, 8);
3299                 if(progressive_score > interlaced_score){
3300                     s->interlaced_dct=1;
3301             
3302                     dct_offset= wrap_y;
3303                     wrap_y<<=1;
3304                 }
3305             }
3306         }
3307         
3308         s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
3309         s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
3310         s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
3311         s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
3312
3313         if(s->flags&CODEC_FLAG_GRAY){
3314             skip_dct[4]= 1;
3315             skip_dct[5]= 1;
3316         }else{
3317             int wrap_c = s->uvlinesize;
3318             ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3319             if(emu){
3320                 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3321                 ptr= s->edge_emu_buffer;
3322             }
3323             s->dsp.get_pixels(s->block[4], ptr, wrap_c);
3324
3325             ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3326             if(emu){
3327                 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3328                 ptr= s->edge_emu_buffer;
3329             }
3330             s->dsp.get_pixels(s->block[5], ptr, wrap_c);
3331         }
3332     }else{
3333         op_pixels_func (*op_pix)[4];
3334         qpel_mc_func (*op_qpix)[16];
3335         uint8_t *dest_y, *dest_cb, *dest_cr;
3336         uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3337         int wrap_y, wrap_c;
3338         int emu=0;
3339
3340         dest_y  = s->dest[0];
3341         dest_cb = s->dest[1];
3342         dest_cr = s->dest[2];
3343         wrap_y = s->linesize;
3344         wrap_c = s->uvlinesize;
3345         ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3346         ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3347         ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3348
3349         if ((!s->no_rounding) || s->pict_type==B_TYPE){
3350             op_pix = s->dsp.put_pixels_tab;
3351             op_qpix= s->dsp.put_qpel_pixels_tab;
3352         }else{
3353             op_pix = s->dsp.put_no_rnd_pixels_tab;
3354             op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3355         }
3356
3357         if (s->mv_dir & MV_DIR_FORWARD) {
3358             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3359             op_pix = s->dsp.avg_pixels_tab;
3360             op_qpix= s->dsp.avg_qpel_pixels_tab;
3361         }
3362         if (s->mv_dir & MV_DIR_BACKWARD) {
3363             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3364         }
3365
3366         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3367             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3368             ptr_y= s->edge_emu_buffer;
3369             emu=1;
3370         }
3371         
3372         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3373             int progressive_score, interlaced_score;
3374
3375             s->interlaced_dct=0;
3376             progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3377                               +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3378             
3379             if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3380
3381             if(progressive_score>0){
3382                 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3383                                   +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3384             
3385                 if(progressive_score > interlaced_score){
3386                     s->interlaced_dct=1;
3387             
3388                     dct_offset= wrap_y;
3389                     wrap_y<<=1;
3390                 }
3391             }
3392         }
3393         
3394         s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3395         s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3396         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3397         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3398         
3399         if(s->flags&CODEC_FLAG_GRAY){
3400             skip_dct[4]= 1;
3401             skip_dct[5]= 1;
3402         }else{
3403             if(emu){
3404                 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3405                 ptr_cb= s->edge_emu_buffer;
3406             }
3407             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3408             if(emu){
3409                 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3410                 ptr_cr= s->edge_emu_buffer;
3411             }
3412             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3413         }
3414         /* pre quantization */         
3415         if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3416             //FIXME optimize
3417             if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3418             if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3419             if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3420             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;
3421             if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3422             if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3423 #if 0
3424 {
3425  static int stat[7];
3426  int num=0;
3427  for(i=0; i<6; i++)
3428   if(skip_dct[i]) num++;
3429  stat[num]++;
3430  
3431  if(s->mb_x==0 && s->mb_y==0){
3432   for(i=0; i<7; i++){
3433    printf("%6d %1d\n", stat[i], i);
3434   }
3435  }
3436 }
3437 #endif
3438         }
3439
3440     }
3441             
3442     /* DCT & quantize */
3443     if(s->out_format==FMT_MJPEG){
3444         for(i=0;i<6;i++) {
3445             int overflow;
3446             s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3447             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3448         }
3449     }else{
3450         for(i=0;i<6;i++) {
3451             if(!skip_dct[i]){
3452                 int overflow;
3453                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3454             // FIXME we could decide to change to quantizer instead of clipping
3455             // JS: I don't think that would be a good idea it could lower quality instead
3456             //     of improve it. Just INTRADC clipping deserves changes in quantizer
3457                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3458             }else
3459                 s->block_last_index[i]= -1;
3460         }
3461         
3462         if(s->luma_elim_threshold && !s->mb_intra)
3463             for(i=0; i<4; i++)
3464                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3465         if(s->chroma_elim_threshold && !s->mb_intra)
3466             for(i=4; i<6; i++)
3467                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3468
3469         if(s->flags & CODEC_FLAG_CBP_RD){
3470             for(i=0;i<6;i++) {
3471                 if(s->block_last_index[i] == -1)
3472                     s->coded_score[i]= INT_MAX/256;
3473             }
3474         }
3475     }
3476
3477     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3478         s->block_last_index[4]=
3479         s->block_last_index[5]= 0;
3480         s->block[4][0]=
3481         s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3482     }
3483
3484     //non c quantize code returns incorrect block_last_index FIXME
3485     if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3486         for(i=0; i<6; i++){
3487             int j;
3488             if(s->block_last_index[i]>0){
3489                 for(j=63; j>0; j--){
3490                     if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3491                 }
3492                 s->block_last_index[i]= j;
3493             }
3494         }
3495     }
3496
3497     /* huffman encode */
3498     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3499     case CODEC_ID_MPEG1VIDEO:
3500     case CODEC_ID_MPEG2VIDEO:
3501         mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3502 #ifdef CONFIG_RISKY
3503     case CODEC_ID_MPEG4:
3504         mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3505     case CODEC_ID_MSMPEG4V2:
3506     case CODEC_ID_MSMPEG4V3:
3507     case CODEC_ID_WMV1:
3508         msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3509     case CODEC_ID_WMV2:
3510          ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3511     case CODEC_ID_H263:
3512     case CODEC_ID_H263P:
3513     case CODEC_ID_FLV1:
3514     case CODEC_ID_RV10:
3515         h263_encode_mb(s, s->block, motion_x, motion_y); break;
3516 #endif
3517     case CODEC_ID_MJPEG:
3518         mjpeg_encode_mb(s, s->block); break;
3519     default:
3520         assert(0);
3521     }
3522 }
3523
3524 #endif //CONFIG_ENCODERS
3525
3526 /**
3527  * combines the (truncated) bitstream to a complete frame
3528  * @returns -1 if no complete frame could be created
3529  */
3530 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3531     ParseContext *pc= &s->parse_context;
3532
3533 #if 0
3534     if(pc->overread){
3535         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3536         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3537     }
3538 #endif
3539
3540     /* copy overreaded byes from last frame into buffer */
3541     for(; pc->overread>0; pc->overread--){
3542         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3543     }
3544     
3545     pc->last_index= pc->index;
3546
3547     /* copy into buffer end return */
3548     if(next == END_NOT_FOUND){
3549         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3550
3551         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3552         pc->index += *buf_size;
3553         return -1;
3554     }
3555
3556     *buf_size=
3557     pc->overread_index= pc->index + next;
3558     
3559     /* append to buffer */
3560     if(pc->index){
3561         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3562
3563         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3564         pc->index = 0;
3565         *buf= pc->buffer;
3566     }
3567
3568     /* store overread bytes */
3569     for(;next < 0; next++){
3570         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3571         pc->overread++;
3572     }
3573
3574 #if 0
3575     if(pc->overread){
3576         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3577         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3578     }
3579 #endif
3580
3581     return 0;
3582 }
3583
3584 void ff_mpeg_flush(AVCodecContext *avctx){
3585     int i;
3586     MpegEncContext *s = avctx->priv_data;
3587     
3588     if(s==NULL || s->picture==NULL) 
3589         return;
3590     
3591     for(i=0; i<MAX_PICTURE_COUNT; i++){
3592        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3593                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
3594         avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3595     }
3596     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3597     
3598     s->parse_context.state= -1;
3599     s->parse_context.frame_start_found= 0;
3600     s->parse_context.overread= 0;
3601     s->parse_context.overread_index= 0;
3602     s->parse_context.index= 0;
3603     s->parse_context.last_index= 0;
3604 }
3605
3606 #ifdef CONFIG_ENCODERS
3607 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3608 {
3609     int bytes= length>>4;
3610     int bits= length&15;
3611     int i;
3612
3613     if(length==0) return;
3614
3615     for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3616     put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3617 }
3618
3619 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3620     int i;
3621
3622     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3623
3624     /* mpeg1 */
3625     d->mb_skip_run= s->mb_skip_run;
3626     for(i=0; i<3; i++)
3627         d->last_dc[i]= s->last_dc[i];
3628     
3629     /* statistics */
3630     d->mv_bits= s->mv_bits;
3631     d->i_tex_bits= s->i_tex_bits;
3632     d->p_tex_bits= s->p_tex_bits;
3633     d->i_count= s->i_count;
3634     d->f_count= s->f_count;
3635     d->b_count= s->b_count;
3636     d->skip_count= s->skip_count;
3637     d->misc_bits= s->misc_bits;
3638     d->last_bits= 0;
3639
3640     d->mb_skiped= 0;
3641     d->qscale= s->qscale;
3642     d->dquant= s->dquant;
3643 }
3644
3645 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3646     int i;
3647
3648     memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3649     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3650     
3651     /* mpeg1 */
3652     d->mb_skip_run= s->mb_skip_run;
3653     for(i=0; i<3; i++)
3654         d->last_dc[i]= s->last_dc[i];
3655     
3656     /* statistics */
3657     d->mv_bits= s->mv_bits;
3658     d->i_tex_bits= s->i_tex_bits;
3659     d->p_tex_bits= s->p_tex_bits;
3660     d->i_count= s->i_count;
3661     d->f_count= s->f_count;
3662     d->b_count= s->b_count;
3663     d->skip_count= s->skip_count;
3664     d->misc_bits= s->misc_bits;
3665
3666     d->mb_intra= s->mb_intra;
3667     d->mb_skiped= s->mb_skiped;
3668     d->mv_type= s->mv_type;
3669     d->mv_dir= s->mv_dir;
3670     d->pb= s->pb;
3671     if(s->data_partitioning){
3672         d->pb2= s->pb2;
3673         d->tex_pb= s->tex_pb;
3674     }
3675     d->block= s->block;
3676     for(i=0; i<6; i++)
3677         d->block_last_index[i]= s->block_last_index[i];
3678     d->interlaced_dct= s->interlaced_dct;
3679     d->qscale= s->qscale;
3680 }
3681
3682 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3683                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3684                            int *dmin, int *next_block, int motion_x, int motion_y)
3685 {
3686     int score;
3687     uint8_t *dest_backup[3];
3688     
3689     copy_context_before_encode(s, backup, type);
3690
3691     s->block= s->blocks[*next_block];
3692     s->pb= pb[*next_block];
3693     if(s->data_partitioning){
3694         s->pb2   = pb2   [*next_block];
3695         s->tex_pb= tex_pb[*next_block];
3696     }
3697     
3698     if(*next_block){
3699         memcpy(dest_backup, s->dest, sizeof(s->dest));
3700         s->dest[0] = s->me.scratchpad;
3701         s->dest[1] = s->me.scratchpad + 16;
3702         s->dest[2] = s->me.scratchpad + 16 + 8;
3703         assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3704         assert(s->linesize >= 64); //FIXME
3705     }
3706
3707     encode_mb(s, motion_x, motion_y);
3708     
3709     score= get_bit_count(&s->pb);
3710     if(s->data_partitioning){
3711         score+= get_bit_count(&s->pb2);
3712         score+= get_bit_count(&s->tex_pb);
3713     }
3714    
3715     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3716         MPV_decode_mb(s, s->block);
3717
3718         score *= s->lambda2;
3719         score += sse_mb(s) << FF_LAMBDA_SHIFT;
3720     }
3721     
3722     if(*next_block){
3723         memcpy(s->dest, dest_backup, sizeof(s->dest));
3724     }
3725
3726     if(score<*dmin){
3727         *dmin= score;
3728         *next_block^=1;
3729
3730         copy_context_after_encode(best, s, type);
3731     }
3732 }
3733                 
3734 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3735     uint32_t *sq = squareTbl + 256;
3736     int acc=0;
3737     int x,y;
3738     
3739     if(w==16 && h==16) 
3740         return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3741     else if(w==8 && h==8)
3742         return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3743     
3744     for(y=0; y<h; y++){
3745         for(x=0; x<w; x++){
3746             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3747         } 
3748     }
3749     
3750     assert(acc>=0);
3751     
3752     return acc;
3753 }
3754
3755 static int sse_mb(MpegEncContext *s){
3756     int w= 16;
3757     int h= 16;
3758
3759     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3760     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3761
3762     if(w==16 && h==16)
3763         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)
3764                +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)
3765                +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);
3766     else
3767         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)
3768                +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)
3769                +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);
3770 }
3771
3772 static void encode_picture(MpegEncContext *s, int picture_number)
3773 {
3774     int mb_x, mb_y, pdif = 0;
3775     int i, j;
3776     int bits;
3777     MpegEncContext best_s, backup_s;
3778     uint8_t bit_buf[2][3000];
3779     uint8_t bit_buf2[2][3000];
3780     uint8_t bit_buf_tex[2][3000];
3781     PutBitContext pb[2], pb2[2], tex_pb[2];
3782
3783     for(i=0; i<2; i++){
3784         init_put_bits(&pb    [i], bit_buf    [i], 3000);
3785         init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
3786         init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
3787     }
3788
3789     s->picture_number = picture_number;
3790     
3791     /* Reset the average MB variance */
3792     s->current_picture.mb_var_sum = 0;
3793     s->current_picture.mc_mb_var_sum = 0;
3794
3795 #ifdef CONFIG_RISKY
3796     /* we need to initialize some time vars before we can encode b-frames */
3797     // RAL: Condition added for MPEG1VIDEO
3798     if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3799         ff_set_mpeg4_time(s, s->picture_number); 
3800 #endif
3801         
3802     s->scene_change_score=0;
3803     
3804     s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
3805     
3806     if(s->pict_type==I_TYPE){
3807         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3808         else                        s->no_rounding=0;
3809     }else if(s->pict_type!=B_TYPE){
3810         if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3811             s->no_rounding ^= 1;          
3812     }
3813     
3814     /* Estimate motion for every MB */
3815     s->mb_intra=0; //for the rate distoration & bit compare functions
3816     if(s->pict_type != I_TYPE){
3817         if(s->pict_type != B_TYPE){
3818             if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3819                 s->me.pre_pass=1;
3820                 s->me.dia_size= s->avctx->pre_dia_size;
3821
3822                 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3823                     for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3824                         s->mb_x = mb_x;
3825                         s->mb_y = mb_y;
3826                         ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3827                     }
3828                 }
3829                 s->me.pre_pass=0;
3830             }
3831         }
3832
3833         s->me.dia_size= s->avctx->dia_size;
3834         for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3835             s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3836             s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3837             s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3838             s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3839             for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3840                 s->mb_x = mb_x;
3841                 s->mb_y = mb_y;
3842                 s->block_index[0]+=2;
3843                 s->block_index[1]+=2;
3844                 s->block_index[2]+=2;
3845                 s->block_index[3]+=2;
3846                 
3847                 /* compute motion vector & mb_type and store in context */
3848                 if(s->pict_type==B_TYPE)
3849                     ff_estimate_b_frame_motion(s, mb_x, mb_y);
3850                 else
3851                     ff_estimate_p_frame_motion(s, mb_x, mb_y);
3852             }
3853         }
3854     }else /* if(s->pict_type == I_TYPE) */{
3855         /* I-Frame */
3856         //FIXME do we need to zero them?
3857         memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3858         memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3859         for(i=0; i<s->mb_stride*s->mb_height; i++)
3860             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3861         
3862         if(!s->fixed_qscale){
3863             /* finding spatial complexity for I-frame rate control */
3864             for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3865                 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3866                     int xx = mb_x * 16;
3867                     int yy = mb_y * 16;
3868                     uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3869                     int varc;
3870                     int sum = s->dsp.pix_sum(pix, s->linesize);
3871     
3872                     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3873
3874                     s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3875                     s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3876                     s->current_picture.mb_var_sum    += varc;
3877                 }
3878             }
3879         }
3880     }
3881     emms_c();
3882
3883     if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3884         s->pict_type= I_TYPE;
3885         for(i=0; i<s->mb_stride*s->mb_height; i++)
3886             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3887 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3888     }
3889
3890     if(!s->umvplus){
3891         if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3892             s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3893
3894             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3895                 int a,b;
3896                 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3897                 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3898                 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
3899             }
3900                     
3901             ff_fix_long_p_mvs(s);
3902             ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3903             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3904                 for(i=0; i<2; i++){
3905                     for(j=0; j<2; j++)
3906                         ff_fix_long_mvs(s, s->p_field_select_table[i], j, 
3907                                         s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3908                 }
3909             }
3910         }
3911
3912         if(s->pict_type==B_TYPE){
3913             int a, b;
3914
3915             a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3916             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3917             s->f_code = FFMAX(a, b);
3918
3919             a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3920             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3921             s->b_code = FFMAX(a, b);
3922
3923             ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3924             ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3925             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3926             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3927             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3928                 int dir;
3929                 for(dir=0; dir<2; dir++){
3930                     for(i=0; i<2; i++){
3931                         for(j=0; j<2; j++){
3932                             int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) 
3933                                           : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3934                             ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, 
3935                                             s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3936                         }
3937                     }
3938                 }
3939             }
3940         }
3941     }
3942     
3943     if (!s->fixed_qscale) 
3944         s->current_picture.quality = ff_rate_estimate_qscale(s);
3945
3946     if(s->adaptive_quant){
3947 #ifdef CONFIG_RISKY
3948         switch(s->codec_id){
3949         case CODEC_ID_MPEG4:
3950             ff_clean_mpeg4_qscales(s);
3951             break;
3952         case CODEC_ID_H263:
3953         case CODEC_ID_H263P:
3954         case CODEC_ID_FLV1:
3955             ff_clean_h263_qscales(s);
3956             break;
3957         }
3958 #endif
3959
3960         s->lambda= s->lambda_table[0];
3961         //FIXME broken
3962     }else
3963         s->lambda= s->current_picture.quality;
3964 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3965     update_qscale(s);
3966     
3967     if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) 
3968         s->qscale= 3; //reduce cliping problems
3969         
3970     if (s->out_format == FMT_MJPEG) {
3971         /* for mjpeg, we do include qscale in the matrix */
3972         s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3973         for(i=1;i<64;i++){
3974             int j= s->dsp.idct_permutation[i];
3975
3976             s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3977         }
3978         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
3979                        s->intra_matrix, s->intra_quant_bias, 8, 8);
3980     }
3981     
3982     //FIXME var duplication
3983     s->current_picture.key_frame= s->pict_type == I_TYPE;
3984     s->current_picture.pict_type= s->pict_type;
3985
3986     if(s->current_picture.key_frame)
3987         s->picture_in_gop_number=0;
3988
3989     s->last_bits= get_bit_count(&s->pb);
3990     switch(s->out_format) {
3991     case FMT_MJPEG:
3992         mjpeg_picture_header(s);
3993         break;
3994 #ifdef CONFIG_RISKY
3995     case FMT_H263:
3996         if (s->codec_id == CODEC_ID_WMV2) 
3997             ff_wmv2_encode_picture_header(s, picture_number);
3998         else if (s->h263_msmpeg4) 
3999             msmpeg4_encode_picture_header(s, picture_number);
4000         else if (s->h263_pred)
4001             mpeg4_encode_picture_header(s, picture_number);
4002         else if (s->codec_id == CODEC_ID_RV10) 
4003             rv10_encode_picture_header(s, picture_number);
4004         else if (s->codec_id == CODEC_ID_FLV1)
4005             ff_flv_encode_picture_header(s, picture_number);
4006         else
4007             h263_encode_picture_header(s, picture_number);
4008         break;
4009 #endif
4010     case FMT_MPEG1:
4011         mpeg1_encode_picture_header(s, picture_number);
4012         break;
4013     case FMT_H264:
4014         break;
4015     }
4016     bits= get_bit_count(&s->pb);
4017     s->header_bits= bits - s->last_bits;
4018     s->last_bits= bits;
4019     s->mv_bits=0;
4020     s->misc_bits=0;
4021     s->i_tex_bits=0;
4022     s->p_tex_bits=0;
4023     s->i_count=0;
4024     s->f_count=0;
4025     s->b_count=0;
4026     s->skip_count=0;
4027
4028     for(i=0; i<3; i++){
4029         /* init last dc values */
4030         /* note: quant matrix value (8) is implied here */
4031         s->last_dc[i] = 128;
4032         
4033         s->current_picture_ptr->error[i] = 0;
4034     }
4035     s->mb_skip_run = 0;
4036     memset(s->last_mv, 0, sizeof(s->last_mv));
4037      
4038     s->last_mv_dir = 0;
4039
4040 #ifdef CONFIG_RISKY
4041     switch(s->codec_id){
4042     case CODEC_ID_H263:
4043     case CODEC_ID_H263P:
4044     case CODEC_ID_FLV1:
4045         s->gob_index = ff_h263_get_gob_height(s);
4046         break;
4047     case CODEC_ID_MPEG4:
4048         if(s->partitioned_frame)
4049             ff_mpeg4_init_partitions(s);
4050         break;
4051     }
4052 #endif
4053
4054     s->resync_mb_x=0;
4055     s->resync_mb_y=0;
4056     s->first_slice_line = 1;
4057     s->ptr_lastgob = s->pb.buf;
4058     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
4059         s->mb_x=0;
4060         s->mb_y= mb_y;
4061
4062         ff_set_qscale(s, s->qscale);
4063         ff_init_block_index(s);
4064         
4065         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4066             const int xy= mb_y*s->mb_stride + mb_x;
4067             int mb_type= s->mb_type[xy];
4068 //            int d;
4069             int dmin= INT_MAX;
4070             int dir;
4071
4072             s->mb_x = mb_x;
4073             ff_update_block_index(s);
4074
4075             /* write gob / video packet header  */
4076 #ifdef CONFIG_RISKY
4077             if(s->rtp_mode){
4078                 int current_packet_size, is_gob_start;
4079                 
4080                 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4081                 
4082                 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4083                 
4084                 switch(s->codec_id){
4085                 case CODEC_ID_H263:
4086                 case CODEC_ID_H263P:
4087                     if(!s->h263_slice_structured)
4088                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4089                     break;
4090                 case CODEC_ID_MPEG2VIDEO:
4091                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=