Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 49fb20cb

History | View | Annotate | Download (87 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 8f2ab833 Michael Niedermayer
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 de6d9b64 Fabrice Bellard
 *
6 7b94177e Diego Biurrun
 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7
 *
8 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11 ff4ec49e Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
14 de6d9b64 Fabrice Bellard
 *
15 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
16 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19 de6d9b64 Fabrice Bellard
 *
20 ff4ec49e Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
21 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
22 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 de6d9b64 Fabrice Bellard
 */
24 115329f1 Diego Biurrun
25 983e3246 Michael Niedermayer
/**
26
 * @file mpegvideo.c
27
 * The simplest mpeg encoder (well, it was the simplest!).
28 115329f1 Diego Biurrun
 */
29
30 de6d9b64 Fabrice Bellard
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33 3ada94ba Benoit Fouet
#include "mpegvideo_common.h"
34 d9c9259f Aurelien Jacobs
#include "mjpegenc.h"
35 15025553 Aurelien Jacobs
#include "msmpeg4.h"
36 65e4c8c9 Michael Niedermayer
#include "faandct.h"
37 e96682e6 Michael Niedermayer
#include <limits.h>
38 de6d9b64 Fabrice Bellard
39 e4eadb4b Michael Niedermayer
//#undef NDEBUG
40
//#include <assert.h>
41 2ad1516a Michael Niedermayer
42 115329f1 Diego Biurrun
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
43 21af69f7 Fabrice Bellard
                                   DCTELEM *block, int n, int qscale);
44 115329f1 Diego Biurrun
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
45 9dbf1ddd Michael Niedermayer
                                   DCTELEM *block, int n, int qscale);
46 d50635cd Michael Niedermayer
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
47
                                   DCTELEM *block, int n, int qscale);
48 e27b6e62 Michael Niedermayer
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
49
                                   DCTELEM *block, int n, int qscale);
50 d50635cd Michael Niedermayer
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52 115329f1 Diego Biurrun
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 d50635cd Michael Niedermayer
                                  DCTELEM *block, int n, int qscale);
54 115329f1 Diego Biurrun
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 21af69f7 Fabrice Bellard
                                  DCTELEM *block, int n, int qscale);
56 3d9fccbf Michael Niedermayer
57 9686df2b Diego Biurrun
int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58
void XVMC_field_end(MpegEncContext *s);
59
void XVMC_decode_mb(MpegEncContext *s);
60 2e7b4c84 Ivan Kalvachev
61 de6d9b64 Fabrice Bellard
62
/* enable all paranoid tests for rounding, overflows, etc... */
63
//#define PARANOID
64
65
//#define DEBUG
66
67 101bea5f Juanjo
68 332f9ac4 Michael Niedermayer
static const uint8_t ff_default_chroma_qscale_table[32]={
69
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
70
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
71
};
72
73 6cbe71bd Aurelien Jacobs
const uint8_t ff_mpeg1_dc_scale_table[128]={
74
//  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
75
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76
    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
};
80
81 2ad1516a Michael Niedermayer
82 82fcbc14 Michael Niedermayer
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
83
    int i;
84
85 8cb90572 Michael Niedermayer
    assert(p<=end);
86
    if(p>=end)
87
        return end;
88
89 82fcbc14 Michael Niedermayer
    for(i=0; i<3; i++){
90
        uint32_t tmp= *state << 8;
91
        *state= tmp + *(p++);
92
        if(tmp == 0x100 || p==end)
93
            return p;
94
    }
95
96
    while(p<end){
97 809b2a30 Michael Niedermayer
        if     (p[-1] > 1      ) p+= 3;
98
        else if(p[-2]          ) p+= 2;
99
        else if(p[-3]|(p[-1]-1)) p++;
100 82fcbc14 Michael Niedermayer
        else{
101
            p++;
102
            break;
103
        }
104
    }
105
106 809b2a30 Michael Niedermayer
    p= FFMIN(p, end)-4;
107 f49f6e88 Roman Shaposhnik
    *state= AV_RB32(p);
108 82fcbc14 Michael Niedermayer
109
    return p+4;
110
}
111
112 defdfc9a Alex Beregszaszi
/* init common dct for both encoder and decoder */
113 6180ade7 Baptiste Coudurier
int ff_dct_common_init(MpegEncContext *s)
114 de6d9b64 Fabrice Bellard
{
115 d50635cd Michael Niedermayer
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
116
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
117
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
118
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
119
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
120 e27b6e62 Michael Niedermayer
    if(s->flags & CODEC_FLAG_BITEXACT)
121
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
122 d50635cd Michael Niedermayer
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
123 b0368839 Michael Niedermayer
124 b250f9c6 Aurelien Jacobs
#if   HAVE_MMX
125 e4eadb4b Michael Niedermayer
    MPV_common_init_mmx(s);
126 b250f9c6 Aurelien Jacobs
#elif ARCH_ALPHA
127 e0580f8c Falk Hüffner
    MPV_common_init_axp(s);
128 b250f9c6 Aurelien Jacobs
#elif CONFIG_MLIB
129 c7e07931 Martin Olschewski
    MPV_common_init_mlib(s);
130 b250f9c6 Aurelien Jacobs
#elif HAVE_MMI
131 5917d17c Leon van Stuivenberg
    MPV_common_init_mmi(s);
132 b250f9c6 Aurelien Jacobs
#elif ARCH_ARM
133 a2fc0f6a Måns Rullgård
    MPV_common_init_arm(s);
134 b250f9c6 Aurelien Jacobs
#elif HAVE_ALTIVEC
135 f62a9a46 Diego Biurrun
    MPV_common_init_altivec(s);
136 b250f9c6 Aurelien Jacobs
#elif ARCH_BFIN
137 1a822d30 Marc Hoffman
    MPV_common_init_bfin(s);
138
#endif
139 676e200c Michael Niedermayer
140 2ad1516a Michael Niedermayer
    /* load & permutate scantables
141 115329f1 Diego Biurrun
       note: only wmv uses different ones
142 2ad1516a Michael Niedermayer
    */
143 bb198e19 Michael Niedermayer
    if(s->alternate_scan){
144
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
145
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
146
    }else{
147
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
148
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
149
    }
150 3d2e8cce Michael Niedermayer
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
151
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
152 d930ef19 Michael Niedermayer
153 defdfc9a Alex Beregszaszi
    return 0;
154
}
155
156 8d2fc163 Carl Eugen Hoyos
void ff_copy_picture(Picture *dst, Picture *src){
157 6571e41d Michael Niedermayer
    *dst = *src;
158
    dst->type= FF_BUFFER_TYPE_COPY;
159
}
160
161 1e491e29 Michael Niedermayer
/**
162 4e00e76b Michael Niedermayer
 * allocates a Picture
163
 * The pixels are allocated/set by calling get_buffer() if shared=0
164 1e491e29 Michael Niedermayer
 */
165 3ada94ba Benoit Fouet
int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
166 755bfeab Diego Biurrun
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
167 7bc9090a Michael Niedermayer
    const int mb_array_size= s->mb_stride*s->mb_height;
168 b40cd4e0 Michael Niedermayer
    const int b8_array_size= s->b8_stride*s->mb_height*2;
169
    const int b4_array_size= s->b4_stride*s->mb_height*4;
170 0da71265 Michael Niedermayer
    int i;
171 29d2dc59 Daniel Kristjansson
    int r= -1;
172 115329f1 Diego Biurrun
173 4e00e76b Michael Niedermayer
    if(shared){
174
        assert(pic->data[0]);
175
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
176
        pic->type= FF_BUFFER_TYPE_SHARED;
177
    }else{
178
        assert(!pic->data[0]);
179 115329f1 Diego Biurrun
180 492cd3a9 Michael Niedermayer
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
181 115329f1 Diego Biurrun
182 4e00e76b Michael Niedermayer
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
183 bb270c08 Diego Biurrun
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
184 4e00e76b Michael Niedermayer
            return -1;
185
        }
186
187
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
188 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
189 29d2dc59 Daniel Kristjansson
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
190 4e00e76b Michael Niedermayer
            return -1;
191
        }
192
193
        if(pic->linesize[1] != pic->linesize[2]){
194 bb628dae Diego Biurrun
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
195 29d2dc59 Daniel Kristjansson
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
196 4e00e76b Michael Niedermayer
            return -1;
197
        }
198
199
        s->linesize  = pic->linesize[0];
200
        s->uvlinesize= pic->linesize[1];
201 1e491e29 Michael Niedermayer
    }
202 115329f1 Diego Biurrun
203 4e00e76b Michael Niedermayer
    if(pic->qscale_table==NULL){
204 115329f1 Diego Biurrun
        if (s->encoding) {
205 7bc9090a Michael Niedermayer
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
206
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
207
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
208 4e00e76b Michael Niedermayer
        }
209 1e491e29 Michael Niedermayer
210 7bc9090a Michael Niedermayer
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
211 e4eadb4b Michael Niedermayer
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
212 0063c05c Michael Niedermayer
        CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
213
        pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
214 0da71265 Michael Niedermayer
        if(s->out_format == FMT_H264){
215
            for(i=0; i<2; i++){
216 02dc8983 Michael Niedermayer
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
217
                pic->motion_val[i]= pic->motion_val_base[i]+4;
218 7c4f71c4 Michael Niedermayer
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
219 b40cd4e0 Michael Niedermayer
            }
220 5ea4b18d Michael Niedermayer
            pic->motion_subsample_log2= 2;
221 0c9bbaec Wolfgang Hesseler
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
222 b40cd4e0 Michael Niedermayer
            for(i=0; i<2; i++){
223 02dc8983 Michael Niedermayer
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
224
                pic->motion_val[i]= pic->motion_val_base[i]+4;
225 7c4f71c4 Michael Niedermayer
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
226 0da71265 Michael Niedermayer
            }
227 5ea4b18d Michael Niedermayer
            pic->motion_subsample_log2= 3;
228 0da71265 Michael Niedermayer
        }
229 8289c6fa Wolfgang Hesseler
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
230
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
231
        }
232 7bc9090a Michael Niedermayer
        pic->qstride= s->mb_stride;
233 fa384dcc Michael Niedermayer
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
234 4e00e76b Michael Niedermayer
    }
235 0da71265 Michael Niedermayer
236 90b5b51e Diego Biurrun
    /* It might be nicer if the application would keep track of these
237
     * but it would require an API change. */
238 f943e138 Michael Niedermayer
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
239 5b0e7dac Michael Niedermayer
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
240 9701840b Aurelien Jacobs
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
241 90b5b51e Diego Biurrun
        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.
242 115329f1 Diego Biurrun
243 1e491e29 Michael Niedermayer
    return 0;
244
fail: //for the CHECKED_ALLOCZ macro
245 29d2dc59 Daniel Kristjansson
    if(r>=0)
246
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
247 1e491e29 Michael Niedermayer
    return -1;
248
}
249
250 4e00e76b Michael Niedermayer
/**
251
 * deallocates a picture
252
 */
253 1e491e29 Michael Niedermayer
static void free_picture(MpegEncContext *s, Picture *pic){
254
    int i;
255 4e00e76b Michael Niedermayer
256
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
257 492cd3a9 Michael Niedermayer
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
258 4e00e76b Michael Niedermayer
    }
259
260 1e491e29 Michael Niedermayer
    av_freep(&pic->mb_var);
261
    av_freep(&pic->mc_mb_var);
262
    av_freep(&pic->mb_mean);
263
    av_freep(&pic->mbskip_table);
264
    av_freep(&pic->qscale_table);
265 0da71265 Michael Niedermayer
    av_freep(&pic->mb_type_base);
266 8289c6fa Wolfgang Hesseler
    av_freep(&pic->dct_coeff);
267 fa384dcc Michael Niedermayer
    av_freep(&pic->pan_scan);
268 0da71265 Michael Niedermayer
    pic->mb_type= NULL;
269
    for(i=0; i<2; i++){
270 b40cd4e0 Michael Niedermayer
        av_freep(&pic->motion_val_base[i]);
271 0da71265 Michael Niedermayer
        av_freep(&pic->ref_index[i]);
272
    }
273 115329f1 Diego Biurrun
274 d90cf87b Michael Niedermayer
    if(pic->type == FF_BUFFER_TYPE_SHARED){
275 4e00e76b Michael Niedermayer
        for(i=0; i<4; i++){
276
            pic->base[i]=
277
            pic->data[i]= NULL;
278
        }
279 115329f1 Diego Biurrun
        pic->type= 0;
280 1e491e29 Michael Niedermayer
    }
281
}
282
283 9c3d33d6 Michael Niedermayer
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
284
    int i;
