Rename copy_picture to ff_copy_picture.
[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  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file mpegvideo.c
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33 #include "mpegvideo_common.h"
34 #include "mjpegenc.h"
35 #include "msmpeg4.h"
36 #include "faandct.h"
37 #include <limits.h>
38
39 //#undef NDEBUG
40 //#include <assert.h>
41
42 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
43                                    DCTELEM *block, int n, int qscale);
44 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
45                                    DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
47                                    DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_bitexact(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
57 extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58 extern void XVMC_field_end(MpegEncContext *s);
59 extern void XVMC_decode_mb(MpegEncContext *s);
60
61
62 /* enable all paranoid tests for rounding, overflows, etc... */
63 //#define PARANOID
64
65 //#define DEBUG
66
67
68 static const uint8_t ff_default_chroma_qscale_table[32]={
69 //  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
70     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
71 };
72
73 const uint8_t ff_mpeg1_dc_scale_table[128]={
74 //  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
75     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 };
80
81
82 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
83     int i;
84
85     assert(p<=end);
86     if(p>=end)
87         return end;
88
89     for(i=0; i<3; i++){
90         uint32_t tmp= *state << 8;
91         *state= tmp + *(p++);
92         if(tmp == 0x100 || p==end)
93             return p;
94     }
95
96     while(p<end){
97         if     (p[-1] > 1      ) p+= 3;
98         else if(p[-2]          ) p+= 2;
99         else if(p[-3]|(p[-1]-1)) p++;
100         else{
101             p++;
102             break;
103         }
104     }
105
106     p= FFMIN(p, end)-4;
107     *state= AV_RB32(p);
108
109     return p+4;
110 }
111
112 /* init common dct for both encoder and decoder */
113 int ff_dct_common_init(MpegEncContext *s)
114 {
115     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
116     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
117     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
118     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
119     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
120     if(s->flags & CODEC_FLAG_BITEXACT)
121         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
122     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
123
124 #if defined(HAVE_MMX)
125     MPV_common_init_mmx(s);
126 #elif defined(ARCH_ALPHA)
127     MPV_common_init_axp(s);
128 #elif defined(CONFIG_MLIB)
129     MPV_common_init_mlib(s);
130 #elif defined(HAVE_MMI)
131     MPV_common_init_mmi(s);
132 #elif defined(ARCH_ARMV4L)
133     MPV_common_init_armv4l(s);
134 #elif defined(HAVE_ALTIVEC)
135     MPV_common_init_altivec(s);
136 #elif defined(ARCH_BFIN)
137     MPV_common_init_bfin(s);
138 #endif
139
140     /* load & permutate scantables
141        note: only wmv uses different ones
142     */
143     if(s->alternate_scan){
144         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
145         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
146     }else{
147         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
148         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
149     }
150     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
151     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
152
153     return 0;
154 }
155
156 void ff_copy_picture(Picture *dst, Picture *src){
157     *dst = *src;
158     dst->type= FF_BUFFER_TYPE_COPY;
159 }
160
161 /**
162  * allocates a Picture
163  * The pixels are allocated/set by calling get_buffer() if shared=0
164  */
165 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
166     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
167     const int mb_array_size= s->mb_stride*s->mb_height;
168     const int b8_array_size= s->b8_stride*s->mb_height*2;
169     const int b4_array_size= s->b4_stride*s->mb_height*4;
170     int i;
171     int r= -1;
172
173     if(shared){
174         assert(pic->data[0]);
175         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
176         pic->type= FF_BUFFER_TYPE_SHARED;
177     }else{
178         assert(!pic->data[0]);
179
180         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
181
182         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
183             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
184             return -1;
185         }
186
187         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
188             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
189             s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
190             return -1;
191         }
192
193         if(pic->linesize[1] != pic->linesize[2]){
194             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
195             s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
196             return -1;
197         }
198
199         s->linesize  = pic->linesize[0];
200         s->uvlinesize= pic->linesize[1];
201     }
202
203     if(pic->qscale_table==NULL){
204         if (s->encoding) {
205             CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
206             CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
207             CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
208         }
209
210         CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
211         CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
212         CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
213         pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
214         if(s->out_format == FMT_H264){
215             for(i=0; i<2; i++){
216                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
217                 pic->motion_val[i]= pic->motion_val_base[i]+4;
218                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
219             }
220             pic->motion_subsample_log2= 2;
221         }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
222             for(i=0; i<2; i++){
223                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
224                 pic->motion_val[i]= pic->motion_val_base[i]+4;
225                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
226             }
227             pic->motion_subsample_log2= 3;
228         }
229         if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
230             CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
231         }
232         pic->qstride= s->mb_stride;
233         CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
234     }
235
236     /* It might be nicer if the application would keep track of these
237      * but it would require an API change. */
238     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
239     s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
240     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
241         pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
242
243     return 0;
244 fail: //for the CHECKED_ALLOCZ macro
245     if(r>=0)
246         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
247     return -1;
248 }
249
250 /**
251  * deallocates a picture
252  */
253 static void free_picture(MpegEncContext *s, Picture *pic){
254     int i;
255
256     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
257         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
258     }
259
260     av_freep(&pic->mb_var);
261     av_freep(&pic->mc_mb_var);
262     av_freep(&pic->mb_mean);
263     av_freep(&pic->mbskip_table);
264     av_freep(&pic->qscale_table);
265     av_freep(&pic->mb_type_base);
266     av_freep(&pic->dct_coeff);
267     av_freep(&pic->pan_scan);
268     pic->mb_type= NULL;
269     for(i=0; i<2; i++){
270         av_freep(&pic->motion_val_base[i]);
271         av_freep(&pic->ref_index[i]);
272     }
273
274     if(pic->type == FF_BUFFER_TYPE_SHARED){
275         for(i=0; i<4; i++){
276             pic->base[i]=
277             pic->data[i]= NULL;
278         }
279         pic->type= 0;
280     }
281 }
282
283 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
284     int i;
285
286     // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
287     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
288     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
289
290      //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
291     CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
292     s->rd_scratchpad=   s->me.scratchpad;
293     s->b_scratchpad=    s->me.scratchpad;
294     s->obmc_scratchpad= s->me.scratchpad + 16;
295     if (s->encoding) {
296         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
297         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
298         if(s->avctx->noise_reduction){
299             CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
300         }
301     }
302     CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
303     s->block= s->blocks[0];
304
305     for(i=0;i<12;i++){
306         s->pblocks[i] = (short *)(&s->block[i]);
307     }
308     return 0;
309 fail:
310     return -1; //free() through MPV_common_end()
311 }
312
313 static void free_duplicate_context(MpegEncContext *s){
314     if(s==NULL) return;
315
316     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
317     av_freep(&s->me.scratchpad);
318     s->rd_scratchpad=
319     s->b_scratchpad=
320     s->obmc_scratchpad= NULL;
321
322     av_freep(&s->dct_error_sum);
323     av_freep(&s->me.map);
324     av_freep(&s->me.score_map);
325     av_freep(&s->blocks);
326     s->block= NULL;
327 }
328
329 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
330 #define COPY(a) bak->a= src->a
331     COPY(allocated_edge_emu_buffer);
332     COPY(edge_emu_buffer);
333     COPY(me.scratchpad);
334     COPY(rd_scratchpad);
335     COPY(b_scratchpad);
336     COPY(obmc_scratchpad);
337     COPY(me.map);
338     COPY(me.score_map);
339     COPY(blocks);
340     COPY(block);
341     COPY(start_mb_y);
342     COPY(end_mb_y);
343     COPY(me.map_generation);
344     COPY(pb);
345     COPY(dct_error_sum);
346     COPY(dct_count[0]);
347     COPY(dct_count[1]);
348 #undef COPY
349 }
350
351 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
352     MpegEncContext bak;
353     int i;
354     //FIXME copy only needed parts
355 //START_TIMER
356     backup_duplicate_context(&bak, dst);
357     memcpy(dst, src, sizeof(MpegEncContext));
358     backup_duplicate_context(dst, &bak);
359     for(i=0;i<12;i++){
360         dst->pblocks[i] = (short *)(&dst->block[i]);
361     }
362 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
363 }
364
365 /**
366  * sets the given MpegEncContext to common defaults (same for encoding and decoding).
367  * the changed fields will not depend upon the prior state of the MpegEncContext.
368  */
369 void MPV_common_defaults(MpegEncContext *s){
370     s->y_dc_scale_table=
371     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
372     s->chroma_qscale_table= ff_default_chroma_qscale_table;
373     s->progressive_frame= 1;
374     s->progressive_sequence= 1;
375     s->picture_structure= PICT_FRAME;
376
377     s->coded_picture_number = 0;
378     s->picture_number = 0;
379     s->input_picture_number = 0;
380
381     s->picture_in_gop_number = 0;
382
383     s->f_code = 1;
384     s->b_code = 1;
385 }
386
387 /**
388  * sets the given MpegEncContext to defaults for decoding.
389  * the changed fields will not depend upon the prior state of the MpegEncContext.
390  */
391 void MPV_decode_defaults(MpegEncContext *s){
392     MPV_common_defaults(s);
393 }
394
395 /**
396  * init common structure for both encoder and decoder.
397  * this assumes that some variables like width/height are already set
398  */
399 int MPV_common_init(MpegEncContext *s)
400 {
401     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
402
403     s->mb_height = (s->height + 15) / 16;
404
405     if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
406         av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
407         return -1;
408     }
409
410     if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
411         return -1;
412
413     dsputil_init(&s->dsp, s->avctx);
414     ff_dct_common_init(s);
415
416     s->flags= s->avctx->flags;
417     s->flags2= s->avctx->flags2;
418
419     s->mb_width  = (s->width  + 15) / 16;
420     s->mb_stride = s->mb_width + 1;
421     s->b8_stride = s->mb_width*2 + 1;
422     s->b4_stride = s->mb_width*4 + 1;
423     mb_array_size= s->mb_height * s->mb_stride;
424     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
425
426     /* set chroma shifts */
427     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
428                                                     &(s->chroma_y_shift) );
429
430     /* set default edge pos, will be overriden in decode_header if needed */
431     s->h_edge_pos= s->mb_width*16;
432     s->v_edge_pos= s->mb_height*16;
433
434     s->mb_num = s->mb_width * s->mb_height;
435
436     s->block_wrap[0]=
437     s->block_wrap[1]=
438     s->block_wrap[2]=
439     s->block_wrap[3]= s->b8_stride;
440     s->block_wrap[4]=
441     s->block_wrap[5]= s->mb_stride;
442
443     y_size = s->b8_stride * (2 * s->mb_height + 1);
444     c_size = s->mb_stride * (s->mb_height + 1);
445     yc_size = y_size + 2 * c_size;
446
447     /* convert fourcc to upper case */
448     s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
449                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
450                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
451                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
452
453     s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
454                                + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
455                                + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
456                                + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
457
458     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
459
460     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
461     for(y=0; y<s->mb_height; y++){
462         for(x=0; x<s->mb_width; x++){
463             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
464         }
465     }
466     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
467
468     if (s->encoding) {
469         /* Allocate MV tables */
470         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
471         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
472         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
473         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
474         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
476         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
477         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
478         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
479         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
480         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
481         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
482
483         if(s->msmpeg4_version){
484             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
485         }
486         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
487
488         /* Allocate MB type table */
489         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
490
491         CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
492
493         CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
494         CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
495         CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
496         CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
497         CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
498         CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
499
500         if(s->avctx->noise_reduction){
501             CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
502         }
503     }
504     CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
505
506     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
507
508     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
509         /* interlaced direct mode decoding tables */
510             for(i=0; i<2; i++){
511                 int j, k;
512                 for(j=0; j<2; j++){
513                     for(k=0; k<2; k++){
514                         CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
515                         s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
516                     }
517                     CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
518                     CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
519                     s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
520                 }
521                 CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
522             }
523     }
524     if (s->out_format == FMT_H263) {
525         /* ac values */
526         CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
527         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
528         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
529         s->ac_val[2] = s->ac_val[1] + c_size;
530
531         /* cbp values */
532         CHECKED_ALLOCZ(s->coded_block_base, y_size);
533         s->coded_block= s->coded_block_base + s->b8_stride + 1;
534
535         /* cbp, ac_pred, pred_dir */
536         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
537         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
538     }
539
540     if (s->h263_pred || s->h263_plus || !s->encoding) {
541         /* dc values */
542         //MN: we need these for error resilience of intra-frames
543         CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
544         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
545         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
546         s->dc_val[2] = s->dc_val[1] + c_size;
547         for(i=0;i<yc_size;i++)
548             s->dc_val_base[i] = 1024;
549     }
550
551     /* which mb is a intra block */
552     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
553     memset(s->mbintra_table, 1, mb_array_size);
554
555     /* init macroblock skip table */
556     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
557     //Note the +1 is for a quicker mpeg4 slice_end detection
558     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
559
560     s->parse_context.state= -1;
561     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
562        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
563        s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
564        s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
565     }
566
567     s->context_initialized = 1;
568
569     s->thread_context[0]= s;
570     threads = s->avctx->thread_count;
571
572     for(i=1; i<threads; i++){
573         s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
574         memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
575     }
576
577     for(i=0; i<threads; i++){
578         if(init_duplicate_context(s->thread_context[i], s) < 0)
579            goto fail;
580         s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
581         s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
582     }
583
584     return 0;
585  fail:
586     MPV_common_end(s);
587     return -1;
588 }
589
590 /* init common structure for both encoder and decoder */
591 void MPV_common_end(MpegEncContext *s)
592 {
593     int i, j, k;
594
595     for(i=0; i<s->avctx->thread_count; i++){
596         free_duplicate_context(s->thread_context[i]);
597     }
598     for(i=1; i<s->avctx->thread_count; i++){
599         av_freep(&s->thread_context[i]);
600     }
601
602     av_freep(&s->parse_context.buffer);
603     s->parse_context.buffer_size=0;
604
605     av_freep(&s->mb_type);
606     av_freep(&s->p_mv_table_base);
607     av_freep(&s->b_forw_mv_table_base);
608     av_freep(&s->b_back_mv_table_base);
609     av_freep(&s->b_bidir_forw_mv_table_base);
610     av_freep(&s->b_bidir_back_mv_table_base);
611     av_freep(&s->b_direct_mv_table_base);
612     s->p_mv_table= NULL;
613     s->b_forw_mv_table= NULL;
614     s->b_back_mv_table= NULL;
615     s->b_bidir_forw_mv_table= NULL;
616     s->b_bidir_back_mv_table= NULL;
617     s->b_direct_mv_table= NULL;
618     for(i=0; i<2; i++){
619         for(j=0; j<2; j++){
620             for(k=0; k<2; k++){
621                 av_freep(&s->b_field_mv_table_base[i][j][k]);
622                 s->b_field_mv_table[i][j][k]=NULL;
623             }
624             av_freep(&s->b_field_select_table[i][j]);
625             av_freep(&s->p_field_mv_table_base[i][j]);
626             s->p_field_mv_table[i][j]=NULL;
627         }
628         av_freep(&s->p_field_select_table[i]);
629     }
630
631     av_freep(&s->dc_val_base);
632     av_freep(&s->ac_val_base);
633     av_freep(&s->coded_block_base);
634     av_freep(&s->mbintra_table);
635     av_freep(&s->cbp_table);
636     av_freep(&s->pred_dir_table);
637
638     av_freep(&s->mbskip_table);
639     av_freep(&s->prev_pict_types);
640     av_freep(&s->bitstream_buffer);
641     s->allocated_bitstream_buffer_size=0;
642
643     av_freep(&s->avctx->stats_out);
644     av_freep(&s->ac_stats);
645     av_freep(&s->error_status_table);
646     av_freep(&s->mb_index2xy);
647     av_freep(&s->lambda_table);
648     av_freep(&s->q_intra_matrix);
649     av_freep(&s->q_inter_matrix);
650     av_freep(&s->q_intra_matrix16);
651     av_freep(&s->q_inter_matrix16);
652     av_freep(&s->input_picture);
653     av_freep(&s->reordered_input_picture);
654     av_freep(&s->dct_offset);
655
656     if(s->picture){
657         for(i=0; i<MAX_PICTURE_COUNT; i++){
658             free_picture(s, &s->picture[i]);
659         }
660     }
661     av_freep(&s->picture);
662     s->context_initialized = 0;
663     s->last_picture_ptr=
664     s->next_picture_ptr=
665     s->current_picture_ptr= NULL;
666     s->linesize= s->uvlinesize= 0;
667
668     for(i=0; i<3; i++)
669         av_freep(&s->visualization_buffer[i]);
670
671     avcodec_default_free_buffers(s->avctx);
672 }
673
674 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
675 {
676     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
677     uint8_t index_run[MAX_RUN+1];
678     int last, run, level, start, end, i;
679
680     /* If table is static, we can quit if rl->max_level[0] is not NULL */
681     if(static_store && rl->max_level[0])
682         return;
683
684     /* compute max_level[], max_run[] and index_run[] */
685     for(last=0;last<2;last++) {
686         if (last == 0) {
687             start = 0;
688             end = rl->last;
689         } else {
690             start = rl->last;
691             end = rl->n;
692         }
693
694         memset(max_level, 0, MAX_RUN + 1);
695         memset(max_run, 0, MAX_LEVEL + 1);
696         memset(index_run, rl->n, MAX_RUN + 1);
697         for(i=start;i<end;i++) {
698             run = rl->table_run[i];
699             level = rl->table_level[i];
700             if (index_run[run] == rl->n)
701                 index_run[run] = i;
702             if (level > max_level[run])
703                 max_level[run] = level;
704             if (run > max_run[level])
705                 max_run[level] = run;
706         }
707         if(static_store)
708             rl->max_level[last] = static_store[last];
709         else
710             rl->max_level[last] = av_malloc(MAX_RUN + 1);
711         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
712         if(static_store)
713             rl->max_run[last] = static_store[last] + MAX_RUN + 1;
714         else
715             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
716         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
717         if(static_store)
718             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
719         else
720             rl->index_run[last] = av_malloc(MAX_RUN + 1);
721         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
722     }
723 }
724
725 void init_vlc_rl(RLTable *rl)
726 {
727     int i, q;
728
729     for(q=0; q<32; q++){
730         int qmul= q*2;
731         int qadd= (q-1)|1;
732
733         if(q==0){
734             qmul=1;
735             qadd=0;
736         }
737         for(i=0; i<rl->vlc.table_size; i++){
738             int code= rl->vlc.table[i][0];
739             int len = rl->vlc.table[i][1];
740             int level, run;
741
742             if(len==0){ // illegal code
743                 run= 66;
744                 level= MAX_LEVEL;
745             }else if(len<0){ //more bits needed
746                 run= 0;
747                 level= code;
748             }else{
749                 if(code==rl->n){ //esc
750                     run= 66;
751                     level= 0;
752                 }else{
753                     run=   rl->table_run  [code] + 1;
754                     level= rl->table_level[code] * qmul + qadd;
755                     if(code >= rl->last) run+=192;
756                 }
757             }
758             rl->rl_vlc[q][i].len= len;
759             rl->rl_vlc[q][i].level= level;
760             rl->rl_vlc[q][i].run= run;
761         }
762     }
763 }
764
765 int ff_find_unused_picture(MpegEncContext *s, int shared){
766     int i;
767
768     if(shared){
769         for(i=0; i<MAX_PICTURE_COUNT; i++){
770             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
771         }
772     }else{
773         for(i=0; i<MAX_PICTURE_COUNT; i++){
774             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
775         }
776         for(i=0; i<MAX_PICTURE_COUNT; i++){
777             if(s->picture[i].data[0]==NULL) return i;
778         }
779     }
780
781     av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
782     /* We could return -1, but the codec would crash trying to draw into a
783      * non-existing frame anyway. This is safer than waiting for a random crash.
784      * Also the return of this is never useful, an encoder must only allocate
785      * as much as allowed in the specification. This has no relationship to how
786      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
787      * enough for such valid streams).
788      * Plus, a decoder has to check stream validity and remove frames if too
789      * many reference frames are around. Waiting for "OOM" is not correct at
790      * all. Similarly, missing reference frames have to be replaced by
791      * interpolated/MC frames, anything else is a bug in the codec ...
792      */
793     abort();
794     return -1;
795 }
796
797 static void update_noise_reduction(MpegEncContext *s){
798     int intra, i;
799
800     for(intra=0; intra<2; intra++){
801         if(s->dct_count[intra] > (1<<16)){
802             for(i=0; i<64; i++){
803                 s->dct_error_sum[intra][i] >>=1;
804             }
805             s->dct_count[intra] >>= 1;
806         }
807
808         for(i=0; i<64; i++){
809             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);
810         }
811     }
812 }
813
814 /**
815  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
816  */
817 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
818 {
819     int i;
820     AVFrame *pic;
821     s->mb_skipped = 0;
822
823     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
824
825     /* mark&release old frames */
826     if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
827       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
828         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
829
830         /* release forgotten pictures */
831         /* if(mpeg124/h263) */
832         if(!s->encoding){
833             for(i=0; i<MAX_PICTURE_COUNT; i++){
834                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
835                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
836                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
837                 }
838             }
839         }
840       }
841     }
842 alloc:
843     if(!s->encoding){
844         /* release non reference frames */
845         for(i=0; i<MAX_PICTURE_COUNT; i++){
846             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
847                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
848             }
849         }
850
851         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
852             pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
853         else{
854             i= ff_find_unused_picture(s, 0);
855             pic= (AVFrame*)&s->picture[i];
856         }
857
858         pic->reference= 0;
859         if (!s->dropable){
860             if (s->codec_id == CODEC_ID_H264)
861                 pic->reference = s->picture_structure;
862             else if (s->pict_type != FF_B_TYPE)
863                 pic->reference = 3;
864         }
865
866         pic->coded_picture_number= s->coded_picture_number++;
867
868         if( alloc_picture(s, (Picture*)pic, 0) < 0)
869             return -1;
870
871         s->current_picture_ptr= (Picture*)pic;
872         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
873         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
874     }
875
876     s->current_picture_ptr->pict_type= s->pict_type;
877 //    if(s->flags && CODEC_FLAG_QSCALE)
878   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
879     s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
880
881     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
882
883     if (s->pict_type != FF_B_TYPE) {
884         s->last_picture_ptr= s->next_picture_ptr;
885         if(!s->dropable)
886             s->next_picture_ptr= s->current_picture_ptr;
887     }
888 /*    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,
889         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
890         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
891         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
892         s->pict_type, s->dropable);*/
893
894     if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
895     if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
896
897     if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable && s->codec_id != CODEC_ID_H264){
898         av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
899         assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
900         goto alloc;
901     }
902
903     assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
904
905     if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
906         int i;
907         for(i=0; i<4; i++){
908             if(s->picture_structure == PICT_BOTTOM_FIELD){
909                  s->current_picture.data[i] += s->current_picture.linesize[i];
910             }
911             s->current_picture.linesize[i] *= 2;
912             s->last_picture.linesize[i] *=2;
913             s->next_picture.linesize[i] *=2;
914         }
915     }
916
917     s->hurry_up= s->avctx->hurry_up;
918     s->error_recognition= avctx->error_recognition;
919
920     /* set dequantizer, we can't do it during init as it might change for mpeg4
921        and we can't do it in the header decode as init is not called for mpeg4 there yet */
922     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
923         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
924         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
925     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
926         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
927         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
928     }else{
929         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
930         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
931     }
932
933     if(s->dct_error_sum){
934         assert(s->avctx->noise_reduction && s->encoding);
935
936         update_noise_reduction(s);
937     }
938
939 #ifdef HAVE_XVMC
940     if(s->avctx->xvmc_acceleration)
941         return XVMC_field_start(s, avctx);
942 #endif
943     return 0;
944 }
945
946 /* generic function for encode/decode called after a frame has been coded/decoded */
947 void MPV_frame_end(MpegEncContext *s)
948 {
949     int i;
950     /* draw edge for correct motion prediction if outside */
951 #ifdef HAVE_XVMC
952 //just to make sure that all data is rendered.
953     if(s->avctx->xvmc_acceleration){
954         XVMC_field_end(s);
955     }else
956 #endif
957     if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
958             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
959             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
960             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
961     }
962     emms_c();
963
964     s->last_pict_type    = s->pict_type;
965     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
966     if(s->pict_type!=FF_B_TYPE){
967         s->last_non_b_pict_type= s->pict_type;
968     }
969 #if 0
970         /* copy back current_picture variables */
971     for(i=0; i<MAX_PICTURE_COUNT; i++){
972         if(s->picture[i].data[0] == s->current_picture.data[0]){
973             s->picture[i]= s->current_picture;
974             break;
975         }
976     }
977     assert(i<MAX_PICTURE_COUNT);
978 #endif
979
980     if(s->encoding){
981         /* release non-reference frames */
982         for(i=0; i<MAX_PICTURE_COUNT; i++){
983             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
984                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
985             }
986         }
987     }
988     // clear copies, to avoid confusion
989 #if 0
990     memset(&s->last_picture, 0, sizeof(Picture));
991     memset(&s->next_picture, 0, sizeof(Picture));
992     memset(&s->current_picture, 0, sizeof(Picture));
993 #endif
994     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
995 }
996
997 /**
998  * draws an line from (ex, ey) -> (sx, sy).
999  * @param w width of the image
1000  * @param h height of the image
1001  * @param stride stride/linesize of the image
1002  * @param color color of the arrow
1003  */
1004 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1005     int x, y, fr, f;
1006
1007     sx= av_clip(sx, 0, w-1);
1008     sy= av_clip(sy, 0, h-1);
1009     ex= av_clip(ex, 0, w-1);
1010     ey= av_clip(ey, 0, h-1);
1011
1012     buf[sy*stride + sx]+= color;
1013
1014     if(FFABS(ex - sx) > FFABS(ey - sy)){
1015         if(sx > ex){
1016             FFSWAP(int, sx, ex);
1017             FFSWAP(int, sy, ey);
1018         }
1019         buf+= sx + sy*stride;
1020         ex-= sx;
1021         f= ((ey-sy)<<16)/ex;
1022         for(x= 0; x <= ex; x++){
1023             y = (x*f)>>16;
1024             fr= (x*f)&0xFFFF;
1025             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1026             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1027         }
1028     }else{
1029         if(sy > ey){
1030             FFSWAP(int, sx, ex);
1031             FFSWAP(int, sy, ey);
1032         }
1033         buf+= sx + sy*stride;
1034         ey-= sy;
1035         if(ey) f= ((ex-sx)<<16)/ey;
1036         else   f= 0;
1037         for(y= 0; y <= ey; y++){
1038             x = (y*f)>>16;
1039             fr= (y*f)&0xFFFF;
1040             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1041             buf[y*stride + x+1]+= (color*         fr )>>16;
1042         }
1043     }
1044 }
1045
1046 /**
1047  * draws an arrow from (ex, ey) -> (sx, sy).
1048  * @param w width of the image
1049  * @param h height of the image
1050  * @param stride stride/linesize of the image
1051  * @param color color of the arrow
1052  */
1053 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1054     int dx,dy;
1055
1056     sx= av_clip(sx, -100, w+100);
1057     sy= av_clip(sy, -100, h+100);
1058     ex= av_clip(ex, -100, w+100);
1059     ey= av_clip(ey, -100, h+100);
1060
1061     dx= ex - sx;
1062     dy= ey - sy;
1063
1064     if(dx*dx + dy*dy > 3*3){
1065         int rx=  dx + dy;
1066         int ry= -dx + dy;
1067         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1068
1069         //FIXME subpixel accuracy
1070         rx= ROUNDED_DIV(rx*3<<4, length);
1071         ry= ROUNDED_DIV(ry*3<<4, length);
1072
1073         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1074         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1075     }
1076     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1077 }
1078
1079 /**
1080  * prints debuging info for the given picture.
1081  */
1082 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1083
1084     if(!pict || !pict->mb_type) return;
1085
1086     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1087         int x,y;
1088
1089         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1090         switch (pict->pict_type) {
1091             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1092             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1093             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1094             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1095             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1096             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1097         }
1098         for(y=0; y<s->mb_height; y++){
1099             for(x=0; x<s->mb_width; x++){
1100                 if(s->avctx->debug&FF_DEBUG_SKIP){
1101                     int count= s->mbskip_table[x + y*s->mb_stride];
1102                     if(count>9) count=9;
1103                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1104                 }
1105                 if(s->avctx->debug&FF_DEBUG_QP){
1106                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1107                 }
1108                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1109                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1110                     //Type & MV direction
1111                     if(IS_PCM(mb_type))
1112                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1113                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1114                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1115                     else if(IS_INTRA4x4(mb_type))
1116                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1117                     else if(IS_INTRA16x16(mb_type))
1118                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1119                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1120                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1121                     else if(IS_DIRECT(mb_type))
1122                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1123                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1124                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1125                     else if(IS_GMC(mb_type))
1126                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1127                     else if(IS_SKIP(mb_type))
1128                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1129                     else if(!USES_LIST(mb_type, 1))
1130                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1131                     else if(!USES_LIST(mb_type, 0))
1132                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1133                     else{
1134                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1135                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1136                     }
1137
1138                     //segmentation
1139                     if(IS_8X8(mb_type))
1140                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1141                     else if(IS_16X8(mb_type))
1142                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1143                     else if(IS_8X16(mb_type))
1144                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1145                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1146                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1147                     else
1148                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1149
1150
1151                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1152                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1153                     else
1154                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1155                 }
1156 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1157             }
1158             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1159         }
1160     }
1161
1162     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1163         const int shift= 1 + s->quarter_sample;
1164         int mb_y;
1165         uint8_t *ptr;
1166         int i;
1167         int h_chroma_shift, v_chroma_shift, block_height;
1168         const int width = s->avctx->width;
1169         const int height= s->avctx->height;
1170         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1171         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1172         s->low_delay=0; //needed to see the vectors without trashing the buffers
1173
1174         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1175         for(i=0; i<3; i++){
1176             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1177             pict->data[i]= s->visualization_buffer[i];
1178         }
1179         pict->type= FF_BUFFER_TYPE_COPY;
1180         ptr= pict->data[0];
1181         block_height = 16>>v_chroma_shift;
1182
1183         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1184             int mb_x;
1185             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1186                 const int mb_index= mb_x + mb_y*s->mb_stride;
1187                 if((s->avctx->debug_mv) && pict->motion_val){
1188                   int type;
1189                   for(type=0; type<3; type++){
1190                     int direction = 0;
1191                     switch (type) {
1192                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1193                                 continue;
1194                               direction = 0;
1195                               break;
1196                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1197                                 continue;
1198                               direction = 0;
1199                               break;
1200                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1201                                 continue;
1202                               direction = 1;
1203                               break;
1204                     }
1205                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1206                         continue;
1207
1208                     if(IS_8X8(pict->mb_type[mb_index])){
1209                       int i;
1210                       for(i=0; i<4; i++){
1211                         int sx= mb_x*16 + 4 + 8*(i&1);
1212                         int sy= mb_y*16 + 4 + 8*(i>>1);
1213                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1214                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1215                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1216                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1217                       }
1218                     }else if(IS_16X8(pict->mb_type[mb_index])){
1219                       int i;
1220                       for(i=0; i<2; i++){
1221                         int sx=mb_x*16 + 8;
1222                         int sy=mb_y*16 + 4 + 8*i;
1223                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1224                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1225                         int my=(pict->motion_val[direction][xy][1]>>shift);
1226
1227                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1228                             my*=2;
1229
1230                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1231                       }
1232                     }else if(IS_8X16(pict->mb_type[mb_index])){
1233                       int i;
1234                       for(i=0; i<2; i++){
1235                         int sx=mb_x*16 + 4 + 8*i;
1236                         int sy=mb_y*16 + 8;
1237                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1238                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1239                         int my=(pict->motion_val[direction][xy][1]>>shift);
1240
1241                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1242                             my*=2;
1243
1244                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1245                       }
1246                     }else{
1247                       int sx= mb_x*16 + 8;
1248                       int sy= mb_y*16 + 8;
1249                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1250                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1251                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1252                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1253                     }
1254                   }
1255                 }
1256                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1257                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1258                     int y;
1259                     for(y=0; y<block_height; y++){
1260                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1261                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1262                     }
1263                 }
1264                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1265                     int mb_type= pict->mb_type[mb_index];
1266                     uint64_t u,v;
1267                     int y;
1268 #define COLOR(theta, r)\
1269 u= (int)(128 + r*cos(theta*3.141592/180));\
1270 v= (int)(128 + r*sin(theta*3.141592/180));
1271
1272
1273                     u=v=128;
1274                     if(IS_PCM(mb_type)){
1275                         COLOR(120,48)
1276                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1277                         COLOR(30,48)
1278                     }else if(IS_INTRA4x4(mb_type)){
1279                         COLOR(90,48)
1280                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1281 //                        COLOR(120,48)
1282                     }else if(IS_DIRECT(mb_type)){
1283                         COLOR(150,48)
1284                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1285                         COLOR(170,48)
1286                     }else if(IS_GMC(mb_type)){
1287                         COLOR(190,48)
1288                     }else if(IS_SKIP(mb_type)){
1289 //                        COLOR(180,48)
1290                     }else if(!USES_LIST(mb_type, 1)){
1291                         COLOR(240,48)
1292                     }else if(!USES_LIST(mb_type, 0)){
1293                         COLOR(0,48)
1294                     }else{
1295                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1296                         COLOR(300,48)
1297                     }
1298
1299                     u*= 0x0101010101010101ULL;
1300                     v*= 0x0101010101010101ULL;
1301                     for(y=0; y<block_height; y++){
1302                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1303                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1304                     }
1305
1306                     //segmentation
1307                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1308                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1309                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1310                     }
1311                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1312                         for(y=0; y<16; y++)
1313                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1314                     }
1315                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1316                         int dm= 1 << (mv_sample_log2-2);
1317                         for(i=0; i<4; i++){
1318                             int sx= mb_x*16 + 8*(i&1);
1319                             int sy= mb_y*16 + 8*(i>>1);
1320                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1321                             //FIXME bidir
1322                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1323                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1324                                 for(y=0; y<8; y++)
1325                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1326                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1327                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1328                         }
1329                     }
1330
1331                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1332                         // hmm
1333                     }
1334                 }
1335                 s->mbskip_table[mb_index]=0;
1336             }
1337         }
1338     }
1339 }
1340
1341 static inline int hpel_motion_lowres(MpegEncContext *s,
1342                                   uint8_t *dest, uint8_t *src,
1343                                   int field_based, int field_select,
1344                                   int src_x, int src_y,
1345                                   int width, int height, int stride,
1346                                   int h_edge_pos, int v_edge_pos,
1347                                   int w, int h, h264_chroma_mc_func *pix_op,
1348                                   int motion_x, int motion_y)
1349 {
1350     const int lowres= s->avctx->lowres;
1351     const int s_mask= (2<<lowres)-1;
1352     int emu=0;
1353     int sx, sy;
1354
1355     if(s->quarter_sample){
1356         motion_x/=2;
1357         motion_y/=2;
1358     }
1359
1360     sx= motion_x & s_mask;
1361     sy= motion_y & s_mask;
1362     src_x += motion_x >> (lowres+1);
1363     src_y += motion_y >> (lowres+1);
1364
1365     src += src_y * stride + src_x;
1366
1367     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1368        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1369         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1370                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1371         src= s->edge_emu_buffer;
1372         emu=1;
1373     }
1374
1375     sx <<= 2 - lowres;
1376     sy <<= 2 - lowres;
1377     if(field_select)
1378         src += s->linesize;
1379     pix_op[lowres](dest, src, stride, h, sx, sy);
1380     return emu;
1381 }
1382
1383 /* apply one mpeg motion vector to the three components */
1384 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1385                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1386                                int field_based, int bottom_field, int field_select,
1387                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1388                                int motion_x, int motion_y, int h)
1389 {
1390     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1391     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1392     const int lowres= s->avctx->lowres;
1393     const int block_s= 8>>lowres;
1394     const int s_mask= (2<<lowres)-1;
1395     const int h_edge_pos = s->h_edge_pos >> lowres;
1396     const int v_edge_pos = s->v_edge_pos >> lowres;
1397     linesize   = s->current_picture.linesize[0] << field_based;
1398     uvlinesize = s->current_picture.linesize[1] << field_based;
1399
1400     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1401         motion_x/=2;
1402         motion_y/=2;
1403     }
1404
1405     if(field_based){
1406         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1407     }
1408
1409     sx= motion_x & s_mask;
1410     sy= motion_y & s_mask;
1411     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1412     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1413
1414     if (s->out_format == FMT_H263) {
1415         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1416         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1417         uvsrc_x = src_x>>1;
1418         uvsrc_y = src_y>>1;
1419     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1420         mx = motion_x / 4;
1421         my = motion_y / 4;
1422         uvsx = (2*mx) & s_mask;
1423         uvsy = (2*my) & s_mask;
1424         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1425         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1426     } else {
1427         mx = motion_x / 2;
1428         my = motion_y / 2;
1429         uvsx = mx & s_mask;
1430         uvsy = my & s_mask;
1431         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1432         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1433     }
1434
1435     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1436     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1437     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1438
1439     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1440        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1441             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1442                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1443             ptr_y = s->edge_emu_buffer;
1444             if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1445                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1446                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1447                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1448                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1449                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1450                 ptr_cb= uvbuf;
1451                 ptr_cr= uvbuf+16;
1452             }
1453     }
1454
1455     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1456         dest_y += s->linesize;
1457         dest_cb+= s->uvlinesize;
1458         dest_cr+= s->uvlinesize;
1459     }
1460
1461     if(field_select){
1462         ptr_y += s->linesize;
1463         ptr_cb+= s->uvlinesize;
1464         ptr_cr+= s->uvlinesize;
1465     }
1466
1467     sx <<= 2 - lowres;
1468     sy <<= 2 - lowres;
1469     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1470
1471     if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1472         uvsx <<= 2 - lowres;
1473         uvsy <<= 2 - lowres;
1474         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1475         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1476     }
1477     //FIXME h261 lowres loop filter
1478 }
1479
1480 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1481                                      uint8_t *dest_cb, uint8_t *dest_cr,
1482                                      uint8_t **ref_picture,
1483                                      h264_chroma_mc_func *pix_op,
1484                                      int mx, int my){
1485     const int lowres= s->avctx->lowres;
1486     const int block_s= 8>>lowres;
1487     const int s_mask= (2<<lowres)-1;
1488     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1489     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1490     int emu=0, src_x, src_y, offset, sx, sy;
1491     uint8_t *ptr;
1492
1493     if(s->quarter_sample){
1494         mx/=2;
1495         my/=2;
1496     }
1497
1498     /* In case of 8X8, we construct a single chroma motion vector
1499        with a special rounding */
1500     mx= ff_h263_round_chroma(mx);
1501     my= ff_h263_round_chroma(my);
1502
1503     sx= mx & s_mask;
1504     sy= my & s_mask;
1505     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1506     src_y = s->mb_y*block_s + (my >> (lowres+1));
1507
1508     offset = src_y * s->uvlinesize + src_x;
1509     ptr = ref_picture[1] + offset;
1510     if(s->flags&CODEC_FLAG_EMU_EDGE){
1511         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1512            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1513             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1514             ptr= s->edge_emu_buffer;
1515             emu=1;
1516         }
1517     }
1518     sx <<= 2 - lowres;
1519     sy <<= 2 - lowres;
1520     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1521
1522     ptr = ref_picture[2] + offset;
1523     if(emu){
1524         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1525         ptr= s->edge_emu_buffer;
1526     }
1527     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1528 }
1529
1530 /**
1531  * motion compensation of a single macroblock
1532  * @param s context
1533  * @param dest_y luma destination pointer
1534  * @param dest_cb chroma cb/u destination pointer
1535  * @param dest_cr chroma cr/v destination pointer
1536  * @param dir direction (0->forward, 1->backward)
1537  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1538  * @param pic_op halfpel motion compensation function (average or put normally)
1539  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1540  */
1541 static inline void MPV_motion_lowres(MpegEncContext *s,
1542                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1543                               int dir, uint8_t **ref_picture,
1544                               h264_chroma_mc_func *pix_op)
1545 {
1546     int mx, my;
1547     int mb_x, mb_y, i;
1548     const int lowres= s->avctx->lowres;
1549     const int block_s= 8>>lowres;
1550
1551     mb_x = s->mb_x;
1552     mb_y = s->mb_y;
1553
1554     switch(s->mv_type) {
1555     case MV_TYPE_16X16:
1556         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1557                     0, 0, 0,
1558                     ref_picture, pix_op,
1559                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1560         break;
1561     case MV_TYPE_8X8:
1562         mx = 0;
1563         my = 0;
1564             for(i=0;i<4;i++) {
1565                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1566                             ref_picture[0], 0, 0,
1567                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1568                             s->width, s->height, s->linesize,
1569                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1570                             block_s, block_s, pix_op,
1571                             s->mv[dir][i][0], s->mv[dir][i][1]);
1572
1573                 mx += s->mv[dir][i][0];
1574                 my += s->mv[dir][i][1];
1575             }
1576
1577         if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1578             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1579         break;
1580     case MV_TYPE_FIELD:
1581         if (s->picture_structure == PICT_FRAME) {
1582             /* top field */
1583             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1584                         1, 0, s->field_select[dir][0],
1585                         ref_picture, pix_op,
1586                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1587             /* bottom field */
1588             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1589                         1, 1, s->field_select[dir][1],
1590                         ref_picture, pix_op,
1591                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1592         } else {
1593             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1594                 ref_picture= s->current_picture_ptr->data;
1595             }
1596
1597             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1598                         0, 0, s->field_select[dir][0],
1599                         ref_picture, pix_op,
1600                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1601         }
1602         break;
1603     case MV_TYPE_16X8:
1604         for(i=0; i<2; i++){
1605             uint8_t ** ref2picture;
1606
1607             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1608                 ref2picture= ref_picture;
1609             }else{
1610                 ref2picture= s->current_picture_ptr->data;
1611             }
1612
1613             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1614                         0, 0, s->field_select[dir][i],
1615                         ref2picture, pix_op,
1616                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1617
1618             dest_y += 2*block_s*s->linesize;
1619             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1620             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1621         }
1622         break;
1623     case MV_TYPE_DMV:
1624         if(s->picture_structure == PICT_FRAME){
1625             for(i=0; i<2; i++){
1626                 int j;
1627                 for(j=0; j<2; j++){
1628                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1629                                 1, j, j^i,
1630                                 ref_picture, pix_op,
1631                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1632                 }
1633                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1634             }
1635         }else{
1636             for(i=0; i<2; i++){
1637                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1638                             0, 0, s->picture_structure != i+1,
1639                             ref_picture, pix_op,
1640                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1641
1642                 // after put we make avg of the same block
1643                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1644
1645                 //opposite parity is always in the same frame if this is second field
1646                 if(!s->first_field){
1647                     ref_picture = s->current_picture_ptr->data;
1648                 }
1649             }
1650         }
1651     break;
1652     default: assert(0);
1653     }
1654 }
1655
1656 /* put block[] to dest[] */
1657 static inline void put_dct(MpegEncContext *s,
1658                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1659 {
1660     s->dct_unquantize_intra(s, block, i, qscale);
1661     s->dsp.idct_put (dest, line_size, block);
1662 }
1663
1664 /* add block[] to dest[] */
1665 static inline void add_dct(MpegEncContext *s,
1666                            DCTELEM *block, int i, uint8_t *dest, int line_size)
1667 {
1668     if (s->block_last_index[i] >= 0) {
1669         s->dsp.idct_add (dest, line_size, block);
1670     }
1671 }
1672
1673 static inline void add_dequant_dct(MpegEncContext *s,
1674                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1675 {
1676     if (s->block_last_index[i] >= 0) {
1677         s->dct_unquantize_inter(s, block, i, qscale);
1678
1679         s->dsp.idct_add (dest, line_size, block);
1680     }
1681 }
1682
1683 /**
1684  * cleans dc, ac, coded_block for the current non intra MB
1685  */
1686 void ff_clean_intra_table_entries(MpegEncContext *s)
1687 {
1688     int wrap = s->b8_stride;
1689     int xy = s->block_index[0];
1690
1691     s->dc_val[0][xy           ] =
1692     s->dc_val[0][xy + 1       ] =
1693     s->dc_val[0][xy     + wrap] =
1694     s->dc_val[0][xy + 1 + wrap] = 1024;
1695     /* ac pred */
1696     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1697     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1698     if (s->msmpeg4_version>=3) {
1699         s->coded_block[xy           ] =
1700         s->coded_block[xy + 1       ] =
1701         s->coded_block[xy     + wrap] =
1702         s->coded_block[xy + 1 + wrap] = 0;
1703     }
1704     /* chroma */
1705     wrap = s->mb_stride;
1706     xy = s->mb_x + s->mb_y * wrap;
1707     s->dc_val[1][xy] =
1708     s->dc_val[2][xy] = 1024;
1709     /* ac pred */
1710     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1711     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1712
1713     s->mbintra_table[xy]= 0;
1714 }
1715
1716 /* generic function called after a macroblock has been parsed by the
1717    decoder or after it has been encoded by the encoder.
1718
1719    Important variables used:
1720    s->mb_intra : true if intra macroblock
1721    s->mv_dir   : motion vector direction
1722    s->mv_type  : motion vector type
1723    s->mv       : motion vector
1724    s->interlaced_dct : true if interlaced dct used (mpeg2)
1725  */
1726 static av_always_inline
1727 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1728                             int lowres_flag, int is_mpeg12)
1729 {
1730     int mb_x, mb_y;
1731     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1732 #ifdef HAVE_XVMC
1733     if(s->avctx->xvmc_acceleration){
1734         XVMC_decode_mb(s);//xvmc uses pblocks
1735         return;
1736     }
1737 #endif
1738
1739     mb_x = s->mb_x;
1740     mb_y = s->mb_y;
1741
1742     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1743        /* save DCT coefficients */
1744        int i,j;
1745        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1746        for(i=0; i<6; i++)
1747            for(j=0; j<64; j++)
1748                *dct++ = block[i][s->dsp.idct_permutation[j]];
1749     }
1750
1751     s->current_picture.qscale_table[mb_xy]= s->qscale;
1752
1753     /* update DC predictors for P macroblocks */
1754     if (!s->mb_intra) {
1755         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1756             if(s->mbintra_table[mb_xy])
1757                 ff_clean_intra_table_entries(s);
1758         } else {
1759             s->last_dc[0] =
1760             s->last_dc[1] =
1761             s->last_dc[2] = 128 << s->intra_dc_precision;
1762         }
1763     }
1764     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1765         s->mbintra_table[mb_xy]=1;
1766
1767     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1768         uint8_t *dest_y, *dest_cb, *dest_cr;
1769         int dct_linesize, dct_offset;
1770         op_pixels_func (*op_pix)[4];
1771         qpel_mc_func (*op_qpix)[16];
1772         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1773         const int uvlinesize= s->current_picture.linesize[1];
1774         const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1775         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1776
1777         /* avoid copy if macroblock skipped in last frame too */
1778         /* skip only during decoding as we might trash the buffers during encoding a bit */
1779         if(!s->encoding){
1780             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1781             const int age= s->current_picture.age;
1782
1783             assert(age);
1784
1785             if (s->mb_skipped) {
1786                 s->mb_skipped= 0;
1787                 assert(s->pict_type!=FF_I_TYPE);
1788
1789                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1790                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1791
1792                 /* if previous was skipped too, then nothing to do !  */
1793                 if (*mbskip_ptr >= age && s->current_picture.reference){
1794                     return;
1795                 }
1796             } else if(!s->current_picture.reference){
1797                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1798                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1799             } else{
1800                 *mbskip_ptr = 0; /* not skipped */
1801             }
1802         }
1803
1804         dct_linesize = linesize << s->interlaced_dct;
1805         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1806
1807         if(readable){
1808             dest_y=  s->dest[0];
1809             dest_cb= s->dest[1];
1810             dest_cr= s->dest[2];
1811         }else{
1812             dest_y = s->b_scratchpad;
1813             dest_cb= s->b_scratchpad+16*linesize;
1814             dest_cr= s->b_scratchpad+32*linesize;
1815         }
1816
1817         if (!s->mb_intra) {
1818             /* motion handling */
1819             /* decoding or more than one mb_type (MC was already done otherwise) */
1820             if(!s->encoding){
1821                 if(lowres_flag){
1822                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1823
1824                     if (s->mv_dir & MV_DIR_FORWARD) {
1825                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1826                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1827                     }
1828                     if (s->mv_dir & MV_DIR_BACKWARD) {
1829                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1830                     }
1831                 }else{
1832                     op_qpix= s->me.qpel_put;
1833                     if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1834                         op_pix = s->dsp.put_pixels_tab;
1835                     }else{
1836                         op_pix = s->dsp.put_no_rnd_pixels_tab;
1837                     }
1838                     if (s->mv_dir & MV_DIR_FORWARD) {
1839                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1840                         op_pix = s->dsp.avg_pixels_tab;
1841                         op_qpix= s->me.qpel_avg;
1842                     }
1843                     if (s->mv_dir & MV_DIR_BACKWARD) {
1844                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1845                     }
1846                 }
1847             }
1848
1849             /* skip dequant / idct if we are really late ;) */
1850             if(s->hurry_up>1) goto skip_idct;
1851             if(s->avctx->skip_idct){
1852                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1853                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1854                    || s->avctx->skip_idct >= AVDISCARD_ALL)
1855                     goto skip_idct;
1856             }
1857
1858             /* add dct residue */
1859             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1860                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1861                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1862                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1863                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1864                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1865
1866                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1867                     if (s->chroma_y_shift){
1868                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1869                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1870                     }else{
1871                         dct_linesize >>= 1;
1872                         dct_offset >>=1;
1873                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1874                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1875                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1876                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1877                     }
1878                 }
1879             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1880                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1881                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1882                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1883                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1884
1885                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1886                     if(s->chroma_y_shift){//Chroma420
1887                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
1888                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
1889                     }else{
1890                         //chroma422
1891                         dct_linesize = uvlinesize << s->interlaced_dct;
1892                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1893
1894                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
1895                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
1896                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1897                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1898                         if(!s->chroma_x_shift){//Chroma444
1899                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1900                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1901                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1902                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1903                         }
1904                     }
1905                 }//fi gray
1906             }
1907             else if (ENABLE_WMV2) {
1908                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1909             }
1910         } else {
1911             /* dct only in intra block */
1912             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1913                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1914                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1915                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1916                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1917
1918                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1919                     if(s->chroma_y_shift){
1920                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1921                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1922                     }else{
1923                         dct_offset >>=1;
1924                         dct_linesize >>=1;
1925                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1926                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1927                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1928                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1929                     }
1930                 }
1931             }else{
1932                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1933                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1934                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1935                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1936
1937                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1938                     if(s->chroma_y_shift){
1939                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1940                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1941                     }else{
1942
1943                         dct_linesize = uvlinesize << s->interlaced_dct;
1944                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1945
1946                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1947                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1948                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1949                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1950                         if(!s->chroma_x_shift){//Chroma444
1951                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1952                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
1953                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1954                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1955                         }
1956                     }
1957                 }//gray
1958             }
1959         }
1960 skip_idct:
1961         if(!readable){
1962             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
1963             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1964             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1965         }
1966     }
1967 }
1968
1969 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1970 #ifndef CONFIG_SMALL
1971     if(s->out_format == FMT_MPEG1) {
1972         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1973         else                 MPV_decode_mb_internal(s, block, 0, 1);
1974     } else
1975 #endif
1976     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1977     else                  MPV_decode_mb_internal(s, block, 0, 0);
1978 }
1979
1980 /**
1981  *
1982  * @param h is the normal height, this will be reduced automatically if needed for the last row
1983  */
1984 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1985     if (s->avctx->draw_horiz_band) {
1986         AVFrame *src;
1987         int offset[4];
1988
1989         if(s->picture_structure != PICT_FRAME){
1990             h <<= 1;
1991             y <<= 1;
1992             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1993         }
1994
1995         h= FFMIN(h, s->avctx->height - y);
1996
1997         if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
1998             src= (AVFrame*)s->current_picture_ptr;
1999         else if(s->last_picture_ptr)
2000             src= (AVFrame*)s->last_picture_ptr;
2001         else
2002             return;
2003
2004         if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2005             offset[0]=
2006             offset[1]=
2007             offset[2]=
2008             offset[3]= 0;
2009         }else{
2010             offset[0]= y * s->linesize;
2011             offset[1]=
2012             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2013             offset[3]= 0;
2014         }
2015
2016         emms_c();
2017
2018         s->avctx->draw_horiz_band(s->avctx, src, offset,
2019                                   y, s->picture_structure, h);
2020     }
2021 }
2022
2023 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2024     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2025     const int uvlinesize= s->current_picture.linesize[1];
2026     const int mb_size= 4 - s->avctx->lowres;
2027
2028     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2029     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2030     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2031     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2032     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2033     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;
2034     //block_index is not used by mpeg2, so it is not affected by chroma_format
2035
2036     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2037     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2038     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2039
2040     if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2041     {
2042         s->dest[0] += s->mb_y *   linesize << mb_size;
2043         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2044         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2045     }
2046 }
2047
2048 void ff_mpeg_flush(AVCodecContext *avctx){
2049     int i;
2050     MpegEncContext *s = avctx->priv_data;
2051
2052     if(s==NULL || s->picture==NULL)
2053         return;
2054
2055     for(i=0; i<MAX_PICTURE_COUNT; i++){
2056        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2057                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2058         avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2059     }
2060     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2061
2062     s->mb_x= s->mb_y= 0;
2063
2064     s->parse_context.state= -1;
2065     s->parse_context.frame_start_found= 0;
2066     s->parse_context.overread= 0;
2067     s->parse_context.overread_index= 0;
2068     s->parse_context.index= 0;
2069     s->parse_context.last_index= 0;
2070     s->bitstream_buffer_size=0;
2071     s->pp_time=0;
2072 }
2073
2074 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2075                                    DCTELEM *block, int n, int qscale)
2076 {
2077     int i, level, nCoeffs;
2078     const uint16_t *quant_matrix;
2079
2080     nCoeffs= s->block_last_index[n];
2081
2082     if (n < 4)
2083         block[0] = block[0] * s->y_dc_scale;
2084     else
2085         block[0] = block[0] * s->c_dc_scale;
2086     /* XXX: only mpeg1 */
2087     quant_matrix = s->intra_matrix;
2088     for(i=1;i<=nCoeffs;i++) {
2089         int j= s->intra_scantable.permutated[i];
2090         level = block[j];
2091         if (level) {
2092             if (level < 0) {
2093                 level = -level;
2094                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2095                 level = (level - 1) | 1;
2096                 level = -level;
2097             } else {
2098                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2099                 level = (level - 1) | 1;
2100             }
2101             block[j] = level;
2102         }
2103     }
2104 }
2105
2106 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2107                                    DCTELEM *block, int n, int qscale)
2108 {
2109     int i, level, nCoeffs;
2110     const uint16_t *quant_matrix;
2111
2112     nCoeffs= s->block_last_index[n];
2113
2114     quant_matrix = s->inter_matrix;
2115     for(i=0; i<=nCoeffs; i++) {
2116         int j= s->intra_scantable.permutated[i];
2117         level = block[j];
2118         if (level) {
2119             if (level < 0) {
2120                 level = -level;
2121                 level = (((level << 1) + 1) * qscale *
2122                          ((int) (quant_matrix[j]))) >> 4;
2123                 level = (level - 1) | 1;
2124                 level = -level;
2125             } else {
2126                 level = (((level << 1) + 1) * qscale *
2127                          ((int) (quant_matrix[j]))) >> 4;
2128                 level = (level - 1) | 1;
2129             }
2130             block[j] = level;
2131         }
2132     }
2133 }
2134
2135 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2136                                    DCTELEM *block, int n, int qscale)
2137 {
2138     int i, level, nCoeffs;
2139     const uint16_t *quant_matrix;
2140
2141     if(s->alternate_scan) nCoeffs= 63;
2142     else nCoeffs= s->block_last_index[n];
2143
2144     if (n < 4)
2145         block[0] = block[0] * s->y_dc_scale;
2146     else
2147         block[0] = block[0] * s->c_dc_scale;
2148     quant_matrix = s->intra_matrix;
2149     for(i=1;i<=nCoeffs;i++) {
2150         int j= s->intra_scantable.permutated[i];
2151         level = block[j];
2152         if (level) {
2153             if (level < 0) {
2154                 level = -level;
2155                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2156                 level = -level;
2157             } else {
2158                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2159             }
2160             block[j] = level;
2161         }
2162     }
2163 }
2164
2165 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2166                                    DCTELEM *block, int n, int qscale)
2167 {
2168     int i, level, nCoeffs;
2169     const uint16_t *quant_matrix;
2170     int sum=-1;
2171
2172     if(s->alternate_scan) nCoeffs= 63;
2173     else nCoeffs= s->block_last_index[n];
2174
2175     if (n < 4)
2176         block[0] = block[0] * s->y_dc_scale;
2177     else
2178         block[0] = block[0] * s->c_dc_scale;
2179     quant_matrix = s->intra_matrix;
2180     for(i=1;i<=nCoeffs;i++) {
2181         int j= s->intra_scantable.permutated[i];
2182         level = block[j];
2183         if (level) {
2184             if (level < 0) {
2185                 level = -level;
2186                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2187                 level = -level;
2188             } else {
2189                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2190             }
2191             block[j] = level;
2192             sum+=level;
2193         }
2194     }
2195     block[63]^=sum&1;
2196 }
2197
2198 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2199                                    DCTELEM *block, int n, int qscale)
2200 {
2201     int i, level, nCoeffs;
2202     const uint16_t *quant_matrix;
2203     int sum=-1;
2204
2205     if(s->alternate_scan) nCoeffs= 63;
2206     else nCoeffs= s->block_last_index[n];
2207
2208     quant_matrix = s->inter_matrix;
2209     for(i=0; i<=nCoeffs; i++) {
2210         int j= s->intra_scantable.permutated[i];
2211         level = block[j];
2212         if (level) {
2213             if (level < 0) {
2214                 level = -level;
2215                 level = (((level << 1) + 1) * qscale *
2216                          ((int) (quant_matrix[j]))) >> 4;
2217                 level = -level;
2218             } else {
2219                 level = (((level << 1) + 1) * qscale *
2220                          ((int) (quant_matrix[j]))) >> 4;
2221             }
2222             block[j] = level;
2223             sum+=level;
2224         }
2225     }
2226     block[63]^=sum&1;
2227 }
2228
2229 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2230                                   DCTELEM *block, int n, int qscale)
2231 {
2232     int i, level, qmul, qadd;
2233     int nCoeffs;
2234
2235     assert(s->block_last_index[n]>=0);
2236
2237     qmul = qscale << 1;
2238
2239     if (!s->h263_aic) {
2240         if (n < 4)
2241             block[0] = block[0] * s->y_dc_scale;
2242         else
2243             block[0] = block[0] * s->c_dc_scale;
2244         qadd = (qscale - 1) | 1;
2245     }else{
2246         qadd = 0;
2247     }
2248     if(s->ac_pred)
2249         nCoeffs=63;
2250     else
2251         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2252
2253     for(i=1; i<=nCoeffs; i++) {
2254         level = block[i];
2255         if (level) {
2256             if (level < 0) {
2257                 level = level * qmul - qadd;
2258             } else {
2259                 level = level * qmul + qadd;
2260             }
2261             block[i] = level;
2262         }
2263     }
2264 }
2265
2266 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2267                                   DCTELEM *block, int n, int qscale)
2268 {
2269     int i, level, qmul, qadd;
2270     int nCoeffs;
2271
2272     assert(s->block_last_index[n]>=0);
2273
2274     qadd = (qscale - 1) | 1;
2275     qmul = qscale << 1;
2276
2277     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2278
2279     for(i=0; i<=nCoeffs; i++) {
2280         level = block[i];
2281         if (level) {
2282             if (level < 0) {
2283                 level = level * qmul - qadd;
2284             } else {
2285                 level = level * qmul + qadd;
2286             }
2287             block[i] = level;
2288         }
2289     }
2290 }
2291
2292 /**
2293  * set qscale and update qscale dependent variables.
2294  */
2295 void ff_set_qscale(MpegEncContext * s, int qscale)
2296 {
2297     if (qscale < 1)
2298         qscale = 1;
2299     else if (qscale > 31)
2300         qscale = 31;
2301
2302     s->qscale = qscale;
2303     s->chroma_qscale= s->chroma_qscale_table[qscale];
2304
2305     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2306     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2307 }