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