285
286 115329f1 Diego Biurrun
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
287 5d18eaad Loren Merritt
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
288
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
289 9c3d33d6 Michael Niedermayer
290 755bfeab Diego Biurrun
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
291 115329f1 Diego Biurrun
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
292 a6f2c0d6 Michael Niedermayer
    s->me.temp=         s->me.scratchpad;
293 9c3d33d6 Michael Niedermayer
    s->rd_scratchpad=   s->me.scratchpad;
294
    s->b_scratchpad=    s->me.scratchpad;
295
    s->obmc_scratchpad= s->me.scratchpad + 16;
296
    if (s->encoding) {
297
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
298
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
299
        if(s->avctx->noise_reduction){
300
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
301
        }
302 115329f1 Diego Biurrun
    }
303 5e5c247a Ivan Kalvachev
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
304 9c3d33d6 Michael Niedermayer
    s->block= s->blocks[0];
305
306
    for(i=0;i<12;i++){
307
        s->pblocks[i] = (short *)(&s->block[i]);
308
    }
309
    return 0;
310
fail:
311
    return -1; //free() through MPV_common_end()
312
}
313
314
static void free_duplicate_context(MpegEncContext *s){
315
    if(s==NULL) return;
316
317
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
318
    av_freep(&s->me.scratchpad);
319 a6f2c0d6 Michael Niedermayer
    s->me.temp=
320 115329f1 Diego Biurrun
    s->rd_scratchpad=
321
    s->b_scratchpad=
322 9c3d33d6 Michael Niedermayer
    s->obmc_scratchpad= NULL;
323 115329f1 Diego Biurrun
324 9c3d33d6 Michael Niedermayer
    av_freep(&s->dct_error_sum);
325
    av_freep(&s->me.map);
326
    av_freep(&s->me.score_map);
327
    av_freep(&s->blocks);
328
    s->block= NULL;
329
}
330
331
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
332
#define COPY(a) bak->a= src->a
333
    COPY(allocated_edge_emu_buffer);
334
    COPY(edge_emu_buffer);
335
    COPY(me.scratchpad);
336 a6f2c0d6 Michael Niedermayer
    COPY(me.temp);
337 9c3d33d6 Michael Niedermayer
    COPY(rd_scratchpad);
338
    COPY(b_scratchpad);
339
    COPY(obmc_scratchpad);
340
    COPY(me.map);
341
    COPY(me.score_map);
342
    COPY(blocks);
343
    COPY(block);
344
    COPY(start_mb_y);
345
    COPY(end_mb_y);
346
    COPY(me.map_generation);
347
    COPY(pb);
348
    COPY(dct_error_sum);
349 da16b204 Michael Niedermayer
    COPY(dct_count[0]);
350
    COPY(dct_count[1]);
351 9c3d33d6 Michael Niedermayer
#undef COPY
352
}
353
354 c62c07d3 Michael Niedermayer
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
355 9c3d33d6 Michael Niedermayer
    MpegEncContext bak;
356 c62c07d3 Michael Niedermayer
    int i;
357 9c3d33d6 Michael Niedermayer
    //FIXME copy only needed parts
358
//START_TIMER
359
    backup_duplicate_context(&bak, dst);
360
    memcpy(dst, src, sizeof(MpegEncContext));
361
    backup_duplicate_context(dst, &bak);
362 c62c07d3 Michael Niedermayer
    for(i=0;i<12;i++){
363
        dst->pblocks[i] = (short *)(&dst->block[i]);
364
    }
365 9c3d33d6 Michael Niedermayer
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
366
}
367
368 3edcacde Michael Niedermayer
/**
369
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
370
 * the changed fields will not depend upon the prior state of the MpegEncContext.
371
 */
372 3ada94ba Benoit Fouet
void MPV_common_defaults(MpegEncContext *s){
373 3edcacde Michael Niedermayer
    s->y_dc_scale_table=
374
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
375
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
376
    s->progressive_frame= 1;
377
    s->progressive_sequence= 1;
378
    s->picture_structure= PICT_FRAME;
379
380
    s->coded_picture_number = 0;
381
    s->picture_number = 0;
382
    s->input_picture_number = 0;
383
384
    s->picture_in_gop_number = 0;
385 7976241a Michael Niedermayer
386
    s->f_code = 1;
387
    s->b_code = 1;
388 3edcacde Michael Niedermayer
}
389
390
/**
391
 * sets the given MpegEncContext to defaults for decoding.
392
 * the changed fields will not depend upon the prior state of the MpegEncContext.
393
 */
394
void MPV_decode_defaults(MpegEncContext *s){
395
    MPV_common_defaults(s);
396
}
397
398
/**
399
 * init common structure for both encoder and decoder.
400
 * this assumes that some variables like width/height are already set
401
 */
402 defdfc9a Alex Beregszaszi
int MPV_common_init(MpegEncContext *s)
403
{
404 afebe2f7 Andreas Öman
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
405 defdfc9a Alex Beregszaszi
406 fdb52bcc Loren Merritt
    s->mb_height = (s->height + 15) / 16;
407
408
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
409 000a9c02 Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
410
        return -1;
411
    }
412
413 0ecca7a4 Michael Niedermayer
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
414
        return -1;
415
416 b0368839 Michael Niedermayer
    dsputil_init(&s->dsp, s->avctx);
417 6180ade7 Baptiste Coudurier
    ff_dct_common_init(s);
418 eb4b3dd3 Zdenek Kabelac
419 9fee1e23 Michael Niedermayer
    s->flags= s->avctx->flags;
420 303e50e6 Michael Niedermayer
    s->flags2= s->avctx->flags2;
421 defdfc9a Alex Beregszaszi
422 1e491e29 Michael Niedermayer
    s->mb_width  = (s->width  + 15) / 16;
423 7bc9090a Michael Niedermayer
    s->mb_stride = s->mb_width + 1;
424 b40cd4e0 Michael Niedermayer
    s->b8_stride = s->mb_width*2 + 1;
425
    s->b4_stride = s->mb_width*4 + 1;
426 7bc9090a Michael Niedermayer
    mb_array_size= s->mb_height * s->mb_stride;
427 bb198e19 Michael Niedermayer
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
428 eb4b3dd3 Zdenek Kabelac
429 ffdff4d7 Ivan Kalvachev
    /* set chroma shifts */
430
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
431
                                                    &(s->chroma_y_shift) );
432
433 b5a093b3 Michael Niedermayer
    /* set default edge pos, will be overriden in decode_header if needed */
434
    s->h_edge_pos= s->mb_width*16;
435
    s->v_edge_pos= s->mb_height*16;
436 eb4b3dd3 Zdenek Kabelac
437
    s->mb_num = s->mb_width * s->mb_height;
438 115329f1 Diego Biurrun
439 7bc9090a Michael Niedermayer
    s->block_wrap[0]=
440
    s->block_wrap[1]=
441
    s->block_wrap[2]=
442 137c8468 Michael Niedermayer
    s->block_wrap[3]= s->b8_stride;
443 7bc9090a Michael Niedermayer
    s->block_wrap[4]=
444 137c8468 Michael Niedermayer
    s->block_wrap[5]= s->mb_stride;
445 115329f1 Diego Biurrun
446 137c8468 Michael Niedermayer
    y_size = s->b8_stride * (2 * s->mb_height + 1);
447
    c_size = s->mb_stride * (s->mb_height + 1);
448 eb4b3dd3 Zdenek Kabelac
    yc_size = y_size + 2 * c_size;
449 115329f1 Diego Biurrun
450 202ef8b8 Michael Niedermayer
    /* convert fourcc to upper case */
451 17662955 Baptiste Coudurier
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
452 7004ffb3 Michael Niedermayer
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
453 115329f1 Diego Biurrun
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
454 7004ffb3 Michael Niedermayer
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
455 b5a093b3 Michael Niedermayer
456 17662955 Baptiste Coudurier
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
457 541ae140 Michael Niedermayer
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
458 115329f1 Diego Biurrun
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
459 541ae140 Michael Niedermayer
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
460
461 492cd3a9 Michael Niedermayer
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
462 1e491e29 Michael Niedermayer
463 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
464
    for(y=0; y<s->mb_height; y++){
465
        for(x=0; x<s->mb_width; x++){
466
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
467
        }
468
    }
469
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
470 115329f1 Diego Biurrun
471 37fbfd0a Juanjo
    if (s->encoding) {
472 9dbcbd92 Michael Niedermayer
        /* Allocate MV tables */
473 7bc9090a Michael Niedermayer
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
474
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
475
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
476
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
477
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
478
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
479
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
480
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
481
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
482
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
483
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
484
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
485 7f2fe444 Michael Niedermayer
486 6b460aa3 Michael Niedermayer
        if(s->msmpeg4_version){
487
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
488
        }
489 3aa102be Michael Niedermayer
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
490 7bc9090a Michael Niedermayer
491
        /* Allocate MB type table */
492 bb198e19 Michael Niedermayer
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
493 115329f1 Diego Biurrun
494 158c7f05 Michael Niedermayer
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
495 115329f1 Diego Biurrun
496 7e4995c3 Michael Niedermayer
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
497
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
498 642ccefb Michael Niedermayer
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
499
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
500 9d9e3172 Michael Niedermayer
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
501
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
502 115329f1 Diego Biurrun
503 821cb11f Michael Niedermayer
        if(s->avctx->noise_reduction){
504
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
505
        }
506 37fbfd0a Juanjo
    }
507 b465449e Michael Niedermayer
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
508
509 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
510 115329f1 Diego Biurrun
511 bb198e19 Michael Niedermayer
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
512 4d2858de Michael Niedermayer
        /* interlaced direct mode decoding tables */
513 bb198e19 Michael Niedermayer
            for(i=0; i<2; i++){
514
                int j, k;
515
                for(j=0; j<2; j++){
516
                    for(k=0; k<2; k++){
517
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
518
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
519
                    }
520
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
521
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
522
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
523
                }
524
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
525
            }
526 de6d9b64 Fabrice Bellard
    }
527 6e2d5f1a Michael Niedermayer
    if (s->out_format == FMT_H263) {
528 de6d9b64 Fabrice Bellard
        /* ac values */
529 137c8468 Michael Niedermayer
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
530
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
531
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
532 de6d9b64 Fabrice Bellard
        s->ac_val[2] = s->ac_val[1] + c_size;
533 115329f1 Diego Biurrun
534 de6d9b64 Fabrice Bellard
        /* cbp values */
535 137c8468 Michael Niedermayer
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
536
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
537 115329f1 Diego Biurrun
538 7f2fe444 Michael Niedermayer
        /* cbp, ac_pred, pred_dir */
539 7bc9090a Michael Niedermayer
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
540
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
541 5b3438c6 Michael Niedermayer
    }
542 115329f1 Diego Biurrun
543 8b32880c Michael Niedermayer
    if (s->h263_pred || s->h263_plus || !s->encoding) {
544
        /* dc values */
545
        //MN: we need these for error resilience of intra-frames
546 137c8468 Michael Niedermayer
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
547
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
548
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
549 8b32880c Michael Niedermayer
        s->dc_val[2] = s->dc_val[1] + c_size;
550
        for(i=0;i<yc_size;i++)
551 137c8468 Michael Niedermayer
            s->dc_val_base[i] = 1024;
552 8b32880c Michael Niedermayer
    }
553
554 7806197d Michael Niedermayer
    /* which mb is a intra block */
555 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
556
    memset(s->mbintra_table, 1, mb_array_size);
557 115329f1 Diego Biurrun
558 3bb4e23a Fabrice Bellard
    /* init macroblock skip table */
559 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
560 4d2858de Michael Niedermayer
    //Note the +1 is for a quicker mpeg4 slice_end detection
561 f943e138 Michael Niedermayer
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
562 115329f1 Diego Biurrun
563 d7425f59 Michael Niedermayer
    s->parse_context.state= -1;
564 0c9bbaec Wolfgang Hesseler
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
565
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
566 014d2f05 Baptiste Coudurier
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
567
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
568 0c9bbaec Wolfgang Hesseler
    }
569 d7425f59 Michael Niedermayer
570 de6d9b64 Fabrice Bellard
    s->context_initialized = 1;
571 9c3d33d6 Michael Niedermayer
572
    s->thread_context[0]= s;
573 79db7ac6 Jeff Downs
    threads = s->avctx->thread_count;
574 afebe2f7 Andreas Öman
575
    for(i=1; i<threads; i++){
576 9c3d33d6 Michael Niedermayer
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
577
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
578
    }
