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