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