579
580 afebe2f7 Andreas Öman
    for(i=0; i<threads; i++){
581 9c3d33d6 Michael Niedermayer
        if(init_duplicate_context(s->thread_context[i], s) < 0)
582
           goto fail;
583
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
584
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
585
    }
586
587 de6d9b64 Fabrice Bellard
    return 0;
588
 fail:
589 8257bf05 Zdenek Kabelac
    MPV_common_end(s);
590 de6d9b64 Fabrice Bellard
    return -1;
591
}
592
593
/* init common structure for both encoder and decoder */
594
void MPV_common_end(MpegEncContext *s)
595
{
596 bb198e19 Michael Niedermayer
    int i, j, k;
597 de6d9b64 Fabrice Bellard
598 9c3d33d6 Michael Niedermayer
    for(i=0; i<s->avctx->thread_count; i++){
599
        free_duplicate_context(s->thread_context[i]);
600
    }
601
    for(i=1; i<s->avctx->thread_count; i++){
602
        av_freep(&s->thread_context[i]);
603
    }
604
605 147e5200 Michael Niedermayer
    av_freep(&s->parse_context.buffer);
606
    s->parse_context.buffer_size=0;
607
608 6000abfa Fabrice Bellard
    av_freep(&s->mb_type);
609 7bc9090a Michael Niedermayer
    av_freep(&s->p_mv_table_base);
610
    av_freep(&s->b_forw_mv_table_base);
611
    av_freep(&s->b_back_mv_table_base);
612
    av_freep(&s->b_bidir_forw_mv_table_base);
613
    av_freep(&s->b_bidir_back_mv_table_base);
614
    av_freep(&s->b_direct_mv_table_base);
615
    s->p_mv_table= NULL;
616
    s->b_forw_mv_table= NULL;
617
    s->b_back_mv_table= NULL;
618
    s->b_bidir_forw_mv_table= NULL;
619
    s->b_bidir_back_mv_table= NULL;
620
    s->b_direct_mv_table= NULL;
621 bb198e19 Michael Niedermayer
    for(i=0; i<2; i++){
622
        for(j=0; j<2; j++){
623
            for(k=0; k<2; k++){
624
                av_freep(&s->b_field_mv_table_base[i][j][k]);
625
                s->b_field_mv_table[i][j][k]=NULL;
626
            }
627
            av_freep(&s->b_field_select_table[i][j]);
628
            av_freep(&s->p_field_mv_table_base[i][j]);
629
            s->p_field_mv_table[i][j]=NULL;
630
        }
631
        av_freep(&s->p_field_select_table[i]);
632
    }
633 115329f1 Diego Biurrun
634 137c8468 Michael Niedermayer
    av_freep(&s->dc_val_base);
635
    av_freep(&s->ac_val_base);
636
    av_freep(&s->coded_block_base);
637 6000abfa Fabrice Bellard
    av_freep(&s->mbintra_table);
638 7f2fe444 Michael Niedermayer
    av_freep(&s->cbp_table);
639
    av_freep(&s->pred_dir_table);
640 115329f1 Diego Biurrun
641 6000abfa Fabrice Bellard
    av_freep(&s->mbskip_table);
642 f943e138 Michael Niedermayer
    av_freep(&s->prev_pict_types);
643 6000abfa Fabrice Bellard
    av_freep(&s->bitstream_buffer);
644 0ecca7a4 Michael Niedermayer
    s->allocated_bitstream_buffer_size=0;
645
646 3aa102be Michael Niedermayer
    av_freep(&s->avctx->stats_out);
647 6b460aa3 Michael Niedermayer
    av_freep(&s->ac_stats);
648 4d2858de Michael Niedermayer
    av_freep(&s->error_status_table);
649 7bc9090a Michael Niedermayer
    av_freep(&s->mb_index2xy);
650 158c7f05 Michael Niedermayer
    av_freep(&s->lambda_table);
651 7e4995c3 Michael Niedermayer
    av_freep(&s->q_intra_matrix);
652
    av_freep(&s->q_inter_matrix);
653 642ccefb Michael Niedermayer
    av_freep(&s->q_intra_matrix16);
654
    av_freep(&s->q_inter_matrix16);
655 9d9e3172 Michael Niedermayer
    av_freep(&s->input_picture);
656
    av_freep(&s->reordered_input_picture);
657 821cb11f Michael Niedermayer
    av_freep(&s->dct_offset);
658 1e491e29 Michael Niedermayer
659 9b4b6e09 Michael Niedermayer
    if(s->picture){
660
        for(i=0; i<MAX_PICTURE_COUNT; i++){
661
            free_picture(s, &s->picture[i]);
662
        }
663 de6d9b64 Fabrice Bellard
    }
664 b465449e Michael Niedermayer
    av_freep(&s->picture);
665 de6d9b64 Fabrice Bellard
    s->context_initialized = 0;
666 431f2172 Michael Niedermayer
    s->last_picture_ptr=
667
    s->next_picture_ptr=
668
    s->current_picture_ptr= NULL;
669 b100eab8 Michael Niedermayer
    s->linesize= s->uvlinesize= 0;
670 8100cab9 Michael Niedermayer
671 0c9bbaec Wolfgang Hesseler
    for(i=0; i<3; i++)
672 8100cab9 Michael Niedermayer
        av_freep(&s->visualization_buffer[i]);
673 b100eab8 Michael Niedermayer
674
    avcodec_default_free_buffers(s->avctx);
675 de6d9b64 Fabrice Bellard
}
676
677 3502a54f Michael Niedermayer
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
678 1d0d55da Michael Niedermayer
{
679 0c1a9eda Zdenek Kabelac
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
680
    uint8_t index_run[MAX_RUN+1];
681 1d0d55da Michael Niedermayer
    int last, run, level, start, end, i;
682
683 073c2593 Burkhard Plaum
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
684 3502a54f Michael Niedermayer
    if(static_store && rl->max_level[0])
685 073c2593 Burkhard Plaum
        return;
686
687 1d0d55da Michael Niedermayer
    /* compute max_level[], max_run[] and index_run[] */
688
    for(last=0;last<2;last++) {
689
        if (last == 0) {
690
            start = 0;
691
            end = rl->last;
692
        } else {
693
            start = rl->last;
694
            end = rl->n;
695
        }
696
697
        memset(max_level, 0, MAX_RUN + 1);
698
        memset(max_run, 0, MAX_LEVEL + 1);
699
        memset(index_run, rl->n, MAX_RUN + 1);
700
        for(i=start;i<end;i++) {
701
            run = rl->table_run[i];
702
            level = rl->table_level[i];
703
            if (index_run[run] == rl->n)
704
                index_run[run] = i;
705
            if (level > max_level[run])
706
                max_level[run] = level;
707
            if (run > max_run[level])
708
                max_run[level] = run;
709
        }
710 3502a54f Michael Niedermayer
        if(static_store)
711
            rl->max_level[last] = static_store[last];
712 073c2593 Burkhard Plaum
        else
713
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
714 1d0d55da Michael Niedermayer
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
715 3502a54f Michael Niedermayer
        if(static_store)
716
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
717 073c2593 Burkhard Plaum
        else
718
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
719 1d0d55da Michael Niedermayer
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
720 3502a54f Michael Niedermayer
        if(static_store)
721
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
722 073c2593 Burkhard Plaum
        else
723
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
724 1d0d55da Michael Niedermayer
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
725
    }
726
}
727
728 ceaaf78b Michael Niedermayer
void init_vlc_rl(RLTable *rl)
729 898d5d5d Aurelien Jacobs
{
730
    int i, q;
731
732
    for(q=0; q<32; q++){
733
        int qmul= q*2;
734
        int qadd= (q-1)|1;
735
736
        if(q==0){
737
            qmul=1;
738
            qadd=0;
739
        }
740
        for(i=0; i<rl->vlc.table_size; i++){
741
            int code= rl->vlc.table[i][0];
742
            int len = rl->vlc.table[i][1];
743
            int level, run;
744
745
            if(len==0){ // illegal code
746
                run= 66;
747
                level= MAX_LEVEL;
748
            }else if(len<0){ //more bits needed
749
                run= 0;
750
                level= code;
751
            }else{
752
                if(code==rl->n){ //esc
753
                    run= 66;
754
                    level= 0;
755
                }else{
756
                    run=   rl->table_run  [code] + 1;
757
                    level= rl->table_level[code] * qmul + qadd;
758
                    if(code >= rl->last) run+=192;
759
                }
760
            }
761
            rl->rl_vlc[q][i].len= len;
762
            rl->rl_vlc[q][i].level= level;
763
            rl->rl_vlc[q][i].run= run;
764
        }
765
    }
766
}
767
768 5f194811 Michael Niedermayer
int ff_find_unused_picture(MpegEncContext *s, int shared){
769 4e00e76b Michael Niedermayer
    int i;
770 115329f1 Diego Biurrun
771 4e00e76b Michael Niedermayer
    if(shared){
772
        for(i=0; i<MAX_PICTURE_COUNT; i++){
773 5f194811 Michael Niedermayer
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
774 4e00e76b Michael Niedermayer
        }
775
    }else{
776
        for(i=0; i<MAX_PICTURE_COUNT; i++){
777 5f194811 Michael Niedermayer
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
778 4e00e76b Michael Niedermayer
        }
779
        for(i=0; i<MAX_PICTURE_COUNT; i++){
780 5f194811 Michael Niedermayer
            if(s->picture[i].data[0]==NULL) return i;
781 4e00e76b Michael Niedermayer
        }
782
    }
783
784 3c11a27b Michael Niedermayer
    av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
785 3a994ca4 Diego Biurrun
    /* We could return -1, but the codec would crash trying to draw into a
786
     * non-existing frame anyway. This is safer than waiting for a random crash.
787
     * Also the return of this is never useful, an encoder must only allocate
788
     * as much as allowed in the specification. This has no relationship to how
789
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
790
     * enough for such valid streams).
791
     * Plus, a decoder has to check stream validity and remove frames if too
792
     * many reference frames are around. Waiting for "OOM" is not correct at
793
     * all. Similarly, missing reference frames have to be replaced by
794
     * interpolated/MC frames, anything else is a bug in the codec ...
795
     */
796 3c11a27b Michael Niedermayer
    abort();
797 5f194811 Michael Niedermayer
    return -1;
798 4e00e76b Michael Niedermayer
}
799
800 821cb11f Michael Niedermayer
static void update_noise_reduction(MpegEncContext *s){
801
    int intra, i;
802
803
    for(intra=0; intra<2; intra++){
804
        if(s->dct_count[intra] > (1<<16)){
805
            for(i=0; i<64; i++){
806
                s->dct_error_sum[intra][i] >>=1;
807
            }
808
            s->dct_count[intra] >>= 1;
809
        }
810 115329f1 Diego Biurrun
811 821cb11f Michael Niedermayer
        for(i=0; i<64; i++){
812
            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);
813
        }
814
    }
815
}
816
817 5f194811 Michael Niedermayer
/**
818
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
819
 */
820 d6db1c9c Michael Niedermayer
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
821 de6d9b64 Fabrice Bellard
{
822 4e00e76b Michael Niedermayer
    int i;
823 492cd3a9 Michael Niedermayer
    AVFrame *pic;
824 160d679c Mike Melanson
    s->mb_skipped = 0;
825 0da71265 Michael Niedermayer
826 8b82a956 Michael Niedermayer
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
827 e20c4069 Michael Niedermayer
828 1e491e29 Michael Niedermayer
    /* mark&release old frames */
829 9701840b Aurelien Jacobs
    if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
830 6ad7cd04 Michael Niedermayer
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
831 b536d0aa Michael Niedermayer
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
832 1e491e29 Michael Niedermayer
833
        /* release forgotten pictures */
834
        /* if(mpeg124/h263) */
835
        if(!s->encoding){
836
            for(i=0; i<MAX_PICTURE_COUNT; i++){
837 b536d0aa Michael Niedermayer
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
838 9b879566 Michel Bardiaux
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
839 115329f1 Diego Biurrun
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
840 1e491e29 Michael Niedermayer
                }
841
            }
842 d6db1c9c Michael Niedermayer
        }
843 6ad7cd04 Michael Niedermayer
      }
844 93a21abd Michael Niedermayer
    }
845 aa388dba Michael Niedermayer
alloc:
846
    if(!s->encoding){
847 bb628dae Diego Biurrun
        /* release non reference frames */
848 e20c4069 Michael Niedermayer
        for(i=0; i<MAX_PICTURE_COUNT; i++){
849
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
850
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
851
            }
852
        }
853
854 5f194811 Michael Niedermayer
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
855 bd107136 Diego Biurrun
            pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
