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