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