856 5f194811 Michael Niedermayer
        else{
857
            i= ff_find_unused_picture(s, 0);
858
            pic= (AVFrame*)&s->picture[i];
859
        }
860
861 2ddcf84b Jeff Downs
        pic->reference= 0;
862
        if (!s->dropable){
863
            if (s->codec_id == CODEC_ID_H264)
864
                pic->reference = s->picture_structure;
865 9701840b Aurelien Jacobs
            else if (s->pict_type != FF_B_TYPE)
866 2ddcf84b Jeff Downs
                pic->reference = 3;
867
        }
868 b536d0aa Michael Niedermayer
869 1031fabd Michael Niedermayer
        pic->coded_picture_number= s->coded_picture_number++;
870 115329f1 Diego Biurrun
871 f23a68df Ivan Kalvachev
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
872
            return -1;
873 93a21abd Michael Niedermayer
874 5f194811 Michael Niedermayer
        s->current_picture_ptr= (Picture*)pic;
875 c70f1716 Michael Niedermayer
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
876 2be9f03a Michael Niedermayer
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
877 1e491e29 Michael Niedermayer
    }
878 b7adc711 Michael Niedermayer
879 9f2e61b6 Michael Niedermayer
    s->current_picture_ptr->pict_type= s->pict_type;
880 115329f1 Diego Biurrun
//    if(s->flags && CODEC_FLAG_QSCALE)
881 158c7f05 Michael Niedermayer
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
882 9701840b Aurelien Jacobs
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
883 9f2e61b6 Michael Niedermayer
884 8d2fc163 Carl Eugen Hoyos
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
885 115329f1 Diego Biurrun
886 9701840b Aurelien Jacobs
    if (s->pict_type != FF_B_TYPE) {
887 b536d0aa Michael Niedermayer
        s->last_picture_ptr= s->next_picture_ptr;
888 14e2a940 Michael Niedermayer
        if(!s->dropable)
889
            s->next_picture_ptr= s->current_picture_ptr;
890 de6d9b64 Fabrice Bellard
    }
891 14e2a940 Michael Niedermayer
/*    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,
892 115329f1 Diego Biurrun
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
893
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
894 14e2a940 Michael Niedermayer
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
895
        s->pict_type, s->dropable);*/
896 115329f1 Diego Biurrun
897 8d2fc163 Carl Eugen Hoyos
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
898
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
899 115329f1 Diego Biurrun
900 fe67a236 Michael Niedermayer
    if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable && s->codec_id != CODEC_ID_H264){
901 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
902 9701840b Aurelien Jacobs
        assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
903 ffba1dc0 Michael Niedermayer
        goto alloc;
904
    }
905
906 9701840b Aurelien Jacobs
    assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
907 ffba1dc0 Michael Niedermayer
908 12d96de3 Jeff Downs
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
909 b536d0aa Michael Niedermayer
        int i;
910
        for(i=0; i<4; i++){
911
            if(s->picture_structure == PICT_BOTTOM_FIELD){
912
                 s->current_picture.data[i] += s->current_picture.linesize[i];
913 115329f1 Diego Biurrun
            }
914 b536d0aa Michael Niedermayer
            s->current_picture.linesize[i] *= 2;
915
            s->last_picture.linesize[i] *=2;
916
            s->next_picture.linesize[i] *=2;
917
        }
918
    }
919 115329f1 Diego Biurrun
920 aa388dba Michael Niedermayer
    s->hurry_up= s->avctx->hurry_up;
921 047599a4 Michael Niedermayer
    s->error_recognition= avctx->error_recognition;
922 aa388dba Michael Niedermayer
923 bb628dae Diego Biurrun
    /* set dequantizer, we can't do it during init as it might change for mpeg4
924 755bfeab Diego Biurrun
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
925 d50635cd Michael Niedermayer
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
926
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
927
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
928 ccff9da6 Maarten Daniels
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
929 d50635cd Michael Niedermayer
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
930
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
931
    }else{
932
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
933
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
934
    }
935 d6db1c9c Michael Niedermayer
936 821cb11f Michael Niedermayer
    if(s->dct_error_sum){
937
        assert(s->avctx->noise_reduction && s->encoding);
938
939
        update_noise_reduction(s);
940
    }
941 115329f1 Diego Biurrun
942 b250f9c6 Aurelien Jacobs
#if CONFIG_XVMC
943 2e7b4c84 Ivan Kalvachev
    if(s->avctx->xvmc_acceleration)
944
        return XVMC_field_start(s, avctx);
945
#endif
946 d6db1c9c Michael Niedermayer
    return 0;
947 de6d9b64 Fabrice Bellard
}
948 21af69f7 Fabrice Bellard
949 de6d9b64 Fabrice Bellard
/* generic function for encode/decode called after a frame has been coded/decoded */
950
void MPV_frame_end(MpegEncContext *s)
951
{
952 1e491e29 Michael Niedermayer
    int i;
953 de6d9b64 Fabrice Bellard
    /* draw edge for correct motion prediction if outside */
954 b250f9c6 Aurelien Jacobs
#if CONFIG_XVMC
955 2e7b4c84 Ivan Kalvachev
//just to make sure that all data is rendered.
956
    if(s->avctx->xvmc_acceleration){
957
        XVMC_field_end(s);
958
    }else
959
#endif
960 369122dd NVIDIA Corporation
    if(!(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
961
       && s->unrestricted_mv
962
       && s->current_picture.reference
963
       && !s->intra_only
964
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
965 5a6a9e78 Aurelien Jacobs
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
966
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
967
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
968 de6d9b64 Fabrice Bellard
    }
969 5975626d Michael Niedermayer
    emms_c();
970 115329f1 Diego Biurrun
971 3aa102be Michael Niedermayer
    s->last_pict_type    = s->pict_type;
972 88e51e1f Michael Niedermayer
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
973 9701840b Aurelien Jacobs
    if(s->pict_type!=FF_B_TYPE){
974 8b4c7dbc Michael Niedermayer
        s->last_non_b_pict_type= s->pict_type;
975
    }
976 b536d0aa Michael Niedermayer
#if 0
977
        /* copy back current_picture variables */
978 1e491e29 Michael Niedermayer
    for(i=0; i<MAX_PICTURE_COUNT; i++){
979
        if(s->picture[i].data[0] == s->current_picture.data[0]){
980
            s->picture[i]= s->current_picture;
981
            break;
982 115329f1 Diego Biurrun
        }
983 1e491e29 Michael Niedermayer
    }
984
    assert(i<MAX_PICTURE_COUNT);
985 115329f1 Diego Biurrun
#endif
986 1e491e29 Michael Niedermayer
987 e20c4069 Michael Niedermayer
    if(s->encoding){
988 bb628dae Diego Biurrun
        /* release non-reference frames */
989 e20c4069 Michael Niedermayer
        for(i=0; i<MAX_PICTURE_COUNT; i++){
990
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
991
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
992
            }
993
        }
994 1e491e29 Michael Niedermayer
    }
995 b536d0aa Michael Niedermayer
    // clear copies, to avoid confusion
996
#if 0
997
    memset(&s->last_picture, 0, sizeof(Picture));
998
    memset(&s->next_picture, 0, sizeof(Picture));
999
    memset(&s->current_picture, 0, sizeof(Picture));
1000
#endif
1001 7b37a6e9 Michael Niedermayer
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1002 de6d9b64 Fabrice Bellard
}
1003
1004 7bc9090a Michael Niedermayer
/**
1005 db6e7795 Michael Niedermayer
 * draws an line from (ex, ey) -> (sx, sy).
1006
 * @param w width of the image
1007
 * @param h height of the image
1008
 * @param stride stride/linesize of the image
1009
 * @param color color of the arrow
1010
 */
1011
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1012 67eca72d Michael Niedermayer
    int x, y, fr, f;
1013 115329f1 Diego Biurrun
1014 f66e4f5f Reimar Döffinger
    sx= av_clip(sx, 0, w-1);
1015
    sy= av_clip(sy, 0, h-1);
1016
    ex= av_clip(ex, 0, w-1);
1017
    ey= av_clip(ey, 0, h-1);
1018 115329f1 Diego Biurrun
1019 db6e7795 Michael Niedermayer
    buf[sy*stride + sx]+= color;
1020 115329f1 Diego Biurrun
1021 c26abfa5 Diego Biurrun
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1022 db6e7795 Michael Niedermayer
        if(sx > ex){
1023 1345f4ed Diego Biurrun
            FFSWAP(int, sx, ex);
1024
            FFSWAP(int, sy, ey);
1025 db6e7795 Michael Niedermayer
        }
1026
        buf+= sx + sy*stride;
1027
        ex-= sx;
1028
        f= ((ey-sy)<<16)/ex;
1029
        for(x= 0; x <= ex; x++){
1030 8100cab9 Michael Niedermayer
            y = (x*f)>>16;
1031
            fr= (x*f)&0xFFFF;
1032
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1033
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1034 db6e7795 Michael Niedermayer
        }
1035
    }else{
1036
        if(sy > ey){
1037 1345f4ed Diego Biurrun
            FFSWAP(int, sx, ex);
1038
            FFSWAP(int, sy, ey);
1039 db6e7795 Michael Niedermayer
        }
1040
        buf+= sx + sy*stride;
1041
        ey-= sy;
1042
        if(ey) f= ((ex-sx)<<16)/ey;
1043
        else   f= 0;
1044
        for(y= 0; y <= ey; y++){
1045 8100cab9 Michael Niedermayer
            x = (y*f)>>16;
1046
            fr= (y*f)&0xFFFF;
1047 cea96420 Michael Niedermayer
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1048
            buf[y*stride + x+1]+= (color*         fr )>>16;
1049 db6e7795 Michael Niedermayer
        }
1050
    }
1051
}
1052
1053
/**
1054
 * draws an arrow from (ex, ey) -> (sx, sy).
1055
 * @param w width of the image
1056
 * @param h height of the image
1057
 * @param stride stride/linesize of the image
1058
 * @param color color of the arrow
1059
 */
1060 115329f1 Diego Biurrun
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1061 db6e7795 Michael Niedermayer
    int dx,dy;
1062
1063 f66e4f5f Reimar Döffinger
    sx= av_clip(sx, -100, w+100);
1064
    sy= av_clip(sy, -100, h+100);
1065
    ex= av_clip(ex, -100, w+100);
1066
    ey= av_clip(ey, -100, h+100);
1067 115329f1 Diego Biurrun
1068 db6e7795 Michael Niedermayer
    dx= ex - sx;
1069
    dy= ey - sy;
1070 115329f1 Diego Biurrun
1071 db6e7795 Michael Niedermayer
    if(dx*dx + dy*dy > 3*3){
1072
        int rx=  dx + dy;
1073
        int ry= -dx + dy;
1074
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1075 115329f1 Diego Biurrun
1076 db6e7795 Michael Niedermayer
        //FIXME subpixel accuracy
1077
        rx= ROUNDED_DIV(rx*3<<4, length);
1078
        ry= ROUNDED_DIV(ry*3<<4, length);
1079 115329f1 Diego Biurrun
1080 db6e7795 Michael Niedermayer
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1081
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1082
    }
1083
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1084
}
1085
1086
/**
1087 7bc9090a Michael Niedermayer
 * prints debuging info for the given picture.
1088
 */
1089 0c9bbaec Wolfgang Hesseler
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1090 7bc9090a Michael Niedermayer
1091
    if(!pict || !pict->mb_type) return;
1092
1093
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1094
        int x,y;
1095 115329f1 Diego Biurrun
1096 0c9bbaec Wolfgang Hesseler
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1097
        switch (pict->pict_type) {
1098
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1099
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1100
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1101
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1102
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1103 115329f1 Diego Biurrun
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1104 0c9bbaec Wolfgang Hesseler
        }
