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