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