1105 7bc9090a Michael Niedermayer
        for(y=0; y<s->mb_height; y++){
1106
            for(x=0; x<s->mb_width; x++){
1107
                if(s->avctx->debug&FF_DEBUG_SKIP){
1108
                    int count= s->mbskip_table[x + y*s->mb_stride];
1109
                    if(count>9) count=9;
1110 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1111 7bc9090a Michael Niedermayer
                }
1112
                if(s->avctx->debug&FF_DEBUG_QP){
1113 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1114 7bc9090a Michael Niedermayer
                }
1115
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1116
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1117
                    //Type & MV direction
1118
                    if(IS_PCM(mb_type))
1119 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1120 7bc9090a Michael Niedermayer
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1121 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1122 7bc9090a Michael Niedermayer
                    else if(IS_INTRA4x4(mb_type))
1123 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1124 7bc9090a Michael Niedermayer
                    else if(IS_INTRA16x16(mb_type))
1125 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1126 7bc9090a Michael Niedermayer
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1127 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1128 7bc9090a Michael Niedermayer
                    else if(IS_DIRECT(mb_type))
1129 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1130 7bc9090a Michael Niedermayer
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1131 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1132 7bc9090a Michael Niedermayer
                    else if(IS_GMC(mb_type))
1133 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1134 7bc9090a Michael Niedermayer
                    else if(IS_SKIP(mb_type))
1135 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1136 7bc9090a Michael Niedermayer
                    else if(!USES_LIST(mb_type, 1))
1137 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1138 7bc9090a Michael Niedermayer
                    else if(!USES_LIST(mb_type, 0))
1139 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1140 7bc9090a Michael Niedermayer
                    else{
1141
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1142 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1143 7bc9090a Michael Niedermayer
                    }
1144 115329f1 Diego Biurrun
1145 7bc9090a Michael Niedermayer
                    //segmentation
1146
                    if(IS_8X8(mb_type))
1147 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1148 7bc9090a Michael Niedermayer
                    else if(IS_16X8(mb_type))
1149 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1150 7bc9090a Michael Niedermayer
                    else if(IS_8X16(mb_type))
1151 30344a83 Måns Rullgård
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1152 7bc9090a Michael Niedermayer
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1153 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1154 7bc9090a Michael Niedermayer
                    else
1155 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1156 115329f1 Diego Biurrun
1157
1158 7bc9090a Michael Niedermayer
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1159 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1160 7bc9090a Michael Niedermayer
                    else
1161 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1162 7bc9090a Michael Niedermayer
                }
1163 9b879566 Michel Bardiaux
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1164 7bc9090a Michael Niedermayer
            }
1165 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1166 7bc9090a Michael Niedermayer
        }
1167
    }
1168 8d7ec294 Wolfgang Hesseler
1169 0c9bbaec Wolfgang Hesseler
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1170 db6e7795 Michael Niedermayer
        const int shift= 1 + s->quarter_sample;
1171
        int mb_y;
1172 0c9bbaec Wolfgang Hesseler
        uint8_t *ptr;
1173
        int i;
1174 014d2f05 Baptiste Coudurier
        int h_chroma_shift, v_chroma_shift, block_height;
1175 4f8a8319 Michael Niedermayer
        const int width = s->avctx->width;
1176
        const int height= s->avctx->height;
1177 650cec0c Loren Merritt
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1178 c6f9e821 Loren Merritt
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1179 b846b231 Michael Niedermayer
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1180 0c9bbaec Wolfgang Hesseler
1181 0982834b Michael Niedermayer
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1182 0c9bbaec Wolfgang Hesseler
        for(i=0; i<3; i++){
1183 4f8a8319 Michael Niedermayer
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1184 0c9bbaec Wolfgang Hesseler
            pict->data[i]= s->visualization_buffer[i];
1185
        }
1186
        pict->type= FF_BUFFER_TYPE_COPY;
1187
        ptr= pict->data[0];
1188 014d2f05 Baptiste Coudurier
        block_height = 16>>v_chroma_shift;
1189 db6e7795 Michael Niedermayer
1190
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1191
            int mb_x;
1192
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1193
                const int mb_index= mb_x + mb_y*s->mb_stride;
1194 0c9bbaec Wolfgang Hesseler
                if((s->avctx->debug_mv) && pict->motion_val){
1195
                  int type;
1196
                  for(type=0; type<3; type++){
1197 e96682e6 Michael Niedermayer
                    int direction = 0;
1198 0c9bbaec Wolfgang Hesseler
                    switch (type) {
1199
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1200
                                continue;
1201
                              direction = 0;
1202
                              break;
1203
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1204
                                continue;
1205
                              direction = 0;
1206
                              break;
1207
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1208
                                continue;
1209
                              direction = 1;
1210
                              break;
1211
                    }
1212 ae55b533 Michael Niedermayer
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1213
                        continue;
1214
1215 0c9bbaec Wolfgang Hesseler
                    if(IS_8X8(pict->mb_type[mb_index])){
1216
                      int i;
1217
                      for(i=0; i<4; i++){
1218 db6e7795 Michael Niedermayer
                        int sx= mb_x*16 + 4 + 8*(i&1);
1219
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1220 88730be6 Måns Rullgård
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1221 0c9bbaec Wolfgang Hesseler
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1222
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1223 4f8a8319 Michael Niedermayer
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1224 0c9bbaec Wolfgang Hesseler
                      }
1225
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1226
                      int i;
1227
                      for(i=0; i<2; i++){
1228 9bc8b386 Michael Niedermayer
                        int sx=mb_x*16 + 8;
1229
                        int sy=mb_y*16 + 4 + 8*i;
1230 88730be6 Måns Rullgård
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1231 650cec0c Loren Merritt
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1232
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1233 115329f1 Diego Biurrun
1234 650cec0c Loren Merritt
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1235
                            my*=2;
1236 115329f1 Diego Biurrun
1237 650cec0c Loren Merritt
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1238
                      }
1239
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1240
                      int i;
1241
                      for(i=0; i<2; i++){
1242
                        int sx=mb_x*16 + 4 + 8*i;
1243
                        int sy=mb_y*16 + 8;
1244 88730be6 Måns Rullgård
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1245 38030214 Michael Niedermayer
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1246
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1247 115329f1 Diego Biurrun
1248 38030214 Michael Niedermayer
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1249
                            my*=2;
1250 115329f1 Diego Biurrun
1251 4f8a8319 Michael Niedermayer
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1252 0c9bbaec Wolfgang Hesseler
                      }
1253
                    }else{
1254
                      int sx= mb_x*16 + 8;
1255
                      int sy= mb_y*16 + 8;
1256 650cec0c Loren Merritt
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1257 0c9bbaec Wolfgang Hesseler
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1258
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1259 4f8a8319 Michael Niedermayer
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1260 9bc8b386 Michael Niedermayer
                    }
1261 115329f1 Diego Biurrun
                  }
1262 864119b6 Michael Niedermayer
                }
1263
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1264
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1265
                    int y;
1266 014d2f05 Baptiste Coudurier
                    for(y=0; y<block_height; y++){
1267
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1268
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1269 864119b6 Michael Niedermayer
                    }
1270
                }
1271
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1272
                    int mb_type= pict->mb_type[mb_index];
1273
                    uint64_t u,v;
1274
                    int y;
1275
#define COLOR(theta, r)\
1276
u= (int)(128 + r*cos(theta*3.141592/180));\
1277
v= (int)(128 + r*sin(theta*3.141592/180));
1278
1279 115329f1 Diego Biurrun
1280 864119b6 Michael Niedermayer
                    u=v=128;
1281
                    if(IS_PCM(mb_type)){
1282
                        COLOR(120,48)
1283
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1284
                        COLOR(30,48)
1285
                    }else if(IS_INTRA4x4(mb_type)){
1286
                        COLOR(90,48)
1287
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1288
//                        COLOR(120,48)
1289
                    }else if(IS_DIRECT(mb_type)){
1290
                        COLOR(150,48)
1291
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1292
                        COLOR(170,48)
1293
                    }else if(IS_GMC(mb_type)){
1294
                        COLOR(190,48)
1295
                    }else if(IS_SKIP(mb_type)){
1296
//                        COLOR(180,48)
1297
                    }else if(!USES_LIST(mb_type, 1)){
1298
                        COLOR(240,48)
1299
                    }else if(!USES_LIST(mb_type, 0)){
1300
                        COLOR(0,48)
1301
                    }else{
1302
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1303
                        COLOR(300,48)
1304
                    }
1305
1306
                    u*= 0x0101010101010101ULL;
1307
                    v*= 0x0101010101010101ULL;
1308 014d2f05 Baptiste Coudurier
                    for(y=0; y<block_height; y++){
1309
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1310
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1311 864119b6 Michael Niedermayer
                    }
1312
1313
                    //segmentation
1314
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1315
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1316
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1317
                    }
1318
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1319
                        for(y=0; y<16; y++)
1320
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1321
                    }
1322 e21f3983 Loren Merritt
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1323
                        int dm= 1 << (mv_sample_log2-2);
1324
                        for(i=0; i<4; i++){
1325
                            int sx= mb_x*16 + 8*(i&1);
1326
                            int sy= mb_y*16 + 8*(i>>1);
1327
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1328
                            //FIXME bidir
1329
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1330
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1331
                                for(y=0; y<8; y++)
1332
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1333
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1334
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1335
                        }
1336
                    }
1337 115329f1 Diego Biurrun
1338 864119b6 Michael Niedermayer
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1339
                        // hmm
1340
                    }
1341 db6e7795 Michael Niedermayer
                }
1342
                s->mbskip_table[mb_index]=0;
1343
            }
1344
        }
1345
    }
1346 7bc9090a Michael Niedermayer
}
1347
1348 115329f1 Diego Biurrun
static inline int hpel_motion_lowres(MpegEncContext *s,
1349 ac8b03c0 Michael Niedermayer
                                  uint8_t *dest, uint8_t *src,
1350
                                  int field_based, int field_select,
1351
                                  int src_x, int src_y,
1352
                                  int width, int height, int stride,
1353
                                  int h_edge_pos, int v_edge_pos,
1354
                                  int w, int h, h264_chroma_mc_func *pix_op,
1355
                                  int motion_x, int motion_y)
1356
{
1357
    const int lowres= s->avctx->lowres;
1358
    const int s_mask= (2<<lowres)-1;
1359
    int emu=0;
1360
    int sx, sy;
1361
1362
    if(s->quarter_sample){
1363
        motion_x/=2;
1364
        motion_y/=2;
1365
    }
1366
1367
    sx= motion_x & s_mask;
1368
    sy= motion_y & s_mask;
1369
    src_x += motion_x >> (lowres+1);
1370
    src_y += motion_y >> (lowres+1);
1371 115329f1 Diego Biurrun
1372 ac8b03c0 Michael Niedermayer
    src += src_y * stride + src_x;
1373
1374
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1375
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1376
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1377
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1378
        src= s->edge_emu_buffer;
1379
        emu=1;
1380
    }
1381
1382
    sx <<= 2 - lowres;
1383
    sy <<= 2 - lowres;
1384
    if(field_select)
1385
        src += s->linesize;
1386
    pix_op[lowres](dest, src, stride, h, sx, sy);
1387
    return emu;
1388
}
1389
1390 de6d9b64 Fabrice Bellard
/* apply one mpeg motion vector to the three components */
1391 3ada94ba Benoit Fouet
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1392 0c1a9eda Zdenek Kabelac
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1393 5ba326b5 Michael Niedermayer
                               int field_based, int bottom_field, int field_select,
1394 3ada94ba Benoit Fouet
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1395 de6d9b64 Fabrice Bellard
                               int motion_x, int motion_y, int h)
1396
{
1397 95d356c5 Michael Niedermayer
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1398 3ada94ba Benoit Fouet
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1399
    const int lowres= s->avctx->lowres;
1400
    const int block_s= 8>>lowres;
1401
    const int s_mask= (2<<lowres)-1;
1402
    const int h_edge_pos = s->h_edge_pos >> lowres;
1403
    const int v_edge_pos = s->v_edge_pos >> lowres;
1404 95d356c5 Michael Niedermayer
    linesize   = s->current_picture.linesize[0] << field_based;
1405 b536d0aa Michael Niedermayer
    uvlinesize = s->current_picture.linesize[1] << field_based;
1406 93a21abd Michael Niedermayer
1407 ca74c0a1 Diego Biurrun
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1408 3ada94ba Benoit Fouet
        motion_x/=2;
1409
        motion_y/=2;
1410
    }
1411
1412
    if(field_based){
1413
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1414
    }
1415
1416
    sx= motion_x & s_mask;
1417
    sy= motion_y & s_mask;
1418
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1419
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1420 115329f1 Diego Biurrun
1421 178fcca8 Michael Niedermayer
    if (s->out_format == FMT_H263) {
1422 71845595 Michael Niedermayer
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1423
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1424 178fcca8 Michael Niedermayer
        uvsrc_x = src_x>>1;
1425
        uvsrc_y = src_y>>1;
1426
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1427
        mx = motion_x / 4;
1428
        my = motion_y / 4;
1429
        uvsx = (2*mx) & s_mask;
1430
        uvsy = (2*my) & s_mask;
1431
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1432
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1433
    } else {
1434
        mx = motion_x / 2;
1435
        my = motion_y / 2;
1436
        uvsx = mx & s_mask;
1437
        uvsy = my & s_mask;
1438
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1439 da9c9637 Michael Niedermayer
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1440 178fcca8 Michael Niedermayer
    }
