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