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