1441
1442
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1443
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1444
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1445
1446
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1447
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1448
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1449
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1450
            ptr_y = s->edge_emu_buffer;
1451 49fb20cb Aurelien Jacobs
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1452 178fcca8 Michael Niedermayer
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1453 115329f1 Diego Biurrun
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1454 178fcca8 Michael Niedermayer
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1455 115329f1 Diego Biurrun
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1456 178fcca8 Michael Niedermayer
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1457
                ptr_cb= uvbuf;
1458
                ptr_cr= uvbuf+16;
1459
            }
1460
    }
1461
1462 da9c9637 Michael Niedermayer
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1463
        dest_y += s->linesize;
1464
        dest_cb+= s->uvlinesize;
1465
        dest_cr+= s->uvlinesize;
1466
    }
1467
1468
    if(field_select){
1469
        ptr_y += s->linesize;
1470
        ptr_cb+= s->uvlinesize;
1471
        ptr_cr+= s->uvlinesize;
1472
    }
1473
1474 178fcca8 Michael Niedermayer
    sx <<= 2 - lowres;
1475
    sy <<= 2 - lowres;
1476
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1477 115329f1 Diego Biurrun
1478 49fb20cb Aurelien Jacobs
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1479 178fcca8 Michael Niedermayer
        uvsx <<= 2 - lowres;
1480
        uvsy <<= 2 - lowres;
1481
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1482
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1483
    }
1484 5f6c92d4 Michael Niedermayer
    //FIXME h261 lowres loop filter
1485 178fcca8 Michael Niedermayer
}
1486
1487 ac8b03c0 Michael Niedermayer
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1488
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1489
                                     uint8_t **ref_picture,
1490
                                     h264_chroma_mc_func *pix_op,
1491
                                     int mx, int my){
1492
    const int lowres= s->avctx->lowres;
1493
    const int block_s= 8>>lowres;
1494
    const int s_mask= (2<<lowres)-1;
1495
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1496
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1497
    int emu=0, src_x, src_y, offset, sx, sy;
1498
    uint8_t *ptr;
1499 115329f1 Diego Biurrun
1500 ac8b03c0 Michael Niedermayer
    if(s->quarter_sample){
1501
        mx/=2;
1502
        my/=2;
1503
    }
1504
1505
    /* In case of 8X8, we construct a single chroma motion vector
1506
       with a special rounding */
1507
    mx= ff_h263_round_chroma(mx);
1508
    my= ff_h263_round_chroma(my);
1509 115329f1 Diego Biurrun
1510 ac8b03c0 Michael Niedermayer
    sx= mx & s_mask;
1511
    sy= my & s_mask;
1512
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1513
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1514 115329f1 Diego Biurrun
1515 ac8b03c0 Michael Niedermayer
    offset = src_y * s->uvlinesize + src_x;
1516
    ptr = ref_picture[1] + offset;
1517
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1518
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1519
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1520
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1521
            ptr= s->edge_emu_buffer;
1522
            emu=1;
1523
        }
1524 115329f1 Diego Biurrun
    }
1525 ac8b03c0 Michael Niedermayer
    sx <<= 2 - lowres;
1526
    sy <<= 2 - lowres;
1527
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1528 115329f1 Diego Biurrun
1529 ac8b03c0 Michael Niedermayer
    ptr = ref_picture[2] + offset;
1530
    if(emu){
1531
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1532
        ptr= s->edge_emu_buffer;
1533
    }
1534
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1535
}
1536
1537 f7190f73 Michael Niedermayer
/**
1538 bb628dae Diego Biurrun
 * motion compensation of a single macroblock
1539 eb14c713 Michael Niedermayer
 * @param s context
1540
 * @param dest_y luma destination pointer
1541
 * @param dest_cb chroma cb/u destination pointer
1542
 * @param dest_cr chroma cr/v destination pointer
1543
 * @param dir direction (0->forward, 1->backward)
1544
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1545
 * @param pic_op halfpel motion compensation function (average or put normally)
1546
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1547
 */
1548 3ada94ba Benoit Fouet
static inline void MPV_motion_lowres(MpegEncContext *s,
1549 0c1a9eda Zdenek Kabelac
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1550 115329f1 Diego Biurrun
                              int dir, uint8_t **ref_picture,
1551 3ada94ba Benoit Fouet
                              h264_chroma_mc_func *pix_op)
1552 de6d9b64 Fabrice Bellard
{
1553 3ada94ba Benoit Fouet
    int mx, my;
1554 de6d9b64 Fabrice Bellard
    int mb_x, mb_y, i;
1555 3ada94ba Benoit Fouet
    const int lowres= s->avctx->lowres;
1556
    const int block_s= 8>>lowres;
1557 de6d9b64 Fabrice Bellard
1558
    mb_x = s->mb_x;
1559
    mb_y = s->mb_y;
1560
1561
    switch(s->mv_type) {
1562
    case MV_TYPE_16X16:
1563 3ada94ba Benoit Fouet
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1564
                    0, 0, 0,
1565
                    ref_picture, pix_op,
1566
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1567 de6d9b64 Fabrice Bellard
        break;
1568
    case MV_TYPE_8X8:
1569 1e7bfebe Michael Niedermayer
        mx = 0;
1570
        my = 0;
1571
            for(i=0;i<4;i++) {
1572 3ada94ba Benoit Fouet
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1573 5ba326b5 Michael Niedermayer
                            ref_picture[0], 0, 0,
1574 3ada94ba Benoit Fouet
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1575 f7190f73 Michael Niedermayer
                            s->width, s->height, s->linesize,
1576 3ada94ba Benoit Fouet
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1577
                            block_s, block_s, pix_op,
1578 f7190f73 Michael Niedermayer
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1579 1e7bfebe Michael Niedermayer
1580
                mx += s->mv[dir][i][0];
1581
                my += s->mv[dir][i][1];
1582 225f9c44 Michael Niedermayer
            }
1583 1e7bfebe Michael Niedermayer
1584 49fb20cb Aurelien Jacobs
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1585 3ada94ba Benoit Fouet
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1586 de6d9b64 Fabrice Bellard
        break;
1587
    case MV_TYPE_FIELD:
1588
        if (s->picture_structure == PICT_FRAME) {
1589 3ada94ba Benoit Fouet
            /* top field */
1590
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1591
                        1, 0, s->field_select[dir][0],
1592
                        ref_picture, pix_op,
1593
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1594
            /* bottom field */
1595
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1596
                        1, 1, s->field_select[dir][1],
1597
                        ref_picture, pix_op,
1598
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1599 de6d9b64 Fabrice Bellard
        } else {
1600 9701840b Aurelien Jacobs
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1601 5ba326b5 Michael Niedermayer
                ref_picture= s->current_picture_ptr->data;
1602 115329f1 Diego Biurrun
            }
1603 de6d9b64 Fabrice Bellard
1604 3ada94ba Benoit Fouet
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1605 5ba326b5 Michael Niedermayer
                        0, 0, s->field_select[dir][0],
1606
                        ref_picture, pix_op,
1607 3ada94ba Benoit Fouet
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1608 de6d9b64 Fabrice Bellard
        }
1609
        break;
1610 c8a4ebbf Michael Niedermayer
    case MV_TYPE_16X8:
1611
        for(i=0; i<2; i++){
1612
            uint8_t ** ref2picture;
1613 d55e93e4 Ivan Kalvachev
1614 9701840b Aurelien Jacobs
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1615 d55e93e4 Ivan Kalvachev
                ref2picture= ref_picture;
1616
            }else{
1617 5ba326b5 Michael Niedermayer
                ref2picture= s->current_picture_ptr->data;
1618 115329f1 Diego Biurrun
            }
1619 d55e93e4 Ivan Kalvachev
1620 3ada94ba Benoit Fouet
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1621 c8a4ebbf Michael Niedermayer
                        0, 0, s->field_select[dir][i],
1622 5ba326b5 Michael Niedermayer
                        ref2picture, pix_op,
1623 3ada94ba Benoit Fouet
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1624 115329f1 Diego Biurrun
1625 3ada94ba Benoit Fouet
            dest_y += 2*block_s*s->linesize;
1626
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1627
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1628 115329f1 Diego Biurrun
        }
1629 d55e93e4 Ivan Kalvachev
        break;
1630 1dff7d56 Ivan Kalvachev
    case MV_TYPE_DMV:
1631
        if(s->picture_structure == PICT_FRAME){
1632 c8a4ebbf Michael Niedermayer
            for(i=0; i<2; i++){
1633
                int j;
1634
                for(j=0; j<2; j++){
1635 3ada94ba Benoit Fouet
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1636 c8a4ebbf Michael Niedermayer
                                1, j, j^i,
1637
                                ref_picture, pix_op,
1638 3ada94ba Benoit Fouet
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1639 c8a4ebbf Michael Niedermayer
                }
1640 3ada94ba Benoit Fouet
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1641 c8a4ebbf Michael Niedermayer
            }
1642 1dff7d56 Ivan Kalvachev
        }else{
1643 c8a4ebbf Michael Niedermayer
            for(i=0; i<2; i++){
1644 3ada94ba Benoit Fouet
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1645 c8a4ebbf Michael Niedermayer
                            0, 0, s->picture_structure != i+1,
1646
                            ref_picture, pix_op,
1647 3ada94ba Benoit Fouet
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1648 1dff7d56 Ivan Kalvachev
1649 c8a4ebbf Michael Niedermayer
                // after put we make avg of the same block
1650 3ada94ba Benoit Fouet
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1651 1dff7d56 Ivan Kalvachev
1652 c8a4ebbf Michael Niedermayer
                //opposite parity is always in the same frame if this is second field
1653
                if(!s->first_field){
1654 115329f1 Diego Biurrun
                    ref_picture = s->current_picture_ptr->data;
1655 c8a4ebbf Michael Niedermayer
                }
1656 5ba326b5 Michael Niedermayer
            }
1657 1dff7d56 Ivan Kalvachev
        }
1658
    break;
1659 f7190f73 Michael Niedermayer
    default: assert(0);
1660 de6d9b64 Fabrice Bellard
    }
