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