closed gop support & flags2 as all bits in flags are used
[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     s->flags2= s->avctx->flags2;
412
413     s->mb_width  = (s->width  + 15) / 16;
414     s->mb_height = (s->height + 15) / 16;
415     s->mb_stride = s->mb_width + 1;
416     s->b8_stride = s->mb_width*2 + 1;
417     s->b4_stride = s->mb_width*4 + 1;
418     mb_array_size= s->mb_height * s->mb_stride;
419     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
420
421     /* set default edge pos, will be overriden in decode_header if needed */
422     s->h_edge_pos= s->mb_width*16;
423     s->v_edge_pos= s->mb_height*16;
424
425     s->mb_num = s->mb_width * s->mb_height;
426     
427     s->block_wrap[0]=
428     s->block_wrap[1]=
429     s->block_wrap[2]=
430     s->block_wrap[3]= s->mb_width*2 + 2;
431     s->block_wrap[4]=
432     s->block_wrap[5]= s->mb_width + 2;
433
434     s->y_dc_scale_table=
435     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
436     s->chroma_qscale_table= ff_default_chroma_qscale_table;
437     if (!s->encoding)
438         s->progressive_sequence= 1;
439     s->progressive_frame= 1;
440     s->coded_picture_number = 0;
441
442     y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
443     c_size = (s->mb_width + 2) * (s->mb_height + 2);
444     yc_size = y_size + 2 * c_size;
445
446     /* convert fourcc to upper case */
447     s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
448                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
449                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
450                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
451
452     s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
453                                + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
454                                + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
455                                + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
456
457     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
458     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
459
460     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
461
462     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
463     for(y=0; y<s->mb_height; y++){
464         for(x=0; x<s->mb_width; x++){
465             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
466         }
467     }
468     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
469     
470     if (s->encoding) {
471         /* Allocate MV tables */
472         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
473         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
474         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
475         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
477         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
478         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
479         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
480         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
481         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
482         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
483         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
484
485         //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
486         CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
487         
488         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
489         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
490
491         if(s->codec_id==CODEC_ID_MPEG4){
492             CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
493             CHECKED_ALLOCZ(   s->pb2_buffer, PB_BUFFER_SIZE);
494         }
495         
496         if(s->msmpeg4_version){
497             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
498         }
499         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
500
501         /* Allocate MB type table */
502         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
503         
504         CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
505         
506         CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
507         CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
508         CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
509         CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
510         CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
511         CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
512         
513         if(s->avctx->noise_reduction){
514             CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
515             CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
516         }
517     }
518     CHECKED_ALLOCZ(s->blocks, 64*6*2 * sizeof(DCTELEM))
519         
520     CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
521
522     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
523     
524     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
525         /* interlaced direct mode decoding tables */
526             for(i=0; i<2; i++){
527                 int j, k;
528                 for(j=0; j<2; j++){
529                     for(k=0; k<2; k++){
530                         CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
531                         s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
532                     }
533                     CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
534                     CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
535                     s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
536                 }
537                 CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
538             }
539     }
540     if (s->out_format == FMT_H263) {
541         /* ac values */
542         CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
543         s->ac_val[1] = s->ac_val[0] + y_size;
544         s->ac_val[2] = s->ac_val[1] + c_size;
545         
546         /* cbp values */
547         CHECKED_ALLOCZ(s->coded_block, y_size);
548         
549         /* divx501 bitstream reorder buffer */
550         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
551
552         /* cbp, ac_pred, pred_dir */
553         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
554         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
555     }
556     
557     if (s->h263_pred || s->h263_plus || !s->encoding) {
558         /* dc values */
559         //MN: we need these for error resilience of intra-frames
560         CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
561         s->dc_val[1] = s->dc_val[0] + y_size;
562         s->dc_val[2] = s->dc_val[1] + c_size;
563         for(i=0;i<yc_size;i++)
564             s->dc_val[0][i] = 1024;
565     }
566
567     /* which mb is a intra block */
568     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
569     memset(s->mbintra_table, 1, mb_array_size);
570     
571     /* default structure is frame */
572     s->picture_structure = PICT_FRAME;
573     
574     /* init macroblock skip table */
575     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
576     //Note the +1 is for a quicker mpeg4 slice_end detection
577     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
578     
579     s->block= s->blocks[0];
580
581     for(i=0;i<12;i++){
582         s->pblocks[i] = (short *)(&s->block[i]);
583     }
584
585     s->parse_context.state= -1;
586     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
587        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
588        s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
589        s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
590     }
591
592     s->context_initialized = 1;
593     return 0;
594  fail:
595     MPV_common_end(s);
596     return -1;
597 }
598
599
600 //extern int sads;
601
602 /* init common structure for both encoder and decoder */
603 void MPV_common_end(MpegEncContext *s)
604 {
605     int i, j, k;
606
607     av_freep(&s->parse_context.buffer);
608     s->parse_context.buffer_size=0;
609
610     av_freep(&s->mb_type);
611     av_freep(&s->p_mv_table_base);
612     av_freep(&s->b_forw_mv_table_base);
613     av_freep(&s->b_back_mv_table_base);
614     av_freep(&s->b_bidir_forw_mv_table_base);
615     av_freep(&s->b_bidir_back_mv_table_base);
616     av_freep(&s->b_direct_mv_table_base);
617     s->p_mv_table= NULL;
618     s->b_forw_mv_table= NULL;
619     s->b_back_mv_table= NULL;
620     s->b_bidir_forw_mv_table= NULL;
621     s->b_bidir_back_mv_table= NULL;
622     s->b_direct_mv_table= NULL;
623     for(i=0; i<2; i++){
624         for(j=0; j<2; j++){
625             for(k=0; k<2; k++){
626                 av_freep(&s->b_field_mv_table_base[i][j][k]);
627                 s->b_field_mv_table[i][j][k]=NULL;
628             }
629             av_freep(&s->b_field_select_table[i][j]);
630             av_freep(&s->p_field_mv_table_base[i][j]);
631             s->p_field_mv_table[i][j]=NULL;
632         }
633         av_freep(&s->p_field_select_table[i]);
634     }
635     
636     av_freep(&s->dc_val[0]);
637     av_freep(&s->ac_val[0]);
638     av_freep(&s->coded_block);
639     av_freep(&s->mbintra_table);
640     av_freep(&s->cbp_table);
641     av_freep(&s->pred_dir_table);
642     av_freep(&s->me.scratchpad);
643     av_freep(&s->me.map);
644     av_freep(&s->me.score_map);
645     
646     av_freep(&s->mbskip_table);
647     av_freep(&s->prev_pict_types);
648     av_freep(&s->bitstream_buffer);
649     av_freep(&s->tex_pb_buffer);
650     av_freep(&s->pb2_buffer);
651     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
652     av_freep(&s->avctx->stats_out);
653     av_freep(&s->ac_stats);
654     av_freep(&s->error_status_table);
655     av_freep(&s->mb_index2xy);
656     av_freep(&s->lambda_table);
657     av_freep(&s->q_intra_matrix);
658     av_freep(&s->q_inter_matrix);
659     av_freep(&s->q_intra_matrix16);
660     av_freep(&s->q_inter_matrix16);
661     av_freep(&s->blocks);
662     av_freep(&s->input_picture);
663     av_freep(&s->reordered_input_picture);
664     av_freep(&s->dct_error_sum);
665     av_freep(&s->dct_offset);
666
667     if(s->picture){
668         for(i=0; i<MAX_PICTURE_COUNT; i++){
669             free_picture(s, &s->picture[i]);
670         }
671     }
672     av_freep(&s->picture);
673     avcodec_default_free_buffers(s->avctx);
674     s->context_initialized = 0;
675     s->last_picture_ptr=
676     s->next_picture_ptr=
677     s->current_picture_ptr= NULL;
678     for(i=0; i<3; i++)
679         if (s->visualization_buffer[i])
680             av_free(s->visualization_buffer[i]);
681 }
682
683 #ifdef CONFIG_ENCODERS
684
685 /* init video encoder */
686 int MPV_encode_init(AVCodecContext *avctx)
687 {
688     MpegEncContext *s = avctx->priv_data;
689     int i, dummy;
690     int chroma_h_shift, chroma_v_shift;
691
692     avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
693
694     s->bit_rate = avctx->bit_rate;
695     s->width = avctx->width;
696     s->height = avctx->height;
697     if(avctx->gop_size > 600){
698         av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
699         avctx->gop_size=600;
700     }
701     s->gop_size = avctx->gop_size;
702     s->avctx = avctx;
703     s->flags= avctx->flags;
704     s->flags2= avctx->flags2;
705     s->max_b_frames= avctx->max_b_frames;
706     s->codec_id= avctx->codec->id;
707     s->luma_elim_threshold  = avctx->luma_elim_threshold;
708     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
709     s->strict_std_compliance= avctx->strict_std_compliance;
710     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
711     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
712     s->mpeg_quant= avctx->mpeg_quant;
713     s->rtp_mode= !!avctx->rtp_payload_size;
714
715     if (s->gop_size <= 1) {
716         s->intra_only = 1;
717         s->gop_size = 12;
718     } else {
719         s->intra_only = 0;
720     }
721
722     s->me_method = avctx->me_method;
723
724     /* Fixed QSCALE */
725     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
726     
727     s->adaptive_quant= (   s->avctx->lumi_masking
728                         || s->avctx->dark_masking
729                         || s->avctx->temporal_cplx_masking 
730                         || s->avctx->spatial_cplx_masking
731                         || s->avctx->p_masking
732                         || (s->flags&CODEC_FLAG_QP_RD))
733                        && !s->fixed_qscale;
734     
735     s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
736     s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
737     s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
738
739     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
740         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
741         return -1;
742     }    
743
744     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
745         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
746     }    
747         
748     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
749        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
750         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
751         return -1;
752     }
753         
754     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
755         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
756         return -1;
757     }
758     
759     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
760         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
761         return -1;
762     }
763     
764     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
765         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
766         return -1;
767     }
768
769     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
770         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
771         return -1;
772     }
773     
774     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
775         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
776         return -1;
777     }
778     
779     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
780         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
781         return -1;
782     }
783         
784     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
785         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
786         return -1;
787     }
788
789     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
790         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
791         return -1;
792     }
793     
794     if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
795         av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
796         return -1;
797     }
798     
799     if(s->codec_id==CODEC_ID_MJPEG){
800         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
801         s->inter_quant_bias= 0;
802     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
803         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
804         s->inter_quant_bias= 0;
805     }else{
806         s->intra_quant_bias=0;
807         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
808     }
809     
810     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
811         s->intra_quant_bias= avctx->intra_quant_bias;
812     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
813         s->inter_quant_bias= avctx->inter_quant_bias;
814         
815     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
816
817     av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
818     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
819
820     switch(avctx->codec->id) {
821     case CODEC_ID_MPEG1VIDEO:
822         s->out_format = FMT_MPEG1;
823         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
824         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
825         break;
826     case CODEC_ID_MPEG2VIDEO:
827         s->out_format = FMT_MPEG1;
828         s->low_delay= 0; //s->max_b_frames ? 0 : 1;
829         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
830         s->rtp_mode= 1;
831         break;
832     case CODEC_ID_LJPEG:
833     case CODEC_ID_MJPEG:
834         s->out_format = FMT_MJPEG;
835         s->intra_only = 1; /* force intra only for jpeg */
836         s->mjpeg_write_tables = 1; /* write all tables */
837         s->mjpeg_data_only_frames = 0; /* write all the needed headers */
838         s->mjpeg_vsample[0] = 1<<chroma_v_shift;
839         s->mjpeg_vsample[1] = 1;
840         s->mjpeg_vsample[2] = 1; 
841         s->mjpeg_hsample[0] = 1<<chroma_h_shift;
842         s->mjpeg_hsample[1] = 1; 
843         s->mjpeg_hsample[2] = 1; 
844         if (mjpeg_init(s) < 0)
845             return -1;
846         avctx->delay=0;
847         s->low_delay=1;
848         break;
849 #ifdef CONFIG_RISKY
850     case CODEC_ID_H263:
851         if (h263_get_picture_format(s->width, s->height) == 7) {
852             av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
853             return -1;
854         }
855         s->out_format = FMT_H263;
856         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
857         avctx->delay=0;
858         s->low_delay=1;
859         break;
860     case CODEC_ID_H263P:
861         s->out_format = FMT_H263;
862         s->h263_plus = 1;
863         /* Fx */
864         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
865         s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
866         s->modified_quant= s->h263_aic;
867         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
868         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
869         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
870         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
871         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
872
873         /* /Fx */
874         /* These are just to be sure */
875         avctx->delay=0;
876         s->low_delay=1;
877         break;
878     case CODEC_ID_FLV1:
879         s->out_format = FMT_H263;
880         s->h263_flv = 2; /* format = 1; 11-bit codes */
881         s->unrestricted_mv = 1;
882         s->rtp_mode=0; /* don't allow GOB */
883         avctx->delay=0;
884         s->low_delay=1;
885         break;
886     case CODEC_ID_RV10:
887         s->out_format = FMT_H263;
888         avctx->delay=0;
889         s->low_delay=1;
890         break;
891     case CODEC_ID_MPEG4:
892         s->out_format = FMT_H263;
893         s->h263_pred = 1;
894         s->unrestricted_mv = 1;
895         s->low_delay= s->max_b_frames ? 0 : 1;
896         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
897         break;
898     case CODEC_ID_MSMPEG4V1:
899         s->out_format = FMT_H263;
900         s->h263_msmpeg4 = 1;
901         s->h263_pred = 1;
902         s->unrestricted_mv = 1;
903         s->msmpeg4_version= 1;
904         avctx->delay=0;
905         s->low_delay=1;
906         break;
907     case CODEC_ID_MSMPEG4V2:
908         s->out_format = FMT_H263;
909         s->h263_msmpeg4 = 1;
910         s->h263_pred = 1;
911         s->unrestricted_mv = 1;
912         s->msmpeg4_version= 2;
913         avctx->delay=0;
914         s->low_delay=1;
915         break;
916     case CODEC_ID_MSMPEG4V3:
917         s->out_format = FMT_H263;
918         s->h263_msmpeg4 = 1;
919         s->h263_pred = 1;
920         s->unrestricted_mv = 1;
921         s->msmpeg4_version= 3;
922         s->flipflop_rounding=1;
923         avctx->delay=0;
924         s->low_delay=1;
925         break;
926     case CODEC_ID_WMV1:
927         s->out_format = FMT_H263;
928         s->h263_msmpeg4 = 1;
929         s->h263_pred = 1;
930         s->unrestricted_mv = 1;
931         s->msmpeg4_version= 4;
932         s->flipflop_rounding=1;
933         avctx->delay=0;
934         s->low_delay=1;
935         break;
936     case CODEC_ID_WMV2:
937         s->out_format = FMT_H263;
938         s->h263_msmpeg4 = 1;
939         s->h263_pred = 1;
940         s->unrestricted_mv = 1;
941         s->msmpeg4_version= 5;
942         s->flipflop_rounding=1;
943         avctx->delay=0;
944         s->low_delay=1;
945         break;
946 #endif
947     default:
948         return -1;
949     }
950
951     { /* set up some save defaults, some codecs might override them later */
952         static int done=0;
953         if(!done){
954             int i;
955             done=1;
956
957             default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
958             memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
959             memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
960
961             for(i=-16; i<16; i++){
962                 default_fcode_tab[i + MAX_MV]= 1;
963             }
964         }
965     }
966     s->me.mv_penalty= default_mv_penalty;
967     s->fcode_tab= default_fcode_tab;
968  
969     /* dont use mv_penalty table for crap MV as it would be confused */
970     //FIXME remove after fixing / removing old ME
971     if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
972
973     s->encoding = 1;
974
975     /* init */
976     if (MPV_common_init(s) < 0)
977         return -1;
978
979     if(s->modified_quant)
980         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
981     s->progressive_frame= 
982     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
983     
984     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
985     
986     ff_init_me(s);
987
988 #ifdef CONFIG_ENCODERS
989 #ifdef CONFIG_RISKY
990     if (s->out_format == FMT_H263)
991         h263_encode_init(s);
992     if(s->msmpeg4_version)
993         ff_msmpeg4_encode_init(s);
994 #endif
995     if (s->out_format == FMT_MPEG1)
996         ff_mpeg1_encode_init(s);
997 #endif
998
999     /* init default q matrix */
1000     for(i=0;i<64;i++) {
1001         int j= s->dsp.idct_permutation[i];
1002 #ifdef CONFIG_RISKY
1003         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1004             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1005             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1006         }else if(s->out_format == FMT_H263){
1007             s->intra_matrix[j] =
1008             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1009         }else
1010 #endif
1011         { /* mpeg1/2 */
1012             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1013             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1014         }
1015         if(s->avctx->intra_matrix)
1016             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1017         if(s->avctx->inter_matrix)
1018             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1019     }
1020
1021     /* precompute matrix */
1022     /* for mjpeg, we do include qscale in the matrix */
1023     if (s->out_format != FMT_MJPEG) {
1024         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1025                        s->intra_matrix, s->intra_quant_bias, 1, 31);
1026         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1027                        s->inter_matrix, s->inter_quant_bias, 1, 31);
1028     }
1029
1030     if(ff_rate_control_init(s) < 0)
1031         return -1;
1032
1033     s->picture_number = 0;
1034     s->input_picture_number = 0;
1035     s->picture_in_gop_number = 0;
1036     /* motion detector init */
1037     s->f_code = 1;
1038     s->b_code = 1;
1039
1040     return 0;
1041 }
1042
1043 int MPV_encode_end(AVCodecContext *avctx)
1044 {
1045     MpegEncContext *s = avctx->priv_data;
1046
1047 #ifdef STATS
1048     print_stats();
1049 #endif
1050
1051     ff_rate_control_uninit(s);
1052
1053     MPV_common_end(s);
1054     if (s->out_format == FMT_MJPEG)
1055         mjpeg_close(s);
1056
1057     av_freep(&avctx->extradata);
1058       
1059     return 0;
1060 }
1061
1062 #endif //CONFIG_ENCODERS
1063
1064 void init_rl(RLTable *rl)
1065 {
1066     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1067     uint8_t index_run[MAX_RUN+1];
1068     int last, run, level, start, end, i;
1069
1070     /* compute max_level[], max_run[] and index_run[] */
1071     for(last=0;last<2;last++) {
1072         if (last == 0) {
1073             start = 0;
1074             end = rl->last;
1075         } else {
1076             start = rl->last;
1077             end = rl->n;
1078         }
1079
1080         memset(max_level, 0, MAX_RUN + 1);
1081         memset(max_run, 0, MAX_LEVEL + 1);
1082         memset(index_run, rl->n, MAX_RUN + 1);
1083         for(i=start;i<end;i++) {
1084             run = rl->table_run[i];
1085             level = rl->table_level[i];
1086             if (index_run[run] == rl->n)
1087                 index_run[run] = i;
1088             if (level > max_level[run])
1089                 max_level[run] = level;
1090             if (run > max_run[level])
1091                 max_run[level] = run;
1092         }
1093         rl->max_level[last] = av_malloc(MAX_RUN + 1);
1094         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1095         rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1096         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1097         rl->index_run[last] = av_malloc(MAX_RUN + 1);
1098         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1099     }
1100 }
1101
1102 /* draw the edges of width 'w' of an image of size width, height */
1103 //FIXME check that this is ok for mpeg4 interlaced
1104 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1105 {
1106     uint8_t *ptr, *last_line;
1107     int i;
1108
1109     last_line = buf + (height - 1) * wrap;
1110     for(i=0;i<w;i++) {
1111         /* top and bottom */
1112         memcpy(buf - (i + 1) * wrap, buf, width);
1113         memcpy(last_line + (i + 1) * wrap, last_line, width);
1114     }
1115     /* left and right */
1116     ptr = buf;
1117     for(i=0;i<height;i++) {
1118         memset(ptr - w, ptr[0], w);
1119         memset(ptr + width, ptr[width-1], w);
1120         ptr += wrap;
1121     }
1122     /* corners */
1123     for(i=0;i<w;i++) {
1124         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1125         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1126         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1127         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1128     }
1129 }
1130
1131 int ff_find_unused_picture(MpegEncContext *s, int shared){
1132     int i;
1133     
1134     if(shared){
1135         for(i=0; i<MAX_PICTURE_COUNT; i++){
1136             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1137         }
1138     }else{
1139         for(i=0; i<MAX_PICTURE_COUNT; i++){
1140             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1141         }
1142         for(i=0; i<MAX_PICTURE_COUNT; i++){
1143             if(s->picture[i].data[0]==NULL) return i;
1144         }
1145     }
1146
1147     assert(0);
1148     return -1;
1149 }
1150
1151 static void update_noise_reduction(MpegEncContext *s){
1152     int intra, i;
1153
1154     for(intra=0; intra<2; intra++){
1155         if(s->dct_count[intra] > (1<<16)){
1156             for(i=0; i<64; i++){
1157                 s->dct_error_sum[intra][i] >>=1;
1158             }
1159             s->dct_count[intra] >>= 1;
1160         }
1161         
1162         for(i=0; i<64; i++){
1163             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);
1164         }
1165     }
1166 }
1167
1168 /**
1169  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1170  */
1171 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1172 {
1173     int i;
1174     AVFrame *pic;
1175     s->mb_skiped = 0;
1176
1177     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1178
1179     /* mark&release old frames */
1180     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1181         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1182
1183         /* release forgotten pictures */
1184         /* if(mpeg124/h263) */
1185         if(!s->encoding){
1186             for(i=0; i<MAX_PICTURE_COUNT; i++){
1187                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1188                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1189                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1190                 }
1191             }
1192         }
1193     }
1194 alloc:
1195     if(!s->encoding){
1196         /* release non refernce frames */
1197         for(i=0; i<MAX_PICTURE_COUNT; i++){
1198             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1199                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1200             }
1201         }
1202
1203         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1204             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1205         else{
1206             i= ff_find_unused_picture(s, 0);
1207             pic= (AVFrame*)&s->picture[i];
1208         }
1209
1210         pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1211
1212         pic->coded_picture_number= s->coded_picture_number++;
1213         
1214         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1215             return -1;
1216
1217         s->current_picture_ptr= (Picture*)pic;
1218         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1219         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1220     }
1221
1222     s->current_picture_ptr->pict_type= s->pict_type;
1223 //    if(s->flags && CODEC_FLAG_QSCALE) 
1224   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1225     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1226
1227     copy_picture(&s->current_picture, s->current_picture_ptr);
1228   
1229   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1230     if (s->pict_type != B_TYPE) {
1231         s->last_picture_ptr= s->next_picture_ptr;
1232         s->next_picture_ptr= s->current_picture_ptr;
1233     }
1234     
1235     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1236     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1237     
1238     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1239         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1240         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1241         goto alloc;
1242     }
1243
1244     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1245
1246     if(s->picture_structure!=PICT_FRAME){
1247         int i;
1248         for(i=0; i<4; i++){
1249             if(s->picture_structure == PICT_BOTTOM_FIELD){
1250                  s->current_picture.data[i] += s->current_picture.linesize[i];
1251             } 
1252             s->current_picture.linesize[i] *= 2;
1253             s->last_picture.linesize[i] *=2;
1254             s->next_picture.linesize[i] *=2;
1255         }
1256     }
1257   }
1258    
1259     s->hurry_up= s->avctx->hurry_up;
1260     s->error_resilience= avctx->error_resilience;
1261
1262     /* set dequantizer, we cant do it during init as it might change for mpeg4
1263        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1264     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1265         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1266         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1267     }else if(s->out_format == FMT_H263){
1268         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1269         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1270     }else{
1271         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1272         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1273     }
1274
1275     if(s->dct_error_sum){
1276         assert(s->avctx->noise_reduction && s->encoding);
1277
1278         update_noise_reduction(s);
1279     }
1280         
1281 #ifdef HAVE_XVMC
1282     if(s->avctx->xvmc_acceleration)
1283         return XVMC_field_start(s, avctx);
1284 #endif
1285     return 0;
1286 }
1287
1288 /* generic function for encode/decode called after a frame has been coded/decoded */
1289 void MPV_frame_end(MpegEncContext *s)
1290 {
1291     int i;
1292     /* draw edge for correct motion prediction if outside */
1293 #ifdef HAVE_XVMC
1294 //just to make sure that all data is rendered.
1295     if(s->avctx->xvmc_acceleration){
1296         XVMC_field_end(s);
1297     }else
1298 #endif
1299     if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1300             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1301             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1302             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1303     }
1304     emms_c();
1305     
1306     s->last_pict_type    = s->pict_type;
1307     if(s->pict_type!=B_TYPE){
1308         s->last_non_b_pict_type= s->pict_type;
1309     }
1310 #if 0
1311         /* copy back current_picture variables */
1312     for(i=0; i<MAX_PICTURE_COUNT; i++){
1313         if(s->picture[i].data[0] == s->current_picture.data[0]){
1314             s->picture[i]= s->current_picture;
1315             break;
1316         }    
1317     }
1318     assert(i<MAX_PICTURE_COUNT);
1319 #endif    
1320
1321     if(s->encoding){
1322         /* release non refernce frames */
1323         for(i=0; i<MAX_PICTURE_COUNT; i++){
1324             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1325                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1326             }
1327         }
1328     }
1329     // clear copies, to avoid confusion
1330 #if 0
1331     memset(&s->last_picture, 0, sizeof(Picture));
1332     memset(&s->next_picture, 0, sizeof(Picture));
1333     memset(&s->current_picture, 0, sizeof(Picture));
1334 #endif
1335 }
1336
1337 /**
1338  * draws an line from (ex, ey) -> (sx, sy).
1339  * @param w width of the image
1340  * @param h height of the image
1341  * @param stride stride/linesize of the image
1342  * @param color color of the arrow
1343  */
1344 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1345     int t, x, y, f;
1346     
1347     sx= clip(sx, 0, w-1);
1348     sy= clip(sy, 0, h-1);
1349     ex= clip(ex, 0, w-1);
1350     ey= clip(ey, 0, h-1);
1351     
1352     buf[sy*stride + sx]+= color;
1353     
1354     if(ABS(ex - sx) > ABS(ey - sy)){
1355         if(sx > ex){
1356             t=sx; sx=ex; ex=t;
1357             t=sy; sy=ey; ey=t;
1358         }
1359         buf+= sx + sy*stride;
1360         ex-= sx;
1361         f= ((ey-sy)<<16)/ex;
1362         for(x= 0; x <= ex; x++){
1363             y= ((x*f) + (1<<15))>>16;
1364             buf[y*stride + x]+= color;
1365         }
1366     }else{
1367         if(sy > ey){
1368             t=sx; sx=ex; ex=t;
1369             t=sy; sy=ey; ey=t;
1370         }
1371         buf+= sx + sy*stride;
1372         ey-= sy;
1373         if(ey) f= ((ex-sx)<<16)/ey;
1374         else   f= 0;
1375         for(y= 0; y <= ey; y++){
1376             x= ((y*f) + (1<<15))>>16;
1377             buf[y*stride + x]+= color;
1378         }
1379     }
1380 }
1381
1382 /**
1383  * draws an arrow from (ex, ey) -> (sx, sy).
1384  * @param w width of the image
1385  * @param h height of the image
1386  * @param stride stride/linesize of the image
1387  * @param color color of the arrow
1388  */
1389 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1390     int dx,dy;
1391
1392     sx= clip(sx, -100, w+100);
1393     sy= clip(sy, -100, h+100);
1394     ex= clip(ex, -100, w+100);
1395     ey= clip(ey, -100, h+100);
1396     
1397     dx= ex - sx;
1398     dy= ey - sy;
1399     
1400     if(dx*dx + dy*dy > 3*3){
1401         int rx=  dx + dy;
1402         int ry= -dx + dy;
1403         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1404         
1405         //FIXME subpixel accuracy
1406         rx= ROUNDED_DIV(rx*3<<4, length);
1407         ry= ROUNDED_DIV(ry*3<<4, length);
1408         
1409         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1410         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1411     }
1412     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1413 }
1414
1415 /**
1416  * prints debuging info for the given picture.
1417  */
1418 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1419
1420     if(!pict || !pict->mb_type) return;
1421
1422     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1423         int x,y;
1424         
1425         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1426         switch (pict->pict_type) {
1427             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1428             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1429             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1430             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1431             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1432             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1433         }
1434         for(y=0; y<s->mb_height; y++){
1435             for(x=0; x<s->mb_width; x++){
1436                 if(s->avctx->debug&FF_DEBUG_SKIP){
1437                     int count= s->mbskip_table[x + y*s->mb_stride];
1438                     if(count>9) count=9;
1439                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1440                 }
1441                 if(s->avctx->debug&FF_DEBUG_QP){
1442                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1443                 }
1444                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1445                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1446                     //Type & MV direction
1447                     if(IS_PCM(mb_type))
1448                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1449                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1450                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1451                     else if(IS_INTRA4x4(mb_type))
1452                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1453                     else if(IS_INTRA16x16(mb_type))
1454                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1455                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1456                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1457                     else if(IS_DIRECT(mb_type))
1458                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1459                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1460                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1461                     else if(IS_GMC(mb_type))
1462                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1463                     else if(IS_SKIP(mb_type))
1464                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1465                     else if(!USES_LIST(mb_type, 1))
1466                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1467                     else if(!USES_LIST(mb_type, 0))
1468                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1469                     else{
1470                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1471                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1472                     }
1473                     
1474                     //segmentation
1475                     if(IS_8X8(mb_type))
1476                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1477                     else if(IS_16X8(mb_type))
1478                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1479                     else if(IS_8X16(mb_type))
1480                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1481                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1482                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1483                     else
1484                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1485                     
1486                         
1487                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1488                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1489                     else
1490                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1491                 }
1492 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1493             }
1494             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1495         }
1496     }
1497
1498     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1499         const int shift= 1 + s->quarter_sample;
1500         int mb_y;
1501         uint8_t *ptr;
1502         int i;
1503         int h_chroma_shift, v_chroma_shift;
1504         s->low_delay=0; //needed to see the vectors without trashing the buffers
1505
1506         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1507         for(i=0; i<3; i++){
1508             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1509             pict->data[i]= s->visualization_buffer[i];
1510         }
1511         pict->type= FF_BUFFER_TYPE_COPY;
1512         ptr= pict->data[0];
1513
1514         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1515             int mb_x;
1516             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1517                 const int mb_index= mb_x + mb_y*s->mb_stride;
1518                 if((s->avctx->debug_mv) && pict->motion_val){
1519                   int type;
1520                   for(type=0; type<3; type++){
1521                     int direction;
1522                     switch (type) {
1523                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1524                                 continue;
1525                               direction = 0;
1526                               break;
1527                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1528                                 continue;
1529                               direction = 0;
1530                               break;
1531                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1532                                 continue;
1533                               direction = 1;
1534                               break;
1535                     }
1536                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1537                         continue;
1538
1539                     if(IS_8X8(pict->mb_type[mb_index])){
1540                       int i;
1541                       for(i=0; i<4; i++){
1542                         int sx= mb_x*16 + 4 + 8*(i&1);
1543                         int sy= mb_y*16 + 4 + 8*(i>>1);
1544                         int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1545                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1546                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1547                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1548                       }
1549                     }else if(IS_16X8(pict->mb_type[mb_index])){
1550                       int i;
1551                       for(i=0; i<2; i++){
1552                         int sx=mb_x*16 + 8;
1553                         int sy=mb_y*16 + 4 + 8*i;
1554                         int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2);
1555                         int mx=(pict->motion_val[direction][xy][0]>>shift) + sx;
1556                         int my=(pict->motion_val[direction][xy][1]>>shift) + sy;
1557                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1558                       }
1559                     }else{
1560                       int sx= mb_x*16 + 8;
1561                       int sy= mb_y*16 + 8;
1562                       int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1563                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1564                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1565                       draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1566                     }
1567                   }                  
1568                 }
1569                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1570                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1571                     int y;
1572                     for(y=0; y<8; y++){
1573                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1574                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1575                     }
1576                 }
1577                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1578                     int mb_type= pict->mb_type[mb_index];
1579                     uint64_t u,v;
1580                     int y;
1581 #define COLOR(theta, r)\
1582 u= (int)(128 + r*cos(theta*3.141592/180));\
1583 v= (int)(128 + r*sin(theta*3.141592/180));
1584
1585                     
1586                     u=v=128;
1587                     if(IS_PCM(mb_type)){
1588                         COLOR(120,48)
1589                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1590                         COLOR(30,48)
1591                     }else if(IS_INTRA4x4(mb_type)){
1592                         COLOR(90,48)
1593                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1594 //                        COLOR(120,48)
1595                     }else if(IS_DIRECT(mb_type)){
1596                         COLOR(150,48)
1597                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1598                         COLOR(170,48)
1599                     }else if(IS_GMC(mb_type)){
1600                         COLOR(190,48)
1601                     }else if(IS_SKIP(mb_type)){
1602 //                        COLOR(180,48)
1603                     }else if(!USES_LIST(mb_type, 1)){
1604                         COLOR(240,48)
1605                     }else if(!USES_LIST(mb_type, 0)){
1606                         COLOR(0,48)
1607                     }else{
1608                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1609                         COLOR(300,48)
1610                     }
1611
1612                     u*= 0x0101010101010101ULL;
1613                     v*= 0x0101010101010101ULL;
1614                     for(y=0; y<8; y++){
1615                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1616                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1617                     }
1618
1619                     //segmentation
1620                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1621                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1622                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1623                     }
1624                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1625                         for(y=0; y<16; y++)
1626                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1627                     }
1628                         
1629                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1630                         // hmm
1631                     }
1632                 }
1633                 s->mbskip_table[mb_index]=0;
1634             }
1635         }
1636     }
1637 }
1638
1639 #ifdef CONFIG_ENCODERS
1640
1641 static int get_sae(uint8_t *src, int ref, int stride){
1642     int x,y;
1643     int acc=0;
1644     
1645     for(y=0; y<16; y++){
1646         for(x=0; x<16; x++){
1647             acc+= ABS(src[x+y*stride] - ref);
1648         }
1649     }
1650     
1651     return acc;
1652 }
1653
1654 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1655     int x, y, w, h;
1656     int acc=0;
1657     
1658     w= s->width &~15;
1659     h= s->height&~15;
1660     
1661     for(y=0; y<h; y+=16){
1662         for(x=0; x<w; x+=16){
1663             int offset= x + y*stride;
1664             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1665             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1666             int sae = get_sae(src + offset, mean, stride);
1667             
1668             acc+= sae + 500 < sad;
1669         }
1670     }
1671     return acc;
1672 }
1673
1674
1675 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1676     AVFrame *pic=NULL;
1677     int i;
1678     const int encoding_delay= s->max_b_frames;
1679     int direct=1;
1680     
1681   if(pic_arg){
1682     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1683     if(pic_arg->linesize[0] != s->linesize) direct=0;
1684     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1685     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1686   
1687 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1688     
1689     if(direct){
1690         i= ff_find_unused_picture(s, 1);
1691
1692         pic= (AVFrame*)&s->picture[i];
1693         pic->reference= 3;
1694     
1695         for(i=0; i<4; i++){
1696             pic->data[i]= pic_arg->data[i];
1697             pic->linesize[i]= pic_arg->linesize[i];
1698         }
1699         alloc_picture(s, (Picture*)pic, 1);
1700     }else{
1701         int offset= 16;
1702         i= ff_find_unused_picture(s, 0);
1703
1704         pic= (AVFrame*)&s->picture[i];
1705         pic->reference= 3;
1706
1707         alloc_picture(s, (Picture*)pic, 0);
1708
1709         if(   pic->data[0] + offset == pic_arg->data[0] 
1710            && pic->data[1] + offset == pic_arg->data[1]
1711            && pic->data[2] + offset == pic_arg->data[2]){
1712        // empty
1713         }else{
1714             int h_chroma_shift, v_chroma_shift;
1715             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1716         
1717             for(i=0; i<3; i++){
1718                 int src_stride= pic_arg->linesize[i];
1719                 int dst_stride= i ? s->uvlinesize : s->linesize;
1720                 int h_shift= i ? h_chroma_shift : 0;
1721                 int v_shift= i ? v_chroma_shift : 0;
1722                 int w= s->width >>h_shift;
1723                 int h= s->height>>v_shift;
1724                 uint8_t *src= pic_arg->data[i];
1725                 uint8_t *dst= pic->data[i] + offset;
1726             
1727                 if(src_stride==dst_stride)
1728                     memcpy(dst, src, src_stride*h);
1729                 else{
1730                     while(h--){
1731                         memcpy(dst, src, w);
1732                         dst += dst_stride;
1733                         src += src_stride;
1734                     }
1735                 }
1736             }
1737         }
1738     }
1739     copy_picture_attributes(pic, pic_arg);
1740     
1741     pic->display_picture_number= s->input_picture_number++;
1742   }
1743
1744     /* shift buffer entries */
1745     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1746         s->input_picture[i-1]= s->input_picture[i];
1747         
1748     s->input_picture[encoding_delay]= (Picture*)pic;
1749
1750     return 0;
1751 }
1752
1753 static void select_input_picture(MpegEncContext *s){
1754     int i;
1755
1756     for(i=1; i<MAX_PICTURE_COUNT; i++)
1757         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1758     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1759
1760     /* set next picture types & ordering */
1761     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1762         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1763             s->reordered_input_picture[0]= s->input_picture[0];
1764             s->reordered_input_picture[0]->pict_type= I_TYPE;
1765             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1766         }else{
1767             int b_frames;
1768             
1769             if(s->flags&CODEC_FLAG_PASS2){
1770                 for(i=0; i<s->max_b_frames+1; i++){
1771                     int pict_num= s->input_picture[0]->display_picture_number + i;
1772                     int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1773                     s->input_picture[i]->pict_type= pict_type;
1774                     
1775                     if(i + 1 >= s->rc_context.num_entries) break;
1776                 }
1777             }
1778
1779             if(s->input_picture[0]->pict_type){
1780                 /* user selected pict_type */
1781                 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1782                     if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1783                 }
1784             
1785                 if(b_frames > s->max_b_frames){
1786                     av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1787                     b_frames = s->max_b_frames;
1788                 }
1789             }else if(s->avctx->b_frame_strategy==0){
1790                 b_frames= s->max_b_frames;
1791                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
1792             }else if(s->avctx->b_frame_strategy==1){
1793                 for(i=1; i<s->max_b_frames+1; i++){
1794                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1795                         s->input_picture[i]->b_frame_score= 
1796                             get_intra_count(s, s->input_picture[i  ]->data[0], 
1797                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
1798                     }
1799                 }
1800                 for(i=0; i<s->max_b_frames; i++){
1801                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1802                 }
1803                                 
1804                 b_frames= FFMAX(0, i-1);
1805                 
1806                 /* reset scores */
1807                 for(i=0; i<b_frames+1; i++){
1808                     s->input_picture[i]->b_frame_score=0;
1809                 }
1810             }else{
1811                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1812                 b_frames=0;
1813             }
1814
1815             emms_c();
1816 //static int b_count=0;
1817 //b_count+= b_frames;
1818 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1819             if(s->picture_in_gop_number + b_frames >= s->gop_size){
1820                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
1821                     b_frames=0;
1822                 s->input_picture[b_frames]->pict_type= I_TYPE;
1823             }
1824             
1825             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
1826                && b_frames
1827                && s->input_picture[b_frames]->pict_type== I_TYPE)
1828                 b_frames--;
1829
1830             s->reordered_input_picture[0]= s->input_picture[b_frames];
1831             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
1832                 s->reordered_input_picture[0]->pict_type= P_TYPE;
1833             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1834             for(i=0; i<b_frames; i++){
1835                 s->reordered_input_picture[i+1]= s->input_picture[i];
1836                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1837                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
1838             }
1839         }
1840     }
1841     
1842     if(s->reordered_input_picture[0]){
1843         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1844
1845         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1846
1847         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1848             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1849         
1850             int i= ff_find_unused_picture(s, 0);
1851             Picture *pic= &s->picture[i];
1852
1853             /* mark us unused / free shared pic */
1854             for(i=0; i<4; i++)
1855                 s->reordered_input_picture[0]->data[i]= NULL;
1856             s->reordered_input_picture[0]->type= 0;
1857             
1858             copy_picture_attributes((AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
1859             pic->reference              = s->reordered_input_picture[0]->reference;
1860             
1861             alloc_picture(s, pic, 0);
1862
1863             s->current_picture_ptr= pic;
1864         }else{
1865             // input is not a shared pix -> reuse buffer for current_pix
1866
1867             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
1868                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1869             
1870             s->current_picture_ptr= s->reordered_input_picture[0];
1871             for(i=0; i<4; i++){
1872                 s->new_picture.data[i]+=16;
1873             }
1874         }
1875         copy_picture(&s->current_picture, s->current_picture_ptr);
1876     
1877         s->picture_number= s->new_picture.display_picture_number;
1878 //printf("dpn:%d\n", s->picture_number);
1879     }else{
1880        memset(&s->new_picture, 0, sizeof(Picture));
1881     }
1882 }
1883
1884 int MPV_encode_picture(AVCodecContext *avctx,
1885                        unsigned char *buf, int buf_size, void *data)
1886 {
1887     MpegEncContext *s = avctx->priv_data;
1888     AVFrame *pic_arg = data;
1889     int i, stuffing_count;
1890
1891     if(avctx->pix_fmt != PIX_FMT_YUV420P){
1892         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1893         return -1;
1894     }
1895     
1896     init_put_bits(&s->pb, buf, buf_size);
1897
1898     s->picture_in_gop_number++;
1899
1900     load_input_picture(s, pic_arg);
1901     
1902     select_input_picture(s);
1903     
1904     /* output? */
1905     if(s->new_picture.data[0]){
1906         s->pict_type= s->new_picture.pict_type;
1907 //emms_c();
1908 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1909         MPV_frame_start(s, avctx);
1910
1911         encode_picture(s, s->picture_number);
1912         
1913         avctx->real_pict_num  = s->picture_number;
1914         avctx->header_bits = s->header_bits;
1915         avctx->mv_bits     = s->mv_bits;
1916         avctx->misc_bits   = s->misc_bits;
1917         avctx->i_tex_bits  = s->i_tex_bits;
1918         avctx->p_tex_bits  = s->p_tex_bits;
1919         avctx->i_count     = s->i_count;
1920         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1921         avctx->skip_count  = s->skip_count;
1922
1923         MPV_frame_end(s);
1924
1925         if (s->out_format == FMT_MJPEG)
1926             mjpeg_picture_trailer(s);
1927         
1928         if(s->flags&CODEC_FLAG_PASS1)
1929             ff_write_pass1_stats(s);
1930
1931         for(i=0; i<4; i++){
1932             avctx->error[i] += s->current_picture_ptr->error[i];
1933         }
1934     }
1935
1936     flush_put_bits(&s->pb);
1937     s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1938
1939     stuffing_count= ff_vbv_update(s, s->frame_bits);
1940     if(stuffing_count){
1941         switch(s->codec_id){
1942         case CODEC_ID_MPEG1VIDEO:
1943         case CODEC_ID_MPEG2VIDEO:
1944             while(stuffing_count--){
1945                 put_bits(&s->pb, 8, 0);
1946             }
1947         break;
1948         case CODEC_ID_MPEG4:
1949             put_bits(&s->pb, 16, 0);
1950             put_bits(&s->pb, 16, 0x1C3);
1951             stuffing_count -= 4;
1952             while(stuffing_count--){
1953                 put_bits(&s->pb, 8, 0xFF);
1954             }
1955         break;
1956         default:
1957             av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1958         }
1959         flush_put_bits(&s->pb);
1960         s->frame_bits  = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1961     }
1962
1963     /* update mpeg1/2 vbv_delay for CBR */    
1964     if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate){
1965         int vbv_delay;
1966
1967         assert(s->repeat_first_field==0);
1968         
1969         vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
1970         assert(vbv_delay < 0xFFFF);
1971
1972         s->vbv_delay_ptr[0] &= 0xF8;
1973         s->vbv_delay_ptr[0] |= vbv_delay>>13;
1974         s->vbv_delay_ptr[1]  = vbv_delay>>5;
1975         s->vbv_delay_ptr[2] &= 0x07;
1976         s->vbv_delay_ptr[2] |= vbv_delay<<3;
1977     }
1978
1979     s->total_bits += s->frame_bits;
1980     avctx->frame_bits  = s->frame_bits;
1981     
1982     return s->frame_bits/8;
1983 }
1984
1985 #endif //CONFIG_ENCODERS
1986
1987 static inline void gmc1_motion(MpegEncContext *s,
1988                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1989                                int dest_offset,
1990                                uint8_t **ref_picture, int src_offset)
1991 {
1992     uint8_t *ptr;
1993     int offset, src_x, src_y, linesize, uvlinesize;
1994     int motion_x, motion_y;
1995     int emu=0;
1996
1997     motion_x= s->sprite_offset[0][0];
1998     motion_y= s->sprite_offset[0][1];
1999     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2000     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2001     motion_x<<=(3-s->sprite_warping_accuracy);
2002     motion_y<<=(3-s->sprite_warping_accuracy);
2003     src_x = clip(src_x, -16, s->width);
2004     if (src_x == s->width)
2005         motion_x =0;
2006     src_y = clip(src_y, -16, s->height);
2007     if (src_y == s->height)
2008         motion_y =0;
2009
2010     linesize = s->linesize;
2011     uvlinesize = s->uvlinesize;
2012     
2013     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2014
2015     dest_y+=dest_offset;
2016     if(s->flags&CODEC_FLAG_EMU_EDGE){
2017         if(   (unsigned)src_x >= s->h_edge_pos - 17
2018            || (unsigned)src_y >= s->v_edge_pos - 17){
2019             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2020             ptr= s->edge_emu_buffer;
2021         }
2022     }
2023     
2024     if((motion_x|motion_y)&7){
2025         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2026         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2027     }else{
2028         int dxy;
2029         
2030         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2031         if (s->no_rounding){
2032             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2033         }else{
2034             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2035         }
2036     }
2037     
2038     if(s->flags&CODEC_FLAG_GRAY) return;
2039
2040     motion_x= s->sprite_offset[1][0];
2041     motion_y= s->sprite_offset[1][1];
2042     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2043     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2044     motion_x<<=(3-s->sprite_warping_accuracy);
2045     motion_y<<=(3-s->sprite_warping_accuracy);
2046     src_x = clip(src_x, -8, s->width>>1);
2047     if (src_x == s->width>>1)
2048         motion_x =0;
2049     src_y = clip(src_y, -8, s->height>>1);
2050     if (src_y == s->height>>1)
2051         motion_y =0;
2052
2053     offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
2054     ptr = ref_picture[1] + offset;
2055     if(s->flags&CODEC_FLAG_EMU_EDGE){
2056         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2057            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2058             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);
2059             ptr= s->edge_emu_buffer;
2060             emu=1;
2061         }
2062     }
2063     s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2064     
2065     ptr = ref_picture[2] + offset;
2066     if(emu){
2067         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);
2068         ptr= s->edge_emu_buffer;
2069     }
2070     s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2071     
2072     return;
2073 }
2074
2075 static inline void gmc_motion(MpegEncContext *s,
2076                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2077                                int dest_offset,
2078                                uint8_t **ref_picture, int src_offset)
2079 {
2080     uint8_t *ptr;
2081     int linesize, uvlinesize;
2082     const int a= s->sprite_warping_accuracy;
2083     int ox, oy;
2084
2085     linesize = s->linesize;
2086     uvlinesize = s->uvlinesize;
2087
2088     ptr = ref_picture[0] + src_offset;
2089
2090     dest_y+=dest_offset;
2091     
2092     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2093     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2094
2095     s->dsp.gmc(dest_y, ptr, linesize, 16,
2096            ox, 
2097            oy, 
2098            s->sprite_delta[0][0], s->sprite_delta[0][1],
2099            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2100            a+1, (1<<(2*a+1)) - s->no_rounding,
2101            s->h_edge_pos, s->v_edge_pos);
2102     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2103            ox + s->sprite_delta[0][0]*8, 
2104            oy + s->sprite_delta[1][0]*8, 
2105            s->sprite_delta[0][0], s->sprite_delta[0][1],
2106            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2107            a+1, (1<<(2*a+1)) - s->no_rounding,
2108            s->h_edge_pos, s->v_edge_pos);
2109
2110     if(s->flags&CODEC_FLAG_GRAY) return;
2111
2112
2113     dest_cb+=dest_offset>>1;
2114     dest_cr+=dest_offset>>1;
2115     
2116     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2117     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2118
2119     ptr = ref_picture[1] + (src_offset>>1);
2120     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2121            ox, 
2122            oy, 
2123            s->sprite_delta[0][0], s->sprite_delta[0][1],
2124            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2125            a+1, (1<<(2*a+1)) - s->no_rounding,
2126            s->h_edge_pos>>1, s->v_edge_pos>>1);
2127     
2128     ptr = ref_picture[2] + (src_offset>>1);
2129     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2130            ox, 
2131            oy, 
2132            s->sprite_delta[0][0], s->sprite_delta[0][1],
2133            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2134            a+1, (1<<(2*a+1)) - s->no_rounding,
2135            s->h_edge_pos>>1, s->v_edge_pos>>1);
2136 }
2137
2138 /**
2139  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2140  * @param buf destination buffer
2141  * @param src source buffer
2142  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2143  * @param block_w width of block
2144  * @param block_h height of block
2145  * @param src_x x coordinate of the top left sample of the block in the source buffer
2146  * @param src_y y coordinate of the top left sample of the block in the source buffer
2147  * @param w width of the source buffer
2148  * @param h height of the source buffer
2149  */
2150 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2151                                     int src_x, int src_y, int w, int h){
2152     int x, y;
2153     int start_y, start_x, end_y, end_x;
2154
2155     if(src_y>= h){
2156         src+= (h-1-src_y)*linesize;
2157         src_y=h-1;
2158     }else if(src_y<=-block_h){
2159         src+= (1-block_h-src_y)*linesize;
2160         src_y=1-block_h;
2161     }
2162     if(src_x>= w){
2163         src+= (w-1-src_x);
2164         src_x=w-1;
2165     }else if(src_x<=-block_w){
2166         src+= (1-block_w-src_x);
2167         src_x=1-block_w;
2168     }
2169
2170     start_y= FFMAX(0, -src_y);
2171     start_x= FFMAX(0, -src_x);
2172     end_y= FFMIN(block_h, h-src_y);
2173     end_x= FFMIN(block_w, w-src_x);
2174
2175     // copy existing part
2176     for(y=start_y; y<end_y; y++){
2177         for(x=start_x; x<end_x; x++){
2178             buf[x + y*linesize]= src[x + y*linesize];
2179         }
2180     }
2181
2182     //top
2183     for(y=0; y<start_y; y++){
2184         for(x=start_x; x<end_x; x++){
2185             buf[x + y*linesize]= buf[x + start_y*linesize];
2186         }
2187     }
2188
2189     //bottom
2190     for(y=end_y; y<block_h; y++){
2191         for(x=start_x; x<end_x; x++){
2192             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2193         }
2194     }
2195                                     
2196     for(y=0; y<block_h; y++){
2197        //left
2198         for(x=0; x<start_x; x++){
2199             buf[x + y*linesize]= buf[start_x + y*linesize];
2200         }
2201        
2202        //right
2203         for(x=end_x; x<block_w; x++){
2204             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2205         }
2206     }
2207 }
2208
2209 static inline int hpel_motion(MpegEncContext *s, 
2210                                   uint8_t *dest, uint8_t *src, 
2211                                   int src_x, int src_y,
2212                                   int width, int height, int stride,
2213                                   int h_edge_pos, int v_edge_pos,
2214                                   int w, int h, op_pixels_func *pix_op,
2215                                   int motion_x, int motion_y)
2216 {
2217     int dxy;
2218     int emu=0;
2219
2220     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2221     src_x += motion_x >> 1;
2222     src_y += motion_y >> 1;
2223                 
2224     /* WARNING: do no forget half pels */
2225     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2226     if (src_x == width)
2227         dxy &= ~1;
2228     src_y = clip(src_y, -16, height);
2229     if (src_y == height)
2230         dxy &= ~2;
2231     src += src_y * stride + src_x;
2232
2233     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2234         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2235            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2236             ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1,
2237                              src_x, src_y, h_edge_pos, v_edge_pos);
2238             src= s->edge_emu_buffer;
2239             emu=1;
2240         }
2241     }
2242     pix_op[dxy](dest, src, stride, h);
2243     return emu;
2244 }
2245
2246 /* apply one mpeg motion vector to the three components */
2247 static inline void mpeg_motion(MpegEncContext *s,
2248                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2249                                int dest_offset,
2250                                uint8_t **ref_picture, int src_offset,
2251                                int field_based, op_pixels_func (*pix_op)[4],
2252                                int motion_x, int motion_y, int h)
2253 {
2254     uint8_t *ptr;
2255     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize;
2256     int emu=0;
2257 #if 0    
2258 if(s->quarter_sample)
2259 {
2260     motion_x>>=1;
2261     motion_y>>=1;
2262 }
2263 #endif
2264
2265     height = s->height >> field_based;
2266     v_edge_pos = s->v_edge_pos >> field_based;
2267     uvlinesize = s->current_picture.linesize[1] << field_based;
2268
2269     emu= hpel_motion(s, 
2270                 dest_y + dest_offset, ref_picture[0] + src_offset,
2271                 s->mb_x * 16, s->mb_y * (16 >> field_based),
2272                 s->width, height, s->current_picture.linesize[0] << field_based,
2273                 s->h_edge_pos, v_edge_pos,
2274                 16, h, pix_op[0],
2275                 motion_x, motion_y);
2276
2277
2278     if(s->flags&CODEC_FLAG_GRAY) return;
2279
2280     if (s->out_format == FMT_H263) {
2281         dxy = 0;
2282         if ((motion_x & 3) != 0)
2283             dxy |= 1;
2284         if ((motion_y & 3) != 0)
2285             dxy |= 2;
2286         mx = motion_x >> 2;
2287         my = motion_y >> 2;
2288     } else {
2289         mx = motion_x / 2;
2290         my = motion_y / 2;
2291         dxy = ((my & 1) << 1) | (mx & 1);
2292         mx >>= 1;
2293         my >>= 1;
2294     }
2295     
2296     src_x = s->mb_x * 8 + mx;
2297     src_y = s->mb_y * (8 >> field_based) + my;
2298     src_x = clip(src_x, -8, s->width >> 1);
2299     if (src_x == (s->width >> 1))
2300         dxy &= ~1;
2301     src_y = clip(src_y, -8, height >> 1);
2302     if (src_y == (height >> 1))
2303         dxy &= ~2;
2304     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2305     ptr = ref_picture[1] + offset;
2306     if(emu){
2307         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2308                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2309         ptr= s->edge_emu_buffer + (src_offset >> 1);
2310     }
2311     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2312
2313     ptr = ref_picture[2] + offset;
2314     if(emu){
2315         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based, 
2316                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2317         ptr= s->edge_emu_buffer + (src_offset >> 1);
2318     }
2319     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2320 }
2321 //FIXME move to dsputil, avg variant, 16x16 version
2322 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2323     int x;
2324     uint8_t * const top   = src[1];
2325     uint8_t * const left  = src[2];
2326     uint8_t * const mid   = src[0];
2327     uint8_t * const right = src[3];
2328     uint8_t * const bottom= src[4];
2329 #define OBMC_FILTER(x, t, l, m, r, b)\
2330     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2331 #define OBMC_FILTER4(x, t, l, m, r, b)\
2332     OBMC_FILTER(x         , t, l, m, r, b);\
2333     OBMC_FILTER(x+1       , t, l, m, r, b);\
2334     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2335     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2336     
2337     x=0;
2338     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2339     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2340     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2341     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2342     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2343     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2344     x+= stride;
2345     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2346     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2347     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2348     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2349     x+= stride;
2350     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2351     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2352     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2353     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2354     x+= 2*stride;
2355     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2356     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2357     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2358     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2359     x+= 2*stride;
2360     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2361     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2362     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2363     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2364     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2365     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2366     x+= stride;
2367     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2368     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2369     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2370     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2371 }
2372
2373 /* obmc for 1 8x8 luma block */
2374 static inline void obmc_motion(MpegEncContext *s,
2375                                uint8_t *dest, uint8_t *src,
2376                                int src_x, int src_y,
2377                                op_pixels_func *pix_op,
2378                                int16_t mv[5][2]/* mid top left right bottom*/)
2379 #define MID    0
2380 {
2381     int i;
2382     uint8_t *ptr[5];
2383     
2384     assert(s->quarter_sample==0);
2385     
2386     for(i=0; i<5; i++){
2387         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2388             ptr[i]= ptr[MID];
2389         }else{
2390             ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1);
2391             hpel_motion(s, ptr[i], src,
2392                         src_x, src_y,
2393                         s->width, s->height, s->linesize,
2394                         s->h_edge_pos, s->v_edge_pos,
2395                         8, 8, pix_op,
2396                         mv[i][0], mv[i][1]);
2397         }
2398     }
2399
2400     put_obmc(dest, ptr, s->linesize);                
2401 }
2402
2403 static inline void qpel_motion(MpegEncContext *s,
2404                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2405                                int dest_offset,
2406                                uint8_t **ref_picture, int src_offset,
2407                                int field_based, op_pixels_func (*pix_op)[4],
2408                                qpel_mc_func (*qpix_op)[16],
2409                                int motion_x, int motion_y, int h)
2410 {
2411     uint8_t *ptr;
2412     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
2413     int emu=0;
2414
2415     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2416     src_x = s->mb_x * 16 + (motion_x >> 2);
2417     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2418
2419     height = s->height >> field_based;
2420     v_edge_pos = s->v_edge_pos >> field_based;
2421     src_x = clip(src_x, -16, s->width);
2422     if (src_x == s->width)
2423         dxy &= ~3;
2424     src_y = clip(src_y, -16, height);
2425     if (src_y == height)
2426         dxy &= ~12;
2427     linesize = s->linesize << field_based;
2428     uvlinesize = s->uvlinesize << field_based;
2429     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2430     dest_y += dest_offset;
2431 //printf("%d %d %d\n", src_x, src_y, dxy);
2432     
2433     if(s->flags&CODEC_FLAG_EMU_EDGE){
2434         if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2435            || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2436             ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, 
2437                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2438             ptr= s->edge_emu_buffer + src_offset;
2439             emu=1;
2440         }
2441     }
2442     if(!field_based)
2443         qpix_op[0][dxy](dest_y, ptr, linesize);
2444     else{
2445         //damn interlaced mode
2446         //FIXME boundary mirroring is not exactly correct here
2447         qpix_op[1][dxy](dest_y  , ptr  , linesize);
2448         qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2449     }
2450
2451     if(s->flags&CODEC_FLAG_GRAY) return;
2452
2453     if(field_based){
2454         mx= motion_x/2;
2455         my= motion_y>>1;
2456     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2457         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2458         mx= (motion_x>>1) + rtab[motion_x&7];
2459         my= (motion_y>>1) + rtab[motion_y&7];
2460     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2461         mx= (motion_x>>1)|(motion_x&1);
2462         my= (motion_y>>1)|(motion_y&1);
2463     }else{
2464         mx= motion_x/2;
2465         my= motion_y/2;
2466     }
2467     mx= (mx>>1)|(mx&1);
2468     my= (my>>1)|(my&1);
2469
2470     dxy= (mx&1) | ((my&1)<<1);
2471     mx>>=1;
2472     my>>=1;
2473
2474     src_x = s->mb_x * 8 + mx;
2475     src_y = s->mb_y * (8 >> field_based) + my;
2476     src_x = clip(src_x, -8, s->width >> 1);
2477     if (src_x == (s->width >> 1))
2478         dxy &= ~1;
2479     src_y = clip(src_y, -8, height >> 1);
2480     if (src_y == (height >> 1))
2481         dxy &= ~2;
2482
2483     offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2484     ptr = ref_picture[1] + offset;
2485     if(emu){
2486         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2487                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2488         ptr= s->edge_emu_buffer + (src_offset >> 1);
2489     }
2490     pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2491     
2492     ptr = ref_picture[2] + offset;
2493     if(emu){
2494         ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based, 
2495                          src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2496         ptr= s->edge_emu_buffer + (src_offset >> 1);
2497     }
2498     pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr,  uvlinesize, h >> 1);
2499 }
2500
2501 inline int ff_h263_round_chroma(int x){
2502     if (x >= 0)
2503         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2504     else {
2505         x = -x;
2506         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2507     }
2508 }
2509
2510 /**
2511  * h263 chorma 4mv motion compensation.
2512  */
2513 static inline void chroma_4mv_motion(MpegEncContext *s,
2514                                      uint8_t *dest_cb, uint8_t *dest_cr,
2515                                      uint8_t **ref_picture,
2516                                      op_pixels_func *pix_op,
2517                                      int mx, int my){
2518     int dxy, emu=0, src_x, src_y, offset;
2519     uint8_t *ptr;
2520     
2521     /* In case of 8X8, we construct a single chroma motion vector
2522        with a special rounding */
2523     mx= ff_h263_round_chroma(mx);
2524     my= ff_h263_round_chroma(my);
2525     
2526     dxy = ((my & 1) << 1) | (mx & 1);
2527     mx >>= 1;
2528     my >>= 1;
2529
2530     src_x = s->mb_x * 8 + mx;
2531     src_y = s->mb_y * 8 + my;
2532     src_x = clip(src_x, -8, s->width/2);
2533     if (src_x == s->width/2)
2534         dxy &= ~1;
2535     src_y = clip(src_y, -8, s->height/2);
2536     if (src_y == s->height/2)
2537         dxy &= ~2;
2538     
2539     offset = (src_y * (s->uvlinesize)) + src_x;
2540     ptr = ref_picture[1] + offset;
2541     if(s->flags&CODEC_FLAG_EMU_EDGE){
2542         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2543            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2544             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);
2545             ptr= s->edge_emu_buffer;
2546             emu=1;
2547         }
2548     }
2549     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2550
2551     ptr = ref_picture[2] + offset;
2552     if(emu){
2553         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);
2554         ptr= s->edge_emu_buffer;
2555     }
2556     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2557 }
2558
2559 /**
2560  * motion compesation of a single macroblock
2561  * @param s context
2562  * @param dest_y luma destination pointer
2563  * @param dest_cb chroma cb/u destination pointer
2564  * @param dest_cr chroma cr/v destination pointer
2565  * @param dir direction (0->forward, 1->backward)
2566  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2567  * @param pic_op halfpel motion compensation function (average or put normally)
2568  * @param pic_op qpel motion compensation function (average or put normally)
2569  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2570  */
2571 static inline void MPV_motion(MpegEncContext *s, 
2572                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2573                               int dir, uint8_t **ref_picture, 
2574                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2575 {
2576     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2577     int mb_x, mb_y, i;
2578     uint8_t *ptr, *dest;
2579
2580     mb_x = s->mb_x;
2581     mb_y = s->mb_y;
2582
2583     if(s->obmc && s->pict_type != B_TYPE){
2584         int16_t mv_cache[4][4][2];
2585         const int xy= s->mb_x + s->mb_y*s->mb_stride;
2586         const int mot_stride= s->mb_width*2 + 2;
2587         const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride;
2588
2589         assert(!s->mb_skiped);
2590                 
2591         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2592         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2593         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2594
2595         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2596             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2597         }else{
2598             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2599         }
2600
2601         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2602             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2603             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2604         }else{
2605             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2606             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2607         }
2608
2609         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2610             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2611             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2612         }else{
2613             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2614             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2615         }
2616         
2617         mx = 0;
2618         my = 0;
2619         for(i=0;i<4;i++) {
2620             const int x= (i&1)+1;
2621             const int y= (i>>1)+1;
2622             int16_t mv[5][2]= {
2623                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2624                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2625                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2626                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2627                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2628             //FIXME cleanup
2629             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2630                         ref_picture[0],
2631                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2632                         pix_op[1],
2633                         mv);
2634
2635             mx += mv[0][0];
2636             my += mv[0][1];
2637         }
2638         if(!(s->flags&CODEC_FLAG_GRAY))
2639             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2640
2641         return;
2642     }
2643    
2644     switch(s->mv_type) {
2645     case MV_TYPE_16X16:
2646 #ifdef CONFIG_RISKY
2647         if(s->mcsel){
2648             if(s->real_sprite_warping_points==1){
2649                 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2650                             ref_picture, 0);
2651             }else{
2652                 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2653                             ref_picture, 0);
2654             }
2655         }else if(s->quarter_sample){
2656             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2657                         ref_picture, 0,
2658                         0, pix_op, qpix_op,
2659                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2660         }else if(s->mspel){
2661             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2662                         ref_picture, pix_op,
2663                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2664         }else
2665 #endif
2666         {
2667             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2668                         ref_picture, 0,
2669                         0, pix_op,
2670                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2671         }           
2672         break;
2673     case MV_TYPE_8X8:
2674         mx = 0;
2675         my = 0;
2676         if(s->quarter_sample){
2677             for(i=0;i<4;i++) {
2678                 motion_x = s->mv[dir][i][0];
2679                 motion_y = s->mv[dir][i][1];
2680
2681                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2682                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2683                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2684                     
2685                 /* WARNING: do no forget half pels */
2686                 src_x = clip(src_x, -16, s->width);
2687                 if (src_x == s->width)
2688                     dxy &= ~3;
2689                 src_y = clip(src_y, -16, s->height);
2690                 if (src_y == s->height)
2691                     dxy &= ~12;
2692                     
2693                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2694                 if(s->flags&CODEC_FLAG_EMU_EDGE){
2695                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2696                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2697                         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);
2698                         ptr= s->edge_emu_buffer;
2699                     }
2700                 }
2701                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2702                 qpix_op[1][dxy](dest, ptr, s->linesize);
2703
2704                 mx += s->mv[dir][i][0]/2;
2705                 my += s->mv[dir][i][1]/2;
2706             }
2707         }else{
2708             for(i=0;i<4;i++) {
2709                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2710                             ref_picture[0],
2711                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2712                             s->width, s->height, s->linesize,
2713                             s->h_edge_pos, s->v_edge_pos,
2714                             8, 8, pix_op[1],
2715                             s->mv[dir][i][0], s->mv[dir][i][1]);
2716
2717                 mx += s->mv[dir][i][0];
2718                 my += s->mv[dir][i][1];
2719             }
2720         }
2721
2722         if(!(s->flags&CODEC_FLAG_GRAY))
2723             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2724         break;
2725     case MV_TYPE_FIELD:
2726         if (s->picture_structure == PICT_FRAME) {
2727             if(s->quarter_sample){
2728                 /* top field */
2729                 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2730                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2731                             1, pix_op, qpix_op,
2732                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
2733                 /* bottom field */
2734                 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2735                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2736                             1, pix_op, qpix_op,
2737                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
2738             }else{
2739                 /* top field */       
2740                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2741                             ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2742                             1, pix_op,
2743                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
2744                 /* bottom field */
2745                 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2746                             ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2747                             1, pix_op,
2748                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
2749             }
2750         } else {
2751             int offset;
2752             if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2753                 offset= s->field_select[dir][0] ? s->linesize : 0;
2754             }else{
2755                 ref_picture= s->current_picture.data;
2756                 offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2757             } 
2758
2759             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2760                         ref_picture, offset,
2761                         0, pix_op,
2762                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
2763         }
2764         break;
2765     case MV_TYPE_16X8:{
2766         int offset;
2767          uint8_t ** ref2picture;
2768
2769             if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2770                 ref2picture= ref_picture;
2771                 offset= s->field_select[dir][0] ? s->linesize : 0;
2772             }else{
2773                 ref2picture= s->current_picture.data;
2774                 offset= s->field_select[dir][0] ? s->linesize : -s->linesize; 
2775             } 
2776
2777             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2778                         ref2picture, offset,
2779                         0, pix_op,
2780                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
2781
2782
2783             if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2784                 ref2picture= ref_picture;
2785                 offset= s->field_select[dir][1] ? s->linesize : 0;
2786             }else{
2787                 ref2picture= s->current_picture.data;
2788                 offset= s->field_select[dir][1] ? s->linesize : -s->linesize; 
2789             } 
2790             // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2791             mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2792                         0,
2793                         ref2picture, offset,
2794                         0, pix_op,
2795                         s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2796         }
2797         
2798         break;
2799     case MV_TYPE_DMV:
2800     {
2801     op_pixels_func (*dmv_pix_op)[4];
2802     int offset;
2803
2804         dmv_pix_op = s->dsp.put_pixels_tab;
2805
2806         if(s->picture_structure == PICT_FRAME){
2807             //put top field from top field
2808             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2809                         ref_picture, 0,
2810                         1, dmv_pix_op,
2811                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
2812             //put bottom field from bottom field
2813             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2814                         ref_picture, s->linesize,
2815                         1, dmv_pix_op,
2816                         s->mv[dir][0][0], s->mv[dir][0][1], 8);
2817
2818             dmv_pix_op = s->dsp.avg_pixels_tab; 
2819         
2820             //avg top field from bottom field
2821             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2822                         ref_picture, s->linesize,
2823                         1, dmv_pix_op,
2824                         s->mv[dir][2][0], s->mv[dir][2][1], 8);
2825             //avg bottom field from top field
2826             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2827                         ref_picture, 0,
2828                         1, dmv_pix_op,
2829                         s->mv[dir][3][0], s->mv[dir][3][1], 8);
2830
2831         }else{
2832             offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2833                          s->linesize : 0;
2834
2835             //put field from the same parity
2836             //same parity is never in the same frame
2837             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2838                         ref_picture,offset,
2839                         0,dmv_pix_op,
2840                         s->mv[dir][0][0],s->mv[dir][0][1],16);
2841
2842             // after put we make avg of the same block
2843             dmv_pix_op=s->dsp.avg_pixels_tab; 
2844
2845             //opposite parity is always in the same frame if this is second field
2846             if(!s->first_field){
2847                 ref_picture = s->current_picture.data;    
2848                 //top field is one linesize from frame beginig
2849                 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2850                         -s->linesize : s->linesize;
2851             }else 
2852                 offset=(s->picture_structure == PICT_BOTTOM_FIELD)? 
2853                         0 : s->linesize;
2854
2855             //avg field from the opposite parity
2856             mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2857                         ref_picture, offset,
2858                         0,dmv_pix_op,
2859                         s->mv[dir][2][0],s->mv[dir][2][1],16);
2860         }
2861     }
2862     break;
2863     default: assert(0);
2864     }
2865 }
2866
2867
2868 /* put block[] to dest[] */
2869 static inline void put_dct(MpegEncContext *s, 
2870                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2871 {
2872     s->dct_unquantize_intra(s, block, i, qscale);
2873     s->dsp.idct_put (dest, line_size, block);
2874 }
2875
2876 /* add block[] to dest[] */
2877 static inline void add_dct(MpegEncContext *s, 
2878                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2879 {
2880     if (s->block_last_index[i] >= 0) {
2881         s->dsp.idct_add (dest, line_size, block);
2882     }
2883 }
2884
2885 static inline void add_dequant_dct(MpegEncContext *s, 
2886                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2887 {
2888     if (s->block_last_index[i] >= 0) {
2889         s->dct_unquantize_inter(s, block, i, qscale);
2890
2891         s->dsp.idct_add (dest, line_size, block);
2892     }
2893 }
2894
2895 /**
2896  * cleans dc, ac, coded_block for the current non intra MB
2897  */
2898 void ff_clean_intra_table_entries(MpegEncContext *s)
2899 {
2900     int wrap = s->block_wrap[0];
2901     int xy = s->block_index[0];
2902     
2903     s->dc_val[0][xy           ] = 
2904     s->dc_val[0][xy + 1       ] = 
2905     s->dc_val[0][xy     + wrap] =
2906     s->dc_val[0][xy + 1 + wrap] = 1024;
2907     /* ac pred */
2908     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2909     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2910     if (s->msmpeg4_version>=3) {
2911         s->coded_block[xy           ] =
2912         s->coded_block[xy + 1       ] =
2913         s->coded_block[xy     + wrap] =
2914         s->coded_block[xy + 1 + wrap] = 0;
2915     }
2916     /* chroma */
2917     wrap = s->block_wrap[4];
2918     xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2919     s->dc_val[1][xy] =
2920     s->dc_val[2][xy] = 1024;
2921     /* ac pred */
2922     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2923     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2924     
2925     s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2926 }
2927
2928 /* generic function called after a macroblock has been parsed by the
2929    decoder or after it has been encoded by the encoder.
2930
2931    Important variables used:
2932    s->mb_intra : true if intra macroblock
2933    s->mv_dir   : motion vector direction
2934    s->mv_type  : motion vector type
2935    s->mv       : motion vector
2936    s->interlaced_dct : true if interlaced dct used (mpeg2)
2937  */
2938 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2939 {
2940     int mb_x, mb_y;
2941     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2942 #ifdef HAVE_XVMC
2943     if(s->avctx->xvmc_acceleration){
2944         XVMC_decode_mb(s);//xvmc uses pblocks
2945         return;
2946     }
2947 #endif
2948
2949     mb_x = s->mb_x;
2950     mb_y = s->mb_y;
2951
2952     s->current_picture.qscale_table[mb_xy]= s->qscale;
2953
2954     /* update DC predictors for P macroblocks */
2955     if (!s->mb_intra) {
2956         if (s->h263_pred || s->h263_aic) {
2957             if(s->mbintra_table[mb_xy])
2958                 ff_clean_intra_table_entries(s);
2959         } else {
2960             s->last_dc[0] =
2961             s->last_dc[1] =
2962             s->last_dc[2] = 128 << s->intra_dc_precision;
2963         }
2964     }
2965     else if (s->h263_pred || s->h263_aic)
2966         s->mbintra_table[mb_xy]=1;
2967
2968     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2969         uint8_t *dest_y, *dest_cb, *dest_cr;
2970         int dct_linesize, dct_offset;
2971         op_pixels_func (*op_pix)[4];
2972         qpel_mc_func (*op_qpix)[16];
2973         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2974         const int uvlinesize= s->current_picture.linesize[1];
2975         const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
2976
2977         /* avoid copy if macroblock skipped in last frame too */
2978         /* skip only during decoding as we might trash the buffers during encoding a bit */
2979         if(!s->encoding){
2980             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2981             const int age= s->current_picture.age;
2982
2983             assert(age);
2984
2985             if (s->mb_skiped) {
2986                 s->mb_skiped= 0;
2987                 assert(s->pict_type!=I_TYPE);
2988  
2989                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2990                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2991
2992                 /* if previous was skipped too, then nothing to do !  */
2993                 if (*mbskip_ptr >= age && s->current_picture.reference){
2994                     return;
2995                 }
2996             } else if(!s->current_picture.reference){
2997                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2998                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2999             } else{
3000                 *mbskip_ptr = 0; /* not skipped */
3001             }
3002         }
3003
3004         if (s->interlaced_dct) {
3005             dct_linesize = linesize * 2;
3006             dct_offset = linesize;
3007         } else {
3008             dct_linesize = linesize;
3009             dct_offset = linesize * 8;
3010         }
3011         if(readable){
3012             dest_y=  s->dest[0];
3013             dest_cb= s->dest[1];
3014             dest_cr= s->dest[2];
3015         }else{
3016             dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers
3017             dest_cb= s->edge_emu_buffer+48;
3018             dest_cr= s->edge_emu_buffer+56;
3019         }
3020         if (!s->mb_intra) {
3021             /* motion handling */
3022             /* decoding or more than one mb_type (MC was allready done otherwise) */
3023             if(!s->encoding){
3024                 if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3025                     op_pix = s->dsp.put_pixels_tab;
3026                     op_qpix= s->dsp.put_qpel_pixels_tab;
3027                 }else{
3028                     op_pix = s->dsp.put_no_rnd_pixels_tab;
3029                     op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3030                 }
3031
3032                 if (s->mv_dir & MV_DIR_FORWARD) {
3033                     MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3034                     op_pix = s->dsp.avg_pixels_tab;
3035                     op_qpix= s->dsp.avg_qpel_pixels_tab;
3036                 }
3037                 if (s->mv_dir & MV_DIR_BACKWARD) {
3038                     MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3039                 }
3040             }
3041
3042             /* skip dequant / idct if we are really late ;) */
3043             if(s->hurry_up>1) return;
3044
3045             /* add dct residue */
3046             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3047                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3048                 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3049                 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3050                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3051                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3052
3053                 if(!(s->flags&CODEC_FLAG_GRAY)){
3054                     add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3055                     add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3056                 }
3057             } else if(s->codec_id != CODEC_ID_WMV2){
3058                 add_dct(s, block[0], 0, dest_y, dct_linesize);
3059                 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3060                 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3061                 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3062
3063                 if(!(s->flags&CODEC_FLAG_GRAY)){
3064                     add_dct(s, block[4], 4, dest_cb, uvlinesize);
3065                     add_dct(s, block[5], 5, dest_cr, uvlinesize);
3066                 }
3067             } 
3068 #ifdef CONFIG_RISKY
3069             else{
3070                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3071             }
3072 #endif
3073         } else {
3074             /* dct only in intra block */
3075             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3076                 put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3077                 put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3078                 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3079                 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3080
3081                 if(!(s->flags&CODEC_FLAG_GRAY)){
3082                     put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3083                     put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3084                 }
3085             }else{
3086                 s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3087                 s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3088                 s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3089                 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3090
3091                 if(!(s->flags&CODEC_FLAG_GRAY)){
3092                     s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3093                     s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3094                 }
3095             }
3096         }
3097         if(!readable){
3098             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3099             s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
3100             s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
3101         }
3102     }
3103 }
3104
3105 #ifdef CONFIG_ENCODERS
3106
3107 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3108 {
3109     static const char tab[64]=
3110         {3,2,2,1,1,1,1,1,
3111          1,1,1,1,1,1,1,1,
3112          1,1,1,1,1,1,1,1,
3113          0,0,0,0,0,0,0,0,
3114          0,0,0,0,0,0,0,0,
3115          0,0,0,0,0,0,0,0,
3116          0,0,0,0,0,0,0,0,
3117          0,0,0,0,0,0,0,0};
3118     int score=0;
3119     int run=0;
3120     int i;
3121     DCTELEM *block= s->block[n];
3122     const int last_index= s->block_last_index[n];
3123     int skip_dc;
3124
3125     if(threshold<0){
3126         skip_dc=0;
3127         threshold= -threshold;
3128     }else
3129         skip_dc=1;
3130
3131     /* are all which we could set to zero are allready zero? */
3132     if(last_index<=skip_dc - 1) return;
3133
3134     for(i=0; i<=last_index; i++){
3135         const int j = s->intra_scantable.permutated[i];
3136         const int level = ABS(block[j]);
3137         if(level==1){
3138             if(skip_dc && i==0) continue;
3139             score+= tab[run];
3140             run=0;
3141         }else if(level>1){
3142             return;
3143         }else{
3144             run++;
3145         }
3146     }
3147     if(score >= threshold) return;
3148     for(i=skip_dc; i<=last_index; i++){
3149         const int j = s->intra_scantable.permutated[i];
3150         block[j]=0;
3151     }
3152     if(block[0]) s->block_last_index[n]= 0;
3153     else         s->block_last_index[n]= -1;
3154 }
3155
3156 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3157 {
3158     int i;
3159     const int maxlevel= s->max_qcoeff;
3160     const int minlevel= s->min_qcoeff;
3161     int overflow=0;
3162     
3163     if(s->mb_intra){
3164         i=1; //skip clipping of intra dc
3165     }else
3166         i=0;
3167     
3168     for(;i<=last_index; i++){
3169         const int j= s->intra_scantable.permutated[i];
3170         int level = block[j];
3171        
3172         if     (level>maxlevel){
3173             level=maxlevel;
3174             overflow++;
3175         }else if(level<minlevel){
3176             level=minlevel;
3177             overflow++;
3178         }
3179         
3180         block[j]= level;
3181     }
3182     
3183     if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3184         av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3185 }
3186
3187 #endif //CONFIG_ENCODERS
3188
3189 /**
3190  *
3191  * @param h is the normal height, this will be reduced automatically if needed for the last row
3192  */
3193 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3194     if (s->avctx->draw_horiz_band) {
3195         AVFrame *src;
3196         int offset[4];
3197         
3198         if(s->picture_structure != PICT_FRAME){
3199             h <<= 1;
3200             y <<= 1;
3201             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3202         }
3203
3204         h= FFMIN(h, s->height - y);
3205
3206         if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3207             src= (AVFrame*)s->current_picture_ptr;
3208         else if(s->last_picture_ptr)
3209             src= (AVFrame*)s->last_picture_ptr;
3210         else
3211             return;
3212             
3213         if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3214             offset[0]=
3215             offset[1]=
3216             offset[2]=
3217             offset[3]= 0;
3218         }else{
3219             offset[0]= y * s->linesize;;
3220             offset[1]= 
3221             offset[2]= (y>>1) * s->uvlinesize;;
3222             offset[3]= 0;
3223         }
3224
3225         emms_c();
3226
3227         s->avctx->draw_horiz_band(s->avctx, src, offset,
3228                                   y, s->picture_structure, h);
3229     }
3230 }
3231
3232 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3233     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3234     const int uvlinesize= s->current_picture.linesize[1];
3235         
3236     s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3237     s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
3238     s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
3239     s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
3240     s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3241     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;
3242     
3243     if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3244         s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3245         s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3246         s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3247     }else{
3248         s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize  ) + s->mb_x * 16 - 16;
3249         s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3250         s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3251     }    
3252 }
3253
3254 #ifdef CONFIG_ENCODERS
3255
3256 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3257 {
3258     const int mb_x= s->mb_x;
3259     const int mb_y= s->mb_y;
3260     int i;
3261     int skip_dct[6];
3262     int dct_offset   = s->linesize*8; //default for progressive frames
3263     
3264     for(i=0; i<6; i++) skip_dct[i]=0;
3265     
3266     if(s->adaptive_quant){
3267         const int last_qp= s->qscale;
3268         const int mb_xy= mb_x + mb_y*s->mb_stride;
3269
3270         s->lambda= s->lambda_table[mb_xy];
3271         update_qscale(s);
3272     
3273         if(!(s->flags&CODEC_FLAG_QP_RD)){
3274             s->dquant= s->qscale - last_qp;
3275
3276             if(s->out_format==FMT_H263)
3277                 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3278             
3279             if(s->codec_id==CODEC_ID_MPEG4){        
3280                 if(!s->mb_intra){
3281                     if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8)
3282                         s->dquant=0;
3283                 }
3284             }
3285         }
3286         ff_set_qscale(s, last_qp + s->dquant);
3287     }
3288
3289     if (s->mb_intra) {
3290         uint8_t *ptr;
3291         int wrap_y;
3292         int emu=0;
3293
3294         wrap_y = s->linesize;
3295         ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3296
3297         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3298             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3299             ptr= s->edge_emu_buffer;
3300             emu=1;
3301         }
3302         
3303         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3304             int progressive_score, interlaced_score;
3305
3306             s->interlaced_dct=0;
3307             progressive_score= s->dsp.ildct_cmp[4](s, ptr           , NULL, wrap_y, 8) 
3308                               +s->dsp.ildct_cmp[4](s, ptr + wrap_y*8, NULL, wrap_y, 8) - 400;
3309
3310             if(progressive_score > 0){
3311                 interlaced_score = s->dsp.ildct_cmp[4](s, ptr           , NULL, wrap_y*2, 8) 
3312                                   +s->dsp.ildct_cmp[4](s, ptr + wrap_y  , NULL, wrap_y*2, 8);
3313                 if(progressive_score > interlaced_score){
3314                     s->interlaced_dct=1;
3315             
3316                     dct_offset= wrap_y;
3317                     wrap_y<<=1;
3318                 }
3319             }
3320         }
3321         
3322         s->dsp.get_pixels(s->block[0], ptr                 , wrap_y);
3323         s->dsp.get_pixels(s->block[1], ptr              + 8, wrap_y);
3324         s->dsp.get_pixels(s->block[2], ptr + dct_offset    , wrap_y);
3325         s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
3326
3327         if(s->flags&CODEC_FLAG_GRAY){
3328             skip_dct[4]= 1;
3329             skip_dct[5]= 1;
3330         }else{
3331             int wrap_c = s->uvlinesize;
3332             ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3333             if(emu){
3334                 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);
3335                 ptr= s->edge_emu_buffer;
3336             }
3337             s->dsp.get_pixels(s->block[4], ptr, wrap_c);
3338
3339             ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3340             if(emu){
3341                 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);
3342                 ptr= s->edge_emu_buffer;
3343             }
3344             s->dsp.get_pixels(s->block[5], ptr, wrap_c);
3345         }
3346     }else{
3347         op_pixels_func (*op_pix)[4];
3348         qpel_mc_func (*op_qpix)[16];
3349         uint8_t *dest_y, *dest_cb, *dest_cr;
3350         uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3351         int wrap_y, wrap_c;
3352         int emu=0;
3353
3354         dest_y  = s->dest[0];
3355         dest_cb = s->dest[1];
3356         dest_cr = s->dest[2];
3357         wrap_y = s->linesize;
3358         wrap_c = s->uvlinesize;
3359         ptr_y  = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3360         ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3361         ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3362
3363         if ((!s->no_rounding) || s->pict_type==B_TYPE){
3364             op_pix = s->dsp.put_pixels_tab;
3365             op_qpix= s->dsp.put_qpel_pixels_tab;
3366         }else{
3367             op_pix = s->dsp.put_no_rnd_pixels_tab;
3368             op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3369         }
3370
3371         if (s->mv_dir & MV_DIR_FORWARD) {
3372             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3373             op_pix = s->dsp.avg_pixels_tab;
3374             op_qpix= s->dsp.avg_qpel_pixels_tab;
3375         }
3376         if (s->mv_dir & MV_DIR_BACKWARD) {
3377             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3378         }
3379
3380         if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3381             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3382             ptr_y= s->edge_emu_buffer;
3383             emu=1;
3384         }
3385         
3386         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3387             int progressive_score, interlaced_score;
3388
3389             s->interlaced_dct=0;
3390             progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3391                               +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3392             
3393             if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3394
3395             if(progressive_score>0){
3396                 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3397                                   +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3398             
3399                 if(progressive_score > interlaced_score){
3400                     s->interlaced_dct=1;
3401             
3402                     dct_offset= wrap_y;
3403                     wrap_y<<=1;
3404                 }
3405             }
3406         }
3407         
3408         s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3409         s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3410         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3411         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3412         
3413         if(s->flags&CODEC_FLAG_GRAY){
3414             skip_dct[4]= 1;
3415             skip_dct[5]= 1;
3416         }else{
3417             if(emu){
3418                 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);
3419                 ptr_cb= s->edge_emu_buffer;
3420             }
3421             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3422             if(emu){
3423                 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);
3424                 ptr_cr= s->edge_emu_buffer;
3425             }
3426             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3427         }
3428         /* pre quantization */         
3429         if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3430             //FIXME optimize
3431             if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3432             if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3433             if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3434             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;
3435             if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3436             if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3437 #if 0
3438 {
3439  static int stat[7];
3440  int num=0;
3441  for(i=0; i<6; i++)
3442   if(skip_dct[i]) num++;
3443  stat[num]++;
3444  
3445  if(s->mb_x==0 && s->mb_y==0){
3446   for(i=0; i<7; i++){
3447    printf("%6d %1d\n", stat[i], i);
3448   }
3449  }
3450 }
3451 #endif
3452         }
3453
3454     }
3455             
3456     /* DCT & quantize */
3457     if(s->out_format==FMT_MJPEG){
3458         for(i=0;i<6;i++) {
3459             int overflow;
3460             s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3461             if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3462         }
3463     }else{
3464         for(i=0;i<6;i++) {
3465             if(!skip_dct[i]){
3466                 int overflow;
3467                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3468             // FIXME we could decide to change to quantizer instead of clipping