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