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