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