1661
}
1662
1663 3ada94ba Benoit Fouet
/* put block[] to dest[] */
1664
static inline void put_dct(MpegEncContext *s,
1665
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1666 178fcca8 Michael Niedermayer
{
1667 3ada94ba Benoit Fouet
    s->dct_unquantize_intra(s, block, i, qscale);
1668
    s->dsp.idct_put (dest, line_size, block);
1669
}
1670 da9c9637 Michael Niedermayer
1671 3ada94ba Benoit Fouet
/* add block[] to dest[] */
1672
static inline void add_dct(MpegEncContext *s,
1673
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1674
{
1675
    if (s->block_last_index[i] >= 0) {
1676
        s->dsp.idct_add (dest, line_size, block);
1677
    }
1678
}
1679 2417652e Michael Niedermayer
1680 115329f1 Diego Biurrun
static inline void add_dequant_dct(MpegEncContext *s,
1681 332f9ac4 Michael Niedermayer
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1682 0f440e02 Michael Niedermayer
{
1683 de6d9b64 Fabrice Bellard
    if (s->block_last_index[i] >= 0) {
1684 d50635cd Michael Niedermayer
        s->dct_unquantize_inter(s, block, i, qscale);
1685 9dbcbd92 Michael Niedermayer
1686 b0368839 Michael Niedermayer
        s->dsp.idct_add (dest, line_size, block);
1687 de6d9b64 Fabrice Bellard
    }
1688
}
1689
1690 7f2fe444 Michael Niedermayer
/**
1691
 * cleans dc, ac, coded_block for the current non intra MB
1692
 */
1693
void ff_clean_intra_table_entries(MpegEncContext *s)
1694
{
1695 137c8468 Michael Niedermayer
    int wrap = s->b8_stride;
1696 7f2fe444 Michael Niedermayer
    int xy = s->block_index[0];
1697 115329f1 Diego Biurrun
1698
    s->dc_val[0][xy           ] =
1699
    s->dc_val[0][xy + 1       ] =
1700 7f2fe444 Michael Niedermayer
    s->dc_val[0][xy     + wrap] =
1701
    s->dc_val[0][xy + 1 + wrap] = 1024;
1702
    /* ac pred */
1703 0c1a9eda Zdenek Kabelac
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1704
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1705 7f2fe444 Michael Niedermayer
    if (s->msmpeg4_version>=3) {
1706
        s->coded_block[xy           ] =
1707
        s->coded_block[xy + 1       ] =
1708
        s->coded_block[xy     + wrap] =
1709
        s->coded_block[xy + 1 + wrap] = 0;
1710
    }
1711
    /* chroma */
1712 137c8468 Michael Niedermayer
    wrap = s->mb_stride;
1713
    xy = s->mb_x + s->mb_y * wrap;
1714 7f2fe444 Michael Niedermayer
    s->dc_val[1][xy] =
1715
    s->dc_val[2][xy] = 1024;
1716
    /* ac pred */
1717 0c1a9eda Zdenek Kabelac
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1718
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1719 115329f1 Diego Biurrun
1720 137c8468 Michael Niedermayer
    s->mbintra_table[xy]= 0;
1721 7f2fe444 Michael Niedermayer
}
1722
1723 de6d9b64 Fabrice Bellard
/* generic function called after a macroblock has been parsed by the
1724
   decoder or after it has been encoded by the encoder.
1725

1726
   Important variables used:
1727
   s->mb_intra : true if intra macroblock
1728
   s->mv_dir   : motion vector direction
1729
   s->mv_type  : motion vector type
1730
   s->mv       : motion vector
1731
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1732
 */
1733 54816a3e Keiji Costantini
static av_always_inline
1734
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1735 bd7c626a Keiji Costantini
                            int lowres_flag, int is_mpeg12)
1736 de6d9b64 Fabrice Bellard
{
1737 8257bf05 Zdenek Kabelac
    int mb_x, mb_y;
1738 7bc9090a Michael Niedermayer
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1739 b250f9c6 Aurelien Jacobs
#if CONFIG_XVMC
1740 2e7b4c84 Ivan Kalvachev
    if(s->avctx->xvmc_acceleration){
1741 a579db0c Ivan Kalvachev
        XVMC_decode_mb(s);//xvmc uses pblocks
1742 2e7b4c84 Ivan Kalvachev
        return;
1743
    }
1744
#endif
1745 de6d9b64 Fabrice Bellard
1746
    mb_x = s->mb_x;
1747
    mb_y = s->mb_y;
1748
1749 8289c6fa Wolfgang Hesseler
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1750
       /* save DCT coefficients */
1751
       int i,j;
1752
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1753
       for(i=0; i<6; i++)
1754
           for(j=0; j<64; j++)
1755
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1756
    }
1757
1758 1e491e29 Michael Niedermayer
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1759 79e7b305 Arpi
1760 de6d9b64 Fabrice Bellard
    /* update DC predictors for P macroblocks */
1761
    if (!s->mb_intra) {
1762 bd7c626a Keiji Costantini
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1763 0f440e02 Michael Niedermayer
            if(s->mbintra_table[mb_xy])
1764 7f2fe444 Michael Niedermayer
                ff_clean_intra_table_entries(s);
1765 de6d9b64 Fabrice Bellard
        } else {
1766 7f2fe444 Michael Niedermayer
            s->last_dc[0] =
1767
            s->last_dc[1] =
1768 de6d9b64 Fabrice Bellard
            s->last_dc[2] = 128 << s->intra_dc_precision;
1769
        }
1770
    }
1771 bd7c626a Keiji Costantini
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1772 0f440e02 Michael Niedermayer
        s->mbintra_table[mb_xy]=1;
1773 bff6ecaa Michael Niedermayer
1774 9701840b Aurelien Jacobs
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1775 0c1a9eda Zdenek Kabelac
        uint8_t *dest_y, *dest_cb, *dest_cr;
1776 0f440e02 Michael Niedermayer
        int dct_linesize, dct_offset;
1777 b3184779 Michael Niedermayer
        op_pixels_func (*op_pix)[4];
1778
        qpel_mc_func (*op_qpix)[16];
1779 dfb706da Kevin Baragona
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1780 b536d0aa Michael Niedermayer
        const int uvlinesize= s->current_picture.linesize[1];
1781 9701840b Aurelien Jacobs
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1782 178fcca8 Michael Niedermayer
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1783 3bb4e23a Fabrice Bellard
1784 1e491e29 Michael Niedermayer
        /* avoid copy if macroblock skipped in last frame too */
1785
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1786
        if(!s->encoding){
1787 0c1a9eda Zdenek Kabelac
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1788 1e491e29 Michael Niedermayer
            const int age= s->current_picture.age;
1789 0fd90455 Michael Niedermayer
1790 1e491e29 Michael Niedermayer
            assert(age);
1791
1792 160d679c Mike Melanson
            if (s->mb_skipped) {
1793
                s->mb_skipped= 0;
1794 9701840b Aurelien Jacobs
                assert(s->pict_type!=FF_I_TYPE);
1795 115329f1 Diego Biurrun
1796 160d679c Mike Melanson
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1797 0fd90455 Michael Niedermayer
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1798
1799 1e491e29 Michael Niedermayer
                /* if previous was skipped too, then nothing to do !  */
1800 f943e138 Michael Niedermayer
                if (*mbskip_ptr >= age && s->current_picture.reference){
1801
                    return;
1802 1e491e29 Michael Niedermayer
                }
1803 f943e138 Michael Niedermayer
            } else if(!s->current_picture.reference){
1804
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1805
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1806
            } else{
1807 3bb4e23a Fabrice Bellard
                *mbskip_ptr = 0; /* not skipped */
1808
            }
1809 3994623d Michael Niedermayer
        }
1810 115329f1 Diego Biurrun
1811 ffdff4d7 Ivan Kalvachev
        dct_linesize = linesize << s->interlaced_dct;
1812 178fcca8 Michael Niedermayer
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1813 115329f1 Diego Biurrun
1814 b68ab260 Michael Niedermayer
        if(readable){
1815
            dest_y=  s->dest[0];
1816
            dest_cb= s->dest[1];
1817
            dest_cr= s->dest[2];
1818
        }else{
1819 9c3d33d6 Michael Niedermayer
            dest_y = s->b_scratchpad;
1820 ae35f5e1 Michael Niedermayer
            dest_cb= s->b_scratchpad+16*linesize;
1821 ffdff4d7 Ivan Kalvachev
            dest_cr= s->b_scratchpad+32*linesize;
1822 b68ab260 Michael Niedermayer
        }
1823 178fcca8 Michael Niedermayer
1824 de6d9b64 Fabrice Bellard
        if (!s->mb_intra) {
1825
            /* motion handling */
1826 dfb706da Kevin Baragona
            /* decoding or more than one mb_type (MC was already done otherwise) */
1827 7d1c3fc1 Michael Niedermayer
            if(!s->encoding){
1828 178fcca8 Michael Niedermayer
                if(lowres_flag){
1829
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1830 de6d9b64 Fabrice Bellard
1831 178fcca8 Michael Niedermayer
                    if (s->mv_dir & MV_DIR_FORWARD) {
1832
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1833
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1834
                    }
1835
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1836
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1837
                    }
1838
                }else{
1839 2833fc46 Loren Merritt
                    op_qpix= s->me.qpel_put;
1840 9701840b Aurelien Jacobs
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1841 178fcca8 Michael Niedermayer
                        op_pix = s->dsp.put_pixels_tab;
1842
                    }else{
1843
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1844
                    }
1845
                    if (s->mv_dir & MV_DIR_FORWARD) {
1846
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1847
                        op_pix = s->dsp.avg_pixels_tab;
1848 2833fc46 Loren Merritt
                        op_qpix= s->me.qpel_avg;
1849 178fcca8 Michael Niedermayer
                    }
1850
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1851
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1852
                    }
1853 9dbcbd92 Michael Niedermayer
                }
1854 de6d9b64 Fabrice Bellard
            }
1855
1856 0f440e02 Michael Niedermayer
            /* skip dequant / idct if we are really late ;) */
1857 8c3eba7c Michael Niedermayer
            if(s->hurry_up>1) goto skip_idct;
1858
            if(s->avctx->skip_idct){
1859 9701840b Aurelien Jacobs
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1860
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1861 8c3eba7c Michael Niedermayer
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1862
                    goto skip_idct;
1863
            }
1864 0f440e02 Michael Niedermayer
1865 de6d9b64 Fabrice Bellard
            /* add dct residue */
1866 029911d1 Michael Niedermayer
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1867 a0201736 Michael Niedermayer
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1868 178fcca8 Michael Niedermayer
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1869
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1870
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1871
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1872 0f440e02 Michael Niedermayer
1873 49fb20cb Aurelien Jacobs
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1874 2d974017 Baptiste Coudurier
                    if (s->chroma_y_shift){
1875
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1876
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1877
                    }else{
1878
                        dct_linesize >>= 1;
1879
                        dct_offset >>=1;
1880
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1881
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1882
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1883
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1884
                    }
1885 b50eef3a Michael Niedermayer
                }
1886 bd7c626a Keiji Costantini
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1887 178fcca8 Michael Niedermayer
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1888
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1889
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1890
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1891 de6d9b64 Fabrice Bellard
1892 49fb20cb Aurelien Jacobs
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1893 ffdff4d7 Ivan Kalvachev
                    if(s->chroma_y_shift){//Chroma420
1894
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
1895
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
1896
                    }else{
1897
                        //chroma422
1898
                        dct_linesize = uvlinesize << s->interlaced_dct;
1899
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1900
1901
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
1902
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
1903
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1904
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1905
                        if(!s->chroma_x_shift){//Chroma444
1906
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1907
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1908
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1909
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1910
                        }
1911
                    }
1912
                }//fi gray
1913
            }
1914 49fb20cb Aurelien Jacobs
            else if (CONFIG_WMV2) {
1915 1457ab52 Michael Niedermayer
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1916 0f440e02 Michael Niedermayer
            }
1917 de6d9b64 Fabrice Bellard
        } else {
1918
            /* dct only in intra block */
1919 029911d1 Michael Niedermayer
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1920 178fcca8 Michael Niedermayer
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1921
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1922
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1923
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1924 a0201736 Michael Niedermayer
1925 49fb20cb Aurelien Jacobs
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1926 2d974017 Baptiste Coudurier
                    if(s->chroma_y_shift){
1927
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1928
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1929
                    }else{
1930
                        dct_offset >>=1;
1931
                        dct_linesize >>=1;
1932
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1933
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1934
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1935 3ada94ba Benoit Fouet
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1936 477ab036 Michael Niedermayer
                    }
1937
                }
1938
            }else{
1939 3ada94ba Benoit Fouet
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1940
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1941
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1942
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1943 fbb89806 Michael Niedermayer
1944 49fb20cb Aurelien Jacobs
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1945 3ada94ba Benoit Fouet
                    if(s->chroma_y_shift){
1946
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1947
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1948
                    }else{
1949 fbb89806 Michael Niedermayer
1950 3ada94ba Benoit Fouet
                        dct_linesize = uvlinesize << s->interlaced_dct;
1951
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1952 9981dfc6 Michael Niedermayer
1953 3ada94ba Benoit Fouet
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1954
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1955
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1956
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1957
                        if(!s->chroma_x_shift){//Chroma444
1958
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1959
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
1960
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1961
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1962
                        }
1963
                    }
1964
                }//gray
1965 9981dfc6 Michael Niedermayer
            }
1966 477ab036 Michael Niedermayer
        }
1967 3ada94ba Benoit Fouet
skip_idct:
1968
        if(!readable){
1969
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
1970
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1971
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1972 34f60ee6 Michael Niedermayer
        }
1973 477ab036 Michael Niedermayer
    }
1974
}
1975
1976 3ada94ba Benoit Fouet
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1977 b250f9c6 Aurelien Jacobs
#if !CONFIG_SMALL
1978 bd7c626a Keiji Costantini
    if(s->out_format == FMT_MPEG1) {
1979
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1980
        else                 MPV_decode_mb_internal(s, block, 0, 1);
1981
    } else
1982
#endif
1983
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1984
    else                  MPV_decode_mb_internal(s, block, 0, 0);
1985 77ea0d4b Michael Niedermayer
}
1986
1987 3ada94ba Benoit Fouet
/**
1988
 *
1989
 * @param h is the normal height, this will be reduced automatically if needed for the last row
1990
 */
