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