41ad43c158c9f1c346677511fb8a7453252bedb9
[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
954     if(!(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
955        && s->unrestricted_mv
956        && s->current_picture.reference
957        && !s->intra_only
958        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
959             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
960             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
961             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
962     }
963     emms_c();
964
965     s->last_pict_type    = s->pict_type;
966     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
967     if(s->pict_type!=FF_B_TYPE){
968         s->last_non_b_pict_type= s->pict_type;
969     }
970 #if 0
971         /* copy back current_picture variables */
972     for(i=0; i<MAX_PICTURE_COUNT; i++){
973         if(s->picture[i].data[0] == s->current_picture.data[0]){
974             s->picture[i]= s->current_picture;
975             break;
976         }
977     }
978     assert(i<MAX_PICTURE_COUNT);
979 #endif
980
981     if(s->encoding){
982         /* release non-reference frames */
983         for(i=0; i<MAX_PICTURE_COUNT; i++){
984             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
985                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
986             }
987         }
988     }
989     // clear copies, to avoid confusion
990 #if 0
991     memset(&s->last_picture, 0, sizeof(Picture));
992     memset(&s->next_picture, 0, sizeof(Picture));
993     memset(&s->current_picture, 0, sizeof(Picture));
994 #endif
995     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
996 }
997
998 /**
999  * draws an line from (ex, ey) -> (sx, sy).
1000  * @param w width of the image
1001  * @param h height of the image
1002  * @param stride stride/linesize of the image
1003  * @param color color of the arrow
1004  */
1005 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1006     int x, y, fr, f;
1007
1008     sx= av_clip(sx, 0, w-1);
1009     sy= av_clip(sy, 0, h-1);
1010     ex= av_clip(ex, 0, w-1);
1011     ey= av_clip(ey, 0, h-1);
1012
1013     buf[sy*stride + sx]+= color;
1014
1015     if(FFABS(ex - sx) > FFABS(ey - sy)){
1016         if(sx > ex){
1017             FFSWAP(int, sx, ex);
1018             FFSWAP(int, sy, ey);
1019         }
1020         buf+= sx + sy*stride;
1021         ex-= sx;
1022         f= ((ey-sy)<<16)/ex;
1023         for(x= 0; x <= ex; x++){
1024             y = (x*f)>>16;
1025             fr= (x*f)&0xFFFF;
1026             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1027             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1028         }
1029     }else{
1030         if(sy > ey){
1031             FFSWAP(int, sx, ex);
1032             FFSWAP(int, sy, ey);
1033         }
1034         buf+= sx + sy*stride;
1035         ey-= sy;
1036         if(ey) f= ((ex-sx)<<16)/ey;
1037         else   f= 0;
1038         for(y= 0; y <= ey; y++){
1039             x = (y*f)>>16;
1040             fr= (y*f)&0xFFFF;
1041             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1042             buf[y*stride + x+1]+= (color*         fr )>>16;
1043         }
1044     }
1045 }
1046
1047 /**
1048  * draws an arrow from (ex, ey) -> (sx, sy).
1049  * @param w width of the image
1050  * @param h height of the image
1051  * @param stride stride/linesize of the image
1052  * @param color color of the arrow
1053  */
1054 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1055     int dx,dy;
1056
1057     sx= av_clip(sx, -100, w+100);
1058     sy= av_clip(sy, -100, h+100);
1059     ex= av_clip(ex, -100, w+100);
1060     ey= av_clip(ey, -100, h+100);
1061
1062     dx= ex - sx;
1063     dy= ey - sy;
1064
1065     if(dx*dx + dy*dy > 3*3){
1066         int rx=  dx + dy;
1067         int ry= -dx + dy;
1068         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1069
1070         //FIXME subpixel accuracy
1071         rx= ROUNDED_DIV(rx*3<<4, length);
1072         ry= ROUNDED_DIV(ry*3<<4, length);
1073
1074         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1075         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1076     }
1077     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1078 }
1079
1080 /**
1081  * prints debuging info for the given picture.
1082  */
1083 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1084
1085     if(!pict || !pict->mb_type) return;
1086
1087     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1088         int x,y;
1089
1090         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1091         switch (pict->pict_type) {
1092             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1093             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1094             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1095             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1096             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1097             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1098         }
1099         for(y=0; y<s->mb_height; y++){
1100             for(x=0; x<s->mb_width; x++){
1101                 if(s->avctx->debug&FF_DEBUG_SKIP){
1102                     int count= s->mbskip_table[x + y*s->mb_stride];
1103                     if(count>9) count=9;
1104                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1105                 }
1106                 if(s->avctx->debug&FF_DEBUG_QP){
1107                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1108                 }
1109                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1110                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1111                     //Type & MV direction
1112                     if(IS_PCM(mb_type))
1113                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1114                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1115                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1116                     else if(IS_INTRA4x4(mb_type))
1117                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1118                     else if(IS_INTRA16x16(mb_type))
1119                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1120                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1121                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1122                     else if(IS_DIRECT(mb_type))
1123                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1124                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1125                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1126                     else if(IS_GMC(mb_type))
1127                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1128                     else if(IS_SKIP(mb_type))
1129                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1130                     else if(!USES_LIST(mb_type, 1))
1131                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1132                     else if(!USES_LIST(mb_type, 0))
1133                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1134                     else{
1135                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1136                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1137                     }
1138
1139                     //segmentation
1140                     if(IS_8X8(mb_type))
1141                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1142                     else if(IS_16X8(mb_type))
1143                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1144                     else if(IS_8X16(mb_type))
1145                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1146                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1147                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1148                     else
1149                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1150
1151
1152                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1153                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1154                     else
1155                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1156                 }
1157 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1158             }
1159             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1160         }
1161     }
1162
1163     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1164         const int shift= 1 + s->quarter_sample;
1165         int mb_y;
1166         uint8_t *ptr;
1167         int i;
1168         int h_chroma_shift, v_chroma_shift, block_height;
1169         const int width = s->avctx->width;
1170         const int height= s->avctx->height;
1171         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1172         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1173         s->low_delay=0; //needed to see the vectors without trashing the buffers
1174
1175         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1176         for(i=0; i<3; i++){
1177             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1178             pict->data[i]= s->visualization_buffer[i];
1179         }
1180         pict->type= FF_BUFFER_TYPE_COPY;
1181         ptr= pict->data[0];
1182         block_height = 16>>v_chroma_shift;
1183
1184         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1185             int mb_x;
1186             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1187                 const int mb_index= mb_x + mb_y*s->mb_stride;
1188                 if((s->avctx->debug_mv) && pict->motion_val){
1189                   int type;
1190                   for(type=0; type<3; type++){
1191                     int direction = 0;
1192                     switch (type) {
1193                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1194                                 continue;
1195                               direction = 0;
1196                               break;
1197                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1198                                 continue;
1199                               direction = 0;
1200                               break;
1201                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1202                                 continue;
1203                               direction = 1;
1204                               break;
1205                     }
1206                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1207                         continue;
1208
1209                     if(IS_8X8(pict->mb_type[mb_index])){
1210                       int i;
1211                       for(i=0; i<4; i++){
1212                         int sx= mb_x*16 + 4 + 8*(i&1);
1213                         int sy= mb_y*16 + 4 + 8*(i>>1);
1214                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1215                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1216                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1217                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1218                       }
1219                     }else if(IS_16X8(pict->mb_type[mb_index])){
1220                       int i;
1221                       for(i=0; i<2; i++){
1222                         int sx=mb_x*16 + 8;
1223                         int sy=mb_y*16 + 4 + 8*i;
1224                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1225                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1226                         int my=(pict->motion_val[direction][xy][1]>>shift);
1227
1228                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1229                             my*=2;
1230
1231                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1232                       }
1233                     }else if(IS_8X16(pict->mb_type[mb_index])){
1234                       int i;
1235                       for(i=0; i<2; i++){
1236                         int sx=mb_x*16 + 4 + 8*i;
1237                         int sy=mb_y*16 + 8;
1238                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1239                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1240                         int my=(pict->motion_val[direction][xy][1]>>shift);
1241
1242                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1243                             my*=2;
1244
1245                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1246                       }
1247                     }else{
1248                       int sx= mb_x*16 + 8;
1249                       int sy= mb_y*16 + 8;
1250                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1251                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1252                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1253                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1254                     }
1255                   }
1256                 }
1257                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1258                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1259                     int y;
1260                     for(y=0; y<block_height; y++){
1261                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1262                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1263                     }
1264                 }
1265                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1266                     int mb_type= pict->mb_type[mb_index];
1267                     uint64_t u,v;
1268                     int y;
1269 #define COLOR(theta, r)\
1270 u= (int)(128 + r*cos(theta*3.141592/180));\
1271 v= (int)(128 + r*sin(theta*3.141592/180));
1272
1273
1274                     u=v=128;
1275                     if(IS_PCM(mb_type)){
1276                         COLOR(120,48)
1277                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1278                         COLOR(30,48)
1279                     }else if(IS_INTRA4x4(mb_type)){
1280                         COLOR(90,48)
1281                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1282 //                        COLOR(120,48)
1283                     }else if(IS_DIRECT(mb_type)){
1284                         COLOR(150,48)
1285                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1286                         COLOR(170,48)
1287                     }else if(IS_GMC(mb_type)){
1288                         COLOR(190,48)
1289                     }else if(IS_SKIP(mb_type)){
1290 //                        COLOR(180,48)
1291                     }else if(!USES_LIST(mb_type, 1)){
1292                         COLOR(240,48)
1293                     }else if(!USES_LIST(mb_type, 0)){
1294                         COLOR(0,48)
1295                     }else{
1296                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1297                         COLOR(300,48)
1298                     }
1299
1300                     u*= 0x0101010101010101ULL;
1301                     v*= 0x0101010101010101ULL;
1302                     for(y=0; y<block_height; y++){
1303                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1304                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1305                     }
1306
1307                     //segmentation
1308                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1309                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1310                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1311                     }
1312                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1313                         for(y=0; y<16; y++)
1314                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1315                     }
1316                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1317                         int dm= 1 << (mv_sample_log2-2);
1318                         for(i=0; i<4; i++){
1319                             int sx= mb_x*16 + 8*(i&1);
1320                             int sy= mb_y*16 + 8*(i>>1);
1321                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1322                             //FIXME bidir
1323                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1324                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1325                                 for(y=0; y<8; y++)
1326                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1327                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1328                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1329                         }
1330                     }
1331
1332                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1333                         // hmm
1334                     }
1335                 }
1336                 s->mbskip_table[mb_index]=0;
1337             }
1338         }
1339     }
1340 }
1341
1342 static inline int hpel_motion_lowres(MpegEncContext *s,
1343                                   uint8_t *dest, uint8_t *src,
1344                                   int field_based, int field_select,
1345                                   int src_x, int src_y,
1346                                   int width, int height, int stride,
1347                                   int h_edge_pos, int v_edge_pos,
1348                                   int w, int h, h264_chroma_mc_func *pix_op,
1349                                   int motion_x, int motion_y)
1350 {
1351     const int lowres= s->avctx->lowres;
1352     const int s_mask= (2<<lowres)-1;
1353     int emu=0;
1354     int sx, sy;
1355
1356     if(s->quarter_sample){
1357         motion_x/=2;
1358         motion_y/=2;
1359     }
1360
1361     sx= motion_x & s_mask;
1362     sy= motion_y & s_mask;
1363     src_x += motion_x >> (lowres+1);
1364     src_y += motion_y >> (lowres+1);
1365
1366     src += src_y * stride + src_x;
1367
1368     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1369        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1370         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1371                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1372         src= s->edge_emu_buffer;
1373         emu=1;
1374     }
1375
1376     sx <<= 2 - lowres;
1377     sy <<= 2 - lowres;
1378     if(field_select)
1379         src += s->linesize;
1380     pix_op[lowres](dest, src, stride, h, sx, sy);
1381     return emu;
1382 }
1383
1384 /* apply one mpeg motion vector to the three components */
1385 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1386                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1387                                int field_based, int bottom_field, int field_select,
1388                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1389                                int motion_x, int motion_y, int h)
1390 {
1391     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1392     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1393     const int lowres= s->avctx->lowres;
1394     const int block_s= 8>>lowres;
1395     const int s_mask= (2<<lowres)-1;
1396     const int h_edge_pos = s->h_edge_pos >> lowres;
1397     const int v_edge_pos = s->v_edge_pos >> lowres;
1398     linesize   = s->current_picture.linesize[0] << field_based;
1399     uvlinesize = s->current_picture.linesize[1] << field_based;
1400
1401     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1402         motion_x/=2;
1403         motion_y/=2;
1404     }
1405
1406     if(field_based){
1407         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1408     }
1409
1410     sx= motion_x & s_mask;
1411     sy= motion_y & s_mask;
1412     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1413     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1414
1415     if (s->out_format == FMT_H263) {
1416         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1417         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1418         uvsrc_x = src_x>>1;
1419         uvsrc_y = src_y>>1;
1420     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1421         mx = motion_x / 4;
1422         my = motion_y / 4;
1423         uvsx = (2*mx) & s_mask;
1424         uvsy = (2*my) & s_mask;
1425         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1426         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1427     } else {
1428         mx = motion_x / 2;
1429         my = motion_y / 2;
1430         uvsx = mx & s_mask;
1431         uvsy = my & s_mask;
1432         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1433         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1434     }
1435
1436     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1437     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1438     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1439
1440     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1441        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1442             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1443                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1444             ptr_y = s->edge_emu_buffer;
1445             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1446                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1447                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1448                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1449                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1450                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1451                 ptr_cb= uvbuf;
1452                 ptr_cr= uvbuf+16;
1453             }
1454     }
1455
1456     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1457         dest_y += s->linesize;
1458         dest_cb+= s->uvlinesize;
1459         dest_cr+= s->uvlinesize;
1460     }
1461
1462     if(field_select){
1463         ptr_y += s->linesize;
1464         ptr_cb+= s->uvlinesize;
1465         ptr_cr+= s->uvlinesize;
1466     }
1467
1468     sx <<= 2 - lowres;
1469     sy <<= 2 - lowres;
1470     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1471
1472     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1473         uvsx <<= 2 - lowres;
1474         uvsy <<= 2 - lowres;
1475         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1476         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1477     }
1478     //FIXME h261 lowres loop filter
1479 }
1480
1481 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1482                                      uint8_t *dest_cb, uint8_t *dest_cr,
1483                                      uint8_t **ref_picture,
1484                                      h264_chroma_mc_func *pix_op,
1485                                      int mx, int my){
1486     const int lowres= s->avctx->lowres;
1487     const int block_s= 8>>lowres;
1488     const int s_mask= (2<<lowres)-1;
1489     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1490     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1491     int emu=0, src_x, src_y, offset, sx, sy;
1492     uint8_t *ptr;
1493
1494     if(s->quarter_sample){
1495         mx/=2;
1496         my/=2;
1497     }
1498
1499     /* In case of 8X8, we construct a single chroma motion vector
1500        with a special rounding */
1501     mx= ff_h263_round_chroma(mx);
1502     my= ff_h263_round_chroma(my);
1503
1504     sx= mx & s_mask;
1505     sy= my & s_mask;
1506     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1507     src_y = s->mb_y*block_s + (my >> (lowres+1));
1508
1509     offset = src_y * s->uvlinesize + src_x;
1510     ptr = ref_picture[1] + offset;
1511     if(s->flags&CODEC_FLAG_EMU_EDGE){
1512         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1513            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1514             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1515             ptr= s->edge_emu_buffer;
1516             emu=1;
1517         }
1518     }
1519     sx <<= 2 - lowres;
1520     sy <<= 2 - lowres;
1521     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1522
1523     ptr = ref_picture[2] + offset;
1524     if(emu){
1525         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1526         ptr= s->edge_emu_buffer;
1527     }
1528     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1529 }
1530
1531 /**
1532  * motion compensation of a single macroblock
1533  * @param s context
1534  * @param dest_y luma destination pointer
1535  * @param dest_cb chroma cb/u destination pointer
1536  * @param dest_cr chroma cr/v destination pointer
1537  * @param dir direction (0->forward, 1->backward)
1538  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1539  * @param pic_op halfpel motion compensation function (average or put normally)
1540  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1541  */
1542 static inline void MPV_motion_lowres(MpegEncContext *s,
1543                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1544                               int dir, uint8_t **ref_picture,
1545                               h264_chroma_mc_func *pix_op)
1546 {
1547     int mx, my;
1548     int mb_x, mb_y, i;
1549     const int lowres= s->avctx->lowres;
1550     const int block_s= 8>>lowres;
1551
1552     mb_x = s->mb_x;
1553     mb_y = s->mb_y;
1554
1555     switch(s->mv_type) {
1556     case MV_TYPE_16X16:
1557         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1558                     0, 0, 0,
1559                     ref_picture, pix_op,
1560                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1561         break;
1562     case MV_TYPE_8X8:
1563         mx = 0;
1564         my = 0;
1565             for(i=0;i<4;i++) {
1566                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1567                             ref_picture[0], 0, 0,
1568                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1569                             s->width, s->height, s->linesize,
1570                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1571                             block_s, block_s, pix_op,
1572                             s->mv[dir][i][0], s->mv[dir][i][1]);
1573
1574                 mx += s->mv[dir][i][0];
1575                 my += s->mv[dir][i][1];
1576             }
1577
1578         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1579             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1580         break;
1581     case MV_TYPE_FIELD:
1582         if (s->picture_structure == PICT_FRAME) {
1583             /* top field */
1584             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1585                         1, 0, s->field_select[dir][0],
1586                         ref_picture, pix_op,
1587                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1588             /* bottom field */
1589             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1590                         1, 1, s->field_select[dir][1],
1591                         ref_picture, pix_op,
1592                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1593         } else {
1594             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1595                 ref_picture= s->current_picture_ptr->data;
1596             }
1597
1598             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1599                         0, 0, s->field_select[dir][0],
1600                         ref_picture, pix_op,
1601                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1602         }
1603         break;
1604     case MV_TYPE_16X8:
1605         for(i=0; i<2; i++){
1606             uint8_t ** ref2picture;
1607
1608             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1609                 ref2picture= ref_picture;
1610             }else{
1611                 ref2picture= s->current_picture_ptr->data;
1612             }
1613
1614             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1615                         0, 0, s->field_select[dir][i],
1616                         ref2picture, pix_op,
1617                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1618
1619             dest_y += 2*block_s*s->linesize;
1620             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1621             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1622         }
1623         break;
1624     case MV_TYPE_DMV:
1625         if(s->picture_structure == PICT_FRAME){
1626             for(i=0; i<2; i++){
1627                 int j;
1628                 for(j=0; j<2; j++){
1629                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1630                                 1, j, j^i,
1631                                 ref_picture, pix_op,
1632                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1633                 }
1634                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1635             }
1636         }else{
1637             for(i=0; i<2; i++){
1638                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1639                             0, 0, s->picture_structure != i+1,
1640                             ref_picture, pix_op,
1641                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1642
1643                 // after put we make avg of the same block
1644                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1645
1646                 //opposite parity is always in the same frame if this is second field
1647                 if(!s->first_field){
1648                     ref_picture = s->current_picture_ptr->data;
1649                 }
1650             }
1651         }
1652     break;
1653     default: assert(0);
1654     }
1655 }
1656
1657 /* put block[] to dest[] */
1658 static inline void put_dct(MpegEncContext *s,
1659                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1660 {
1661     s->dct_unquantize_intra(s, block, i, qscale);
1662     s->dsp.idct_put (dest, line_size, block);
1663 }
1664
1665 /* add block[] to dest[] */
1666 static inline void add_dct(MpegEncContext *s,
1667                            DCTELEM *block, int i, uint8_t *dest, int line_size)
1668 {
1669     if (s->block_last_index[i] >= 0) {
1670         s->dsp.idct_add (dest, line_size, block);
1671     }
1672 }
1673
1674 static inline void add_dequant_dct(MpegEncContext *s,
1675                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1676 {
1677     if (s->block_last_index[i] >= 0) {
1678         s->dct_unquantize_inter(s, block, i, qscale);
1679
1680         s->dsp.idct_add (dest, line_size, block);
1681     }
1682 }
1683
1684 /**
1685  * cleans dc, ac, coded_block for the current non intra MB
1686  */
1687 void ff_clean_intra_table_entries(MpegEncContext *s)
1688 {
1689     int wrap = s->b8_stride;
1690     int xy = s->block_index[0];
1691
1692     s->dc_val[0][xy           ] =
1693     s->dc_val[0][xy + 1       ] =
1694     s->dc_val[0][xy     + wrap] =
1695     s->dc_val[0][xy + 1 + wrap] = 1024;
1696     /* ac pred */
1697     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1698     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1699     if (s->msmpeg4_version>=3) {
1700         s->coded_block[xy           ] =
1701         s->coded_block[xy + 1       ] =
1702         s->coded_block[xy     + wrap] =
1703         s->coded_block[xy + 1 + wrap] = 0;
1704     }
1705     /* chroma */
1706     wrap = s->mb_stride;
1707     xy = s->mb_x + s->mb_y * wrap;
1708     s->dc_val[1][xy] =
1709     s->dc_val[2][xy] = 1024;
1710     /* ac pred */
1711     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1712     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1713
1714     s->mbintra_table[xy]= 0;
1715 }
1716
1717 /* generic function called after a macroblock has been parsed by the
1718    decoder or after it has been encoded by the encoder.
1719
1720    Important variables used:
1721    s->mb_intra : true if intra macroblock
1722    s->mv_dir   : motion vector direction
1723    s->mv_type  : motion vector type
1724    s->mv       : motion vector
1725    s->interlaced_dct : true if interlaced dct used (mpeg2)
1726  */
1727 static av_always_inline
1728 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1729                             int lowres_flag, int is_mpeg12)
1730 {
1731     int mb_x, mb_y;
1732     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1733     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1734         ff_xvmc_decode_mb(s);//xvmc uses pblocks
1735         return;
1736     }
1737
1738     mb_x = s->mb_x;
1739     mb_y = s->mb_y;
1740
1741     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1742        /* save DCT coefficients */
1743        int i,j;
1744        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1745        for(i=0; i<6; i++)
1746            for(j=0; j<64; j++)
1747                *dct++ = block[i][s->dsp.idct_permutation[j]];
1748     }
1749
1750     s->current_picture.qscale_table[mb_xy]= s->qscale;
1751
1752     /* update DC predictors for P macroblocks */
1753     if (!s->mb_intra) {
1754         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1755             if(s->mbintra_table[mb_xy])
1756                 ff_clean_intra_table_entries(s);
1757         } else {
1758             s->last_dc[0] =
1759             s->last_dc[1] =
1760             s->last_dc[2] = 128 << s->intra_dc_precision;
1761         }
1762     }
1763     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1764         s->mbintra_table[mb_xy]=1;
1765
1766     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
1767         uint8_t *dest_y, *dest_cb, *dest_cr;
1768         int dct_linesize, dct_offset;
1769         op_pixels_func (*op_pix)[4];
1770         qpel_mc_func (*op_qpix)[16];
1771         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1772         const int uvlinesize= s->current_picture.linesize[1];
1773         const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1774         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1775
1776         /* avoid copy if macroblock skipped in last frame too */
1777         /* skip only during decoding as we might trash the buffers during encoding a bit */
1778         if(!s->encoding){
1779             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1780             const int age= s->current_picture.age;
1781
1782             assert(age);
1783
1784             if (s->mb_skipped) {
1785                 s->mb_skipped= 0;
1786                 assert(s->pict_type!=FF_I_TYPE);
1787
1788                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1789                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1790
1791                 /* if previous was skipped too, then nothing to do !  */
1792                 if (*mbskip_ptr >= age && s->current_picture.reference){
1793                     return;
1794                 }
1795             } else if(!s->current_picture.reference){
1796                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1797                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1798             } else{
1799                 *mbskip_ptr = 0; /* not skipped */
1800             }
1801         }
1802
1803         dct_linesize = linesize << s->interlaced_dct;
1804         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1805
1806         if(readable){
1807             dest_y=  s->dest[0];
1808             dest_cb= s->dest[1];
1809             dest_cr= s->dest[2];
1810         }else{
1811             dest_y = s->b_scratchpad;
1812             dest_cb= s->b_scratchpad+16*linesize;
1813             dest_cr= s->b_scratchpad+32*linesize;
1814         }
1815
1816         if (!s->mb_intra) {
1817             /* motion handling */
1818             /* decoding or more than one mb_type (MC was already done otherwise) */
1819             if(!s->encoding){
1820                 if(lowres_flag){
1821                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1822
1823                     if (s->mv_dir & MV_DIR_FORWARD) {
1824                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1825                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1826                     }
1827                     if (s->mv_dir & MV_DIR_BACKWARD) {
1828                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1829                     }
1830                 }else{
1831                     op_qpix= s->me.qpel_put;
1832                     if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1833                         op_pix = s->dsp.put_pixels_tab;
1834                     }else{
1835                         op_pix = s->dsp.put_no_rnd_pixels_tab;
1836                     }
1837                     if (s->mv_dir & MV_DIR_FORWARD) {
1838                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1839                         op_pix = s->dsp.avg_pixels_tab;
1840                         op_qpix= s->me.qpel_avg;
1841                     }
1842                     if (s->mv_dir & MV_DIR_BACKWARD) {
1843                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1844                     }
1845                 }
1846             }
1847
1848             /* skip dequant / idct if we are really late ;) */
1849             if(s->hurry_up>1) goto skip_idct;
1850             if(s->avctx->skip_idct){
1851                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1852                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1853                    || s->avctx->skip_idct >= AVDISCARD_ALL)
1854                     goto skip_idct;
1855             }
1856
1857             /* add dct residue */
1858             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1859                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1860                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1861                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1862                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1863                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1864
1865                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1866                     if (s->chroma_y_shift){
1867                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1868                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1869                     }else{
1870                         dct_linesize >>= 1;
1871                         dct_offset >>=1;
1872                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1873                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1874                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1875                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1876                     }
1877                 }
1878             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1879                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1880                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1881                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1882                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1883
1884                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1885                     if(s->chroma_y_shift){//Chroma420
1886                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
1887                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
1888                     }else{
1889                         //chroma422
1890                         dct_linesize = uvlinesize << s->interlaced_dct;
1891                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1892
1893                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
1894                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
1895                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1896                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1897                         if(!s->chroma_x_shift){//Chroma444
1898                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1899                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1900                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1901                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1902                         }
1903                     }
1904                 }//fi gray
1905             }
1906             else if (CONFIG_WMV2) {
1907                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1908             }
1909         } else {
1910             /* dct only in intra block */
1911             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1912                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1913                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1914                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1915                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1916
1917                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1918                     if(s->chroma_y_shift){
1919                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1920                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1921                     }else{
1922                         dct_offset >>=1;
1923                         dct_linesize >>=1;
1924                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1925                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1926                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1927                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1928                     }
1929                 }
1930             }else{
1931                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1932                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1933                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1934                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1935
1936                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1937                     if(s->chroma_y_shift){
1938                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1939                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1940                     }else{
1941
1942                         dct_linesize = uvlinesize << s->interlaced_dct;
1943                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1944
1945                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1946                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1947                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1948                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1949                         if(!s->chroma_x_shift){//Chroma444
1950                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1951                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
1952                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1953                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1954                         }
1955                     }
1956                 }//gray
1957             }
1958         }
1959 skip_idct:
1960         if(!readable){
1961             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
1962             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1963             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1964         }
1965     }
1966 }
1967
1968 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1969 #if !CONFIG_SMALL
1970     if(s->out_format == FMT_MPEG1) {
1971         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1972         else                 MPV_decode_mb_internal(s, block, 0, 1);
1973     } else
1974 #endif
1975     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1976     else                  MPV_decode_mb_internal(s, block, 0, 0);
1977 }
1978
1979 /**
1980  *
1981  * @param h is the normal height, this will be reduced automatically if needed for the last row
1982  */
1983 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1984     if (s->avctx->draw_horiz_band) {
1985         AVFrame *src;
1986         int offset[4];
1987
1988         if(s->picture_structure != PICT_FRAME){
1989             h <<= 1;
1990             y <<= 1;
1991             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1992         }
1993
1994         h= FFMIN(h, s->avctx->height - y);
1995
1996         if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
1997             src= (AVFrame*)s->current_picture_ptr;
1998         else if(s->last_picture_ptr)
1999             src= (AVFrame*)s->last_picture_ptr;
2000         else
2001             return;
2002
2003         if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2004             offset[0]=
2005             offset[1]=
2006             offset[2]=
2007             offset[3]= 0;
2008         }else{
2009             offset[0]= y * s->linesize;
2010             offset[1]=
2011             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2012             offset[3]= 0;
2013         }
2014
2015         emms_c();
2016
2017         s->avctx->draw_horiz_band(s->avctx, src, offset,
2018                                   y, s->picture_structure, h);
2019     }
2020 }
2021
2022 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2023     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2024     const int uvlinesize= s->current_picture.linesize[1];
2025     const int mb_size= 4 - s->avctx->lowres;
2026
2027     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2028     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2029     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2030     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2031     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2032     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;
2033     //block_index is not used by mpeg2, so it is not affected by chroma_format
2034
2035     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2036     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2037     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2038
2039     if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2040     {
2041         s->dest[0] += s->mb_y *   linesize << mb_size;
2042         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2043         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2044     }
2045 }
2046
2047 void ff_mpeg_flush(AVCodecContext *avctx){
2048     int i;
2049     MpegEncContext *s = avctx->priv_data;
2050
2051     if(s==NULL || s->picture==NULL)
2052         return;
2053
2054     for(i=0; i<MAX_PICTURE_COUNT; i++){
2055        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2056                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2057         avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2058     }
2059     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2060
2061     s->mb_x= s->mb_y= 0;
2062
2063     s->parse_context.state= -1;
2064     s->parse_context.frame_start_found= 0;
2065     s->parse_context.overread= 0;
2066     s->parse_context.overread_index= 0;
2067     s->parse_context.index= 0;
2068     s->parse_context.last_index= 0;
2069     s->bitstream_buffer_size=0;
2070     s->pp_time=0;
2071 }
2072
2073 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2074                                    DCTELEM *block, int n, int qscale)
2075 {
2076     int i, level, nCoeffs;
2077     const uint16_t *quant_matrix;
2078
2079     nCoeffs= s->block_last_index[n];
2080
2081     if (n < 4)
2082         block[0] = block[0] * s->y_dc_scale;
2083     else
2084         block[0] = block[0] * s->c_dc_scale;
2085     /* XXX: only mpeg1 */
2086     quant_matrix = s->intra_matrix;
2087     for(i=1;i<=nCoeffs;i++) {
2088         int j= s->intra_scantable.permutated[i];
2089         level = block[j];
2090         if (level) {
2091             if (level < 0) {
2092                 level = -level;
2093                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2094                 level = (level - 1) | 1;
2095                 level = -level;
2096             } else {
2097                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2098                 level = (level - 1) | 1;
2099             }
2100             block[j] = level;
2101         }
2102     }
2103 }
2104
2105 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2106                                    DCTELEM *block, int n, int qscale)
2107 {
2108     int i, level, nCoeffs;
2109     const uint16_t *quant_matrix;
2110
2111     nCoeffs= s->block_last_index[n];
2112
2113     quant_matrix = s->inter_matrix;
2114     for(i=0; i<=nCoeffs; i++) {
2115         int j= s->intra_scantable.permutated[i];
2116         level = block[j];
2117         if (level) {
2118             if (level < 0) {
2119                 level = -level;
2120                 level = (((level << 1) + 1) * qscale *
2121                          ((int) (quant_matrix[j]))) >> 4;
2122                 level = (level - 1) | 1;
2123                 level = -level;
2124             } else {
2125                 level = (((level << 1) + 1) * qscale *
2126                          ((int) (quant_matrix[j]))) >> 4;
2127                 level = (level - 1) | 1;
2128             }
2129             block[j] = level;
2130         }
2131     }
2132 }
2133
2134 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2135                                    DCTELEM *block, int n, int qscale)
2136 {
2137     int i, level, nCoeffs;
2138     const uint16_t *quant_matrix;
2139
2140     if(s->alternate_scan) nCoeffs= 63;
2141     else nCoeffs= s->block_last_index[n];
2142
2143     if (n < 4)
2144         block[0] = block[0] * s->y_dc_scale;
2145     else
2146         block[0] = block[0] * s->c_dc_scale;
2147     quant_matrix = s->intra_matrix;
2148     for(i=1;i<=nCoeffs;i++) {
2149         int j= s->intra_scantable.permutated[i];
2150         level = block[j];
2151         if (level) {
2152             if (level < 0) {
2153                 level = -level;
2154                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2155                 level = -level;
2156             } else {
2157                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2158             }
2159             block[j] = level;
2160         }
2161     }
2162 }
2163
2164 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2165                                    DCTELEM *block, int n, int qscale)
2166 {
2167     int i, level, nCoeffs;
2168     const uint16_t *quant_matrix;
2169     int sum=-1;
2170
2171     if(s->alternate_scan) nCoeffs= 63;
2172     else nCoeffs= s->block_last_index[n];
2173
2174     if (n < 4)
2175         block[0] = block[0] * s->y_dc_scale;
2176     else
2177         block[0] = block[0] * s->c_dc_scale;
2178     quant_matrix = s->intra_matrix;
2179     for(i=1;i<=nCoeffs;i++) {
2180         int j= s->intra_scantable.permutated[i];
2181         level = block[j];
2182         if (level) {
2183             if (level < 0) {
2184                 level = -level;
2185                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2186                 level = -level;
2187             } else {
2188                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2189             }
2190             block[j] = level;
2191             sum+=level;
2192         }
2193     }
2194     block[63]^=sum&1;
2195 }
2196
2197 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2198                                    DCTELEM *block, int n, int qscale)
2199 {
2200     int i, level, nCoeffs;
2201     const uint16_t *quant_matrix;
2202     int sum=-1;
2203
2204     if(s->alternate_scan) nCoeffs= 63;
2205     else nCoeffs= s->block_last_index[n];
2206
2207     quant_matrix = s->inter_matrix;
2208     for(i=0; i<=nCoeffs; i++) {
2209         int j= s->intra_scantable.permutated[i];
2210         level = block[j];
2211         if (level) {
2212             if (level < 0) {
2213                 level = -level;
2214                 level = (((level << 1) + 1) * qscale *
2215                          ((int) (quant_matrix[j]))) >> 4;
2216                 level = -level;
2217             } else {
2218                 level = (((level << 1) + 1) * qscale *
2219                          ((int) (quant_matrix[j]))) >> 4;
2220             }
2221             block[j] = level;
2222             sum+=level;
2223         }
2224     }
2225     block[63]^=sum&1;
2226 }
2227
2228 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2229                                   DCTELEM *block, int n, int qscale)
2230 {
2231     int i, level, qmul, qadd;
2232     int nCoeffs;
2233
2234     assert(s->block_last_index[n]>=0);
2235
2236     qmul = qscale << 1;
2237
2238     if (!s->h263_aic) {
2239         if (n < 4)
2240             block[0] = block[0] * s->y_dc_scale;
2241         else
2242             block[0] = block[0] * s->c_dc_scale;
2243         qadd = (qscale - 1) | 1;
2244     }else{
2245         qadd = 0;
2246     }
2247     if(s->ac_pred)
2248         nCoeffs=63;
2249     else
2250         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2251
2252     for(i=1; i<=nCoeffs; i++) {
2253         level = block[i];
2254         if (level) {
2255             if (level < 0) {
2256                 level = level * qmul - qadd;
2257             } else {
2258                 level = level * qmul + qadd;
2259             }
2260             block[i] = level;
2261         }
2262     }
2263 }
2264
2265 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2266                                   DCTELEM *block, int n, int qscale)
2267 {
2268     int i, level, qmul, qadd;
2269     int nCoeffs;
2270
2271     assert(s->block_last_index[n]>=0);
2272
2273     qadd = (qscale - 1) | 1;
2274     qmul = qscale << 1;
2275
2276     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2277
2278     for(i=0; i<=nCoeffs; i++) {
2279         level = block[i];
2280         if (level) {
2281             if (level < 0) {
2282                 level = level * qmul - qadd;
2283             } else {
2284                 level = level * qmul + qadd;
2285             }
2286             block[i] = level;
2287         }
2288     }
2289 }
2290
2291 /**
2292  * set qscale and update qscale dependent variables.
2293  */
2294 void ff_set_qscale(MpegEncContext * s, int qscale)
2295 {
2296     if (qscale < 1)
2297         qscale = 1;
2298     else if (qscale > 31)
2299         qscale = 31;
2300
2301     s->qscale = qscale;
2302     s->chroma_qscale= s->chroma_qscale_table[qscale];
2303
2304     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2305     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2306 }