1991
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1992
    if (s->avctx->draw_horiz_band) {
1993
        AVFrame *src;
1994
        int offset[4];
1995 77ea0d4b Michael Niedermayer
1996 3ada94ba Benoit Fouet
        if(s->picture_structure != PICT_FRAME){
1997
            h <<= 1;
1998
            y <<= 1;
1999
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2000 77ea0d4b Michael Niedermayer
        }
2001
2002 3ada94ba Benoit Fouet
        h= FFMIN(h, s->avctx->height - y);
2003 77ea0d4b Michael Niedermayer
2004 9701840b Aurelien Jacobs
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2005 3ada94ba Benoit Fouet
            src= (AVFrame*)s->current_picture_ptr;
2006
        else if(s->last_picture_ptr)
2007
            src= (AVFrame*)s->last_picture_ptr;
2008
        else
2009
            return;
2010 115329f1 Diego Biurrun
2011 9701840b Aurelien Jacobs
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2012 3ada94ba Benoit Fouet
            offset[0]=
2013
            offset[1]=
2014
            offset[2]=
2015
            offset[3]= 0;
2016 77ea0d4b Michael Niedermayer
        }else{
2017 cea96420 Michael Niedermayer
            offset[0]= y * s->linesize;
2018 3ada94ba Benoit Fouet
            offset[1]=
2019
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2020
            offset[3]= 0;
2021 77ea0d4b Michael Niedermayer
        }
2022 115329f1 Diego Biurrun
2023 3ada94ba Benoit Fouet
        emms_c();
2024 77ea0d4b Michael Niedermayer
2025 3ada94ba Benoit Fouet
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2026
                                  y, s->picture_structure, h);
2027
    }
2028
}
2029 115329f1 Diego Biurrun
2030 3ada94ba Benoit Fouet
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2031
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2032
    const int uvlinesize= s->current_picture.linesize[1];
2033
    const int mb_size= 4 - s->avctx->lowres;
2034 77ea0d4b Michael Niedermayer
2035 3ada94ba Benoit Fouet
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2036
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2037
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2038
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2039
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2040
    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;
2041
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2042 115329f1 Diego Biurrun
2043 3ada94ba Benoit Fouet
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2044
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2045
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2046 115329f1 Diego Biurrun
2047 9701840b Aurelien Jacobs
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2048 3ada94ba Benoit Fouet
    {
2049
        s->dest[0] += s->mb_y *   linesize << mb_size;
2050
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2051
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2052 77ea0d4b Michael Niedermayer
    }
2053
}
2054 115329f1 Diego Biurrun
2055 3ada94ba Benoit Fouet
void ff_mpeg_flush(AVCodecContext *avctx){
2056
    int i;
2057
    MpegEncContext *s = avctx->priv_data;
2058 77ea0d4b Michael Niedermayer
2059 3ada94ba Benoit Fouet
    if(s==NULL || s->picture==NULL)
2060
        return;
2061 77ea0d4b Michael Niedermayer
2062 3ada94ba Benoit Fouet
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2063
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2064
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2065
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2066 de6d9b64 Fabrice Bellard
    }
2067 3ada94ba Benoit Fouet
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2068 115329f1 Diego Biurrun
2069 3ada94ba Benoit Fouet
    s->mb_x= s->mb_y= 0;
2070 7801d21d Michael Niedermayer
2071 3ada94ba Benoit Fouet
    s->parse_context.state= -1;
2072
    s->parse_context.frame_start_found= 0;
2073
    s->parse_context.overread= 0;
2074
    s->parse_context.overread_index= 0;
2075
    s->parse_context.index= 0;
2076
    s->parse_context.last_index= 0;
2077
    s->bitstream_buffer_size=0;
2078
    s->pp_time=0;
2079 de6d9b64 Fabrice Bellard
}
2080
2081 115329f1 Diego Biurrun
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2082 21af69f7 Fabrice Bellard
                                   DCTELEM *block, int n, int qscale)
2083 de6d9b64 Fabrice Bellard
{
2084 badaf88e Michael Niedermayer
    int i, level, nCoeffs;
2085 0c1a9eda Zdenek Kabelac
    const uint16_t *quant_matrix;
2086 de6d9b64 Fabrice Bellard
2087 2ad1516a Michael Niedermayer
    nCoeffs= s->block_last_index[n];
2088 115329f1 Diego Biurrun
2089
    if (n < 4)
2090 d50635cd Michael Niedermayer
        block[0] = block[0] * s->y_dc_scale;
2091
    else
2092
        block[0] = block[0] * s->c_dc_scale;
2093
    /* XXX: only mpeg1 */
2094
    quant_matrix = s->intra_matrix;
2095
    for(i=1;i<=nCoeffs;i++) {
2096
        int j= s->intra_scantable.permutated[i];
2097
        level = block[j];
2098
        if (level) {
2099
            if (level < 0) {
2100
                level = -level;
2101
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2102
                level = (level - 1) | 1;
2103
                level = -level;
2104
            } else {
2105
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2106
                level = (level - 1) | 1;
2107 de6d9b64 Fabrice Bellard
            }
2108 d50635cd Michael Niedermayer
            block[j] = level;
2109 de6d9b64 Fabrice Bellard
        }
2110 d50635cd Michael Niedermayer
    }
2111
}
2112
2113 115329f1 Diego Biurrun
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2114 d50635cd Michael Niedermayer
                                   DCTELEM *block, int n, int qscale)
2115
{
2116
    int i, level, nCoeffs;
2117
    const uint16_t *quant_matrix;
2118
2119
    nCoeffs= s->block_last_index[n];
2120 115329f1 Diego Biurrun
2121 d50635cd Michael Niedermayer
    quant_matrix = s->inter_matrix;
2122
    for(i=0; i<=nCoeffs; i++) {
2123
        int j= s->intra_scantable.permutated[i];
2124
        level = block[j];
2125
        if (level) {
2126
            if (level < 0) {
2127
                level = -level;
2128
                level = (((level << 1) + 1) * qscale *
2129
                         ((int) (quant_matrix[j]))) >> 4;
2130
                level = (level - 1) | 1;
2131
                level = -level;
2132
            } else {
2133
                level = (((level << 1) + 1) * qscale *
2134
                         ((int) (quant_matrix[j]))) >> 4;
2135
                level = (level - 1) | 1;
2136 de6d9b64 Fabrice Bellard
            }
2137 d50635cd Michael Niedermayer
            block[j] = level;
2138 de6d9b64 Fabrice Bellard
        }
2139
    }
2140
}
2141 21af69f7 Fabrice Bellard
2142 115329f1 Diego Biurrun
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2143 9dbf1ddd Michael Niedermayer
                                   DCTELEM *block, int n, int qscale)
2144
{
2145
    int i, level, nCoeffs;
2146 0c1a9eda Zdenek Kabelac
    const uint16_t *quant_matrix;
2147 9dbf1ddd Michael Niedermayer
2148 2ad1516a Michael Niedermayer
    if(s->alternate_scan) nCoeffs= 63;
2149
    else nCoeffs= s->block_last_index[n];
2150 115329f1 Diego Biurrun
2151
    if (n < 4)
2152 d50635cd Michael Niedermayer
        block[0] = block[0] * s->y_dc_scale;
2153
    else
2154
        block[0] = block[0] * s->c_dc_scale;
2155
    quant_matrix = s->intra_matrix;
2156
    for(i=1;i<=nCoeffs;i++) {
2157
        int j= s->intra_scantable.permutated[i];
2158
        level = block[j];
2159
        if (level) {
2160
            if (level < 0) {
2161
                level = -level;
2162
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2163
                level = -level;
2164
            } else {
2165
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2166
            }
2167
            block[j] = level;
2168
        }
2169
    }
2170
}
2171
2172 e27b6e62 Michael Niedermayer
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2173
                                   DCTELEM *block, int n, int qscale)
2174
{
2175
    int i, level, nCoeffs;
2176
    const uint16_t *quant_matrix;
2177
    int sum=-1;
2178
2179
    if(s->alternate_scan) nCoeffs= 63;
2180
    else nCoeffs= s->block_last_index[n];
2181
2182
    if (n < 4)
2183
        block[0] = block[0] * s->y_dc_scale;
2184
    else
2185
        block[0] = block[0] * s->c_dc_scale;
2186
    quant_matrix = s->intra_matrix;
2187
    for(i=1;i<=nCoeffs;i++) {
2188
        int j= s->intra_scantable.permutated[i];
2189
        level = block[j];
2190
        if (level) {
2191
            if (level < 0) {
2192
                level = -level;
2193
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2194
                level = -level;
2195
            } else {
2196
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2197
            }
2198
            block[j] = level;
2199
            sum+=level;
2200
        }
2201
    }
2202
    block[63]^=sum&1;
2203
}
2204
2205 115329f1 Diego Biurrun
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2206 d50635cd Michael Niedermayer
                                   DCTELEM *block, int n, int qscale)
2207
{
2208
    int i, level, nCoeffs;
2209
    const uint16_t *quant_matrix;
2210
    int sum=-1;
2211
2212
    if(s->alternate_scan) nCoeffs= 63;
2213
    else nCoeffs= s->block_last_index[n];
2214 115329f1 Diego Biurrun
2215 d50635cd Michael Niedermayer
    quant_matrix = s->inter_matrix;
2216
    for(i=0; i<=nCoeffs; i++) {
2217
        int j= s->intra_scantable.permutated[i];
2218
        level = block[j];
2219
        if (level) {
2220
            if (level < 0) {
2221
                level = -level;
2222
                level = (((level << 1) + 1) * qscale *
2223
                         ((int) (quant_matrix[j]))) >> 4;
2224
                level = -level;
2225
            } else {
2226
                level = (((level << 1) + 1) * qscale *
2227
                         ((int) (quant_matrix[j]))) >> 4;
2228
            }
2229
            block[j] = level;
2230
            sum+=level;
2231
        }
2232
    }
2233
    block[63]^=sum&1;
2234
}
2235
2236 115329f1 Diego Biurrun
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2237 d50635cd Michael Niedermayer
                                  DCTELEM *block, int n, int qscale)
2238
{
2239
    int i, level, qmul, qadd;
2240
    int nCoeffs;
2241 115329f1 Diego Biurrun
2242 d50635cd Michael Niedermayer
    assert(s->block_last_index[n]>=0);
2243 115329f1 Diego Biurrun
2244 d50635cd Michael Niedermayer
    qmul = qscale << 1;
2245 115329f1 Diego Biurrun
2246 d50635cd Michael Niedermayer
    if (!s->h263_aic) {
2247 115329f1 Diego Biurrun
        if (n < 4)
2248 9dbf1ddd Michael Niedermayer
            block[0] = block[0] * s->y_dc_scale;
2249
        else
2250
            block[0] = block[0] * s->c_dc_scale;
2251 d50635cd Michael Niedermayer
        qadd = (qscale - 1) | 1;
2252
    }else{
2253
        qadd = 0;
2254
    }
2255
    if(s->ac_pred)
2256
        nCoeffs=63;
2257
    else
2258
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2259
2260
    for(i=1; i<=nCoeffs; i++) {
2261
        level = block[i];
2262
        if (level) {
2263
            if (level < 0) {
2264
                level = level * qmul - qadd;
2265
            } else {
2266
                level = level * qmul + qadd;
2267 9dbf1ddd Michael Niedermayer
            }
2268 d50635cd Michael Niedermayer
            block[i] = level;
2269 9dbf1ddd Michael Niedermayer
        }
2270
    }
2271
}
2272
2273 115329f1 Diego Biurrun
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2274 21af69f7 Fabrice Bellard
                                  DCTELEM *block, int n, int qscale)
2275
{
2276
    int i, level, qmul, qadd;
2277 badaf88e Michael Niedermayer
    int nCoeffs;
2278 115329f1 Diego Biurrun
2279 2ad1516a Michael Niedermayer
    assert(s->block_last_index[n]>=0);
2280 115329f1 Diego Biurrun
2281 2ad1516a Michael Niedermayer
    qadd = (qscale - 1) | 1;
2282
    qmul = qscale << 1;
2283 115329f1 Diego Biurrun
2284 d50635cd Michael Niedermayer
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2285 21af69f7 Fabrice Bellard
2286 d50635cd Michael Niedermayer
    for(i=0; i<=nCoeffs; i++) {
2287 21af69f7 Fabrice Bellard
        level = block[i];
2288
        if (level) {
2289
            if (level < 0) {
2290
                level = level * qmul - qadd;
2291
            } else {
2292
                level = level * qmul + qadd;
2293
            }
2294
            block[i] = level;
2295
        }
2296
    }
2297
}
2298 de6d9b64 Fabrice Bellard
2299 b776e3d1 Aurelien Jacobs
/**
2300
 * set qscale and update qscale dependent variables.
2301
 */
2302
void ff_set_qscale(MpegEncContext * s, int qscale)
2303
{
2304
    if (qscale < 1)
2305
        qscale = 1;
2306
    else if (qscale > 31)
2307
        qscale = 31;
2308
2309
    s->qscale = qscale;
2310
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2311
2312
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2313
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2314
}