b498c98d9eefb008e176fd5043f6aaf9665ccf6b
[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_RV20:
1124         s->out_format = FMT_H263;
1125         avctx->delay=0;
1126         s->low_delay=1;
1127         s->modified_quant=1;
1128         s->h263_aic=1;
1129         s->h263_plus=1;
1130         s->loop_filter=1;
1131         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1132         break;
1133     case CODEC_ID_MPEG4:
1134         s->out_format = FMT_H263;
1135         s->h263_pred = 1;
1136         s->unrestricted_mv = 1;
1137         s->low_delay= s->max_b_frames ? 0 : 1;
1138         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1139         break;
1140     case CODEC_ID_MSMPEG4V1:
1141         s->out_format = FMT_H263;
1142         s->h263_msmpeg4 = 1;
1143         s->h263_pred = 1;
1144         s->unrestricted_mv = 1;
1145         s->msmpeg4_version= 1;
1146         avctx->delay=0;
1147         s->low_delay=1;
1148         break;
1149     case CODEC_ID_MSMPEG4V2:
1150         s->out_format = FMT_H263;
1151         s->h263_msmpeg4 = 1;
1152         s->h263_pred = 1;
1153         s->unrestricted_mv = 1;
1154         s->msmpeg4_version= 2;
1155         avctx->delay=0;
1156         s->low_delay=1;
1157         break;
1158     case CODEC_ID_MSMPEG4V3:
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= 3;
1164         s->flipflop_rounding=1;
1165         avctx->delay=0;
1166         s->low_delay=1;
1167         break;
1168     case CODEC_ID_WMV1:
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= 4;
1174         s->flipflop_rounding=1;
1175         avctx->delay=0;
1176         s->low_delay=1;
1177         break;
1178     case CODEC_ID_WMV2:
1179         s->out_format = FMT_H263;
1180         s->h263_msmpeg4 = 1;
1181         s->h263_pred = 1;
1182         s->unrestricted_mv = 1;
1183         s->msmpeg4_version= 5;
1184         s->flipflop_rounding=1;
1185         avctx->delay=0;
1186         s->low_delay=1;
1187         break;
1188 #endif
1189     default:
1190         return -1;
1191     }
1192     
1193     avctx->has_b_frames= !s->low_delay;
1194
1195     s->encoding = 1;
1196
1197     /* init */
1198     if (MPV_common_init(s) < 0)
1199         return -1;
1200
1201     if(s->modified_quant)
1202         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1203     s->progressive_frame= 
1204     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1205     s->quant_precision=5;
1206     
1207     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1208     
1209 #ifdef CONFIG_ENCODERS
1210 #ifdef CONFIG_RISKY
1211     if (s->out_format == FMT_H261)
1212         ff_h261_encode_init(s);
1213     if (s->out_format == FMT_H263)
1214         h263_encode_init(s);
1215     if(s->msmpeg4_version)
1216         ff_msmpeg4_encode_init(s);
1217 #endif
1218     if (s->out_format == FMT_MPEG1)
1219         ff_mpeg1_encode_init(s);
1220 #endif
1221
1222     /* init q matrix */
1223     for(i=0;i<64;i++) {
1224         int j= s->dsp.idct_permutation[i];
1225 #ifdef CONFIG_RISKY
1226         if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1227             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1228             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1229         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1230             s->intra_matrix[j] =
1231             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1232         }else
1233 #endif
1234         { /* mpeg1/2 */
1235             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1236             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1237         }
1238         if(s->avctx->intra_matrix)
1239             s->intra_matrix[j] = s->avctx->intra_matrix[i];
1240         if(s->avctx->inter_matrix)
1241             s->inter_matrix[j] = s->avctx->inter_matrix[i];
1242     }
1243
1244     /* precompute matrix */
1245     /* for mjpeg, we do include qscale in the matrix */
1246     if (s->out_format != FMT_MJPEG) {
1247         convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1248                        s->intra_matrix, s->intra_quant_bias, 1, 31);
1249         convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1250                        s->inter_matrix, s->inter_quant_bias, 1, 31);
1251     }
1252
1253     if(ff_rate_control_init(s) < 0)
1254         return -1;
1255     
1256     return 0;
1257 }
1258
1259 int MPV_encode_end(AVCodecContext *avctx)
1260 {
1261     MpegEncContext *s = avctx->priv_data;
1262
1263 #ifdef STATS
1264     print_stats();
1265 #endif
1266
1267     ff_rate_control_uninit(s);
1268
1269     MPV_common_end(s);
1270     if (s->out_format == FMT_MJPEG)
1271         mjpeg_close(s);
1272
1273     av_freep(&avctx->extradata);
1274       
1275     return 0;
1276 }
1277
1278 #endif //CONFIG_ENCODERS
1279
1280 void init_rl(RLTable *rl, int use_static)
1281 {
1282     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1283     uint8_t index_run[MAX_RUN+1];
1284     int last, run, level, start, end, i;
1285
1286     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1287     if(use_static && rl->max_level[0])
1288         return;
1289
1290     /* compute max_level[], max_run[] and index_run[] */
1291     for(last=0;last<2;last++) {
1292         if (last == 0) {
1293             start = 0;
1294             end = rl->last;
1295         } else {
1296             start = rl->last;
1297             end = rl->n;
1298         }
1299
1300         memset(max_level, 0, MAX_RUN + 1);
1301         memset(max_run, 0, MAX_LEVEL + 1);
1302         memset(index_run, rl->n, MAX_RUN + 1);
1303         for(i=start;i<end;i++) {
1304             run = rl->table_run[i];
1305             level = rl->table_level[i];
1306             if (index_run[run] == rl->n)
1307                 index_run[run] = i;
1308             if (level > max_level[run])
1309                 max_level[run] = level;
1310             if (run > max_run[level])
1311                 max_run[level] = run;
1312         }
1313         if(use_static)
1314             rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1315         else
1316             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1317         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1318         if(use_static)
1319             rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1320         else
1321             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1322         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1323         if(use_static)
1324             rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1325         else
1326             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1327         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1328     }
1329 }
1330
1331 /* draw the edges of width 'w' of an image of size width, height */
1332 //FIXME check that this is ok for mpeg4 interlaced
1333 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1334 {
1335     uint8_t *ptr, *last_line;
1336     int i;
1337
1338     last_line = buf + (height - 1) * wrap;
1339     for(i=0;i<w;i++) {
1340         /* top and bottom */
1341         memcpy(buf - (i + 1) * wrap, buf, width);
1342         memcpy(last_line + (i + 1) * wrap, last_line, width);
1343     }
1344     /* left and right */
1345     ptr = buf;
1346     for(i=0;i<height;i++) {
1347         memset(ptr - w, ptr[0], w);
1348         memset(ptr + width, ptr[width-1], w);
1349         ptr += wrap;
1350     }
1351     /* corners */
1352     for(i=0;i<w;i++) {
1353         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1354         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1355         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1356         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1357     }
1358 }
1359
1360 int ff_find_unused_picture(MpegEncContext *s, int shared){
1361     int i;
1362     
1363     if(shared){
1364         for(i=0; i<MAX_PICTURE_COUNT; i++){
1365             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1366         }
1367     }else{
1368         for(i=0; i<MAX_PICTURE_COUNT; i++){
1369             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1370         }
1371         for(i=0; i<MAX_PICTURE_COUNT; i++){
1372             if(s->picture[i].data[0]==NULL) return i;
1373         }
1374     }
1375
1376     assert(0);
1377     return -1;
1378 }
1379
1380 static void update_noise_reduction(MpegEncContext *s){
1381     int intra, i;
1382
1383     for(intra=0; intra<2; intra++){
1384         if(s->dct_count[intra] > (1<<16)){
1385             for(i=0; i<64; i++){
1386                 s->dct_error_sum[intra][i] >>=1;
1387             }
1388             s->dct_count[intra] >>= 1;
1389         }
1390         
1391         for(i=0; i<64; i++){
1392             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);
1393         }
1394     }
1395 }
1396
1397 /**
1398  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1399  */
1400 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1401 {
1402     int i;
1403     AVFrame *pic;
1404     s->mb_skiped = 0;
1405
1406     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1407
1408     /* mark&release old frames */
1409     if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1410         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1411
1412         /* release forgotten pictures */
1413         /* if(mpeg124/h263) */
1414         if(!s->encoding){
1415             for(i=0; i<MAX_PICTURE_COUNT; i++){
1416                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1417                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1418                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1419                 }
1420             }
1421         }
1422     }
1423 alloc:
1424     if(!s->encoding){
1425         /* release non refernce frames */
1426         for(i=0; i<MAX_PICTURE_COUNT; i++){
1427             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1428                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1429             }
1430         }
1431
1432         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1433             pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1434         else{
1435             i= ff_find_unused_picture(s, 0);
1436             pic= (AVFrame*)&s->picture[i];
1437         }
1438
1439         pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1440
1441         pic->coded_picture_number= s->coded_picture_number++;
1442         
1443         if( alloc_picture(s, (Picture*)pic, 0) < 0)
1444             return -1;
1445
1446         s->current_picture_ptr= (Picture*)pic;
1447         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1448         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1449     }
1450
1451     s->current_picture_ptr->pict_type= s->pict_type;
1452 //    if(s->flags && CODEC_FLAG_QSCALE) 
1453   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1454     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1455
1456     copy_picture(&s->current_picture, s->current_picture_ptr);
1457   
1458   if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1459     if (s->pict_type != B_TYPE) {
1460         s->last_picture_ptr= s->next_picture_ptr;
1461         if(!s->dropable)
1462             s->next_picture_ptr= s->current_picture_ptr;
1463     }
1464 /*    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,
1465         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1466         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1467         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1468         s->pict_type, s->dropable);*/
1469     
1470     if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1471     if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1472     
1473     if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1474         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1475         assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1476         goto alloc;
1477     }
1478
1479     assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1480
1481     if(s->picture_structure!=PICT_FRAME){
1482         int i;
1483         for(i=0; i<4; i++){
1484             if(s->picture_structure == PICT_BOTTOM_FIELD){
1485                  s->current_picture.data[i] += s->current_picture.linesize[i];
1486             } 
1487             s->current_picture.linesize[i] *= 2;
1488             s->last_picture.linesize[i] *=2;
1489             s->next_picture.linesize[i] *=2;
1490         }
1491     }
1492   }
1493    
1494     s->hurry_up= s->avctx->hurry_up;
1495     s->error_resilience= avctx->error_resilience;
1496
1497     /* set dequantizer, we cant do it during init as it might change for mpeg4
1498        and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1499     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1500         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1501         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1502     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1503         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1504         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1505     }else{
1506         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1507         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1508     }
1509
1510     if(s->dct_error_sum){
1511         assert(s->avctx->noise_reduction && s->encoding);
1512
1513         update_noise_reduction(s);
1514     }
1515         
1516 #ifdef HAVE_XVMC
1517     if(s->avctx->xvmc_acceleration)
1518         return XVMC_field_start(s, avctx);
1519 #endif
1520     return 0;
1521 }
1522
1523 /* generic function for encode/decode called after a frame has been coded/decoded */
1524 void MPV_frame_end(MpegEncContext *s)
1525 {
1526     int i;
1527     /* draw edge for correct motion prediction if outside */
1528 #ifdef HAVE_XVMC
1529 //just to make sure that all data is rendered.
1530     if(s->avctx->xvmc_acceleration){
1531         XVMC_field_end(s);
1532     }else
1533 #endif
1534     if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1535             draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1536             draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1537             draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1538     }
1539     emms_c();
1540     
1541     s->last_pict_type    = s->pict_type;
1542     if(s->pict_type!=B_TYPE){
1543         s->last_non_b_pict_type= s->pict_type;
1544     }
1545 #if 0
1546         /* copy back current_picture variables */
1547     for(i=0; i<MAX_PICTURE_COUNT; i++){
1548         if(s->picture[i].data[0] == s->current_picture.data[0]){
1549             s->picture[i]= s->current_picture;
1550             break;
1551         }    
1552     }
1553     assert(i<MAX_PICTURE_COUNT);
1554 #endif    
1555
1556     if(s->encoding){
1557         /* release non refernce frames */
1558         for(i=0; i<MAX_PICTURE_COUNT; i++){
1559             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1560                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1561             }
1562         }
1563     }
1564     // clear copies, to avoid confusion
1565 #if 0
1566     memset(&s->last_picture, 0, sizeof(Picture));
1567     memset(&s->next_picture, 0, sizeof(Picture));
1568     memset(&s->current_picture, 0, sizeof(Picture));
1569 #endif
1570     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1571 }
1572
1573 /**
1574  * draws an line from (ex, ey) -> (sx, sy).
1575  * @param w width of the image
1576  * @param h height of the image
1577  * @param stride stride/linesize of the image
1578  * @param color color of the arrow
1579  */
1580 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1581     int t, x, y, fr, f;
1582     
1583     sx= clip(sx, 0, w-1);
1584     sy= clip(sy, 0, h-1);
1585     ex= clip(ex, 0, w-1);
1586     ey= clip(ey, 0, h-1);
1587     
1588     buf[sy*stride + sx]+= color;
1589     
1590     if(ABS(ex - sx) > ABS(ey - sy)){
1591         if(sx > ex){
1592             t=sx; sx=ex; ex=t;
1593             t=sy; sy=ey; ey=t;
1594         }
1595         buf+= sx + sy*stride;
1596         ex-= sx;
1597         f= ((ey-sy)<<16)/ex;
1598         for(x= 0; x <= ex; x++){
1599             y = (x*f)>>16;
1600             fr= (x*f)&0xFFFF;
1601             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1602             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1603         }
1604     }else{
1605         if(sy > ey){
1606             t=sx; sx=ex; ex=t;
1607             t=sy; sy=ey; ey=t;
1608         }
1609         buf+= sx + sy*stride;
1610         ey-= sy;
1611         if(ey) f= ((ex-sx)<<16)/ey;
1612         else   f= 0;
1613         for(y= 0; y <= ey; y++){
1614             x = (y*f)>>16;
1615             fr= (y*f)&0xFFFF;
1616             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1617             buf[y*stride + x+1]+= (color*         fr )>>16;;
1618         }
1619     }
1620 }
1621
1622 /**
1623  * draws an arrow from (ex, ey) -> (sx, sy).
1624  * @param w width of the image
1625  * @param h height of the image
1626  * @param stride stride/linesize of the image
1627  * @param color color of the arrow
1628  */
1629 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1630     int dx,dy;
1631
1632     sx= clip(sx, -100, w+100);
1633     sy= clip(sy, -100, h+100);
1634     ex= clip(ex, -100, w+100);
1635     ey= clip(ey, -100, h+100);
1636     
1637     dx= ex - sx;
1638     dy= ey - sy;
1639     
1640     if(dx*dx + dy*dy > 3*3){
1641         int rx=  dx + dy;
1642         int ry= -dx + dy;
1643         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1644         
1645         //FIXME subpixel accuracy
1646         rx= ROUNDED_DIV(rx*3<<4, length);
1647         ry= ROUNDED_DIV(ry*3<<4, length);
1648         
1649         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1650         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1651     }
1652     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1653 }
1654
1655 /**
1656  * prints debuging info for the given picture.
1657  */
1658 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1659
1660     if(!pict || !pict->mb_type) return;
1661
1662     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1663         int x,y;
1664         
1665         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1666         switch (pict->pict_type) {
1667             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1668             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1669             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1670             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1671             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1672             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1673         }
1674         for(y=0; y<s->mb_height; y++){
1675             for(x=0; x<s->mb_width; x++){
1676                 if(s->avctx->debug&FF_DEBUG_SKIP){
1677                     int count= s->mbskip_table[x + y*s->mb_stride];
1678                     if(count>9) count=9;
1679                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1680                 }
1681                 if(s->avctx->debug&FF_DEBUG_QP){
1682                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1683                 }
1684                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1685                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1686                     //Type & MV direction
1687                     if(IS_PCM(mb_type))
1688                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1689                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1690                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1691                     else if(IS_INTRA4x4(mb_type))
1692                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1693                     else if(IS_INTRA16x16(mb_type))
1694                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1695                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1696                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1697                     else if(IS_DIRECT(mb_type))
1698                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1699                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1700                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1701                     else if(IS_GMC(mb_type))
1702                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1703                     else if(IS_SKIP(mb_type))
1704                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1705                     else if(!USES_LIST(mb_type, 1))
1706                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1707                     else if(!USES_LIST(mb_type, 0))
1708                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1709                     else{
1710                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1711                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1712                     }
1713                     
1714                     //segmentation
1715                     if(IS_8X8(mb_type))
1716                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1717                     else if(IS_16X8(mb_type))
1718                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1719                     else if(IS_8X16(mb_type))
1720                         av_log(s->avctx, AV_LOG_DEBUG, "¦");
1721                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1722                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1723                     else
1724                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1725                     
1726                         
1727                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1728                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1729                     else
1730                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1731                 }
1732 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1733             }
1734             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1735         }
1736     }
1737
1738     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1739         const int shift= 1 + s->quarter_sample;
1740         int mb_y;
1741         uint8_t *ptr;
1742         int i;
1743         int h_chroma_shift, v_chroma_shift;
1744         const int width = s->avctx->width;
1745         const int height= s->avctx->height;
1746         s->low_delay=0; //needed to see the vectors without trashing the buffers
1747
1748         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1749         for(i=0; i<3; i++){
1750             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1751             pict->data[i]= s->visualization_buffer[i];
1752         }
1753         pict->type= FF_BUFFER_TYPE_COPY;
1754         ptr= pict->data[0];
1755
1756         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1757             int mb_x;
1758             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1759                 const int mb_index= mb_x + mb_y*s->mb_stride;
1760                 if((s->avctx->debug_mv) && pict->motion_val){
1761                   int type;
1762                   for(type=0; type<3; type++){
1763                     int direction = 0;
1764                     switch (type) {
1765                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1766                                 continue;
1767                               direction = 0;
1768                               break;
1769                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1770                                 continue;
1771                               direction = 0;
1772                               break;
1773                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1774                                 continue;
1775                               direction = 1;
1776                               break;
1777                     }
1778                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1779                         continue;
1780
1781                     //FIXME for h264
1782                     if(IS_8X8(pict->mb_type[mb_index])){
1783                       int i;
1784                       for(i=0; i<4; i++){
1785                         int sx= mb_x*16 + 4 + 8*(i&1);
1786                         int sy= mb_y*16 + 4 + 8*(i>>1);
1787                         int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1788                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1789                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1790                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1791                       }
1792                     }else if(IS_16X8(pict->mb_type[mb_index])){
1793                       int i;
1794                       for(i=0; i<2; i++){
1795                         int sx=mb_x*16 + 8;
1796                         int sy=mb_y*16 + 4 + 8*i;
1797                         int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1798                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1799                         int my=(pict->motion_val[direction][xy][1]>>shift);
1800                         
1801                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1802                             my*=2;
1803                         
1804                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1805                       }
1806                     }else{
1807                       int sx= mb_x*16 + 8;
1808                       int sy= mb_y*16 + 8;
1809                       int xy= mb_x*2 + mb_y*2*s->b8_stride;
1810                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1811                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1812                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1813                     }
1814                   }                  
1815                 }
1816                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1817                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1818                     int y;
1819                     for(y=0; y<8; y++){
1820                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1821                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1822                     }
1823                 }
1824                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1825                     int mb_type= pict->mb_type[mb_index];
1826                     uint64_t u,v;
1827                     int y;
1828 #define COLOR(theta, r)\
1829 u= (int)(128 + r*cos(theta*3.141592/180));\
1830 v= (int)(128 + r*sin(theta*3.141592/180));
1831
1832                     
1833                     u=v=128;
1834                     if(IS_PCM(mb_type)){
1835                         COLOR(120,48)
1836                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1837                         COLOR(30,48)
1838                     }else if(IS_INTRA4x4(mb_type)){
1839                         COLOR(90,48)
1840                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1841 //                        COLOR(120,48)
1842                     }else if(IS_DIRECT(mb_type)){
1843                         COLOR(150,48)
1844                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1845                         COLOR(170,48)
1846                     }else if(IS_GMC(mb_type)){
1847                         COLOR(190,48)
1848                     }else if(IS_SKIP(mb_type)){
1849 //                        COLOR(180,48)
1850                     }else if(!USES_LIST(mb_type, 1)){
1851                         COLOR(240,48)
1852                     }else if(!USES_LIST(mb_type, 0)){
1853                         COLOR(0,48)
1854                     }else{
1855                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1856                         COLOR(300,48)
1857                     }
1858
1859                     u*= 0x0101010101010101ULL;
1860                     v*= 0x0101010101010101ULL;
1861                     for(y=0; y<8; y++){
1862                         *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1863                         *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1864                     }
1865
1866                     //segmentation
1867                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1868                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1869                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1870                     }
1871                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1872                         for(y=0; y<16; y++)
1873                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1874                     }
1875                         
1876                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1877                         // hmm
1878                     }
1879                 }
1880                 s->mbskip_table[mb_index]=0;
1881             }
1882         }
1883     }
1884 }
1885
1886 #ifdef CONFIG_ENCODERS
1887
1888 static int get_sae(uint8_t *src, int ref, int stride){
1889     int x,y;
1890     int acc=0;
1891     
1892     for(y=0; y<16; y++){
1893         for(x=0; x<16; x++){
1894             acc+= ABS(src[x+y*stride] - ref);
1895         }
1896     }
1897     
1898     return acc;
1899 }
1900
1901 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1902     int x, y, w, h;
1903     int acc=0;
1904     
1905     w= s->width &~15;
1906     h= s->height&~15;
1907     
1908     for(y=0; y<h; y+=16){
1909         for(x=0; x<w; x+=16){
1910             int offset= x + y*stride;
1911             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1912             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1913             int sae = get_sae(src + offset, mean, stride);
1914             
1915             acc+= sae + 500 < sad;
1916         }
1917     }
1918     return acc;
1919 }
1920
1921
1922 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1923     AVFrame *pic=NULL;
1924     int i;
1925     const int encoding_delay= s->max_b_frames;
1926     int direct=1;
1927     
1928   if(pic_arg){
1929     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1930     if(pic_arg->linesize[0] != s->linesize) direct=0;
1931     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1932     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1933   
1934 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1935     
1936     if(direct){
1937         i= ff_find_unused_picture(s, 1);
1938
1939         pic= (AVFrame*)&s->picture[i];
1940         pic->reference= 3;
1941     
1942         for(i=0; i<4; i++){
1943             pic->data[i]= pic_arg->data[i];
1944             pic->linesize[i]= pic_arg->linesize[i];
1945         }
1946         alloc_picture(s, (Picture*)pic, 1);
1947     }else{
1948         int offset= 16;
1949         i= ff_find_unused_picture(s, 0);
1950
1951         pic= (AVFrame*)&s->picture[i];
1952         pic->reference= 3;
1953
1954         alloc_picture(s, (Picture*)pic, 0);
1955
1956         if(   pic->data[0] + offset == pic_arg->data[0] 
1957            && pic->data[1] + offset == pic_arg->data[1]
1958            && pic->data[2] + offset == pic_arg->data[2]){
1959        // empty
1960         }else{
1961             int h_chroma_shift, v_chroma_shift;
1962             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1963         
1964             for(i=0; i<3; i++){
1965                 int src_stride= pic_arg->linesize[i];
1966                 int dst_stride= i ? s->uvlinesize : s->linesize;
1967                 int h_shift= i ? h_chroma_shift : 0;
1968                 int v_shift= i ? v_chroma_shift : 0;
1969                 int w= s->width >>h_shift;
1970                 int h= s->height>>v_shift;
1971                 uint8_t *src= pic_arg->data[i];
1972                 uint8_t *dst= pic->data[i] + offset;
1973             
1974                 if(src_stride==dst_stride)
1975                     memcpy(dst, src, src_stride*h);
1976                 else{
1977                     while(h--){
1978                         memcpy(dst, src, w);
1979                         dst += dst_stride;
1980                         src += src_stride;
1981                     }
1982                 }
1983             }
1984         }
1985     }
1986     copy_picture_attributes(s, pic, pic_arg);
1987     
1988     pic->display_picture_number= s->input_picture_number++;
1989  
1990     if(pic->pts != AV_NOPTS_VALUE){ 
1991         if(s->user_specified_pts != AV_NOPTS_VALUE){
1992             int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1993             int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1994         
1995             if(time <= last){            
1996                 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1997                 return -1;
1998             }
1999         }
2000         s->user_specified_pts= pic->pts;
2001     }else{
2002         if(s->user_specified_pts != AV_NOPTS_VALUE){
2003             s->user_specified_pts= 
2004             pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2005             av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
2006         }else{
2007             pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2008         }
2009     }
2010   }
2011   
2012     /* shift buffer entries */
2013     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2014         s->input_picture[i-1]= s->input_picture[i];
2015         
2016     s->input_picture[encoding_delay]= (Picture*)pic;
2017
2018     return 0;
2019 }
2020
2021 static inline int block_max(DCTELEM *block){
2022     int i, max;
2023     
2024     max=0;
2025     for(i=0; i<64; i++){
2026         int v= ABS(block[i]);
2027         if(v>max) max= v;
2028     }
2029     return max;
2030 }
2031
2032 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2033     int x, y, plane;
2034     int score=0;
2035
2036     for(plane=0; plane<3; plane++){
2037         const int stride= p->linesize[plane];
2038         const int bw= plane ? 1 : 2;
2039         for(y=0; y<s->mb_height*bw; y++){
2040             for(x=0; x<s->mb_width*bw; x++){
2041                 int v;
2042                 
2043                 s->dsp.diff_pixels(s->block[0], p->data[plane] + 8*(x + y*stride), ref->data[plane] + 8*(x + y*stride), stride);
2044                 v= block_max(s->block[0]);
2045                 
2046                 if(v>score) 
2047                     score=v;
2048             }
2049         }
2050     }
2051
2052     if(score < s->avctx->frame_skip_threshold)
2053         return 1;
2054     if(score < ((s->avctx->frame_skip_factor * s->lambda)>>8))
2055         return 1;
2056     return 0;
2057 }
2058
2059 static void select_input_picture(MpegEncContext *s){
2060     int i;
2061
2062     for(i=1; i<MAX_PICTURE_COUNT; i++)
2063         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2064     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2065
2066     /* set next picture types & ordering */
2067     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2068         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2069             s->reordered_input_picture[0]= s->input_picture[0];
2070             s->reordered_input_picture[0]->pict_type= I_TYPE;
2071             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2072         }else{
2073             int b_frames;
2074
2075             if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2076                 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2077 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2078                 
2079                     if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2080                         for(i=0; i<4; i++)
2081                             s->input_picture[0]->data[i]= NULL;
2082                         s->input_picture[0]->type= 0;            
2083                     }else{
2084                         assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2085                                || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2086             
2087                         s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2088                     }
2089
2090                     goto no_output_pic;
2091                 }
2092             }
2093
2094             if(s->flags&CODEC_FLAG_PASS2){
2095                 for(i=0; i<s->max_b_frames+1; i++){
2096                     int pict_num= s->input_picture[0]->display_picture_number + i;
2097
2098                     if(pict_num >= s->rc_context.num_entries) 
2099                         break;
2100                     if(!s->input_picture[i]){
2101                         s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2102                         break;
2103                     }
2104
2105                     s->input_picture[i]->pict_type= 
2106                         s->rc_context.entry[pict_num].new_pict_type;
2107                 }
2108             }
2109
2110             if(s->avctx->b_frame_strategy==0){
2111                 b_frames= s->max_b_frames;
2112                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2113             }else if(s->avctx->b_frame_strategy==1){
2114                 for(i=1; i<s->max_b_frames+1; i++){
2115                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2116                         s->input_picture[i]->b_frame_score= 
2117                             get_intra_count(s, s->input_picture[i  ]->data[0], 
2118                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
2119                     }
2120                 }
2121                 for(i=0; i<s->max_b_frames; i++){
2122                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2123                 }
2124                                 
2125                 b_frames= FFMAX(0, i-1);
2126                 
2127                 /* reset scores */
2128                 for(i=0; i<b_frames+1; i++){
2129                     s->input_picture[i]->b_frame_score=0;
2130                 }
2131             }else{
2132                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2133                 b_frames=0;
2134             }
2135
2136             emms_c();
2137 //static int b_count=0;
2138 //b_count+= b_frames;
2139 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2140
2141             for(i= b_frames - 1; i>=0; i--){
2142                 int type= s->input_picture[i]->pict_type;
2143                 if(type && type != B_TYPE)
2144                     b_frames= i;
2145             }
2146             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2147                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2148             }
2149
2150             if(s->picture_in_gop_number + b_frames >= s->gop_size){
2151               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2152                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
2153               }else{
2154                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2155                     b_frames=0;
2156                 s->input_picture[b_frames]->pict_type= I_TYPE;
2157               }
2158             }
2159             
2160             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2161                && b_frames
2162                && s->input_picture[b_frames]->pict_type== I_TYPE)
2163                 b_frames--;
2164
2165             s->reordered_input_picture[0]= s->input_picture[b_frames];
2166             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2167                 s->reordered_input_picture[0]->pict_type= P_TYPE;
2168             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2169             for(i=0; i<b_frames; i++){
2170                 s->reordered_input_picture[i+1]= s->input_picture[i];
2171                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2172                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2173             }
2174         }
2175     }
2176 no_output_pic:
2177     if(s->reordered_input_picture[0]){
2178         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2179
2180         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2181
2182         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2183             // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2184         
2185             int i= ff_find_unused_picture(s, 0);
2186             Picture *pic= &s->picture[i];
2187
2188             /* mark us unused / free shared pic */
2189             for(i=0; i<4; i++)
2190                 s->reordered_input_picture[0]->data[i]= NULL;
2191             s->reordered_input_picture[0]->type= 0;
2192             
2193             pic->reference              = s->reordered_input_picture[0]->reference;
2194             
2195             alloc_picture(s, pic, 0);
2196
2197             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2198
2199             s->current_picture_ptr= pic;
2200         }else{
2201             // input is not a shared pix -> reuse buffer for current_pix
2202
2203             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2204                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2205             
2206             s->current_picture_ptr= s->reordered_input_picture[0];
2207             for(i=0; i<4; i++){
2208                 s->new_picture.data[i]+=16;
2209             }
2210         }
2211         copy_picture(&s->current_picture, s->current_picture_ptr);
2212     
2213         s->picture_number= s->new_picture.display_picture_number;
2214 //printf("dpn:%d\n", s->picture_number);
2215     }else{
2216        memset(&s->new_picture, 0, sizeof(Picture));
2217     }
2218 }
2219
2220 int MPV_encode_picture(AVCodecContext *avctx,
2221                        unsigned char *buf, int buf_size, void *data)
2222 {
2223     MpegEncContext *s = avctx->priv_data;
2224     AVFrame *pic_arg = data;
2225     int i, stuffing_count;
2226
2227     if(avctx->pix_fmt != PIX_FMT_YUV420P){
2228         av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2229         return -1;
2230     }
2231     
2232     for(i=0; i<avctx->thread_count; i++){
2233         int start_y= s->thread_context[i]->start_mb_y;
2234         int   end_y= s->thread_context[i]->  end_mb_y;
2235         int h= s->mb_height;
2236         uint8_t *start= buf + buf_size*start_y/h;
2237         uint8_t *end  = buf + buf_size*  end_y/h;
2238
2239         init_put_bits(&s->thread_context[i]->pb, start, end - start);
2240     }
2241
2242     s->picture_in_gop_number++;
2243
2244     if(load_input_picture(s, pic_arg) < 0)
2245         return -1;
2246     
2247     select_input_picture(s);
2248     
2249     /* output? */
2250     if(s->new_picture.data[0]){
2251         s->pict_type= s->new_picture.pict_type;
2252 //emms_c();
2253 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2254         MPV_frame_start(s, avctx);
2255
2256         encode_picture(s, s->picture_number);
2257         
2258         avctx->real_pict_num  = s->picture_number;
2259         avctx->header_bits = s->header_bits;
2260         avctx->mv_bits     = s->mv_bits;
2261         avctx->misc_bits   = s->misc_bits;
2262         avctx->i_tex_bits  = s->i_tex_bits;
2263         avctx->p_tex_bits  = s->p_tex_bits;
2264         avctx->i_count     = s->i_count;
2265         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2266         avctx->skip_count  = s->skip_count;
2267
2268         MPV_frame_end(s);
2269
2270         if (s->out_format == FMT_MJPEG)
2271             mjpeg_picture_trailer(s);
2272         
2273         if(s->flags&CODEC_FLAG_PASS1)
2274             ff_write_pass1_stats(s);
2275
2276         for(i=0; i<4; i++){
2277             avctx->error[i] += s->current_picture_ptr->error[i];
2278         }
2279
2280         flush_put_bits(&s->pb);
2281         s->frame_bits  = put_bits_count(&s->pb);
2282
2283         stuffing_count= ff_vbv_update(s, s->frame_bits);
2284         if(stuffing_count){
2285             switch(s->codec_id){
2286             case CODEC_ID_MPEG1VIDEO:
2287             case CODEC_ID_MPEG2VIDEO:
2288                 while(stuffing_count--){
2289                     put_bits(&s->pb, 8, 0);
2290                 }
2291             break;
2292             case CODEC_ID_MPEG4:
2293                 put_bits(&s->pb, 16, 0);
2294                 put_bits(&s->pb, 16, 0x1C3);
2295                 stuffing_count -= 4;
2296                 while(stuffing_count--){
2297                     put_bits(&s->pb, 8, 0xFF);
2298                 }
2299             break;
2300             default:
2301                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2302             }
2303             flush_put_bits(&s->pb);
2304             s->frame_bits  = put_bits_count(&s->pb);
2305         }
2306
2307         /* update mpeg1/2 vbv_delay for CBR */    
2308         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2309            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2310             int vbv_delay;
2311
2312             assert(s->repeat_first_field==0);
2313             
2314             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2315             assert(vbv_delay < 0xFFFF);
2316
2317             s->vbv_delay_ptr[0] &= 0xF8;
2318             s->vbv_delay_ptr[0] |= vbv_delay>>13;
2319             s->vbv_delay_ptr[1]  = vbv_delay>>5;
2320             s->vbv_delay_ptr[2] &= 0x07;
2321             s->vbv_delay_ptr[2] |= vbv_delay<<3;
2322         }
2323         s->total_bits += s->frame_bits;
2324         avctx->frame_bits  = s->frame_bits;
2325     }else{
2326         assert((pbBufPtr(&s->pb) == s->pb.buf));
2327         s->frame_bits=0;
2328     }
2329     assert((s->frame_bits&7)==0);
2330     
2331     return s->frame_bits/8;
2332 }
2333
2334 #endif //CONFIG_ENCODERS
2335
2336 static inline void gmc1_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 offset, src_x, src_y, linesize, uvlinesize;
2342     int motion_x, motion_y;
2343     int emu=0;
2344
2345     motion_x= s->sprite_offset[0][0];
2346     motion_y= s->sprite_offset[0][1];
2347     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2348     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2349     motion_x<<=(3-s->sprite_warping_accuracy);
2350     motion_y<<=(3-s->sprite_warping_accuracy);
2351     src_x = clip(src_x, -16, s->width);
2352     if (src_x == s->width)
2353         motion_x =0;
2354     src_y = clip(src_y, -16, s->height);
2355     if (src_y == s->height)
2356         motion_y =0;
2357
2358     linesize = s->linesize;
2359     uvlinesize = s->uvlinesize;
2360     
2361     ptr = ref_picture[0] + (src_y * linesize) + src_x;
2362
2363     if(s->flags&CODEC_FLAG_EMU_EDGE){
2364         if(   (unsigned)src_x >= s->h_edge_pos - 17
2365            || (unsigned)src_y >= s->v_edge_pos - 17){
2366             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2367             ptr= s->edge_emu_buffer;
2368         }
2369     }
2370     
2371     if((motion_x|motion_y)&7){
2372         s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2373         s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2374     }else{
2375         int dxy;
2376         
2377         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2378         if (s->no_rounding){
2379             s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2380         }else{
2381             s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2382         }
2383     }
2384     
2385     if(s->flags&CODEC_FLAG_GRAY) return;
2386
2387     motion_x= s->sprite_offset[1][0];
2388     motion_y= s->sprite_offset[1][1];
2389     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2390     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2391     motion_x<<=(3-s->sprite_warping_accuracy);
2392     motion_y<<=(3-s->sprite_warping_accuracy);
2393     src_x = clip(src_x, -8, s->width>>1);
2394     if (src_x == s->width>>1)
2395         motion_x =0;
2396     src_y = clip(src_y, -8, s->height>>1);
2397     if (src_y == s->height>>1)
2398         motion_y =0;
2399
2400     offset = (src_y * uvlinesize) + src_x;
2401     ptr = ref_picture[1] + offset;
2402     if(s->flags&CODEC_FLAG_EMU_EDGE){
2403         if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2404            || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2405             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);
2406             ptr= s->edge_emu_buffer;
2407             emu=1;
2408         }
2409     }
2410     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2411     
2412     ptr = ref_picture[2] + offset;
2413     if(emu){
2414         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);
2415         ptr= s->edge_emu_buffer;
2416     }
2417     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2418     
2419     return;
2420 }
2421
2422 static inline void gmc_motion(MpegEncContext *s,
2423                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2424                                uint8_t **ref_picture)
2425 {
2426     uint8_t *ptr;
2427     int linesize, uvlinesize;
2428     const int a= s->sprite_warping_accuracy;
2429     int ox, oy;
2430
2431     linesize = s->linesize;
2432     uvlinesize = s->uvlinesize;
2433
2434     ptr = ref_picture[0];
2435
2436     ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2437     oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2438
2439     s->dsp.gmc(dest_y, ptr, linesize, 16,
2440            ox, 
2441            oy, 
2442            s->sprite_delta[0][0], s->sprite_delta[0][1],
2443            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2444            a+1, (1<<(2*a+1)) - s->no_rounding,
2445            s->h_edge_pos, s->v_edge_pos);
2446     s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2447            ox + s->sprite_delta[0][0]*8, 
2448            oy + s->sprite_delta[1][0]*8, 
2449            s->sprite_delta[0][0], s->sprite_delta[0][1],
2450            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2451            a+1, (1<<(2*a+1)) - s->no_rounding,
2452            s->h_edge_pos, s->v_edge_pos);
2453
2454     if(s->flags&CODEC_FLAG_GRAY) return;
2455
2456     ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2457     oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2458
2459     ptr = ref_picture[1];
2460     s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2461            ox, 
2462            oy, 
2463            s->sprite_delta[0][0], s->sprite_delta[0][1],
2464            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2465            a+1, (1<<(2*a+1)) - s->no_rounding,
2466            s->h_edge_pos>>1, s->v_edge_pos>>1);
2467     
2468     ptr = ref_picture[2];
2469     s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2470            ox, 
2471            oy, 
2472            s->sprite_delta[0][0], s->sprite_delta[0][1],
2473            s->sprite_delta[1][0], s->sprite_delta[1][1], 
2474            a+1, (1<<(2*a+1)) - s->no_rounding,
2475            s->h_edge_pos>>1, s->v_edge_pos>>1);
2476 }
2477
2478 /**
2479  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2480  * @param buf destination buffer
2481  * @param src source buffer
2482  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2483  * @param block_w width of block
2484  * @param block_h height of block
2485  * @param src_x x coordinate of the top left sample of the block in the source buffer
2486  * @param src_y y coordinate of the top left sample of the block in the source buffer
2487  * @param w width of the source buffer
2488  * @param h height of the source buffer
2489  */
2490 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2491                                     int src_x, int src_y, int w, int h){
2492     int x, y;
2493     int start_y, start_x, end_y, end_x;
2494
2495     if(src_y>= h){
2496         src+= (h-1-src_y)*linesize;
2497         src_y=h-1;
2498     }else if(src_y<=-block_h){
2499         src+= (1-block_h-src_y)*linesize;
2500         src_y=1-block_h;
2501     }
2502     if(src_x>= w){
2503         src+= (w-1-src_x);
2504         src_x=w-1;
2505     }else if(src_x<=-block_w){
2506         src+= (1-block_w-src_x);
2507         src_x=1-block_w;
2508     }
2509
2510     start_y= FFMAX(0, -src_y);
2511     start_x= FFMAX(0, -src_x);
2512     end_y= FFMIN(block_h, h-src_y);
2513     end_x= FFMIN(block_w, w-src_x);
2514
2515     // copy existing part
2516     for(y=start_y; y<end_y; y++){
2517         for(x=start_x; x<end_x; x++){
2518             buf[x + y*linesize]= src[x + y*linesize];
2519         }
2520     }
2521
2522     //top
2523     for(y=0; y<start_y; y++){
2524         for(x=start_x; x<end_x; x++){
2525             buf[x + y*linesize]= buf[x + start_y*linesize];
2526         }
2527     }
2528
2529     //bottom
2530     for(y=end_y; y<block_h; y++){
2531         for(x=start_x; x<end_x; x++){
2532             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2533         }
2534     }
2535                                     
2536     for(y=0; y<block_h; y++){
2537        //left
2538         for(x=0; x<start_x; x++){
2539             buf[x + y*linesize]= buf[start_x + y*linesize];
2540         }
2541        
2542        //right
2543         for(x=end_x; x<block_w; x++){
2544             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2545         }
2546     }
2547 }
2548
2549 static inline int hpel_motion(MpegEncContext *s, 
2550                                   uint8_t *dest, uint8_t *src,
2551                                   int field_based, int field_select,
2552                                   int src_x, int src_y,
2553                                   int width, int height, int stride,
2554                                   int h_edge_pos, int v_edge_pos,
2555                                   int w, int h, op_pixels_func *pix_op,
2556                                   int motion_x, int motion_y)
2557 {
2558     int dxy;
2559     int emu=0;
2560
2561     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2562     src_x += motion_x >> 1;
2563     src_y += motion_y >> 1;
2564                 
2565     /* WARNING: do no forget half pels */
2566     src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2567     if (src_x == width)
2568         dxy &= ~1;
2569     src_y = clip(src_y, -16, height);
2570     if (src_y == height)
2571         dxy &= ~2;
2572     src += src_y * stride + src_x;
2573
2574     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2575         if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2576            || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2577             ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2578                              src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2579             src= s->edge_emu_buffer;
2580             emu=1;
2581         }
2582     }
2583     if(field_select)
2584         src += s->linesize;
2585     pix_op[dxy](dest, src, stride, h);
2586     return emu;
2587 }
2588
2589 static inline int hpel_motion_lowres(MpegEncContext *s, 
2590                                   uint8_t *dest, uint8_t *src,
2591                                   int field_based, int field_select,
2592                                   int src_x, int src_y,
2593                                   int width, int height, int stride,
2594                                   int h_edge_pos, int v_edge_pos,
2595                                   int w, int h, h264_chroma_mc_func *pix_op,
2596                                   int motion_x, int motion_y)
2597 {
2598     const int lowres= s->avctx->lowres;
2599     const int s_mask= (2<<lowres)-1;
2600     int emu=0;
2601     int sx, sy;
2602
2603     if(s->quarter_sample){
2604         motion_x/=2;
2605         motion_y/=2;
2606     }
2607
2608     sx= motion_x & s_mask;
2609     sy= motion_y & s_mask;
2610     src_x += motion_x >> (lowres+1);
2611     src_y += motion_y >> (lowres+1);
2612                 
2613     src += src_y * stride + src_x;
2614
2615     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2616        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2617         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2618                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2619         src= s->edge_emu_buffer;
2620         emu=1;
2621     }
2622
2623     sx <<= 2 - lowres;
2624     sy <<= 2 - lowres;
2625     if(field_select)
2626         src += s->linesize;
2627     pix_op[lowres](dest, src, stride, h, sx, sy);
2628     return emu;
2629 }
2630
2631 /* apply one mpeg motion vector to the three components */
2632 static always_inline void mpeg_motion(MpegEncContext *s,
2633                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2634                                int field_based, int bottom_field, int field_select,
2635                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2636                                int motion_x, int motion_y, int h)
2637 {
2638     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2639     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2640     
2641 #if 0    
2642 if(s->quarter_sample)
2643 {
2644     motion_x>>=1;
2645     motion_y>>=1;
2646 }
2647 #endif
2648
2649     v_edge_pos = s->v_edge_pos >> field_based;
2650     linesize   = s->current_picture.linesize[0] << field_based;
2651     uvlinesize = s->current_picture.linesize[1] << field_based;
2652
2653     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2654     src_x = s->mb_x* 16               + (motion_x >> 1);
2655     src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2656
2657     if (s->out_format == FMT_H263) {
2658         if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2659             mx = (motion_x>>1)|(motion_x&1);
2660             my = motion_y >>1;
2661             uvdxy = ((my & 1) << 1) | (mx & 1);
2662             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2663             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2664         }else{
2665             uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2666             uvsrc_x = src_x>>1;
2667             uvsrc_y = src_y>>1;
2668         }
2669     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2670         mx = motion_x / 4;
2671         my = motion_y / 4;
2672         uvdxy = 0;
2673         uvsrc_x = s->mb_x*8 + mx;
2674         uvsrc_y = s->mb_y*8 + my;
2675     } else {
2676         if(s->chroma_y_shift){
2677             mx = motion_x / 2;
2678             my = motion_y / 2;
2679             uvdxy = ((my & 1) << 1) | (mx & 1);
2680             uvsrc_x = s->mb_x* 8               + (mx >> 1);
2681             uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2682         } else {
2683             if(s->chroma_x_shift){
2684             //Chroma422
2685                 mx = motion_x / 2;
2686                 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2687                 uvsrc_x = s->mb_x* 8           + (mx >> 1);
2688                 uvsrc_y = src_y;
2689             } else {
2690             //Chroma444
2691                 uvdxy = dxy;
2692                 uvsrc_x = src_x;
2693                 uvsrc_y = src_y;
2694             }
2695         }
2696     }
2697
2698     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2699     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2700     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2701
2702     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2703        || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2704             if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2705                s->codec_id == CODEC_ID_MPEG1VIDEO){
2706                 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2707                 return ;
2708             }
2709             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2710                              src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2711             ptr_y = s->edge_emu_buffer;
2712             if(!(s->flags&CODEC_FLAG_GRAY)){
2713                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2714                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2715                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2716                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2717                                  uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2718                 ptr_cb= uvbuf;
2719                 ptr_cr= uvbuf+16;
2720             }
2721     }
2722
2723     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2724         dest_y += s->linesize;
2725         dest_cb+= s->uvlinesize;
2726         dest_cr+= s->uvlinesize;
2727     }
2728
2729     if(field_select){
2730         ptr_y += s->linesize;
2731         ptr_cb+= s->uvlinesize;
2732         ptr_cr+= s->uvlinesize;
2733     }
2734
2735     pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2736     
2737     if(!(s->flags&CODEC_FLAG_GRAY)){
2738         pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2739         pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2740     }
2741     if(s->out_format == FMT_H261){
2742         ff_h261_loop_filter(s);
2743     }
2744 }
2745
2746 /* apply one mpeg motion vector to the three components */
2747 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2748                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2749                                int field_based, int bottom_field, int field_select,
2750                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2751                                int motion_x, int motion_y, int h)
2752 {
2753     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2754     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2755     const int lowres= s->avctx->lowres;
2756     const int block_s= 8>>lowres;
2757     const int s_mask= (2<<lowres)-1;
2758     const int h_edge_pos = s->h_edge_pos >> lowres;
2759     const int v_edge_pos = s->v_edge_pos >> lowres;
2760     linesize   = s->current_picture.linesize[0] << field_based;
2761     uvlinesize = s->current_picture.linesize[1] << field_based;
2762
2763     if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2764         motion_x/=2;
2765         motion_y/=2;
2766     }
2767     
2768     if(field_based){
2769         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2770     }
2771
2772     sx= motion_x & s_mask;
2773     sy= motion_y & s_mask;
2774     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2775     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2776     
2777     if (s->out_format == FMT_H263) {
2778         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2779         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2780         uvsrc_x = src_x>>1;
2781         uvsrc_y = src_y>>1;
2782     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2783         mx = motion_x / 4;
2784         my = motion_y / 4;
2785         uvsx = (2*mx) & s_mask;
2786         uvsy = (2*my) & s_mask;
2787         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2788         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2789     } else {
2790         mx = motion_x / 2;
2791         my = motion_y / 2;
2792         uvsx = mx & s_mask;
2793         uvsy = my & s_mask;
2794         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2795         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2796     }
2797
2798     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2799     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2800     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2801
2802     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2803        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2804             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2805                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2806             ptr_y = s->edge_emu_buffer;
2807             if(!(s->flags&CODEC_FLAG_GRAY)){
2808                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2809                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2810                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2811                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2812                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2813                 ptr_cb= uvbuf;
2814                 ptr_cr= uvbuf+16;
2815             }
2816     }
2817
2818     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2819         dest_y += s->linesize;
2820         dest_cb+= s->uvlinesize;
2821         dest_cr+= s->uvlinesize;
2822     }
2823
2824     if(field_select){
2825         ptr_y += s->linesize;
2826         ptr_cb+= s->uvlinesize;
2827         ptr_cr+= s->uvlinesize;
2828     }
2829
2830     sx <<= 2 - lowres;
2831     sy <<= 2 - lowres;
2832     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2833     
2834     if(!(s->flags&CODEC_FLAG_GRAY)){
2835         uvsx <<= 2 - lowres;
2836         uvsy <<= 2 - lowres;
2837         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2838         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2839     }
2840     //FIXME h261 lowres loop filter
2841 }
2842
2843 //FIXME move to dsputil, avg variant, 16x16 version
2844 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2845     int x;
2846     uint8_t * const top   = src[1];
2847     uint8_t * const left  = src[2];
2848     uint8_t * const mid   = src[0];
2849     uint8_t * const right = src[3];
2850     uint8_t * const bottom= src[4];
2851 #define OBMC_FILTER(x, t, l, m, r, b)\
2852     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2853 #define OBMC_FILTER4(x, t, l, m, r, b)\
2854     OBMC_FILTER(x         , t, l, m, r, b);\
2855     OBMC_FILTER(x+1       , t, l, m, r, b);\
2856     OBMC_FILTER(x  +stride, t, l, m, r, b);\
2857     OBMC_FILTER(x+1+stride, t, l, m, r, b);
2858     
2859     x=0;
2860     OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2861     OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2862     OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2863     OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2864     OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2865     OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2866     x+= stride;
2867     OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2868     OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2869     OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2870     OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2871     x+= stride;
2872     OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2873     OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2874     OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2875     OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2876     x+= 2*stride;
2877     OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2878     OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2879     OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2880     OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2881     x+= 2*stride;
2882     OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2883     OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2884     OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2885     OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2886     OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2887     OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2888     x+= stride;
2889     OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2890     OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2891     OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2892     OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2893 }
2894
2895 /* obmc for 1 8x8 luma block */
2896 static inline void obmc_motion(MpegEncContext *s,
2897                                uint8_t *dest, uint8_t *src,
2898                                int src_x, int src_y,
2899                                op_pixels_func *pix_op,
2900                                int16_t mv[5][2]/* mid top left right bottom*/)
2901 #define MID    0
2902 {
2903     int i;
2904     uint8_t *ptr[5];
2905     
2906     assert(s->quarter_sample==0);
2907     
2908     for(i=0; i<5; i++){
2909         if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2910             ptr[i]= ptr[MID];
2911         }else{
2912             ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2913             hpel_motion(s, ptr[i], src, 0, 0,
2914                         src_x, src_y,
2915                         s->width, s->height, s->linesize,
2916                         s->h_edge_pos, s->v_edge_pos,
2917                         8, 8, pix_op,
2918                         mv[i][0], mv[i][1]);
2919         }
2920     }
2921
2922     put_obmc(dest, ptr, s->linesize);                
2923 }
2924
2925 static inline void qpel_motion(MpegEncContext *s,
2926                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2927                                int field_based, int bottom_field, int field_select,
2928                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2929                                qpel_mc_func (*qpix_op)[16],
2930                                int motion_x, int motion_y, int h)
2931 {
2932     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2933     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2934
2935     dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2936     src_x = s->mb_x *  16                 + (motion_x >> 2);
2937     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2938
2939     v_edge_pos = s->v_edge_pos >> field_based;
2940     linesize = s->linesize << field_based;
2941     uvlinesize = s->uvlinesize << field_based;
2942     
2943     if(field_based){
2944         mx= motion_x/2;
2945         my= motion_y>>1;
2946     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2947         static const int rtab[8]= {0,0,1,1,0,0,0,1};
2948         mx= (motion_x>>1) + rtab[motion_x&7];
2949         my= (motion_y>>1) + rtab[motion_y&7];
2950     }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2951         mx= (motion_x>>1)|(motion_x&1);
2952         my= (motion_y>>1)|(motion_y&1);
2953     }else{
2954         mx= motion_x/2;
2955         my= motion_y/2;
2956     }
2957     mx= (mx>>1)|(mx&1);
2958     my= (my>>1)|(my&1);
2959
2960     uvdxy= (mx&1) | ((my&1)<<1);
2961     mx>>=1;
2962     my>>=1;
2963
2964     uvsrc_x = s->mb_x *  8                 + mx;
2965     uvsrc_y = s->mb_y * (8 >> field_based) + my;
2966
2967     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2968     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2969     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2970
2971     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2972        || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2973         ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2974                          src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2975         ptr_y= s->edge_emu_buffer;
2976         if(!(s->flags&CODEC_FLAG_GRAY)){
2977             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2978             ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2979                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2980             ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2981                              uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2982             ptr_cb= uvbuf;
2983             ptr_cr= uvbuf + 16;
2984         }
2985     }
2986
2987     if(!field_based)
2988         qpix_op[0][dxy](dest_y, ptr_y, linesize);
2989     else{
2990         if(bottom_field){
2991             dest_y += s->linesize;
2992             dest_cb+= s->uvlinesize;
2993             dest_cr+= s->uvlinesize;
2994         }
2995
2996         if(field_select){
2997             ptr_y  += s->linesize;
2998             ptr_cb += s->uvlinesize;
2999             ptr_cr += s->uvlinesize;
3000         }
3001         //damn interlaced mode
3002         //FIXME boundary mirroring is not exactly correct here
3003         qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3004         qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3005     }
3006     if(!(s->flags&CODEC_FLAG_GRAY)){
3007         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3008         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3009     }
3010 }
3011
3012 inline int ff_h263_round_chroma(int x){
3013     if (x >= 0)
3014         return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3015     else {
3016         x = -x;
3017         return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3018     }
3019 }
3020
3021 /**
3022  * h263 chorma 4mv motion compensation.
3023  */
3024 static inline void chroma_4mv_motion(MpegEncContext *s,
3025                                      uint8_t *dest_cb, uint8_t *dest_cr,
3026                                      uint8_t **ref_picture,
3027                                      op_pixels_func *pix_op,
3028                                      int mx, int my){
3029     int dxy, emu=0, src_x, src_y, offset;
3030     uint8_t *ptr;
3031     
3032     /* In case of 8X8, we construct a single chroma motion vector
3033        with a special rounding */
3034     mx= ff_h263_round_chroma(mx);
3035     my= ff_h263_round_chroma(my);
3036     
3037     dxy = ((my & 1) << 1) | (mx & 1);
3038     mx >>= 1;
3039     my >>= 1;
3040
3041     src_x = s->mb_x * 8 + mx;
3042     src_y = s->mb_y * 8 + my;
3043     src_x = clip(src_x, -8, s->width/2);
3044     if (src_x == s->width/2)
3045         dxy &= ~1;
3046     src_y = clip(src_y, -8, s->height/2);
3047     if (src_y == s->height/2)
3048         dxy &= ~2;
3049     
3050     offset = (src_y * (s->uvlinesize)) + src_x;
3051     ptr = ref_picture[1] + offset;
3052     if(s->flags&CODEC_FLAG_EMU_EDGE){
3053         if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3054            || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3055             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);
3056             ptr= s->edge_emu_buffer;
3057             emu=1;
3058         }
3059     }
3060     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3061
3062     ptr = ref_picture[2] + offset;
3063     if(emu){
3064         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);
3065         ptr= s->edge_emu_buffer;
3066     }
3067     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3068 }
3069
3070 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3071                                      uint8_t *dest_cb, uint8_t *dest_cr,
3072                                      uint8_t **ref_picture,
3073                                      h264_chroma_mc_func *pix_op,
3074                                      int mx, int my){
3075     const int lowres= s->avctx->lowres;
3076     const int block_s= 8>>lowres;
3077     const int s_mask= (2<<lowres)-1;
3078     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3079     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3080     int emu=0, src_x, src_y, offset, sx, sy;
3081     uint8_t *ptr;
3082     
3083     if(s->quarter_sample){
3084         mx/=2;
3085         my/=2;
3086     }
3087
3088     /* In case of 8X8, we construct a single chroma motion vector
3089        with a special rounding */
3090     mx= ff_h263_round_chroma(mx);
3091     my= ff_h263_round_chroma(my);
3092     
3093     sx= mx & s_mask;
3094     sy= my & s_mask;
3095     src_x = s->mb_x*block_s + (mx >> (lowres+1));
3096     src_y = s->mb_y*block_s + (my >> (lowres+1));
3097     
3098     offset = src_y * s->uvlinesize + src_x;
3099     ptr = ref_picture[1] + offset;
3100     if(s->flags&CODEC_FLAG_EMU_EDGE){
3101         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3102            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3103             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3104             ptr= s->edge_emu_buffer;
3105             emu=1;
3106         }
3107     }     
3108     sx <<= 2 - lowres;
3109     sy <<= 2 - lowres;
3110     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3111           
3112     ptr = ref_picture[2] + offset;
3113     if(emu){
3114         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3115         ptr= s->edge_emu_buffer;
3116     }
3117     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3118 }
3119
3120 /**
3121  * motion compesation of a single macroblock
3122  * @param s context
3123  * @param dest_y luma destination pointer
3124  * @param dest_cb chroma cb/u destination pointer
3125  * @param dest_cr chroma cr/v destination pointer
3126  * @param dir direction (0->forward, 1->backward)
3127  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3128  * @param pic_op halfpel motion compensation function (average or put normally)
3129  * @param pic_op qpel motion compensation function (average or put normally)
3130  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3131  */
3132 static inline void MPV_motion(MpegEncContext *s, 
3133                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3134                               int dir, uint8_t **ref_picture, 
3135                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3136 {
3137     int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3138     int mb_x, mb_y, i;
3139     uint8_t *ptr, *dest;
3140
3141     mb_x = s->mb_x;
3142     mb_y = s->mb_y;
3143
3144     if(s->obmc && s->pict_type != B_TYPE){
3145         int16_t mv_cache[4][4][2];
3146         const int xy= s->mb_x + s->mb_y*s->mb_stride;
3147         const int mot_stride= s->b8_stride;
3148         const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3149
3150         assert(!s->mb_skiped);
3151                 
3152         memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3153         memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3154         memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3155
3156         if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3157             memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3158         }else{
3159             memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3160         }
3161
3162         if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3163             *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3164             *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3165         }else{
3166             *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3167             *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3168         }
3169
3170         if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3171             *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3172             *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3173         }else{
3174             *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3175             *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3176         }
3177         
3178         mx = 0;
3179         my = 0;
3180         for(i=0;i<4;i++) {
3181             const int x= (i&1)+1;
3182             const int y= (i>>1)+1;
3183             int16_t mv[5][2]= {
3184                 {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3185                 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3186                 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3187                 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3188                 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3189             //FIXME cleanup
3190             obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3191                         ref_picture[0],
3192                         mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3193                         pix_op[1],
3194                         mv);
3195
3196             mx += mv[0][0];
3197             my += mv[0][1];
3198         }
3199         if(!(s->flags&CODEC_FLAG_GRAY))
3200             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3201
3202         return;
3203     }
3204    
3205     switch(s->mv_type) {
3206     case MV_TYPE_16X16:
3207 #ifdef CONFIG_RISKY
3208         if(s->mcsel){
3209             if(s->real_sprite_warping_points==1){
3210                 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3211                             ref_picture);
3212             }else{
3213                 gmc_motion(s, dest_y, dest_cb, dest_cr,
3214                             ref_picture);
3215             }
3216         }else if(s->quarter_sample){
3217             qpel_motion(s, dest_y, dest_cb, dest_cr, 
3218                         0, 0, 0,
3219                         ref_picture, pix_op, qpix_op,
3220                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3221         }else if(s->mspel){
3222             ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3223                         ref_picture, pix_op,
3224                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3225         }else
3226 #endif
3227         {
3228             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3229                         0, 0, 0,
3230                         ref_picture, pix_op,
3231                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3232         }           
3233         break;
3234     case MV_TYPE_8X8:
3235         mx = 0;
3236         my = 0;
3237         if(s->quarter_sample){
3238             for(i=0;i<4;i++) {
3239                 motion_x = s->mv[dir][i][0];
3240                 motion_y = s->mv[dir][i][1];
3241
3242                 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3243                 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3244                 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3245                     
3246                 /* WARNING: do no forget half pels */
3247                 src_x = clip(src_x, -16, s->width);
3248                 if (src_x == s->width)
3249                     dxy &= ~3;
3250                 src_y = clip(src_y, -16, s->height);
3251                 if (src_y == s->height)
3252                     dxy &= ~12;
3253                     
3254                 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3255                 if(s->flags&CODEC_FLAG_EMU_EDGE){
3256                     if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3257                        || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3258                         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);
3259                         ptr= s->edge_emu_buffer;
3260                     }
3261                 }
3262                 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3263                 qpix_op[1][dxy](dest, ptr, s->linesize);
3264
3265                 mx += s->mv[dir][i][0]/2;
3266                 my += s->mv[dir][i][1]/2;
3267             }
3268         }else{
3269             for(i=0;i<4;i++) {
3270                 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3271                             ref_picture[0], 0, 0,
3272                             mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3273                             s->width, s->height, s->linesize,
3274                             s->h_edge_pos, s->v_edge_pos,
3275                             8, 8, pix_op[1],
3276                             s->mv[dir][i][0], s->mv[dir][i][1]);
3277
3278                 mx += s->mv[dir][i][0];
3279                 my += s->mv[dir][i][1];
3280             }
3281         }
3282
3283         if(!(s->flags&CODEC_FLAG_GRAY))
3284             chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3285         break;
3286     case MV_TYPE_FIELD:
3287         if (s->picture_structure == PICT_FRAME) {
3288             if(s->quarter_sample){
3289                 for(i=0; i<2; i++){
3290                     qpel_motion(s, dest_y, dest_cb, dest_cr,
3291                                 1, i, s->field_select[dir][i],
3292                                 ref_picture, pix_op, qpix_op,
3293                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3294                 }
3295             }else{
3296                 /* top field */       
3297                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3298                             1, 0, s->field_select[dir][0],
3299                             ref_picture, pix_op,
3300                             s->mv[dir][0][0], s->mv[dir][0][1], 8);
3301                 /* bottom field */
3302                 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3303                             1, 1, s->field_select[dir][1],
3304                             ref_picture, pix_op,
3305                             s->mv[dir][1][0], s->mv[dir][1][1], 8);
3306             }
3307         } else {
3308             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3309                 ref_picture= s->current_picture_ptr->data;
3310             } 
3311
3312             mpeg_motion(s, dest_y, dest_cb, dest_cr,
3313                         0, 0, s->field_select[dir][0],
3314                         ref_picture, pix_op,
3315                         s->mv[dir][0][0], s->mv[dir][0][1], 16);
3316         }
3317         break;
3318     case MV_TYPE_16X8:
3319         for(i=0; i<2; i++){
3320             uint8_t ** ref2picture;
3321
3322             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3323                 ref2picture= ref_picture;
3324             }else{
3325                 ref2picture= s->current_picture_ptr->data;
3326             } 
3327
3328             mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3329                         0, 0, s->field_select[dir][i],
3330                         ref2picture, pix_op,
3331                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3332                 
3333             dest_y += 16*s->linesize;
3334             dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3335             dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3336         }        
3337         break;
3338     case MV_TYPE_DMV:
3339         if(s->picture_structure == PICT_FRAME){
3340             for(i=0; i<2; i++){
3341                 int j;
3342                 for(j=0; j<2; j++){
3343                     mpeg_motion(s, dest_y, dest_cb, dest_cr,
3344                                 1, j, j^i,
3345                                 ref_picture, pix_op,
3346                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3347                 }
3348                 pix_op = s->dsp.avg_pixels_tab; 
3349             }
3350         }else{
3351             for(i=0; i<2; i++){
3352                 mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3353                             0, 0, s->picture_structure != i+1,
3354                             ref_picture, pix_op,
3355                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3356
3357                 // after put we make avg of the same block
3358                 pix_op=s->dsp.avg_pixels_tab; 
3359
3360                 //opposite parity is always in the same frame if this is second field
3361                 if(!s->first_field){
3362                     ref_picture = s->current_picture_ptr->data;    
3363                 }
3364             }
3365         }
3366     break;
3367     default: assert(0);
3368     }
3369 }
3370
3371 /**
3372  * motion compesation of a single macroblock
3373  * @param s context
3374  * @param dest_y luma destination pointer
3375  * @param dest_cb chroma cb/u destination pointer
3376  * @param dest_cr chroma cr/v destination pointer
3377  * @param dir direction (0->forward, 1->backward)
3378  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3379  * @param pic_op halfpel motion compensation function (average or put normally)
3380  * the motion vectors are taken from s->mv and the MV type from s->mv_type
3381  */
3382 static inline void MPV_motion_lowres(MpegEncContext *s, 
3383                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3384                               int dir, uint8_t **ref_picture, 
3385                               h264_chroma_mc_func *pix_op)
3386 {
3387     int mx, my;
3388     int mb_x, mb_y, i;
3389     const int lowres= s->avctx->lowres;
3390     const int block_s= 8>>lowres;    
3391
3392     mb_x = s->mb_x;
3393     mb_y = s->mb_y;
3394
3395     switch(s->mv_type) {
3396     case MV_TYPE_16X16:
3397         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3398                     0, 0, 0,
3399                     ref_picture, pix_op,
3400                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3401         break;
3402     case MV_TYPE_8X8:
3403         mx = 0;
3404         my = 0;
3405             for(i=0;i<4;i++) {
3406                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3407                             ref_picture[0], 0, 0,
3408                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3409                             s->width, s->height, s->linesize,
3410                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3411                             block_s, block_s, pix_op,
3412                             s->mv[dir][i][0], s->mv[dir][i][1]);
3413
3414                 mx += s->mv[dir][i][0];
3415                 my += s->mv[dir][i][1];
3416             }
3417
3418         if(!(s->flags&CODEC_FLAG_GRAY))
3419             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3420         break;
3421     case MV_TYPE_FIELD:
3422         if (s->picture_structure == PICT_FRAME) {
3423             /* top field */       
3424             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3425                         1, 0, s->field_select[dir][0],
3426                         ref_picture, pix_op,
3427                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3428             /* bottom field */
3429             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3430                         1, 1, s->field_select[dir][1],
3431                         ref_picture, pix_op,
3432                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3433         } else {
3434             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3435                 ref_picture= s->current_picture_ptr->data;
3436             } 
3437
3438             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3439                         0, 0, s->field_select[dir][0],
3440                         ref_picture, pix_op,
3441                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3442         }
3443         break;
3444     case MV_TYPE_16X8:
3445         for(i=0; i<2; i++){
3446             uint8_t ** ref2picture;
3447
3448             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3449                 ref2picture= ref_picture;
3450             }else{
3451                 ref2picture= s->current_picture_ptr->data;
3452             } 
3453
3454             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3455                         0, 0, s->field_select[dir][i],
3456                         ref2picture, pix_op,
3457                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3458                 
3459             dest_y += 2*block_s*s->linesize;
3460             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3461             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3462         }        
3463         break;
3464     case MV_TYPE_DMV:
3465         if(s->picture_structure == PICT_FRAME){
3466             for(i=0; i<2; i++){
3467                 int j;
3468                 for(j=0; j<2; j++){
3469                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3470                                 1, j, j^i,
3471                                 ref_picture, pix_op,
3472                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3473                 }
3474                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3475             }
3476         }else{
3477             for(i=0; i<2; i++){
3478                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3479                             0, 0, s->picture_structure != i+1,
3480                             ref_picture, pix_op,
3481                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3482
3483                 // after put we make avg of the same block
3484                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3485
3486                 //opposite parity is always in the same frame if this is second field
3487                 if(!s->first_field){
3488                     ref_picture = s->current_picture_ptr->data;    
3489                 }
3490             }
3491         }
3492     break;
3493     default: assert(0);
3494     }
3495 }
3496
3497 /* put block[] to dest[] */
3498 static inline void put_dct(MpegEncContext *s, 
3499                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3500 {
3501     s->dct_unquantize_intra(s, block, i, qscale);
3502     s->dsp.idct_put (dest, line_size, block);
3503 }
3504
3505 /* add block[] to dest[] */
3506 static inline void add_dct(MpegEncContext *s, 
3507                            DCTELEM *block, int i, uint8_t *dest, int line_size)
3508 {
3509     if (s->block_last_index[i] >= 0) {
3510         s->dsp.idct_add (dest, line_size, block);
3511     }
3512 }
3513
3514 static inline void add_dequant_dct(MpegEncContext *s, 
3515                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3516 {
3517     if (s->block_last_index[i] >= 0) {
3518         s->dct_unquantize_inter(s, block, i, qscale);
3519
3520         s->dsp.idct_add (dest, line_size, block);
3521     }
3522 }
3523
3524 /**
3525  * cleans dc, ac, coded_block for the current non intra MB
3526  */
3527 void ff_clean_intra_table_entries(MpegEncContext *s)
3528 {
3529     int wrap = s->b8_stride;
3530     int xy = s->block_index[0];
3531     
3532     s->dc_val[0][xy           ] = 
3533     s->dc_val[0][xy + 1       ] = 
3534     s->dc_val[0][xy     + wrap] =
3535     s->dc_val[0][xy + 1 + wrap] = 1024;
3536     /* ac pred */
3537     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3538     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3539     if (s->msmpeg4_version>=3) {
3540         s->coded_block[xy           ] =
3541         s->coded_block[xy + 1       ] =
3542         s->coded_block[xy     + wrap] =
3543         s->coded_block[xy + 1 + wrap] = 0;
3544     }
3545     /* chroma */
3546     wrap = s->mb_stride;
3547     xy = s->mb_x + s->mb_y * wrap;
3548     s->dc_val[1][xy] =
3549     s->dc_val[2][xy] = 1024;
3550     /* ac pred */
3551     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3552     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3553     
3554     s->mbintra_table[xy]= 0;
3555 }
3556
3557 /* generic function called after a macroblock has been parsed by the
3558    decoder or after it has been encoded by the encoder.
3559
3560    Important variables used:
3561    s->mb_intra : true if intra macroblock
3562    s->mv_dir   : motion vector direction
3563    s->mv_type  : motion vector type
3564    s->mv       : motion vector
3565    s->interlaced_dct : true if interlaced dct used (mpeg2)
3566  */
3567 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3568 {
3569     int mb_x, mb_y;
3570     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3571 #ifdef HAVE_XVMC
3572     if(s->avctx->xvmc_acceleration){
3573         XVMC_decode_mb(s);//xvmc uses pblocks
3574         return;
3575     }
3576 #endif
3577
3578     mb_x = s->mb_x;
3579     mb_y = s->mb_y;
3580
3581     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3582        /* save DCT coefficients */
3583        int i,j;
3584        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3585        for(i=0; i<6; i++)
3586            for(j=0; j<64; j++)
3587                *dct++ = block[i][s->dsp.idct_permutation[j]];
3588     }
3589
3590     s->current_picture.qscale_table[mb_xy]= s->qscale;
3591
3592     /* update DC predictors for P macroblocks */
3593     if (!s->mb_intra) {
3594         if (s->h263_pred || s->h263_aic) {
3595             if(s->mbintra_table[mb_xy])
3596                 ff_clean_intra_table_entries(s);
3597         } else {
3598             s->last_dc[0] =
3599             s->last_dc[1] =
3600             s->last_dc[2] = 128 << s->intra_dc_precision;
3601         }
3602     }
3603     else if (s->h263_pred || s->h263_aic)
3604         s->mbintra_table[mb_xy]=1;
3605
3606     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3607         uint8_t *dest_y, *dest_cb, *dest_cr;
3608         int dct_linesize, dct_offset;
3609         op_pixels_func (*op_pix)[4];
3610         qpel_mc_func (*op_qpix)[16];
3611         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3612         const int uvlinesize= s->current_picture.linesize[1];
3613         const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3614         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3615
3616         /* avoid copy if macroblock skipped in last frame too */
3617         /* skip only during decoding as we might trash the buffers during encoding a bit */
3618         if(!s->encoding){
3619             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3620             const int age= s->current_picture.age;
3621
3622             assert(age);
3623
3624             if (s->mb_skiped) {
3625                 s->mb_skiped= 0;
3626                 assert(s->pict_type!=I_TYPE);
3627  
3628                 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3629                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3630
3631                 /* if previous was skipped too, then nothing to do !  */
3632                 if (*mbskip_ptr >= age && s->current_picture.reference){
3633                     return;
3634                 }
3635             } else if(!s->current_picture.reference){
3636                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3637                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3638             } else{
3639                 *mbskip_ptr = 0; /* not skipped */
3640             }
3641         }
3642         
3643         dct_linesize = linesize << s->interlaced_dct;
3644         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3645         
3646         if(readable){
3647             dest_y=  s->dest[0];
3648             dest_cb= s->dest[1];
3649             dest_cr= s->dest[2];
3650         }else{
3651             dest_y = s->b_scratchpad;
3652             dest_cb= s->b_scratchpad+16*linesize;
3653             dest_cr= s->b_scratchpad+32*linesize;
3654         }
3655
3656         if (!s->mb_intra) {
3657             /* motion handling */
3658             /* decoding or more than one mb_type (MC was allready done otherwise) */
3659             if(!s->encoding){
3660                 if(lowres_flag){
3661                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3662
3663                     if (s->mv_dir & MV_DIR_FORWARD) {
3664                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3665                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3666                     }
3667                     if (s->mv_dir & MV_DIR_BACKWARD) {
3668                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3669                     }
3670                 }else{
3671                     if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3672                         op_pix = s->dsp.put_pixels_tab;
3673                         op_qpix= s->dsp.put_qpel_pixels_tab;
3674                     }else{
3675                         op_pix = s->dsp.put_no_rnd_pixels_tab;
3676                         op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3677                     }
3678                     if (s->mv_dir & MV_DIR_FORWARD) {
3679                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3680                         op_pix = s->dsp.avg_pixels_tab;
3681                         op_qpix= s->dsp.avg_qpel_pixels_tab;
3682                     }
3683                     if (s->mv_dir & MV_DIR_BACKWARD) {
3684                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3685                     }
3686                 }
3687             }
3688
3689             /* skip dequant / idct if we are really late ;) */
3690             if(s->hurry_up>1) return;
3691
3692             /* add dct residue */
3693             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3694                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3695                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3696                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3697                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3698                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3699
3700                 if(!(s->flags&CODEC_FLAG_GRAY)){
3701                     add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3702                     add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3703                 }
3704             } else if(s->codec_id != CODEC_ID_WMV2){
3705                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3706                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3707                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3708                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3709
3710                 if(!(s->flags&CODEC_FLAG_GRAY)){
3711                     if(s->chroma_y_shift){//Chroma420
3712                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
3713                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
3714                     }else{
3715                         //chroma422
3716                         dct_linesize = uvlinesize << s->interlaced_dct;
3717                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3718
3719                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
3720                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
3721                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3722                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3723                         if(!s->chroma_x_shift){//Chroma444
3724                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3725                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3726                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3727                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3728                         }
3729                     }
3730                 }//fi gray
3731             }
3732 #ifdef CONFIG_RISKY
3733             else{
3734                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3735             }
3736 #endif
3737         } else {
3738             /* dct only in intra block */
3739             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3740                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3741                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3742                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3743                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3744
3745                 if(!(s->flags&CODEC_FLAG_GRAY)){
3746                     put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3747                     put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3748                 }
3749             }else{
3750                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3751                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3752                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3753                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3754
3755                 if(!(s->flags&CODEC_FLAG_GRAY)){
3756                     if(s->chroma_y_shift){
3757                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3758                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3759                     }else{
3760
3761                         dct_linesize = uvlinesize << s->interlaced_dct;
3762                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3763
3764                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3765                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3766                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3767                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3768                         if(!s->chroma_x_shift){//Chroma444
3769                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3770                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3771                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3772                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3773                         }
3774                     }
3775                 }//gray
3776             }
3777         }
3778         if(!readable){
3779             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3780             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3781             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3782         }
3783     }
3784 }
3785
3786 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3787     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3788     else                  MPV_decode_mb_internal(s, block, 0);
3789 }
3790
3791 #ifdef CONFIG_ENCODERS
3792
3793 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3794 {
3795     static const char tab[64]=
3796         {3,2,2,1,1,1,1,1,
3797          1,1,1,1,1,1,1,1,
3798          1,1,1,1,1,1,1,1,
3799          0,0,0,0,0,0,0,0,
3800          0,0,0,0,0,0,0,0,
3801          0,0,0,0,0,0,0,0,
3802          0,0,0,0,0,0,0,0,
3803          0,0,0,0,0,0,0,0};
3804     int score=0;
3805     int run=0;
3806     int i;
3807     DCTELEM *block= s->block[n];
3808     const int last_index= s->block_last_index[n];
3809     int skip_dc;
3810
3811     if(threshold<0){
3812         skip_dc=0;
3813         threshold= -threshold;
3814     }else
3815         skip_dc=1;
3816
3817     /* are all which we could set to zero are allready zero? */
3818     if(last_index<=skip_dc - 1) return;
3819
3820     for(i=0; i<=last_index; i++){
3821         const int j = s->intra_scantable.permutated[i];
3822         const int level = ABS(block[j]);
3823         if(level==1){
3824             if(skip_dc && i==0) continue;
3825             score+= tab[run];
3826             run=0;
3827         }else if(level>1){
3828             return;
3829         }else{
3830             run++;
3831         }
3832     }
3833     if(score >= threshold) return;
3834     for(i=skip_dc; i<=last_index; i++){
3835         const int j = s->intra_scantable.permutated[i];
3836         block[j]=0;
3837     }
3838     if(block[0]) s->block_last_index[n]= 0;
3839     else         s->block_last_index[n]= -1;
3840 }
3841
3842 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3843 {
3844     int i;
3845     const int maxlevel= s->max_qcoeff;
3846     const int minlevel= s->min_qcoeff;
3847     int overflow=0;
3848     
3849     if(s->mb_intra){
3850         i=1; //skip clipping of intra dc
3851     }else
3852         i=0;
3853     
3854     for(;i<=last_index; i++){
3855         const int j= s->intra_scantable.permutated[i];
3856         int level = block[j];
3857        
3858         if     (level>maxlevel){
3859             level=maxlevel;
3860             overflow++;
3861         }else if(level<minlevel){
3862             level=minlevel;
3863             overflow++;
3864         }
3865         
3866         block[j]= level;
3867     }
3868     
3869     if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3870         av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3871 }
3872
3873 #endif //CONFIG_ENCODERS
3874
3875 /**
3876  *
3877  * @param h is the normal height, this will be reduced automatically if needed for the last row
3878  */
3879 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3880     if (s->avctx->draw_horiz_band) {
3881         AVFrame *src;
3882         int offset[4];
3883         
3884         if(s->picture_structure != PICT_FRAME){
3885             h <<= 1;
3886             y <<= 1;
3887             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3888         }
3889
3890         h= FFMIN(h, s->avctx->height - y);
3891
3892         if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3893             src= (AVFrame*)s->current_picture_ptr;
3894         else if(s->last_picture_ptr)
3895             src= (AVFrame*)s->last_picture_ptr;
3896         else
3897             return;
3898             
3899         if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3900             offset[0]=
3901             offset[1]=
3902             offset[2]=
3903             offset[3]= 0;
3904         }else{
3905             offset[0]= y * s->linesize;;
3906             offset[1]= 
3907             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3908             offset[3]= 0;
3909         }
3910
3911         emms_c();
3912
3913         s->avctx->draw_horiz_band(s->avctx, src, offset,
3914                                   y, s->picture_structure, h);
3915     }
3916 }
3917
3918 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3919     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3920     const int uvlinesize= s->current_picture.linesize[1];
3921     const int mb_size= 4 - s->avctx->lowres;
3922         
3923     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3924     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3925     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3926     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3927     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3928     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;
3929     //block_index is not used by mpeg2, so it is not affected by chroma_format
3930
3931     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3932     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3933     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3934
3935     if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3936     {
3937         s->dest[0] += s->mb_y *   linesize << mb_size;
3938         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3939         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3940     }
3941 }
3942
3943 #ifdef CONFIG_ENCODERS
3944
3945 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3946     int x, y;
3947 //FIXME optimize
3948     for(y=0; y<8; y++){
3949         for(x=0; x<8; x++){
3950             int x2, y2;
3951             int sum=0;
3952             int sqr=0;
3953             int count=0;
3954
3955             for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3956                 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3957                     int v= ptr[x2 + y2*stride];
3958                     sum += v;
3959                     sqr += v*v;
3960                     count++;
3961                 }
3962             }
3963             weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3964         }
3965     }
3966 }
3967
3968 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3969 {
3970     int16_t weight[6][64];
3971     DCTELEM orig[6][64];
3972     const int mb_x= s->mb_x;
3973     const int mb_y= s->mb_y;
3974     int i;
3975     int skip_dct[6];
3976     int dct_offset   = s->linesize*8; //default for progressive frames
3977     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3978     int wrap_y, wrap_c;
3979     
3980     for(i=0; i<6; i++) skip_dct[i]=0;
3981     
3982     if(s->adaptive_quant){
3983         const int last_qp= s->qscale;
3984         const int mb_xy= mb_x + mb_y*s->mb_stride;
3985
3986         s->lambda= s->lambda_table[mb_xy];
3987         update_qscale(s);
3988     
3989         if(!(s->flags&CODEC_FLAG_QP_RD)){
3990             s->dquant= s->qscale - last_qp;
3991
3992             if(s->out_format==FMT_H263){
3993                 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3994             
3995                 if(s->codec_id==CODEC_ID_MPEG4){        
3996                     if(!s->mb_intra){
3997                         if(s->pict_type == B_TYPE){
3998                             if(s->dquant&1) 
3999                                 s->dquant= (s->dquant/2)*2;
4000                             if(s->mv_dir&MV_DIRECT)
4001                                 s->dquant= 0;
4002                         }
4003                         if(s->mv_type==MV_TYPE_8X8)
4004                             s->dquant=0;
4005                     }
4006                 }
4007             }
4008         }
4009         ff_set_qscale(s, last_qp + s->dquant);
4010     }else if(s->flags&CODEC_FLAG_QP_RD)
4011         ff_set_qscale(s, s->qscale + s->dquant);
4012
4013     wrap_y = s->linesize;
4014     wrap_c = s->uvlinesize;
4015     ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4016     ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4017     ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4018
4019     if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4020         uint8_t *ebuf= s->edge_emu_buffer + 32;
4021         ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4022         ptr_y= ebuf;
4023         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);
4024         ptr_cb= ebuf+18*wrap_y;
4025         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);
4026         ptr_cr= ebuf+18*wrap_y+8;
4027     }
4028
4029     if (s->mb_intra) {
4030         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4031             int progressive_score, interlaced_score;
4032
4033             s->interlaced_dct=0;
4034             progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
4035                               +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4036
4037             if(progressive_score > 0){
4038                 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
4039                                   +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4040                 if(progressive_score > interlaced_score){
4041                     s->interlaced_dct=1;
4042             
4043                     dct_offset= wrap_y;
4044                     wrap_y<<=1;
4045                 }
4046             }