Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ b6204677

History | View | Annotate | Download (239 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 ff4ec49e Fabrice Bellard
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10 de6d9b64 Fabrice Bellard
 *
11 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
12 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15 de6d9b64 Fabrice Bellard
 *
16 ff4ec49e Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 cf8039b2 Michael Niedermayer
 *
20 9dbf1ddd Michael Niedermayer
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21 de6d9b64 Fabrice Bellard
 */
22 115329f1 Diego Biurrun
23 983e3246 Michael Niedermayer
/**
24
 * @file mpegvideo.c
25
 * The simplest mpeg encoder (well, it was the simplest!).
26 115329f1 Diego Biurrun
 */
27
28 de6d9b64 Fabrice Bellard
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "mpegvideo.h"
31 65e4c8c9 Michael Niedermayer
#include "faandct.h"
32 e96682e6 Michael Niedermayer
#include <limits.h>
33 de6d9b64 Fabrice Bellard
34 54329dd5 Nick Kurshev
#ifdef USE_FASTMEMCPY
35
#include "fastmemcpy.h"
36
#endif
37
38 e4eadb4b Michael Niedermayer
//#undef NDEBUG
39
//#include <assert.h>
40 2ad1516a Michael Niedermayer
41 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
42 21af69f7 Fabrice Bellard
static void encode_picture(MpegEncContext *s, int picture_number);
43 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
44 115329f1 Diego Biurrun
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 21af69f7 Fabrice Bellard
                                   DCTELEM *block, int n, int qscale);
46 115329f1 Diego Biurrun
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 9dbf1ddd Michael Niedermayer
                                   DCTELEM *block, int n, int qscale);
48 d50635cd Michael Niedermayer
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49
                                   DCTELEM *block, int n, int qscale);
50
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52 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 0c1a9eda Zdenek Kabelac
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
58 d7e9533a Michael Niedermayer
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 477ab036 Michael Niedermayer
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 77ea0d4b Michael Niedermayer
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 7d1c3fc1 Michael Niedermayer
static int sse_mb(MpegEncContext *s);
62 783df5f3 Michael Niedermayer
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
64 3d9fccbf Michael Niedermayer
65 2e7b4c84 Ivan Kalvachev
#ifdef HAVE_XVMC
66
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67
extern void XVMC_field_end(MpegEncContext *s);
68 a579db0c Ivan Kalvachev
extern void XVMC_decode_mb(MpegEncContext *s);
69 2e7b4c84 Ivan Kalvachev
#endif
70
71 0c1a9eda Zdenek Kabelac
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
72 3d9fccbf Michael Niedermayer
73 de6d9b64 Fabrice Bellard
74
/* enable all paranoid tests for rounding, overflows, etc... */
75
//#define PARANOID
76
77
//#define DEBUG
78
79 101bea5f Juanjo
80 de6d9b64 Fabrice Bellard
/* for jpeg fast DCT */
81
#define CONST_BITS 14
82
83 eb4b3dd3 Zdenek Kabelac
static const uint16_t aanscales[64] = {
84 de6d9b64 Fabrice Bellard
    /* precomputed values scaled up by 14 bits */
85
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
86
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
87
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
88
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
89
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
90
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
91 1457ab52 Michael Niedermayer
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
92
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
93 de6d9b64 Fabrice Bellard
};
94
95 eb4b3dd3 Zdenek Kabelac
static const uint8_t h263_chroma_roundtab[16] = {
96 67725183 Michael Niedermayer
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
97 de6d9b64 Fabrice Bellard
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
98
};
99
100 332f9ac4 Michael Niedermayer
static const uint8_t ff_default_chroma_qscale_table[32]={
101
//  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
102
    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
103
};
104
105 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
106 30952237 Michael Niedermayer
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 0c1a9eda Zdenek Kabelac
static uint8_t default_fcode_tab[MAX_MV*2+1];
108 45870f57 Michael Niedermayer
109 a33c7159 Michael Niedermayer
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
110
111 6b56c616 Michael Niedermayer
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112 732ce18e Michael Niedermayer
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
113 de6d9b64 Fabrice Bellard
{
114 d7e9533a Michael Niedermayer
    int qscale;
115 732ce18e Michael Niedermayer
    int shift=0;
116 d7e9533a Michael Niedermayer
117 cc7ac888 Michael Niedermayer
    for(qscale=qmin; qscale<=qmax; qscale++){
118 d7e9533a Michael Niedermayer
        int i;
119 115329f1 Diego Biurrun
        if (dsp->fdct == ff_jpeg_fdct_islow
120 b4c3816c Michael Niedermayer
#ifdef FAAN_POSTSCALE
121 6b56c616 Michael Niedermayer
            || dsp->fdct == ff_faandct
122 b4c3816c Michael Niedermayer
#endif
123
            ) {
124 28db7fce Michael Niedermayer
            for(i=0;i<64;i++) {
125 6b56c616 Michael Niedermayer
                const int j= dsp->idct_permutation[i];
126 28db7fce Michael Niedermayer
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
127
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
128
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130 115329f1 Diego Biurrun
131
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 28db7fce Michael Niedermayer
                                (qscale * quant_matrix[j]));
133
            }
134 6b56c616 Michael Niedermayer
        } else if (dsp->fdct == fdct_ifast
135 b4c3816c Michael Niedermayer
#ifndef FAAN_POSTSCALE
136 6b56c616 Michael Niedermayer
                   || dsp->fdct == ff_faandct
137 b4c3816c Michael Niedermayer
#endif
138
                   ) {
139 d7e9533a Michael Niedermayer
            for(i=0;i<64;i++) {
140 6b56c616 Michael Niedermayer
                const int j= dsp->idct_permutation[i];
141 d7e9533a Michael Niedermayer
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
142
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
143
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145 115329f1 Diego Biurrun
146
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 d7e9533a Michael Niedermayer
                                (aanscales[i] * qscale * quant_matrix[j]));
148
            }
149
        } else {
150
            for(i=0;i<64;i++) {
151 6b56c616 Michael Niedermayer
                const int j= dsp->idct_permutation[i];
152 d7e9533a Michael Niedermayer
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153
                   So 16           <= qscale * quant_matrix[i]             <= 7905
154
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
156
                */
157 0c1a9eda Zdenek Kabelac
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 477ab036 Michael Niedermayer
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159 642ccefb Michael Niedermayer
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160 d7e9533a Michael Niedermayer
161 642ccefb Michael Niedermayer
                if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162
                qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
163 d7e9533a Michael Niedermayer
            }
164 de6d9b64 Fabrice Bellard
        }
165 115329f1 Diego Biurrun
166 732ce18e Michael Niedermayer
        for(i=intra; i<64; i++){
167 3c9ec07e Michael Niedermayer
            int64_t max= 8191;
168
            if (dsp->fdct == fdct_ifast
169
#ifndef FAAN_POSTSCALE
170
                   || dsp->fdct == ff_faandct
171
#endif
172
                   ) {
173
                max= (8191LL*aanscales[i]) >> 14;
174
            }
175 115329f1 Diego Biurrun
            while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
176 732ce18e Michael Niedermayer
                shift++;
177
            }
178
        }
179
    }
180
    if(shift){
181
        av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
182 de6d9b64 Fabrice Bellard
    }
183
}
184 158c7f05 Michael Niedermayer
185
static inline void update_qscale(MpegEncContext *s){
186
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
188 115329f1 Diego Biurrun
189 158c7f05 Michael Niedermayer
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
190
}
191 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
192
193 3d2e8cce Michael Niedermayer
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
194 2ad1516a Michael Niedermayer
    int i;
195
    int end;
196 115329f1 Diego Biurrun
197 7801d21d Michael Niedermayer
    st->scantable= src_scantable;
198 2ad1516a Michael Niedermayer
199
    for(i=0; i<64; i++){
200
        int j;
201
        j = src_scantable[i];
202 3d2e8cce Michael Niedermayer
        st->permutated[i] = permutation[j];
203 05c4072b Michael Niedermayer
#ifdef ARCH_POWERPC
204
        st->inverse[j] = i;
205
#endif
206 2ad1516a Michael Niedermayer
    }
207 115329f1 Diego Biurrun
208 2ad1516a Michael Niedermayer
    end=-1;
209
    for(i=0; i<64; i++){
210
        int j;
211
        j = st->permutated[i];
212
        if(j>end) end=j;
213
        st->raster_end[i]= end;
214
    }
215
}
216
217 764ef400 Mike Melanson
#ifdef CONFIG_ENCODERS
218 d6eb3c50 Michael Niedermayer
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
219
    int i;
220
221
    if(matrix){
222
        put_bits(pb, 1, 1);
223
        for(i=0;i<64;i++) {
224
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
225
        }
226
    }else
227
        put_bits(pb, 1, 0);
228
}
229 764ef400 Mike Melanson
#endif //CONFIG_ENCODERS
230 d6eb3c50 Michael Niedermayer
231 defdfc9a Alex Beregszaszi
/* init common dct for both encoder and decoder */
232
int DCT_common_init(MpegEncContext *s)
233 de6d9b64 Fabrice Bellard
{
234 d50635cd Michael Niedermayer
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240 b0368839 Michael Niedermayer
241 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
242 28db7fce Michael Niedermayer
    s->dct_quantize= dct_quantize_c;
243 783df5f3 Michael Niedermayer
    s->denoise_dct= denoise_dct_c;
244 6f921f31 Mike Melanson
#endif //CONFIG_ENCODERS
245 115329f1 Diego Biurrun
246 21af69f7 Fabrice Bellard
#ifdef HAVE_MMX
247 e4eadb4b Michael Niedermayer
    MPV_common_init_mmx(s);
248 a9b3f630 Nick Kurshev
#endif
249 e0580f8c Falk Hüffner
#ifdef ARCH_ALPHA
250
    MPV_common_init_axp(s);
251
#endif
252 c7e07931 Martin Olschewski
#ifdef HAVE_MLIB
253
    MPV_common_init_mlib(s);
254
#endif
255 5917d17c Leon van Stuivenberg
#ifdef HAVE_MMI
256
    MPV_common_init_mmi(s);
257
#endif
258 676e200c Michael Niedermayer
#ifdef ARCH_ARMV4L
259 83f238cb Zdenek Kabelac
    MPV_common_init_armv4l(s);
260 676e200c Michael Niedermayer
#endif
261 05c4072b Michael Niedermayer
#ifdef ARCH_POWERPC
262
    MPV_common_init_ppc(s);
263
#endif
264 676e200c Michael Niedermayer
265 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
266 3a87ac94 Michael Niedermayer
    s->fast_dct_quantize= s->dct_quantize;
267
268 477ab036 Michael Niedermayer
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
270
    }
271
272 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
273
274 2ad1516a Michael Niedermayer
    /* load & permutate scantables
275 115329f1 Diego Biurrun
       note: only wmv uses different ones
276 2ad1516a Michael Niedermayer
    */
277 bb198e19 Michael Niedermayer
    if(s->alternate_scan){
278
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
279
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
280
    }else{
281
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
282
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
283
    }
284 3d2e8cce Michael Niedermayer
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286 d930ef19 Michael Niedermayer
287 defdfc9a Alex Beregszaszi
    return 0;
288
}
289
290 6571e41d Michael Niedermayer
static void copy_picture(Picture *dst, Picture *src){
291
    *dst = *src;
292
    dst->type= FF_BUFFER_TYPE_COPY;
293
}
294
295 137c8468 Michael Niedermayer
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
296
    int i;
297
298 71c47d6e Michael Niedermayer
    dst->pict_type              = src->pict_type;
299
    dst->quality                = src->quality;
300
    dst->coded_picture_number   = src->coded_picture_number;
301
    dst->display_picture_number = src->display_picture_number;
302
//    dst->reference              = src->reference;
303
    dst->pts                    = src->pts;
304
    dst->interlaced_frame       = src->interlaced_frame;
305
    dst->top_field_first        = src->top_field_first;
306 137c8468 Michael Niedermayer
307 a4d36c11 Michael Niedermayer
    if(s->avctx->me_threshold){
308
        if(!src->motion_val[0])
309
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
310
        if(!src->mb_type)
311
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312
        if(!src->ref_index[0])
313
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314 137c8468 Michael Niedermayer
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315 dfb706da Kevin Baragona
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
316 f4f3223f Michael Niedermayer
            src->motion_subsample_log2, dst->motion_subsample_log2);
317 a4d36c11 Michael Niedermayer
318
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
319 115329f1 Diego Biurrun
320 a4d36c11 Michael Niedermayer
        for(i=0; i<2; i++){
321 137c8468 Michael Niedermayer
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
323
324 a4d36c11 Michael Niedermayer
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
326
            }
327
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328 7c4f71c4 Michael Niedermayer
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329 a4d36c11 Michael Niedermayer
            }
330 137c8468 Michael Niedermayer
        }
331
    }
332 71c47d6e Michael Niedermayer
}
333
334 1e491e29 Michael Niedermayer
/**
335 4e00e76b Michael Niedermayer
 * allocates a Picture
336
 * The pixels are allocated/set by calling get_buffer() if shared=0
337 1e491e29 Michael Niedermayer
 */
338 4e00e76b Michael Niedermayer
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339 7bc9090a Michael Niedermayer
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340
    const int mb_array_size= s->mb_stride*s->mb_height;
341 b40cd4e0 Michael Niedermayer
    const int b8_array_size= s->b8_stride*s->mb_height*2;
342
    const int b4_array_size= s->b4_stride*s->mb_height*4;
343 0da71265 Michael Niedermayer
    int i;
344 115329f1 Diego Biurrun
345 4e00e76b Michael Niedermayer
    if(shared){
346
        assert(pic->data[0]);
347
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348
        pic->type= FF_BUFFER_TYPE_SHARED;
349
    }else{
350
        int r;
351 115329f1 Diego Biurrun
352 4e00e76b Michael Niedermayer
        assert(!pic->data[0]);
353 115329f1 Diego Biurrun
354 492cd3a9 Michael Niedermayer
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355 115329f1 Diego Biurrun
356 4e00e76b Michael Niedermayer
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357 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]);
358 4e00e76b Michael Niedermayer
            return -1;
359
        }
360
361
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
363 4e00e76b Michael Niedermayer
            return -1;
364
        }
365
366
        if(pic->linesize[1] != pic->linesize[2]){
367 bb628dae Diego Biurrun
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
368 4e00e76b Michael Niedermayer
            return -1;
369
        }
370
371
        s->linesize  = pic->linesize[0];
372
        s->uvlinesize= pic->linesize[1];
373 1e491e29 Michael Niedermayer
    }
374 115329f1 Diego Biurrun
375 4e00e76b Michael Niedermayer
    if(pic->qscale_table==NULL){
376 115329f1 Diego Biurrun
        if (s->encoding) {
377 7bc9090a Michael Niedermayer
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
378
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
380 4e00e76b Michael Niedermayer
        }
381 1e491e29 Michael Niedermayer
382 7bc9090a Michael Niedermayer
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383 e4eadb4b Michael Niedermayer
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384 507a8e0d Michael Niedermayer
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
385 7bc9090a Michael Niedermayer
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386 0da71265 Michael Niedermayer
        if(s->out_format == FMT_H264){
387
            for(i=0; i<2; i++){
388 02dc8983 Michael Niedermayer
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
389
                pic->motion_val[i]= pic->motion_val_base[i]+4;
390 7c4f71c4 Michael Niedermayer
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391 b40cd4e0 Michael Niedermayer
            }
392 5ea4b18d Michael Niedermayer
            pic->motion_subsample_log2= 2;
393 0c9bbaec Wolfgang Hesseler
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394 b40cd4e0 Michael Niedermayer
            for(i=0; i<2; i++){
395 02dc8983 Michael Niedermayer
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
396
                pic->motion_val[i]= pic->motion_val_base[i]+4;
397 7c4f71c4 Michael Niedermayer
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398 0da71265 Michael Niedermayer
            }
399 5ea4b18d Michael Niedermayer
            pic->motion_subsample_log2= 3;
400 0da71265 Michael Niedermayer
        }
401 8289c6fa Wolfgang Hesseler
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
403
        }
404 7bc9090a Michael Niedermayer
        pic->qstride= s->mb_stride;
405 fa384dcc Michael Niedermayer
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
406 4e00e76b Michael Niedermayer
    }
407 0da71265 Michael Niedermayer
408 f943e138 Michael Niedermayer
    //it might be nicer if the application would keep track of these but it would require a API change
409
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
410
    s->prev_pict_types[0]= s->pict_type;
411
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412 160d679c Mike Melanson
        pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
413 115329f1 Diego Biurrun
414 1e491e29 Michael Niedermayer
    return 0;
415
fail: //for the CHECKED_ALLOCZ macro
416
    return -1;
417
}
418
419 4e00e76b Michael Niedermayer
/**
420
 * deallocates a picture
421
 */
422 1e491e29 Michael Niedermayer
static void free_picture(MpegEncContext *s, Picture *pic){
423
    int i;
424 4e00e76b Michael Niedermayer
425
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426 492cd3a9 Michael Niedermayer
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
427 4e00e76b Michael Niedermayer
    }
428
429 1e491e29 Michael Niedermayer
    av_freep(&pic->mb_var);
430
    av_freep(&pic->mc_mb_var);
431
    av_freep(&pic->mb_mean);
432
    av_freep(&pic->mbskip_table);
433
    av_freep(&pic->qscale_table);
434 0da71265 Michael Niedermayer
    av_freep(&pic->mb_type_base);
435 8289c6fa Wolfgang Hesseler
    av_freep(&pic->dct_coeff);
436 fa384dcc Michael Niedermayer
    av_freep(&pic->pan_scan);
437 0da71265 Michael Niedermayer
    pic->mb_type= NULL;
438
    for(i=0; i<2; i++){
439 b40cd4e0 Michael Niedermayer
        av_freep(&pic->motion_val_base[i]);
440 0da71265 Michael Niedermayer
        av_freep(&pic->ref_index[i]);
441
    }
442 115329f1 Diego Biurrun
443 d90cf87b Michael Niedermayer
    if(pic->type == FF_BUFFER_TYPE_SHARED){
444 4e00e76b Michael Niedermayer
        for(i=0; i<4; i++){
445
            pic->base[i]=
446
            pic->data[i]= NULL;
447
        }
448 115329f1 Diego Biurrun
        pic->type= 0;
449 1e491e29 Michael Niedermayer
    }
450
}
451
452 9c3d33d6 Michael Niedermayer
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
453
    int i;
454
455 115329f1 Diego Biurrun
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
456 9c3d33d6 Michael Niedermayer
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458
459
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460 115329f1 Diego Biurrun
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
461 9c3d33d6 Michael Niedermayer
    s->rd_scratchpad=   s->me.scratchpad;
462
    s->b_scratchpad=    s->me.scratchpad;
463
    s->obmc_scratchpad= s->me.scratchpad + 16;
464
    if (s->encoding) {
465
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
466
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467
        if(s->avctx->noise_reduction){
468
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
469
        }
470 115329f1 Diego Biurrun
    }
471 5e5c247a Ivan Kalvachev
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472 9c3d33d6 Michael Niedermayer
    s->block= s->blocks[0];
473
474
    for(i=0;i<12;i++){
475
        s->pblocks[i] = (short *)(&s->block[i]);
476
    }
477
    return 0;
478
fail:
479
    return -1; //free() through MPV_common_end()
480
}
481
482
static void free_duplicate_context(MpegEncContext *s){
483
    if(s==NULL) return;
484
485
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486
    av_freep(&s->me.scratchpad);
487 115329f1 Diego Biurrun
    s->rd_scratchpad=
488
    s->b_scratchpad=
489 9c3d33d6 Michael Niedermayer
    s->obmc_scratchpad= NULL;
490 115329f1 Diego Biurrun
491 9c3d33d6 Michael Niedermayer
    av_freep(&s->dct_error_sum);
492
    av_freep(&s->me.map);
493
    av_freep(&s->me.score_map);
494
    av_freep(&s->blocks);
495
    s->block= NULL;
496
}
497
498
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499
#define COPY(a) bak->a= src->a
500
    COPY(allocated_edge_emu_buffer);
501
    COPY(edge_emu_buffer);
502
    COPY(me.scratchpad);
503
    COPY(rd_scratchpad);
504
    COPY(b_scratchpad);
505
    COPY(obmc_scratchpad);
506
    COPY(me.map);
507
    COPY(me.score_map);
508
    COPY(blocks);
509
    COPY(block);
510
    COPY(start_mb_y);
511
    COPY(end_mb_y);
512
    COPY(me.map_generation);
513
    COPY(pb);
514
    COPY(dct_error_sum);
515 da16b204 Michael Niedermayer
    COPY(dct_count[0]);
516
    COPY(dct_count[1]);
517 9c3d33d6 Michael Niedermayer
#undef COPY
518
}
519
520 c62c07d3 Michael Niedermayer
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521 9c3d33d6 Michael Niedermayer
    MpegEncContext bak;
522 c62c07d3 Michael Niedermayer
    int i;
523 9c3d33d6 Michael Niedermayer
    //FIXME copy only needed parts
524
//START_TIMER
525
    backup_duplicate_context(&bak, dst);
526
    memcpy(dst, src, sizeof(MpegEncContext));
527
    backup_duplicate_context(dst, &bak);
528 c62c07d3 Michael Niedermayer
    for(i=0;i<12;i++){
529
        dst->pblocks[i] = (short *)(&dst->block[i]);
530
    }
531 9c3d33d6 Michael Niedermayer
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
532
}
533
534
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535
#define COPY(a) dst->a= src->a
536
    COPY(pict_type);
537
    COPY(current_picture);
538
    COPY(f_code);
539
    COPY(b_code);
540
    COPY(qscale);
541
    COPY(lambda);
542
    COPY(lambda2);
543
    COPY(picture_in_gop_number);
544
    COPY(gop_picture_number);
545 bb628dae Diego Biurrun
    COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
546
    COPY(progressive_frame); //FIXME don't set in encode_header
547
    COPY(partitioned_frame); //FIXME don't set in encode_header
548 9c3d33d6 Michael Niedermayer
#undef COPY
549
}
550
551 3edcacde Michael Niedermayer
/**
552
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553
 * the changed fields will not depend upon the prior state of the MpegEncContext.
554
 */
555
static void MPV_common_defaults(MpegEncContext *s){
556
    s->y_dc_scale_table=
557
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
559
    s->progressive_frame= 1;
560
    s->progressive_sequence= 1;
561
    s->picture_structure= PICT_FRAME;
562
563
    s->coded_picture_number = 0;
564
    s->picture_number = 0;
565
    s->input_picture_number = 0;
566
567
    s->picture_in_gop_number = 0;
568 7976241a Michael Niedermayer
569
    s->f_code = 1;
570
    s->b_code = 1;
571 3edcacde Michael Niedermayer
}
572
573
/**
574
 * sets the given MpegEncContext to defaults for decoding.
575
 * the changed fields will not depend upon the prior state of the MpegEncContext.
576
 */
577
void MPV_decode_defaults(MpegEncContext *s){
578
    MPV_common_defaults(s);
579
}
580
581
/**
582
 * sets the given MpegEncContext to defaults for encoding.
583
 * the changed fields will not depend upon the prior state of the MpegEncContext.
584
 */
585 6b47b730 Michael Niedermayer
586
#ifdef CONFIG_ENCODERS
587 e96682e6 Michael Niedermayer
static void MPV_encode_defaults(MpegEncContext *s){
588 3edcacde Michael Niedermayer
    static int done=0;
589 115329f1 Diego Biurrun
590 3edcacde Michael Niedermayer
    MPV_common_defaults(s);
591 115329f1 Diego Biurrun
592 3edcacde Michael Niedermayer
    if(!done){
593
        int i;
594
        done=1;
595
596
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598
599
        for(i=-16; i<16; i++){
600
            default_fcode_tab[i + MAX_MV]= 1;
601
        }
602
    }
603
    s->me.mv_penalty= default_mv_penalty;
604
    s->fcode_tab= default_fcode_tab;
605
}
606 6b47b730 Michael Niedermayer
#endif //CONFIG_ENCODERS
607 3edcacde Michael Niedermayer
608 115329f1 Diego Biurrun
/**
609 3edcacde Michael Niedermayer
 * init common structure for both encoder and decoder.
610
 * this assumes that some variables like width/height are already set
611
 */
612 defdfc9a Alex Beregszaszi
int MPV_common_init(MpegEncContext *s)
613
{
614 bb198e19 Michael Niedermayer
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615 defdfc9a Alex Beregszaszi
616 844ce49d Michael Niedermayer
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617 000a9c02 Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
618
        return -1;
619
    }
620
621 0ecca7a4 Michael Niedermayer
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
622
        return -1;
623
624 b0368839 Michael Niedermayer
    dsputil_init(&s->dsp, s->avctx);
625 defdfc9a Alex Beregszaszi
    DCT_common_init(s);
626 eb4b3dd3 Zdenek Kabelac
627 9fee1e23 Michael Niedermayer
    s->flags= s->avctx->flags;
628 303e50e6 Michael Niedermayer
    s->flags2= s->avctx->flags2;
629 defdfc9a Alex Beregszaszi
630 1e491e29 Michael Niedermayer
    s->mb_width  = (s->width  + 15) / 16;
631 de6d9b64 Fabrice Bellard
    s->mb_height = (s->height + 15) / 16;
632 7bc9090a Michael Niedermayer
    s->mb_stride = s->mb_width + 1;
633 b40cd4e0 Michael Niedermayer
    s->b8_stride = s->mb_width*2 + 1;
634
    s->b4_stride = s->mb_width*4 + 1;
635 7bc9090a Michael Niedermayer
    mb_array_size= s->mb_height * s->mb_stride;
636 bb198e19 Michael Niedermayer
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637 eb4b3dd3 Zdenek Kabelac
638 ffdff4d7 Ivan Kalvachev
    /* set chroma shifts */
639
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640
                                                    &(s->chroma_y_shift) );
641
642 b5a093b3 Michael Niedermayer
    /* set default edge pos, will be overriden in decode_header if needed */
643
    s->h_edge_pos= s->mb_width*16;
644
    s->v_edge_pos= s->mb_height*16;
645 eb4b3dd3 Zdenek Kabelac
646
    s->mb_num = s->mb_width * s->mb_height;
647 115329f1 Diego Biurrun
648 7bc9090a Michael Niedermayer
    s->block_wrap[0]=
649
    s->block_wrap[1]=
650
    s->block_wrap[2]=
651 137c8468 Michael Niedermayer
    s->block_wrap[3]= s->b8_stride;
652 7bc9090a Michael Niedermayer
    s->block_wrap[4]=
653 137c8468 Michael Niedermayer
    s->block_wrap[5]= s->mb_stride;
654 115329f1 Diego Biurrun
655 137c8468 Michael Niedermayer
    y_size = s->b8_stride * (2 * s->mb_height + 1);
656
    c_size = s->mb_stride * (s->mb_height + 1);
657 eb4b3dd3 Zdenek Kabelac
    yc_size = y_size + 2 * c_size;
658 115329f1 Diego Biurrun
659 202ef8b8 Michael Niedermayer
    /* convert fourcc to upper case */
660 115329f1 Diego Biurrun
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
661 7004ffb3 Michael Niedermayer
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662 115329f1 Diego Biurrun
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663 7004ffb3 Michael Niedermayer
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664 b5a093b3 Michael Niedermayer
665 115329f1 Diego Biurrun
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)
666 541ae140 Michael Niedermayer
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667 115329f1 Diego Biurrun
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668 541ae140 Michael Niedermayer
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
669
670 492cd3a9 Michael Niedermayer
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
671 1e491e29 Michael Niedermayer
672 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673
    for(y=0; y<s->mb_height; y++){
674
        for(x=0; x<s->mb_width; x++){
675
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
676
        }
677
    }
678
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679 115329f1 Diego Biurrun
680 37fbfd0a Juanjo
    if (s->encoding) {
681 9dbcbd92 Michael Niedermayer
        /* Allocate MV tables */
682 7bc9090a Michael Niedermayer
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
683
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
684
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
685
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
688
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
689
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
690
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
691
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
694 7f2fe444 Michael Niedermayer
695 6b460aa3 Michael Niedermayer
        if(s->msmpeg4_version){
696
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
697
        }
698 3aa102be Michael Niedermayer
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699 7bc9090a Michael Niedermayer
700
        /* Allocate MB type table */
701 bb198e19 Michael Niedermayer
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
702 115329f1 Diego Biurrun
703 158c7f05 Michael Niedermayer
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704 115329f1 Diego Biurrun
705 7e4995c3 Michael Niedermayer
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707 642ccefb Michael Niedermayer
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709 9d9e3172 Michael Niedermayer
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711 115329f1 Diego Biurrun
712 821cb11f Michael Niedermayer
        if(s->avctx->noise_reduction){
713
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
714
        }
715 37fbfd0a Juanjo
    }
716 b465449e Michael Niedermayer
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
717
718 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719 115329f1 Diego Biurrun
720 bb198e19 Michael Niedermayer
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721 4d2858de Michael Niedermayer
        /* interlaced direct mode decoding tables */
722 bb198e19 Michael Niedermayer
            for(i=0; i<2; i++){
723
                int j, k;
724
                for(j=0; j<2; j++){
725
                    for(k=0; k<2; k++){
726
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
727
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
728
                    }
729
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
730
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
731
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
732
                }
733
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
734
            }
735 de6d9b64 Fabrice Bellard
    }
736 6e2d5f1a Michael Niedermayer
    if (s->out_format == FMT_H263) {
737 de6d9b64 Fabrice Bellard
        /* ac values */
738 137c8468 Michael Niedermayer
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741 de6d9b64 Fabrice Bellard
        s->ac_val[2] = s->ac_val[1] + c_size;
742 115329f1 Diego Biurrun
743 de6d9b64 Fabrice Bellard
        /* cbp values */
744 137c8468 Michael Niedermayer
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
745
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
746 115329f1 Diego Biurrun
747 7f2fe444 Michael Niedermayer
        /* cbp, ac_pred, pred_dir */
748 7bc9090a Michael Niedermayer
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
749
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750 5b3438c6 Michael Niedermayer
    }
751 115329f1 Diego Biurrun
752 8b32880c Michael Niedermayer
    if (s->h263_pred || s->h263_plus || !s->encoding) {
753
        /* dc values */
754
        //MN: we need these for error resilience of intra-frames
755 137c8468 Michael Niedermayer
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758 8b32880c Michael Niedermayer
        s->dc_val[2] = s->dc_val[1] + c_size;
759
        for(i=0;i<yc_size;i++)
760 137c8468 Michael Niedermayer
            s->dc_val_base[i] = 1024;
761 8b32880c Michael Niedermayer
    }
762
763 7806197d Michael Niedermayer
    /* which mb is a intra block */
764 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765
    memset(s->mbintra_table, 1, mb_array_size);
766 115329f1 Diego Biurrun
767 3bb4e23a Fabrice Bellard
    /* init macroblock skip table */
768 7bc9090a Michael Niedermayer
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769 4d2858de Michael Niedermayer
    //Note the +1 is for a quicker mpeg4 slice_end detection
770 f943e138 Michael Niedermayer
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771 115329f1 Diego Biurrun
772 d7425f59 Michael Niedermayer
    s->parse_context.state= -1;
773 0c9bbaec Wolfgang Hesseler
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777
    }
778 d7425f59 Michael Niedermayer
779 de6d9b64 Fabrice Bellard
    s->context_initialized = 1;
780 9c3d33d6 Michael Niedermayer
781
    s->thread_context[0]= s;
782
    for(i=1; i<s->avctx->thread_count; i++){
783
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
785
    }
786
787
    for(i=0; i<s->avctx->thread_count; i++){
788
        if(init_duplicate_context(s->thread_context[i], s) < 0)
789
           goto fail;
790
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
792
    }
793
794 de6d9b64 Fabrice Bellard
    return 0;
795
 fail:
796 8257bf05 Zdenek Kabelac
    MPV_common_end(s);
797 de6d9b64 Fabrice Bellard
    return -1;
798
}
799
800
/* init common structure for both encoder and decoder */
801
void MPV_common_end(MpegEncContext *s)
802
{
803 bb198e19 Michael Niedermayer
    int i, j, k;
804 de6d9b64 Fabrice Bellard
805 9c3d33d6 Michael Niedermayer
    for(i=0; i<s->avctx->thread_count; i++){
806
        free_duplicate_context(s->thread_context[i]);
807
    }
808
    for(i=1; i<s->avctx->thread_count; i++){
809
        av_freep(&s->thread_context[i]);
810
    }
811
812 147e5200 Michael Niedermayer
    av_freep(&s->parse_context.buffer);
813
    s->parse_context.buffer_size=0;
814
815 6000abfa Fabrice Bellard
    av_freep(&s->mb_type);
816 7bc9090a Michael Niedermayer
    av_freep(&s->p_mv_table_base);
817
    av_freep(&s->b_forw_mv_table_base);
818
    av_freep(&s->b_back_mv_table_base);
819
    av_freep(&s->b_bidir_forw_mv_table_base);
820
    av_freep(&s->b_bidir_back_mv_table_base);
821
    av_freep(&s->b_direct_mv_table_base);
822
    s->p_mv_table= NULL;
823
    s->b_forw_mv_table= NULL;
824
    s->b_back_mv_table= NULL;
825
    s->b_bidir_forw_mv_table= NULL;
826
    s->b_bidir_back_mv_table= NULL;
827
    s->b_direct_mv_table= NULL;
828 bb198e19 Michael Niedermayer
    for(i=0; i<2; i++){
829
        for(j=0; j<2; j++){
830
            for(k=0; k<2; k++){
831
                av_freep(&s->b_field_mv_table_base[i][j][k]);
832
                s->b_field_mv_table[i][j][k]=NULL;
833
            }
834
            av_freep(&s->b_field_select_table[i][j]);
835
            av_freep(&s->p_field_mv_table_base[i][j]);
836
            s->p_field_mv_table[i][j]=NULL;
837
        }
838
        av_freep(&s->p_field_select_table[i]);
839
    }
840 115329f1 Diego Biurrun
841 137c8468 Michael Niedermayer
    av_freep(&s->dc_val_base);
842
    av_freep(&s->ac_val_base);
843
    av_freep(&s->coded_block_base);
844 6000abfa Fabrice Bellard
    av_freep(&s->mbintra_table);
845 7f2fe444 Michael Niedermayer
    av_freep(&s->cbp_table);
846
    av_freep(&s->pred_dir_table);
847 115329f1 Diego Biurrun
848 6000abfa Fabrice Bellard
    av_freep(&s->mbskip_table);
849 f943e138 Michael Niedermayer
    av_freep(&s->prev_pict_types);
850 6000abfa Fabrice Bellard
    av_freep(&s->bitstream_buffer);
851 0ecca7a4 Michael Niedermayer
    s->allocated_bitstream_buffer_size=0;
852
853 3aa102be Michael Niedermayer
    av_freep(&s->avctx->stats_out);
854 6b460aa3 Michael Niedermayer
    av_freep(&s->ac_stats);
855 4d2858de Michael Niedermayer
    av_freep(&s->error_status_table);
856 7bc9090a Michael Niedermayer
    av_freep(&s->mb_index2xy);
857 158c7f05 Michael Niedermayer
    av_freep(&s->lambda_table);
858 7e4995c3 Michael Niedermayer
    av_freep(&s->q_intra_matrix);
859
    av_freep(&s->q_inter_matrix);
860 642ccefb Michael Niedermayer
    av_freep(&s->q_intra_matrix16);
861
    av_freep(&s->q_inter_matrix16);
862 9d9e3172 Michael Niedermayer
    av_freep(&s->input_picture);
863
    av_freep(&s->reordered_input_picture);
864 821cb11f Michael Niedermayer
    av_freep(&s->dct_offset);
865 1e491e29 Michael Niedermayer
866 9b4b6e09 Michael Niedermayer
    if(s->picture){
867
        for(i=0; i<MAX_PICTURE_COUNT; i++){
868
            free_picture(s, &s->picture[i]);
869
        }
870 de6d9b64 Fabrice Bellard
    }
871 b465449e Michael Niedermayer
    av_freep(&s->picture);
872 de6d9b64 Fabrice Bellard
    s->context_initialized = 0;
873 431f2172 Michael Niedermayer
    s->last_picture_ptr=
874
    s->next_picture_ptr=
875
    s->current_picture_ptr= NULL;
876 b100eab8 Michael Niedermayer
    s->linesize= s->uvlinesize= 0;
877 8100cab9 Michael Niedermayer
878 0c9bbaec Wolfgang Hesseler
    for(i=0; i<3; i++)
879 8100cab9 Michael Niedermayer
        av_freep(&s->visualization_buffer[i]);
880 b100eab8 Michael Niedermayer
881
    avcodec_default_free_buffers(s->avctx);
882 de6d9b64 Fabrice Bellard
}
883
884 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
885
886 de6d9b64 Fabrice Bellard
/* init video encoder */
887
int MPV_encode_init(AVCodecContext *avctx)
888
{
889
    MpegEncContext *s = avctx->priv_data;
890 bf4e3bd2 Måns Rullgård
    int i;
891 b1e6b355 Michael Niedermayer
    int chroma_h_shift, chroma_v_shift;
892 115329f1 Diego Biurrun
893 3edcacde Michael Niedermayer
    MPV_encode_defaults(s);
894 bc657ac3 Zdenek Kabelac
895 dd4f8a04 Michael Niedermayer
    if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896
        av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
897
        return -1;
898
    }
899
900
    if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901 9cd81798 Michael Niedermayer
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902 dd4f8a04 Michael Niedermayer
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
903
            return -1;
904
        }
905
    }else{
906 9cd81798 Michael Niedermayer
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
907 dd4f8a04 Michael Niedermayer
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
908
            return -1;
909
        }
910
    }
911 36b58e85 Roman Shaposhnik
912 de6d9b64 Fabrice Bellard
    s->bit_rate = avctx->bit_rate;
913
    s->width = avctx->width;
914
    s->height = avctx->height;
915 7f2fe444 Michael Niedermayer
    if(avctx->gop_size > 600){
916 bb270c08 Diego Biurrun
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917 7f2fe444 Michael Niedermayer
        avctx->gop_size=600;
918
    }
919 de6d9b64 Fabrice Bellard
    s->gop_size = avctx->gop_size;
920 477c35a9 Arpi
    s->avctx = avctx;
921 ba6802de Michael Niedermayer
    s->flags= avctx->flags;
922 303e50e6 Michael Niedermayer
    s->flags2= avctx->flags2;
923 9dbcbd92 Michael Niedermayer
    s->max_b_frames= avctx->max_b_frames;
924 d7e9533a Michael Niedermayer
    s->codec_id= avctx->codec->id;
925 7f2fe444 Michael Niedermayer
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
926
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927
    s->strict_std_compliance= avctx->strict_std_compliance;
928
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929 1457ab52 Michael Niedermayer
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930 87f8cab4 Michael Niedermayer
    s->mpeg_quant= avctx->mpeg_quant;
931 ba58dabc Michael Niedermayer
    s->rtp_mode= !!avctx->rtp_payload_size;
932 bf266e19 Michael Niedermayer
    s->intra_dc_precision= avctx->intra_dc_precision;
933 9ebb8e11 Michael Niedermayer
    s->user_specified_pts = AV_NOPTS_VALUE;
934 e4eadb4b Michael Niedermayer
935 de6d9b64 Fabrice Bellard
    if (s->gop_size <= 1) {
936
        s->intra_only = 1;
937
        s->gop_size = 12;
938
    } else {
939
        s->intra_only = 0;
940
    }
941 5e746b99 Michael Niedermayer
942 1457ab52 Michael Niedermayer
    s->me_method = avctx->me_method;
943 5e746b99 Michael Niedermayer
944 e4986da9 Juanjo
    /* Fixed QSCALE */
945 bb198e19 Michael Niedermayer
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946 115329f1 Diego Biurrun
947 c5d309f2 Michael Niedermayer
    s->adaptive_quant= (   s->avctx->lumi_masking
948 5e746b99 Michael Niedermayer
                        || s->avctx->dark_masking
949 115329f1 Diego Biurrun
                        || s->avctx->temporal_cplx_masking
950 c5d309f2 Michael Niedermayer
                        || s->avctx->spatial_cplx_masking
951 1f26c6f3 Michael Niedermayer
                        || s->avctx->p_masking
952 957c743a Christophe Massiot
                        || s->avctx->border_masking
953 1f26c6f3 Michael Niedermayer
                        || (s->flags&CODEC_FLAG_QP_RD))
954 c5d309f2 Michael Niedermayer
                       && !s->fixed_qscale;
955 115329f1 Diego Biurrun
956 bb198e19 Michael Niedermayer
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959 5e746b99 Michael Niedermayer
960 273977d8 Michael Niedermayer
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
962
        return -1;
963 115329f1 Diego Biurrun
    }
964 273977d8 Michael Niedermayer
965
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966 dfb706da Kevin Baragona
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
967 b73afeac Michael Niedermayer
    }
968 115329f1 Diego Biurrun
969 23854cad Michael Niedermayer
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971
        return -1;
972
    }
973 115329f1 Diego Biurrun
974 23854cad Michael Niedermayer
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976
        return -1;
977
    }
978 115329f1 Diego Biurrun
979
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980 b73afeac Michael Niedermayer
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982 115329f1 Diego Biurrun
983 b73afeac Michael Niedermayer
        av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
984
    }
985 115329f1 Diego Biurrun
986
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987 747a0554 Tinic Uro
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989 9acbbd16 Michael Niedermayer
        return -1;
990
    }
991 115329f1 Diego Biurrun
992 f7190f73 Michael Niedermayer
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993 dfb706da Kevin Baragona
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
994 f7190f73 Michael Niedermayer
        return -1;
995
    }
996 115329f1 Diego Biurrun
997 332f9ac4 Michael Niedermayer
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999
        return -1;
1000
    }
1001 115329f1 Diego Biurrun
1002 9acbbd16 Michael Niedermayer
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004 9acbbd16 Michael Niedermayer
        return -1;
1005
    }
1006
1007
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009 9acbbd16 Michael Niedermayer
        return -1;
1010
    }
1011 115329f1 Diego Biurrun
1012 029911d1 Michael Niedermayer
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014 9acbbd16 Michael Niedermayer
        return -1;
1015
    }
1016 1671083f Michael Niedermayer
1017 115329f1 Diego Biurrun
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1018 1671083f Michael Niedermayer
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020
        return -1;
1021
    }
1022 115329f1 Diego Biurrun
1023 9acbbd16 Michael Niedermayer
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024 dfb706da Kevin Baragona
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1025 9acbbd16 Michael Niedermayer
        return -1;
1026
    }
1027 115329f1 Diego Biurrun
1028 f2f6134b Michael Niedermayer
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030 f2f6134b Michael Niedermayer
        return -1;
1031
    }
1032
1033 dd3e415e Michael Niedermayer
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035
        return -1;
1036
    }
1037 115329f1 Diego Biurrun
1038 303e50e6 Michael Niedermayer
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040
        return -1;
1041
    }
1042 115329f1 Diego Biurrun
1043
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1044
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045 9c3d33d6 Michael Niedermayer
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047
        return -1;
1048
    }
1049 115329f1 Diego Biurrun
1050 9c3d33d6 Michael Niedermayer
    if(s->avctx->thread_count > 1)
1051
        s->rtp_mode= 1;
1052 11a8a71d Michael Niedermayer
1053 c0df9d75 Michael Niedermayer
    if(!avctx->time_base.den || !avctx->time_base.num){
1054 e8ea9012 Michael Niedermayer
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055
        return -1;
1056
    }
1057 115329f1 Diego Biurrun
1058 cec1f05f Michael Niedermayer
    i= (INT_MAX/2+128)>>8;
1059
    if(avctx->me_threshold >= i){
1060
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1061
        return -1;
1062
    }
1063
    if(avctx->mb_threshold >= i){
1064
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1065
        return -1;
1066
    }
1067 115329f1 Diego Biurrun
1068 bf873ee6 Michael Niedermayer
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1069
        av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass");
1070
        return -1;
1071
    }
1072
1073 c0df9d75 Michael Niedermayer
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1074 11a8a71d Michael Niedermayer
    if(i > 1){
1075
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1076 c0df9d75 Michael Niedermayer
        avctx->time_base.den /= i;
1077
        avctx->time_base.num /= i;
1078 11a8a71d Michael Niedermayer
//        return -1;
1079
    }
1080 115329f1 Diego Biurrun
1081 1984f635 Michael Niedermayer
    if(s->codec_id==CODEC_ID_MJPEG){
1082
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1083
        s->inter_quant_bias= 0;
1084 029911d1 Michael Niedermayer
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1085 1984f635 Michael Niedermayer
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1086
        s->inter_quant_bias= 0;
1087
    }else{
1088
        s->intra_quant_bias=0;
1089
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1090
    }
1091 115329f1 Diego Biurrun
1092 1984f635 Michael Niedermayer
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1093
        s->intra_quant_bias= avctx->intra_quant_bias;
1094
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1095
        s->inter_quant_bias= avctx->inter_quant_bias;
1096 115329f1 Diego Biurrun
1097 b1e6b355 Michael Niedermayer
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1098
1099 1192ce37 Michael Niedermayer
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1100 c0df9d75 Michael Niedermayer
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1101 115329f1 Diego Biurrun
        return -1;
1102 c0df9d75 Michael Niedermayer
    }
1103
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1104 22ddd60b Michael Niedermayer
1105 de6d9b64 Fabrice Bellard
    switch(avctx->codec->id) {
1106
    case CODEC_ID_MPEG1VIDEO:
1107
        s->out_format = FMT_MPEG1;
1108 14bea432 Michael Niedermayer
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1109
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1110 de6d9b64 Fabrice Bellard
        break;
1111 029911d1 Michael Niedermayer
    case CODEC_ID_MPEG2VIDEO:
1112
        s->out_format = FMT_MPEG1;
1113
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1114
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1115 ba58dabc Michael Niedermayer
        s->rtp_mode= 1;
1116 029911d1 Michael Niedermayer
        break;
1117 b1e6b355 Michael Niedermayer
    case CODEC_ID_LJPEG:
1118 2ceff404 Michael Niedermayer
    case CODEC_ID_JPEGLS:
1119 de6d9b64 Fabrice Bellard
    case CODEC_ID_MJPEG:
1120
        s->out_format = FMT_MJPEG;
1121
        s->intra_only = 1; /* force intra only for jpeg */
1122 2ceff404 Michael Niedermayer
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1123 bb270c08 Diego Biurrun
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1124 b1e6b355 Michael Niedermayer
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1125
        s->mjpeg_vsample[1] = 1;
1126 115329f1 Diego Biurrun
        s->mjpeg_vsample[2] = 1;
1127 b1e6b355 Michael Niedermayer
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1128 115329f1 Diego Biurrun
        s->mjpeg_hsample[1] = 1;
1129
        s->mjpeg_hsample[2] = 1;
1130 de6d9b64 Fabrice Bellard
        if (mjpeg_init(s) < 0)
1131
            return -1;
1132 1ff662cc Michael Niedermayer
        avctx->delay=0;
1133 4e00e76b Michael Niedermayer
        s->low_delay=1;
1134 de6d9b64 Fabrice Bellard
        break;
1135 1c3990db Michael Niedermayer
    case CODEC_ID_H261:
1136
        s->out_format = FMT_H261;
1137
        avctx->delay=0;
1138
        s->low_delay=1;
1139
        break;
1140 de6d9b64 Fabrice Bellard
    case CODEC_ID_H263:
1141 37fbfd0a Juanjo
        if (h263_get_picture_format(s->width, s->height) == 7) {
1142 9b879566 Michel Bardiaux
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1143 de6d9b64 Fabrice Bellard
            return -1;
1144 37fbfd0a Juanjo
        }
1145 de6d9b64 Fabrice Bellard
        s->out_format = FMT_H263;
1146 bb270c08 Diego Biurrun
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1147 1ff662cc Michael Niedermayer
        avctx->delay=0;
1148 4e00e76b Michael Niedermayer
        s->low_delay=1;
1149 de6d9b64 Fabrice Bellard
        break;
1150
    case CODEC_ID_H263P:
1151
        s->out_format = FMT_H263;
1152
        s->h263_plus = 1;
1153 bb270c08 Diego Biurrun
        /* Fx */
1154 332f9ac4 Michael Niedermayer
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1155 bb270c08 Diego Biurrun
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1156
        s->modified_quant= s->h263_aic;
1157
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1158
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1159
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1160
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1161 ba58dabc Michael Niedermayer
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1162 332f9ac4 Michael Niedermayer
1163 bb270c08 Diego Biurrun
        /* /Fx */
1164 544286b3 Juanjo
        /* These are just to be sure */
1165 1ff662cc Michael Niedermayer
        avctx->delay=0;
1166 4e00e76b Michael Niedermayer
        s->low_delay=1;
1167 de6d9b64 Fabrice Bellard
        break;
1168 d4f5d74a Garrick Meeker
    case CODEC_ID_FLV1:
1169
        s->out_format = FMT_H263;
1170
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1171
        s->unrestricted_mv = 1;
1172
        s->rtp_mode=0; /* don't allow GOB */
1173
        avctx->delay=0;
1174
        s->low_delay=1;
1175
        break;
1176 de6d9b64 Fabrice Bellard
    case CODEC_ID_RV10:
1177
        s->out_format = FMT_H263;
1178 1ff662cc Michael Niedermayer
        avctx->delay=0;
1179 4e00e76b Michael Niedermayer
        s->low_delay=1;
1180 de6d9b64 Fabrice Bellard
        break;
1181 d0271e8a Michael Niedermayer
    case CODEC_ID_RV20:
1182
        s->out_format = FMT_H263;
1183
        avctx->delay=0;
1184
        s->low_delay=1;
1185
        s->modified_quant=1;
1186
        s->h263_aic=1;
1187
        s->h263_plus=1;
1188
        s->loop_filter=1;
1189
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1190
        break;
1191 58f26ba9 Fabrice Bellard
    case CODEC_ID_MPEG4:
1192 de6d9b64 Fabrice Bellard
        s->out_format = FMT_H263;
1193
        s->h263_pred = 1;
1194
        s->unrestricted_mv = 1;
1195 4e00e76b Michael Niedermayer
        s->low_delay= s->max_b_frames ? 0 : 1;
1196 4d2858de Michael Niedermayer
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1197 de6d9b64 Fabrice Bellard
        break;
1198 84afee34 Michael Niedermayer
    case CODEC_ID_MSMPEG4V1:
1199 de6d9b64 Fabrice Bellard
        s->out_format = FMT_H263;
1200
        s->h263_msmpeg4 = 1;
1201
        s->h263_pred = 1;
1202
        s->unrestricted_mv = 1;
1203 84afee34 Michael Niedermayer
        s->msmpeg4_version= 1;
1204 1ff662cc Michael Niedermayer
        avctx->delay=0;
1205 4e00e76b Michael Niedermayer
        s->low_delay=1;
1206 84afee34 Michael Niedermayer
        break;
1207
    case CODEC_ID_MSMPEG4V2:
1208
        s->out_format = FMT_H263;
1209
        s->h263_msmpeg4 = 1;
1210
        s->h263_pred = 1;
1211
        s->unrestricted_mv = 1;
1212
        s->msmpeg4_version= 2;
1213 1ff662cc Michael Niedermayer
        avctx->delay=0;
1214 4e00e76b Michael Niedermayer
        s->low_delay=1;
1215 84afee34 Michael Niedermayer
        break;
1216
    case CODEC_ID_MSMPEG4V3:
1217
        s->out_format = FMT_H263;
1218
        s->h263_msmpeg4 = 1;
1219
        s->h263_pred = 1;
1220
        s->unrestricted_mv = 1;
1221
        s->msmpeg4_version= 3;
1222 1f9aea9b Michael Niedermayer
        s->flipflop_rounding=1;
1223 1ff662cc Michael Niedermayer
        avctx->delay=0;
1224 4e00e76b Michael Niedermayer
        s->low_delay=1;
1225 de6d9b64 Fabrice Bellard
        break;
1226 f5957f3f Michael Niedermayer
    case CODEC_ID_WMV1:
1227
        s->out_format = FMT_H263;
1228
        s->h263_msmpeg4 = 1;
1229
        s->h263_pred = 1;
1230
        s->unrestricted_mv = 1;
1231
        s->msmpeg4_version= 4;
1232 1f9aea9b Michael Niedermayer
        s->flipflop_rounding=1;
1233 f5957f3f Michael Niedermayer
        avctx->delay=0;
1234 4e00e76b Michael Niedermayer
        s->low_delay=1;
1235 f5957f3f Michael Niedermayer
        break;
1236
    case CODEC_ID_WMV2:
1237
        s->out_format = FMT_H263;
1238
        s->h263_msmpeg4 = 1;
1239
        s->h263_pred = 1;
1240
        s->unrestricted_mv = 1;
1241
        s->msmpeg4_version= 5;
1242 1f9aea9b Michael Niedermayer
        s->flipflop_rounding=1;
1243 f5957f3f Michael Niedermayer
        avctx->delay=0;
1244 4e00e76b Michael Niedermayer
        s->low_delay=1;
1245 f5957f3f Michael Niedermayer
        break;
1246 de6d9b64 Fabrice Bellard
    default:
1247
        return -1;
1248
    }
1249 115329f1 Diego Biurrun
1250 57518155 Michael Niedermayer
    avctx->has_b_frames= !s->low_delay;
1251 2c492e94 Michael Niedermayer
1252 3bb4e23a Fabrice Bellard
    s->encoding = 1;
1253
1254 de6d9b64 Fabrice Bellard
    /* init */
1255
    if (MPV_common_init(s) < 0)
1256
        return -1;
1257 dd5e90cd Michael Niedermayer
1258
    if(s->modified_quant)
1259
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1260 115329f1 Diego Biurrun
    s->progressive_frame=
1261 bb198e19 Michael Niedermayer
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1262 9c3d33d6 Michael Niedermayer
    s->quant_precision=5;
1263 115329f1 Diego Biurrun
1264 622348f9 Michael Niedermayer
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1265 0fd6aea1 Michael Niedermayer
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1266 115329f1 Diego Biurrun
1267 8b975b7c Michael Niedermayer
#ifdef CONFIG_H261_ENCODER
1268 1c3990db Michael Niedermayer
    if (s->out_format == FMT_H261)
1269
        ff_h261_encode_init(s);
1270 8b975b7c Michael Niedermayer
#endif
1271 2ad1516a Michael Niedermayer
    if (s->out_format == FMT_H263)
1272
        h263_encode_init(s);
1273
    if(s->msmpeg4_version)
1274
        ff_msmpeg4_encode_init(s);
1275 1d0d55da Michael Niedermayer
    if (s->out_format == FMT_MPEG1)
1276
        ff_mpeg1_encode_init(s);
1277 2ad1516a Michael Niedermayer
1278 3edcacde Michael Niedermayer
    /* init q matrix */
1279 519c2b6d Fabrice Bellard
    for(i=0;i<64;i++) {
1280 b0368839 Michael Niedermayer
        int j= s->dsp.idct_permutation[i];
1281 87f8cab4 Michael Niedermayer
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1282 2ad1516a Michael Niedermayer
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1283
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1284 1c3990db Michael Niedermayer
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1285 2ad1516a Michael Niedermayer
            s->intra_matrix[j] =
1286
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1287 1d0d55da Michael Niedermayer
        }else
1288 029911d1 Michael Niedermayer
        { /* mpeg1/2 */
1289 2ad1516a Michael Niedermayer
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1290
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1291 87f8cab4 Michael Niedermayer
        }
1292 d6eb3c50 Michael Niedermayer
        if(s->avctx->intra_matrix)
1293
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1294
        if(s->avctx->inter_matrix)
1295
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1296 d7e9533a Michael Niedermayer
    }
1297
1298
    /* precompute matrix */
1299 ef5b1b5a Juanjo
    /* for mjpeg, we do include qscale in the matrix */
1300 d7e9533a Michael Niedermayer
    if (s->out_format != FMT_MJPEG) {
1301 115329f1 Diego Biurrun
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1302 732ce18e Michael Niedermayer
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1303 115329f1 Diego Biurrun
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1304 732ce18e Michael Niedermayer
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1305 519c2b6d Fabrice Bellard
    }
1306
1307 8b4c7dbc Michael Niedermayer
    if(ff_rate_control_init(s) < 0)
1308
        return -1;
1309 115329f1 Diego Biurrun
1310 de6d9b64 Fabrice Bellard
    return 0;
1311
}
1312
1313
int MPV_encode_end(AVCodecContext *avctx)
1314
{
1315
    MpegEncContext *s = avctx->priv_data;
1316
1317
#ifdef STATS
1318
    print_stats();
1319
#endif
1320 8b4c7dbc Michael Niedermayer
1321
    ff_rate_control_uninit(s);
1322
1323 de6d9b64 Fabrice Bellard
    MPV_common_end(s);
1324
    if (s->out_format == FMT_MJPEG)
1325
        mjpeg_close(s);
1326 541ae140 Michael Niedermayer
1327 22ddd60b Michael Niedermayer
    av_freep(&avctx->extradata);
1328 115329f1 Diego Biurrun
1329 de6d9b64 Fabrice Bellard
    return 0;
1330
}
1331
1332 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
1333
1334 073c2593 Burkhard Plaum
void init_rl(RLTable *rl, int use_static)
1335 1d0d55da Michael Niedermayer
{
1336 0c1a9eda Zdenek Kabelac
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1337
    uint8_t index_run[MAX_RUN+1];
1338 1d0d55da Michael Niedermayer
    int last, run, level, start, end, i;
1339
1340 073c2593 Burkhard Plaum
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1341
    if(use_static && rl->max_level[0])
1342
        return;
1343
1344 1d0d55da Michael Niedermayer
    /* compute max_level[], max_run[] and index_run[] */
1345
    for(last=0;last<2;last++) {
1346
        if (last == 0) {
1347
            start = 0;
1348
            end = rl->last;
1349
        } else {
1350
            start = rl->last;
1351
            end = rl->n;
1352
        }
1353
1354
        memset(max_level, 0, MAX_RUN + 1);
1355
        memset(max_run, 0, MAX_LEVEL + 1);
1356
        memset(index_run, rl->n, MAX_RUN + 1);
1357
        for(i=start;i<end;i++) {
1358
            run = rl->table_run[i];
1359
            level = rl->table_level[i];
1360
            if (index_run[run] == rl->n)
1361
                index_run[run] = i;
1362
            if (level > max_level[run])
1363
                max_level[run] = level;
1364
            if (run > max_run[level])
1365
                max_run[level] = run;
1366
        }
1367 073c2593 Burkhard Plaum
        if(use_static)
1368
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1369
        else
1370
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1371 1d0d55da Michael Niedermayer
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1372 073c2593 Burkhard Plaum
        if(use_static)
1373
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1374
        else
1375
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1376 1d0d55da Michael Niedermayer
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1377 073c2593 Burkhard Plaum
        if(use_static)
1378
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1379
        else
1380
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1381 1d0d55da Michael Niedermayer
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1382
    }
1383
}
1384
1385 de6d9b64 Fabrice Bellard
/* draw the edges of width 'w' of an image of size width, height */
1386 fd7db0fd Michael Niedermayer
//FIXME check that this is ok for mpeg4 interlaced
1387 0c1a9eda Zdenek Kabelac
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1388 de6d9b64 Fabrice Bellard
{
1389 0c1a9eda Zdenek Kabelac
    uint8_t *ptr, *last_line;
1390 de6d9b64 Fabrice Bellard
    int i;
1391
1392
    last_line = buf + (height - 1) * wrap;
1393
    for(i=0;i<w;i++) {
1394
        /* top and bottom */
1395
        memcpy(buf - (i + 1) * wrap, buf, width);
1396
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1397
    }
1398
    /* left and right */
1399
    ptr = buf;
1400
    for(i=0;i<height;i++) {
1401
        memset(ptr - w, ptr[0], w);
1402
        memset(ptr + width, ptr[width-1], w);
1403
        ptr += wrap;
1404
    }
1405
    /* corners */
1406
    for(i=0;i<w;i++) {
1407
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1408
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1409
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1410
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1411
    }
1412
}
1413
1414 5f194811 Michael Niedermayer
int ff_find_unused_picture(MpegEncContext *s, int shared){
1415 4e00e76b Michael Niedermayer
    int i;
1416 115329f1 Diego Biurrun
1417 4e00e76b Michael Niedermayer
    if(shared){
1418
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1419 5f194811 Michael Niedermayer
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1420 4e00e76b Michael Niedermayer
        }
1421
    }else{
1422
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1423 5f194811 Michael Niedermayer
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1424 4e00e76b Michael Niedermayer
        }
1425
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1426 5f194811 Michael Niedermayer
            if(s->picture[i].data[0]==NULL) return i;
1427 4e00e76b Michael Niedermayer
        }
1428
    }
1429
1430 5f194811 Michael Niedermayer
    assert(0);
1431
    return -1;
1432 4e00e76b Michael Niedermayer
}
1433
1434 821cb11f Michael Niedermayer
static void update_noise_reduction(MpegEncContext *s){
1435
    int intra, i;
1436
1437
    for(intra=0; intra<2; intra++){
1438
        if(s->dct_count[intra] > (1<<16)){
1439
            for(i=0; i<64; i++){
1440
                s->dct_error_sum[intra][i] >>=1;
1441
            }
1442
            s->dct_count[intra] >>= 1;
1443
        }
1444 115329f1 Diego Biurrun
1445 821cb11f Michael Niedermayer
        for(i=0; i<64; i++){
1446
            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);
1447
        }
1448
    }
1449
}
1450
1451 5f194811 Michael Niedermayer
/**
1452
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1453
 */
1454 d6db1c9c Michael Niedermayer
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1455 de6d9b64 Fabrice Bellard
{
1456 4e00e76b Michael Niedermayer
    int i;
1457 492cd3a9 Michael Niedermayer
    AVFrame *pic;
1458 160d679c Mike Melanson
    s->mb_skipped = 0;
1459 0da71265 Michael Niedermayer
1460 8b82a956 Michael Niedermayer
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1461 e20c4069 Michael Niedermayer
1462 1e491e29 Michael Niedermayer
    /* mark&release old frames */
1463 14e2a940 Michael Niedermayer
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1464 b536d0aa Michael Niedermayer
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1465 1e491e29 Michael Niedermayer
1466
        /* release forgotten pictures */
1467
        /* if(mpeg124/h263) */
1468
        if(!s->encoding){
1469
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1470 b536d0aa Michael Niedermayer
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1471 9b879566 Michel Bardiaux
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1472 115329f1 Diego Biurrun
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1473 1e491e29 Michael Niedermayer
                }
1474
            }
1475 d6db1c9c Michael Niedermayer
        }
1476 93a21abd Michael Niedermayer
    }
1477 aa388dba Michael Niedermayer
alloc:
1478
    if(!s->encoding){
1479 bb628dae Diego Biurrun
        /* release non reference frames */
1480 e20c4069 Michael Niedermayer
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1481
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1482
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1483
            }
1484
        }
1485
1486 5f194811 Michael Niedermayer
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1487
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1488
        else{
1489
            i= ff_find_unused_picture(s, 0);
1490
            pic= (AVFrame*)&s->picture[i];
1491
        }
1492
1493 2f944356 Loren Merritt
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1494
                        && !s->dropable ? 3 : 0;
1495 b536d0aa Michael Niedermayer
1496 1031fabd Michael Niedermayer
        pic->coded_picture_number= s->coded_picture_number++;
1497 115329f1 Diego Biurrun
1498 f23a68df Ivan Kalvachev
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1499
            return -1;
1500 93a21abd Michael Niedermayer
1501 5f194811 Michael Niedermayer
        s->current_picture_ptr= (Picture*)pic;
1502 c70f1716 Michael Niedermayer
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1503 2be9f03a Michael Niedermayer
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1504 1e491e29 Michael Niedermayer
    }
1505 b7adc711 Michael Niedermayer
1506 9f2e61b6 Michael Niedermayer
    s->current_picture_ptr->pict_type= s->pict_type;
1507 115329f1 Diego Biurrun
//    if(s->flags && CODEC_FLAG_QSCALE)
1508 158c7f05 Michael Niedermayer
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1509 7bc9090a Michael Niedermayer
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1510 9f2e61b6 Michael Niedermayer
1511 6571e41d Michael Niedermayer
    copy_picture(&s->current_picture, s->current_picture_ptr);
1512 115329f1 Diego Biurrun
1513 8b82a956 Michael Niedermayer
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1514 1e491e29 Michael Niedermayer
    if (s->pict_type != B_TYPE) {
1515 b536d0aa Michael Niedermayer
        s->last_picture_ptr= s->next_picture_ptr;
1516 14e2a940 Michael Niedermayer
        if(!s->dropable)
1517
            s->next_picture_ptr= s->current_picture_ptr;
1518 de6d9b64 Fabrice Bellard
    }
1519 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,
1520 115329f1 Diego Biurrun
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1521
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1522 14e2a940 Michael Niedermayer
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1523
        s->pict_type, s->dropable);*/
1524 115329f1 Diego Biurrun
1525 6571e41d Michael Niedermayer
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1526
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1527 115329f1 Diego Biurrun
1528 6571e41d Michael Niedermayer
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1529 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1530 bb628dae Diego Biurrun
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1531 ffba1dc0 Michael Niedermayer
        goto alloc;
1532
    }
1533
1534
    assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1535
1536 b536d0aa Michael Niedermayer
    if(s->picture_structure!=PICT_FRAME){
1537
        int i;
1538
        for(i=0; i<4; i++){
1539
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1540
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1541 115329f1 Diego Biurrun
            }
1542 b536d0aa Michael Niedermayer
            s->current_picture.linesize[i] *= 2;
1543
            s->last_picture.linesize[i] *=2;
1544
            s->next_picture.linesize[i] *=2;
1545
        }
1546
    }
1547 0da71265 Michael Niedermayer
  }
1548 115329f1 Diego Biurrun
1549 aa388dba Michael Niedermayer
    s->hurry_up= s->avctx->hurry_up;
1550
    s->error_resilience= avctx->error_resilience;
1551
1552 bb628dae Diego Biurrun
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1553
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1554 d50635cd Michael Niedermayer
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1555
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1556
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1557 ccff9da6 Maarten Daniels
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1558 d50635cd Michael Niedermayer
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1559
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1560
    }else{
1561
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1562
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1563
    }
1564 d6db1c9c Michael Niedermayer
1565 821cb11f Michael Niedermayer
    if(s->dct_error_sum){
1566
        assert(s->avctx->noise_reduction && s->encoding);
1567
1568
        update_noise_reduction(s);
1569
    }
1570 115329f1 Diego Biurrun
1571 2e7b4c84 Ivan Kalvachev
#ifdef HAVE_XVMC
1572
    if(s->avctx->xvmc_acceleration)
1573
        return XVMC_field_start(s, avctx);
1574
#endif
1575 d6db1c9c Michael Niedermayer
    return 0;
1576 de6d9b64 Fabrice Bellard
}
1577 21af69f7 Fabrice Bellard
1578 de6d9b64 Fabrice Bellard
/* generic function for encode/decode called after a frame has been coded/decoded */
1579
void MPV_frame_end(MpegEncContext *s)
1580
{
1581 1e491e29 Michael Niedermayer
    int i;
1582 de6d9b64 Fabrice Bellard
    /* draw edge for correct motion prediction if outside */
1583 2e7b4c84 Ivan Kalvachev
#ifdef HAVE_XVMC
1584
//just to make sure that all data is rendered.
1585
    if(s->avctx->xvmc_acceleration){
1586
        XVMC_field_end(s);
1587
    }else
1588
#endif
1589 2f944356 Loren Merritt
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1590 1e491e29 Michael Niedermayer
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1591
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1592
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1593 de6d9b64 Fabrice Bellard
    }
1594 5975626d Michael Niedermayer
    emms_c();
1595 115329f1 Diego Biurrun
1596 3aa102be Michael Niedermayer
    s->last_pict_type    = s->pict_type;
1597 8b4c7dbc Michael Niedermayer
    if(s->pict_type!=B_TYPE){
1598
        s->last_non_b_pict_type= s->pict_type;
1599
    }
1600 b536d0aa Michael Niedermayer
#if 0
1601
        /* copy back current_picture variables */
1602 1e491e29 Michael Niedermayer
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1603
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1604
            s->picture[i]= s->current_picture;
1605
            break;
1606 115329f1 Diego Biurrun
        }
1607 1e491e29 Michael Niedermayer
    }
1608
    assert(i<MAX_PICTURE_COUNT);
1609 115329f1 Diego Biurrun
#endif
1610 1e491e29 Michael Niedermayer
1611 e20c4069 Michael Niedermayer
    if(s->encoding){
1612 bb628dae Diego Biurrun
        /* release non-reference frames */
1613 e20c4069 Michael Niedermayer
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1614
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1615
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1616
            }
1617
        }
1618 1e491e29 Michael Niedermayer
    }
1619 b536d0aa Michael Niedermayer
    // clear copies, to avoid confusion
1620
#if 0
1621
    memset(&s->last_picture, 0, sizeof(Picture));
1622
    memset(&s->next_picture, 0, sizeof(Picture));
1623
    memset(&s->current_picture, 0, sizeof(Picture));
1624
#endif
1625 7b37a6e9 Michael Niedermayer
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1626 de6d9b64 Fabrice Bellard
}
1627
1628 7bc9090a Michael Niedermayer
/**
1629 db6e7795 Michael Niedermayer
 * draws an line from (ex, ey) -> (sx, sy).
1630
 * @param w width of the image
1631
 * @param h height of the image
1632
 * @param stride stride/linesize of the image
1633
 * @param color color of the arrow
1634
 */
1635
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1636 8100cab9 Michael Niedermayer
    int t, x, y, fr, f;
1637 115329f1 Diego Biurrun
1638 db6e7795 Michael Niedermayer
    sx= clip(sx, 0, w-1);
1639
    sy= clip(sy, 0, h-1);
1640
    ex= clip(ex, 0, w-1);
1641
    ey= clip(ey, 0, h-1);
1642 115329f1 Diego Biurrun
1643 db6e7795 Michael Niedermayer
    buf[sy*stride + sx]+= color;
1644 115329f1 Diego Biurrun
1645 db6e7795 Michael Niedermayer
    if(ABS(ex - sx) > ABS(ey - sy)){
1646
        if(sx > ex){
1647
            t=sx; sx=ex; ex=t;
1648
            t=sy; sy=ey; ey=t;
1649
        }
1650
        buf+= sx + sy*stride;
1651
        ex-= sx;
1652
        f= ((ey-sy)<<16)/ex;
1653
        for(x= 0; x <= ex; x++){
1654 8100cab9 Michael Niedermayer
            y = (x*f)>>16;
1655
            fr= (x*f)&0xFFFF;
1656
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1657
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1658 db6e7795 Michael Niedermayer
        }
1659
    }else{
1660
        if(sy > ey){
1661
            t=sx; sx=ex; ex=t;
1662
            t=sy; sy=ey; ey=t;
1663
        }
1664
        buf+= sx + sy*stride;
1665
        ey-= sy;
1666
        if(ey) f= ((ex-sx)<<16)/ey;
1667
        else   f= 0;
1668
        for(y= 0; y <= ey; y++){
1669 8100cab9 Michael Niedermayer
            x = (y*f)>>16;
1670
            fr= (y*f)&0xFFFF;
1671
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1672
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1673 db6e7795 Michael Niedermayer
        }
1674
    }
1675
}
1676
1677
/**
1678
 * draws an arrow from (ex, ey) -> (sx, sy).
1679
 * @param w width of the image
1680
 * @param h height of the image
1681
 * @param stride stride/linesize of the image
1682
 * @param color color of the arrow
1683
 */
1684 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){
1685 db6e7795 Michael Niedermayer
    int dx,dy;
1686
1687
    sx= clip(sx, -100, w+100);
1688
    sy= clip(sy, -100, h+100);
1689
    ex= clip(ex, -100, w+100);
1690
    ey= clip(ey, -100, h+100);
1691 115329f1 Diego Biurrun
1692 db6e7795 Michael Niedermayer
    dx= ex - sx;
1693
    dy= ey - sy;
1694 115329f1 Diego Biurrun
1695 db6e7795 Michael Niedermayer
    if(dx*dx + dy*dy > 3*3){
1696
        int rx=  dx + dy;
1697
        int ry= -dx + dy;
1698
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1699 115329f1 Diego Biurrun
1700 db6e7795 Michael Niedermayer
        //FIXME subpixel accuracy
1701
        rx= ROUNDED_DIV(rx*3<<4, length);
1702
        ry= ROUNDED_DIV(ry*3<<4, length);
1703 115329f1 Diego Biurrun
1704 db6e7795 Michael Niedermayer
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1705
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1706
    }
1707
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1708
}
1709
1710
/**
1711 7bc9090a Michael Niedermayer
 * prints debuging info for the given picture.
1712
 */
1713 0c9bbaec Wolfgang Hesseler
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1714 7bc9090a Michael Niedermayer
1715
    if(!pict || !pict->mb_type) return;
1716
1717
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1718
        int x,y;
1719 115329f1 Diego Biurrun
1720 0c9bbaec Wolfgang Hesseler
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1721
        switch (pict->pict_type) {
1722
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1723
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1724
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1725
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1726
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1727 115329f1 Diego Biurrun
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1728 0c9bbaec Wolfgang Hesseler
        }
1729 7bc9090a Michael Niedermayer
        for(y=0; y<s->mb_height; y++){
1730
            for(x=0; x<s->mb_width; x++){
1731
                if(s->avctx->debug&FF_DEBUG_SKIP){
1732
                    int count= s->mbskip_table[x + y*s->mb_stride];
1733
                    if(count>9) count=9;
1734 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1735 7bc9090a Michael Niedermayer
                }
1736
                if(s->avctx->debug&FF_DEBUG_QP){
1737 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1738 7bc9090a Michael Niedermayer
                }
1739
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1740
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1741
                    //Type & MV direction
1742
                    if(IS_PCM(mb_type))
1743 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1744 7bc9090a Michael Niedermayer
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1745 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1746 7bc9090a Michael Niedermayer
                    else if(IS_INTRA4x4(mb_type))
1747 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1748 7bc9090a Michael Niedermayer
                    else if(IS_INTRA16x16(mb_type))
1749 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1750 7bc9090a Michael Niedermayer
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1751 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1752 7bc9090a Michael Niedermayer
                    else if(IS_DIRECT(mb_type))
1753 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1754 7bc9090a Michael Niedermayer
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1755 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1756 7bc9090a Michael Niedermayer
                    else if(IS_GMC(mb_type))
1757 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1758 7bc9090a Michael Niedermayer
                    else if(IS_SKIP(mb_type))
1759 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1760 7bc9090a Michael Niedermayer
                    else if(!USES_LIST(mb_type, 1))
1761 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1762 7bc9090a Michael Niedermayer
                    else if(!USES_LIST(mb_type, 0))
1763 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1764 7bc9090a Michael Niedermayer
                    else{
1765
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1766 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1767 7bc9090a Michael Niedermayer
                    }
1768 115329f1 Diego Biurrun
1769 7bc9090a Michael Niedermayer
                    //segmentation
1770
                    if(IS_8X8(mb_type))
1771 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1772 7bc9090a Michael Niedermayer
                    else if(IS_16X8(mb_type))
1773 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1774 7bc9090a Michael Niedermayer
                    else if(IS_8X16(mb_type))
1775 30344a83 Måns Rullgård
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1776 7bc9090a Michael Niedermayer
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1777 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1778 7bc9090a Michael Niedermayer
                    else
1779 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1780 115329f1 Diego Biurrun
1781
1782 7bc9090a Michael Niedermayer
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1783 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1784 7bc9090a Michael Niedermayer
                    else
1785 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1786 7bc9090a Michael Niedermayer
                }
1787 9b879566 Michel Bardiaux
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1788 7bc9090a Michael Niedermayer
            }
1789 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1790 7bc9090a Michael Niedermayer
        }
1791
    }
1792 8d7ec294 Wolfgang Hesseler
1793 0c9bbaec Wolfgang Hesseler
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1794 db6e7795 Michael Niedermayer
        const int shift= 1 + s->quarter_sample;
1795
        int mb_y;
1796 0c9bbaec Wolfgang Hesseler
        uint8_t *ptr;
1797
        int i;
1798 0982834b Michael Niedermayer
        int h_chroma_shift, v_chroma_shift;
1799 4f8a8319 Michael Niedermayer
        const int width = s->avctx->width;
1800
        const int height= s->avctx->height;
1801 650cec0c Loren Merritt
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1802
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1803 b846b231 Michael Niedermayer
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1804 0c9bbaec Wolfgang Hesseler
1805 0982834b Michael Niedermayer
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1806 0c9bbaec Wolfgang Hesseler
        for(i=0; i<3; i++){
1807 4f8a8319 Michael Niedermayer
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1808 0c9bbaec Wolfgang Hesseler
            pict->data[i]= s->visualization_buffer[i];
1809
        }
1810
        pict->type= FF_BUFFER_TYPE_COPY;
1811
        ptr= pict->data[0];
1812 db6e7795 Michael Niedermayer
1813
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1814
            int mb_x;
1815
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1816
                const int mb_index= mb_x + mb_y*s->mb_stride;
1817 0c9bbaec Wolfgang Hesseler
                if((s->avctx->debug_mv) && pict->motion_val){
1818
                  int type;
1819
                  for(type=0; type<3; type++){
1820 e96682e6 Michael Niedermayer
                    int direction = 0;
1821 0c9bbaec Wolfgang Hesseler
                    switch (type) {
1822
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1823
                                continue;
1824
                              direction = 0;
1825
                              break;
1826
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1827
                                continue;
1828
                              direction = 0;
1829
                              break;
1830
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1831
                                continue;
1832
                              direction = 1;
1833
                              break;
1834
                    }
1835 ae55b533 Michael Niedermayer
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1836
                        continue;
1837
1838 0c9bbaec Wolfgang Hesseler
                    if(IS_8X8(pict->mb_type[mb_index])){
1839
                      int i;
1840
                      for(i=0; i<4; i++){
1841 db6e7795 Michael Niedermayer
                        int sx= mb_x*16 + 4 + 8*(i&1);
1842
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1843 88730be6 Måns Rullgård
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1844 0c9bbaec Wolfgang Hesseler
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1845
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1846 4f8a8319 Michael Niedermayer
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1847 0c9bbaec Wolfgang Hesseler
                      }
1848
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1849
                      int i;
1850
                      for(i=0; i<2; i++){
1851 9bc8b386 Michael Niedermayer
                        int sx=mb_x*16 + 8;
1852
                        int sy=mb_y*16 + 4 + 8*i;
1853 88730be6 Måns Rullgård
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1854 650cec0c Loren Merritt
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1855
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1856 115329f1 Diego Biurrun
1857 650cec0c Loren Merritt
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1858
                            my*=2;
1859 115329f1 Diego Biurrun
1860 650cec0c Loren Merritt
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1861
                      }
1862
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1863
                      int i;
1864
                      for(i=0; i<2; i++){
1865
                        int sx=mb_x*16 + 4 + 8*i;
1866
                        int sy=mb_y*16 + 8;
1867 88730be6 Måns Rullgård
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1868 38030214 Michael Niedermayer
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1869
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1870 115329f1 Diego Biurrun
1871 38030214 Michael Niedermayer
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1872
                            my*=2;
1873 115329f1 Diego Biurrun
1874 4f8a8319 Michael Niedermayer
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1875 0c9bbaec Wolfgang Hesseler
                      }
1876
                    }else{
1877
                      int sx= mb_x*16 + 8;
1878
                      int sy= mb_y*16 + 8;
1879 650cec0c Loren Merritt
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1880 0c9bbaec Wolfgang Hesseler
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1881
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1882 4f8a8319 Michael Niedermayer
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1883 9bc8b386 Michael Niedermayer
                    }
1884 115329f1 Diego Biurrun
                  }
1885 864119b6 Michael Niedermayer
                }
1886
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1887
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1888
                    int y;
1889
                    for(y=0; y<8; y++){
1890
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1891
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1892
                    }
1893
                }
1894
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1895
                    int mb_type= pict->mb_type[mb_index];
1896
                    uint64_t u,v;
1897
                    int y;
1898
#define COLOR(theta, r)\
1899
u= (int)(128 + r*cos(theta*3.141592/180));\
1900
v= (int)(128 + r*sin(theta*3.141592/180));
1901
1902 115329f1 Diego Biurrun
1903 864119b6 Michael Niedermayer
                    u=v=128;
1904
                    if(IS_PCM(mb_type)){
1905
                        COLOR(120,48)
1906
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1907
                        COLOR(30,48)
1908
                    }else if(IS_INTRA4x4(mb_type)){
1909
                        COLOR(90,48)
1910
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1911
//                        COLOR(120,48)
1912
                    }else if(IS_DIRECT(mb_type)){
1913
                        COLOR(150,48)
1914
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1915
                        COLOR(170,48)
1916
                    }else if(IS_GMC(mb_type)){
1917
                        COLOR(190,48)
1918
                    }else if(IS_SKIP(mb_type)){
1919
//                        COLOR(180,48)
1920
                    }else if(!USES_LIST(mb_type, 1)){
1921
                        COLOR(240,48)
1922
                    }else if(!USES_LIST(mb_type, 0)){
1923
                        COLOR(0,48)
1924
                    }else{
1925
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1926
                        COLOR(300,48)
1927
                    }
1928
1929
                    u*= 0x0101010101010101ULL;
1930
                    v*= 0x0101010101010101ULL;
1931
                    for(y=0; y<8; y++){
1932
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1933
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1934
                    }
1935
1936
                    //segmentation
1937
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1938
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1939
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1940
                    }
1941
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1942
                        for(y=0; y<16; y++)
1943
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1944
                    }
1945 e21f3983 Loren Merritt
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1946
                        int dm= 1 << (mv_sample_log2-2);
1947
                        for(i=0; i<4; i++){
1948
                            int sx= mb_x*16 + 8*(i&1);
1949
                            int sy= mb_y*16 + 8*(i>>1);
1950
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1951
                            //FIXME bidir
1952
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1953
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1954
                                for(y=0; y<8; y++)
1955
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1956
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1957
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1958
                        }
1959
                    }
1960 115329f1 Diego Biurrun
1961 864119b6 Michael Niedermayer
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1962
                        // hmm
1963
                    }
1964 db6e7795 Michael Niedermayer
                }
1965
                s->mbskip_table[mb_index]=0;
1966
            }
1967
        }
1968
    }
1969 7bc9090a Michael Niedermayer
}
1970
1971 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
1972
1973 0d1e9246 Michael Niedermayer
static int get_sae(uint8_t *src, int ref, int stride){
1974
    int x,y;
1975
    int acc=0;
1976 115329f1 Diego Biurrun
1977 0d1e9246 Michael Niedermayer
    for(y=0; y<16; y++){
1978
        for(x=0; x<16; x++){
1979
            acc+= ABS(src[x+y*stride] - ref);
1980
        }
1981
    }
1982 115329f1 Diego Biurrun
1983 0d1e9246 Michael Niedermayer
    return acc;
1984
}
1985
1986
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1987
    int x, y, w, h;
1988
    int acc=0;
1989 115329f1 Diego Biurrun
1990 0d1e9246 Michael Niedermayer
    w= s->width &~15;
1991
    h= s->height&~15;
1992 115329f1 Diego Biurrun
1993 0d1e9246 Michael Niedermayer
    for(y=0; y<h; y+=16){
1994
        for(x=0; x<w; x+=16){
1995
            int offset= x + y*stride;
1996 bb198e19 Michael Niedermayer
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1997 0d1e9246 Michael Niedermayer
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1998
            int sae = get_sae(src + offset, mean, stride);
1999 115329f1 Diego Biurrun
2000 0d1e9246 Michael Niedermayer
            acc+= sae + 500 < sad;
2001
        }
2002
    }
2003
    return acc;
2004
}
2005
2006 4e00e76b Michael Niedermayer
2007 492cd3a9 Michael Niedermayer
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2008 17d71fb9 Michael Niedermayer
    AVFrame *pic=NULL;
2009 30231f81 Michael Niedermayer
    int64_t pts;
2010 4e00e76b Michael Niedermayer
    int i;
2011 1e491e29 Michael Niedermayer
    const int encoding_delay= s->max_b_frames;
2012 4e00e76b Michael Niedermayer
    int direct=1;
2013 115329f1 Diego Biurrun
2014 eaba7c7f Michael Niedermayer
    if(pic_arg){
2015 30231f81 Michael Niedermayer
        pts= pic_arg->pts;
2016
        pic_arg->display_picture_number= s->input_picture_number++;
2017
2018 115329f1 Diego Biurrun
        if(pts != AV_NOPTS_VALUE){
2019 eaba7c7f Michael Niedermayer
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2020 c0df9d75 Michael Niedermayer
                int64_t time= pts;
2021
                int64_t last= s->user_specified_pts;
2022 115329f1 Diego Biurrun
2023
                if(time <= last){
2024 4733abcb Måns Rullgård
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2025 eaba7c7f Michael Niedermayer
                    return -1;
2026
                }
2027
            }
2028 30231f81 Michael Niedermayer
            s->user_specified_pts= pts;
2029 eaba7c7f Michael Niedermayer
        }else{
2030
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2031 115329f1 Diego Biurrun
                s->user_specified_pts=
2032 c0df9d75 Michael Niedermayer
                pts= s->user_specified_pts + 1;
2033 4733abcb Måns Rullgård
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2034 eaba7c7f Michael Niedermayer
            }else{
2035 c0df9d75 Michael Niedermayer
                pts= pic_arg->display_picture_number;
2036 eaba7c7f Michael Niedermayer
            }
2037
        }
2038
    }
2039
2040 17d71fb9 Michael Niedermayer
  if(pic_arg){
2041 4e00e76b Michael Niedermayer
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2042
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2043
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2044
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2045 115329f1 Diego Biurrun
2046 9b879566 Michel Bardiaux
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2047 115329f1 Diego Biurrun
2048 4e00e76b Michael Niedermayer
    if(direct){
2049 5f194811 Michael Niedermayer
        i= ff_find_unused_picture(s, 1);
2050 1e491e29 Michael Niedermayer
2051 492cd3a9 Michael Niedermayer
        pic= (AVFrame*)&s->picture[i];
2052 0da71265 Michael Niedermayer
        pic->reference= 3;
2053 115329f1 Diego Biurrun
2054 4e00e76b Michael Niedermayer
        for(i=0; i<4; i++){
2055
            pic->data[i]= pic_arg->data[i];
2056
            pic->linesize[i]= pic_arg->linesize[i];
2057
        }
2058
        alloc_picture(s, (Picture*)pic, 1);
2059
    }else{
2060 6571e41d Michael Niedermayer
        int offset= 16;
2061 5f194811 Michael Niedermayer
        i= ff_find_unused_picture(s, 0);
2062 1e491e29 Michael Niedermayer
2063 492cd3a9 Michael Niedermayer
        pic= (AVFrame*)&s->picture[i];
2064 0da71265 Michael Niedermayer
        pic->reference= 3;
2065 1e491e29 Michael Niedermayer
2066 4e00e76b Michael Niedermayer
        alloc_picture(s, (Picture*)pic, 0);
2067
2068 115329f1 Diego Biurrun
        if(   pic->data[0] + offset == pic_arg->data[0]
2069 6571e41d Michael Niedermayer
           && pic->data[1] + offset == pic_arg->data[1]
2070
           && pic->data[2] + offset == pic_arg->data[2]){
2071 1e491e29 Michael Niedermayer
       // empty
2072 4e00e76b Michael Niedermayer
        }else{
2073
            int h_chroma_shift, v_chroma_shift;
2074
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2075 115329f1 Diego Biurrun
2076 4e00e76b Michael Niedermayer
            for(i=0; i<3; i++){
2077
                int src_stride= pic_arg->linesize[i];
2078
                int dst_stride= i ? s->uvlinesize : s->linesize;
2079
                int h_shift= i ? h_chroma_shift : 0;
2080
                int v_shift= i ? v_chroma_shift : 0;
2081
                int w= s->width >>h_shift;
2082
                int h= s->height>>v_shift;
2083
                uint8_t *src= pic_arg->data[i];
2084 6571e41d Michael Niedermayer
                uint8_t *dst= pic->data[i] + offset;
2085 115329f1 Diego Biurrun
2086 4e00e76b Michael Niedermayer
                if(src_stride==dst_stride)
2087
                    memcpy(dst, src, src_stride*h);
2088
                else{
2089
                    while(h--){
2090
                        memcpy(dst, src, w);
2091
                        dst += dst_stride;
2092
                        src += src_stride;
2093
                    }
2094 1e491e29 Michael Niedermayer
                }
2095 9dbcbd92 Michael Niedermayer
            }
2096 1e491e29 Michael Niedermayer
        }
2097
    }
2098 137c8468 Michael Niedermayer
    copy_picture_attributes(s, pic, pic_arg);
2099 30231f81 Michael Niedermayer
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2100 17d71fb9 Michael Niedermayer
  }
2101 115329f1 Diego Biurrun
2102 4e00e76b Michael Niedermayer
    /* shift buffer entries */
2103
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2104
        s->input_picture[i-1]= s->input_picture[i];
2105 115329f1 Diego Biurrun
2106 4e00e76b Michael Niedermayer
    s->input_picture[encoding_delay]= (Picture*)pic;
2107 1e491e29 Michael Niedermayer
2108
    return 0;
2109
}
2110 9dbcbd92 Michael Niedermayer
2111 bbf18b21 Michael Niedermayer
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2112
    int x, y, plane;
2113
    int score=0;
2114 0fd6aea1 Michael Niedermayer
    int64_t score64=0;
2115 bbf18b21 Michael Niedermayer
2116
    for(plane=0; plane<3; plane++){
2117
        const int stride= p->linesize[plane];
2118
        const int bw= plane ? 1 : 2;
2119
        for(y=0; y<s->mb_height*bw; y++){
2120
            for(x=0; x<s->mb_width*bw; x++){
2121 a75a3ca4 Michael Niedermayer
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2122
                int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2123 115329f1 Diego Biurrun
2124 0fd6aea1 Michael Niedermayer
                switch(s->avctx->frame_skip_exp){
2125
                    case 0: score= FFMAX(score, v); break;
2126
                    case 1: score+= ABS(v);break;
2127
                    case 2: score+= v*v;break;
2128
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2129
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2130
                }
2131 bbf18b21 Michael Niedermayer
            }
2132
        }
2133
    }
2134 115329f1 Diego Biurrun
2135 0fd6aea1 Michael Niedermayer
    if(score) score64= score;
2136 bbf18b21 Michael Niedermayer
2137 0fd6aea1 Michael Niedermayer
    if(score64 < s->avctx->frame_skip_threshold)
2138 bbf18b21 Michael Niedermayer
        return 1;
2139 0fd6aea1 Michael Niedermayer
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2140 bbf18b21 Michael Niedermayer
        return 1;
2141
    return 0;
2142
}
2143
2144 984b8e4d Michael Niedermayer
static int estimate_best_b_count(MpegEncContext *s){
2145
    AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2146
    AVCodecContext *c= avcodec_alloc_context();
2147
    AVFrame input[FF_MAX_B_FRAMES+2];
2148 e8501c93 Michael Niedermayer
    const int scale= s->avctx->brd_scale;
2149 984b8e4d Michael Niedermayer
    int i, j, out_size;
2150 e8501c93 Michael Niedermayer
    int outbuf_size= s->width * s->height; //FIXME
2151 984b8e4d Michael Niedermayer
    uint8_t *outbuf= av_malloc(outbuf_size);
2152
    ImgReSampleContext *resample;
2153
    int64_t best_rd= INT64_MAX;
2154
    int best_b_count= -1;
2155
    const int lambda2= s->lambda2;
2156
2157
    c->width = s->width >> scale;
2158
    c->height= s->height>> scale;
2159
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2160
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2161
    c->mb_decision= s->avctx->mb_decision;
2162
    c->me_cmp= s->avctx->me_cmp;
2163
    c->mb_cmp= s->avctx->mb_cmp;
2164
    c->me_sub_cmp= s->avctx->me_sub_cmp;
2165
    c->pix_fmt = PIX_FMT_YUV420P;
2166
    c->time_base= s->avctx->time_base;
2167
    c->max_b_frames= s->max_b_frames;
2168
2169
    if (avcodec_open(c, codec) < 0)
2170
        return -1;
2171
2172
    resample= img_resample_init(c->width, c->height, s->width, s->height); //FIXME use sws
2173
2174
    for(i=0; i<s->max_b_frames+2; i++){
2175
        int ysize= c->width*c->height;
2176
        int csize= (c->width/2)*(c->height/2);
2177
2178
        avcodec_get_frame_defaults(&input[i]);
2179
        input[i].data[0]= av_malloc(ysize + 2*csize);
2180
        input[i].data[1]= input[i].data[0] + ysize;
2181
        input[i].data[2]= input[i].data[1] + csize;
2182
        input[i].linesize[0]= c->width;
2183
        input[i].linesize[1]=
2184
        input[i].linesize[2]= c->width/2;
2185
2186
        if(!i || s->input_picture[i-1])
2187
            img_resample(resample, &input[i], i ? s->input_picture[i-1] : s->next_picture_ptr);
2188
    }
2189
2190
    for(j=0; j<s->max_b_frames+1; j++){
2191
        int64_t rd=0;
2192
2193
        if(!s->input_picture[j])
2194
            break;
2195
2196
        c->error[0]= c->error[1]= c->error[2]= 0;
2197
2198
        input[0].pict_type= I_TYPE;
2199
        input[0].quality= 2 * FF_QP2LAMBDA;
2200
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2201 e8501c93 Michael Niedermayer
        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2202 984b8e4d Michael Niedermayer
2203
        for(i=0; i<s->max_b_frames+1; i++){
2204
            int is_p= i % (j+1) == j || i==s->max_b_frames;
2205
2206
            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2207
            input[i+1].quality= s->rc_context.last_qscale_for[input[i+1].pict_type];
2208
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2209
            rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2210
        }
2211
2212
        /* get the delayed frames */
2213
        while(out_size){
2214
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2215
            rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2216
        }
2217
2218
        rd += c->error[0] + c->error[1] + c->error[2];
2219
2220
        if(rd < best_rd){
2221
            best_rd= rd;
2222
            best_b_count= j;
2223
        }
2224
    }
2225
2226
    av_freep(&outbuf);
2227
    avcodec_close(c);
2228
    av_freep(&c);
2229
    img_resample_close(resample);
2230
2231
    for(i=0; i<s->max_b_frames+2; i++){
2232
        av_freep(&input[i].data[0]);
2233
    }
2234
2235
    return best_b_count;
2236
}
2237
2238 1e491e29 Michael Niedermayer
static void select_input_picture(MpegEncContext *s){
2239
    int i;
2240 4e00e76b Michael Niedermayer
2241 1e491e29 Michael Niedermayer
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2242
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2243
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2244
2245 bb628dae Diego Biurrun
    /* set next picture type & ordering */
2246 1e491e29 Michael Niedermayer
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2247 b536d0aa Michael Niedermayer
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2248 0d1e9246 Michael Niedermayer
            s->reordered_input_picture[0]= s->input_picture[0];
2249
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2250 1031fabd Michael Niedermayer
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2251 0d1e9246 Michael Niedermayer
        }else{
2252
            int b_frames;
2253 bbf18b21 Michael Niedermayer
2254
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2255 a75a3ca4 Michael Niedermayer
                if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2256
                //FIXME check that te gop check above is +-1 correct
2257 bbf18b21 Michael Niedermayer
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2258 115329f1 Diego Biurrun
2259 bbf18b21 Michael Niedermayer
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2260
                        for(i=0; i<4; i++)
2261
                            s->input_picture[0]->data[i]= NULL;
2262 115329f1 Diego Biurrun
                        s->input_picture[0]->type= 0;
2263 bbf18b21 Michael Niedermayer
                    }else{
2264 115329f1 Diego Biurrun
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2265 bbf18b21 Michael Niedermayer
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2266 115329f1 Diego Biurrun
2267 bbf18b21 Michael Niedermayer
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2268
                    }
2269 115329f1 Diego Biurrun
2270 a75a3ca4 Michael Niedermayer
                    emms_c();
2271
                    ff_vbv_update(s, 0);
2272 bbf18b21 Michael Niedermayer
2273
                    goto no_output_pic;
2274
                }
2275
            }
2276
2277 0d1e9246 Michael Niedermayer
            if(s->flags&CODEC_FLAG_PASS2){
2278
                for(i=0; i<s->max_b_frames+1; i++){
2279
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2280 80516d72 Loren Merritt
2281 115329f1 Diego Biurrun
                    if(pict_num >= s->rc_context.num_entries)
2282 6db2583c Michael Niedermayer
                        break;
2283 80516d72 Loren Merritt
                    if(!s->input_picture[i]){
2284 6db2583c Michael Niedermayer
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2285 80516d72 Loren Merritt
                        break;
2286
                    }
2287 6db2583c Michael Niedermayer
2288 115329f1 Diego Biurrun
                    s->input_picture[i]->pict_type=
2289 6db2583c Michael Niedermayer
                        s->rc_context.entry[pict_num].new_pict_type;
2290 0d1e9246 Michael Niedermayer
                }
2291
            }
2292 4e00e76b Michael Niedermayer
2293 9efc77c8 Michael Niedermayer
            if(s->avctx->b_frame_strategy==0){
2294 0d1e9246 Michael Niedermayer
                b_frames= s->max_b_frames;
2295 17d71fb9 Michael Niedermayer
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2296 d55f7b65 Michael Niedermayer
            }else if(s->avctx->b_frame_strategy==1){
2297 0d1e9246 Michael Niedermayer
                for(i=1; i<s->max_b_frames+1; i++){
2298 17d71fb9 Michael Niedermayer
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2299 115329f1 Diego Biurrun
                        s->input_picture[i]->b_frame_score=
2300
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2301 4e00e76b Michael Niedermayer
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2302 0d1e9246 Michael Niedermayer
                    }
2303
                }
2304 ded8477d Michael Niedermayer
                for(i=0; i<s->max_b_frames+1; i++){
2305 17d71fb9 Michael Niedermayer
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2306 0d1e9246 Michael Niedermayer
                }
2307 115329f1 Diego Biurrun
2308 0d1e9246 Michael Niedermayer
                b_frames= FFMAX(0, i-1);
2309 115329f1 Diego Biurrun
2310 0d1e9246 Michael Niedermayer
                /* reset scores */
2311
                for(i=0; i<b_frames+1; i++){
2312
                    s->input_picture[i]->b_frame_score=0;
2313
                }
2314 984b8e4d Michael Niedermayer
            }else if(s->avctx->b_frame_strategy==2){
2315
                b_frames= estimate_best_b_count(s);
2316 0d1e9246 Michael Niedermayer
            }else{
2317 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2318 0d1e9246 Michael Niedermayer
                b_frames=0;
2319 140cb663 Michael Niedermayer
            }
2320 0d1e9246 Michael Niedermayer
2321
            emms_c();
2322
//static int b_count=0;
2323
//b_count+= b_frames;
2324 9b879566 Michel Bardiaux
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2325 9efc77c8 Michael Niedermayer
2326
            for(i= b_frames - 1; i>=0; i--){
2327
                int type= s->input_picture[i]->pict_type;
2328
                if(type && type != B_TYPE)
2329
                    b_frames= i;
2330
            }
2331
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2332 dfb706da Kevin Baragona
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2333 9efc77c8 Michael Niedermayer
            }
2334
2335 303e50e6 Michael Niedermayer
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2336 03581772 Michael Niedermayer
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2337
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2338
              }else{
2339 303e50e6 Michael Niedermayer
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2340
                    b_frames=0;
2341
                s->input_picture[b_frames]->pict_type= I_TYPE;
2342 03581772 Michael Niedermayer
              }
2343 303e50e6 Michael Niedermayer
            }
2344 115329f1 Diego Biurrun
2345 303e50e6 Michael Niedermayer
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2346
               && b_frames
2347
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2348
                b_frames--;
2349
2350 0d1e9246 Michael Niedermayer
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2351 303e50e6 Michael Niedermayer
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2352 0d1e9246 Michael Niedermayer
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2353 1031fabd Michael Niedermayer
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2354 0d1e9246 Michael Niedermayer
            for(i=0; i<b_frames; i++){
2355
                s->reordered_input_picture[i+1]= s->input_picture[i];
2356
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2357 1031fabd Michael Niedermayer
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2358 9dbcbd92 Michael Niedermayer
            }
2359
        }
2360
    }
2361 bbf18b21 Michael Niedermayer
no_output_pic:
2362 1e491e29 Michael Niedermayer
    if(s->reordered_input_picture[0]){
2363 0da71265 Michael Niedermayer
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2364 b536d0aa Michael Niedermayer
2365 6571e41d Michael Niedermayer
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2366 4e00e76b Michael Niedermayer
2367
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2368 bb628dae Diego Biurrun
            // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2369 115329f1 Diego Biurrun
2370 5f194811 Michael Niedermayer
            int i= ff_find_unused_picture(s, 0);
2371 4e00e76b Michael Niedermayer
            Picture *pic= &s->picture[i];
2372
2373
            /* mark us unused / free shared pic */
2374
            for(i=0; i<4; i++)
2375
                s->reordered_input_picture[0]->data[i]= NULL;
2376
            s->reordered_input_picture[0]->type= 0;
2377 115329f1 Diego Biurrun
2378 71c47d6e Michael Niedermayer
            pic->reference              = s->reordered_input_picture[0]->reference;
2379 115329f1 Diego Biurrun
2380 4e00e76b Michael Niedermayer
            alloc_picture(s, pic, 0);
2381
2382 f4f3223f Michael Niedermayer
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2383
2384 b536d0aa Michael Niedermayer
            s->current_picture_ptr= pic;
2385 4e00e76b Michael Niedermayer
        }else{
2386 b536d0aa Michael Niedermayer
            // input is not a shared pix -> reuse buffer for current_pix
2387
2388 115329f1 Diego Biurrun
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2389 4e00e76b Michael Niedermayer
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2390 115329f1 Diego Biurrun
2391 b536d0aa Michael Niedermayer
            s->current_picture_ptr= s->reordered_input_picture[0];
2392 4e00e76b Michael Niedermayer
            for(i=0; i<4; i++){
2393 6571e41d Michael Niedermayer
                s->new_picture.data[i]+=16;
2394 4e00e76b Michael Niedermayer
            }
2395 1e491e29 Michael Niedermayer
        }
2396 6571e41d Michael Niedermayer
        copy_picture(&s->current_picture, s->current_picture_ptr);
2397 115329f1 Diego Biurrun
2398 1e491e29 Michael Niedermayer
        s->picture_number= s->new_picture.display_picture_number;
2399
//printf("dpn:%d\n", s->picture_number);
2400
    }else{
2401
       memset(&s->new_picture, 0, sizeof(Picture));
2402 9dbcbd92 Michael Niedermayer
    }
2403
}
2404
2405 de6d9b64 Fabrice Bellard
int MPV_encode_picture(AVCodecContext *avctx,
2406
                       unsigned char *buf, int buf_size, void *data)
2407
{
2408
    MpegEncContext *s = avctx->priv_data;
2409 492cd3a9 Michael Niedermayer
    AVFrame *pic_arg = data;
2410 11dffbe1 Michael Niedermayer
    int i, stuffing_count;
2411 de6d9b64 Fabrice Bellard
2412 dd4f8a04 Michael Niedermayer
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2413 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2414 6e230912 Michael Niedermayer
        return -1;
2415
    }
2416 115329f1 Diego Biurrun
2417 9c3d33d6 Michael Niedermayer
    for(i=0; i<avctx->thread_count; i++){
2418 259630df Michael Niedermayer
        int start_y= s->thread_context[i]->start_mb_y;
2419
        int   end_y= s->thread_context[i]->  end_mb_y;
2420 9c3d33d6 Michael Niedermayer
        int h= s->mb_height;
2421 acb22f93 Martin Boehme
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2422
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2423 9c3d33d6 Michael Niedermayer
2424
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2425
    }
2426 de6d9b64 Fabrice Bellard
2427 1e491e29 Michael Niedermayer
    s->picture_in_gop_number++;
2428 de6d9b64 Fabrice Bellard
2429 9ebb8e11 Michael Niedermayer
    if(load_input_picture(s, pic_arg) < 0)
2430
        return -1;
2431 115329f1 Diego Biurrun
2432 1e491e29 Michael Niedermayer
    select_input_picture(s);
2433 115329f1 Diego Biurrun
2434 9dbcbd92 Michael Niedermayer
    /* output? */
2435 1e491e29 Michael Niedermayer
    if(s->new_picture.data[0]){
2436
        s->pict_type= s->new_picture.pict_type;
2437
//emms_c();
2438
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2439 93a21abd Michael Niedermayer
        MPV_frame_start(s, avctx);
2440 9dbcbd92 Michael Niedermayer
2441
        encode_picture(s, s->picture_number);
2442 115329f1 Diego Biurrun
2443 9cd3766f Juanjo
        avctx->real_pict_num  = s->picture_number;
2444 9dbcbd92 Michael Niedermayer
        avctx->header_bits = s->header_bits;
2445
        avctx->mv_bits     = s->mv_bits;
2446
        avctx->misc_bits   = s->misc_bits;
2447
        avctx->i_tex_bits  = s->i_tex_bits;
2448
        avctx->p_tex_bits  = s->p_tex_bits;
2449
        avctx->i_count     = s->i_count;
2450 66370d3f Michael Niedermayer
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2451 9dbcbd92 Michael Niedermayer
        avctx->skip_count  = s->skip_count;
2452
2453
        MPV_frame_end(s);
2454
2455
        if (s->out_format == FMT_MJPEG)
2456
            mjpeg_picture_trailer(s);
2457 115329f1 Diego Biurrun
2458 8b4c7dbc Michael Niedermayer
        if(s->flags&CODEC_FLAG_PASS1)
2459
            ff_write_pass1_stats(s);
2460 b536d0aa Michael Niedermayer
2461
        for(i=0; i<4; i++){
2462 60d76256 Michael Niedermayer
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2463 b536d0aa Michael Niedermayer
            avctx->error[i] += s->current_picture_ptr->error[i];
2464
        }
2465 11dffbe1 Michael Niedermayer
2466 a9c3ff5b Michael Niedermayer
        if(s->flags&CODEC_FLAG_PASS1)
2467
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2468 11dffbe1 Michael Niedermayer
        flush_put_bits(&s->pb);
2469 cfbd16df Michael Niedermayer
        s->frame_bits  = put_bits_count(&s->pb);
2470 d60a8f85 Michael Niedermayer
2471 2c8b796f Michael Niedermayer
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2472
        if(stuffing_count){
2473 0ecca7a4 Michael Niedermayer
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2474
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2475
                return -1;
2476
            }
2477
2478 2c8b796f Michael Niedermayer
            switch(s->codec_id){
2479
            case CODEC_ID_MPEG1VIDEO:
2480
            case CODEC_ID_MPEG2VIDEO:
2481
                while(stuffing_count--){
2482
                    put_bits(&s->pb, 8, 0);
2483
                }
2484
            break;
2485
            case CODEC_ID_MPEG4:
2486
                put_bits(&s->pb, 16, 0);
2487
                put_bits(&s->pb, 16, 0x1C3);
2488
                stuffing_count -= 4;
2489
                while(stuffing_count--){
2490
                    put_bits(&s->pb, 8, 0xFF);
2491
                }
2492
            break;
2493
            default:
2494
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2495
            }
2496
            flush_put_bits(&s->pb);
2497 cfbd16df Michael Niedermayer
            s->frame_bits  = put_bits_count(&s->pb);
2498 2c8b796f Michael Niedermayer
        }
2499 d60a8f85 Michael Niedermayer
2500 115329f1 Diego Biurrun
        /* update mpeg1/2 vbv_delay for CBR */
2501 b73afeac Michael Niedermayer
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2502
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2503 2c8b796f Michael Niedermayer
            int vbv_delay;
2504 d60a8f85 Michael Niedermayer
2505 2c8b796f Michael Niedermayer
            assert(s->repeat_first_field==0);
2506 115329f1 Diego Biurrun
2507 2c8b796f Michael Niedermayer
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2508
            assert(vbv_delay < 0xFFFF);
2509
2510
            s->vbv_delay_ptr[0] &= 0xF8;
2511
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2512
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2513
            s->vbv_delay_ptr[2] &= 0x07;
2514
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2515
        }
2516
        s->total_bits += s->frame_bits;
2517
        avctx->frame_bits  = s->frame_bits;
2518
    }else{
2519
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2520
        s->frame_bits=0;
2521 d60a8f85 Michael Niedermayer
    }
2522 2c8b796f Michael Niedermayer
    assert((s->frame_bits&7)==0);
2523 115329f1 Diego Biurrun
2524 11dffbe1 Michael Niedermayer
    return s->frame_bits/8;
2525 de6d9b64 Fabrice Bellard
}
2526
2527 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
2528
2529 44eb4951 Michael Niedermayer
static inline void gmc1_motion(MpegEncContext *s,
2530 0c1a9eda Zdenek Kabelac
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2531 5ba326b5 Michael Niedermayer
                               uint8_t **ref_picture)
2532 44eb4951 Michael Niedermayer
{
2533 0c1a9eda Zdenek Kabelac
    uint8_t *ptr;
2534 0fd90455 Michael Niedermayer
    int offset, src_x, src_y, linesize, uvlinesize;
2535 44eb4951 Michael Niedermayer
    int motion_x, motion_y;
2536 54993774 Michael Niedermayer
    int emu=0;
2537 44eb4951 Michael Niedermayer
2538
    motion_x= s->sprite_offset[0][0];
2539
    motion_y= s->sprite_offset[0][1];
2540
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2541
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2542
    motion_x<<=(3-s->sprite_warping_accuracy);
2543
    motion_y<<=(3-s->sprite_warping_accuracy);
2544
    src_x = clip(src_x, -16, s->width);
2545
    if (src_x == s->width)
2546
        motion_x =0;
2547
    src_y = clip(src_y, -16, s->height);
2548
    if (src_y == s->height)
2549
        motion_y =0;
2550 073b013d Michael Niedermayer
2551 44eb4951 Michael Niedermayer
    linesize = s->linesize;
2552 0fd90455 Michael Niedermayer
    uvlinesize = s->uvlinesize;
2553 115329f1 Diego Biurrun
2554 5ba326b5 Michael Niedermayer
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2555 44eb4951 Michael Niedermayer
2556 54993774 Michael Niedermayer
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2557 a573cc27 Michael Niedermayer
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2558
           || (unsigned)src_y >= s->v_edge_pos - 17){
2559 c009df3f Michael Niedermayer
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2560 54993774 Michael Niedermayer
            ptr= s->edge_emu_buffer;
2561
        }
2562
    }
2563 115329f1 Diego Biurrun
2564 073b013d Michael Niedermayer
    if((motion_x|motion_y)&7){
2565 eb4b3dd3 Zdenek Kabelac
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2566
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2567 073b013d Michael Niedermayer
    }else{
2568
        int dxy;
2569 115329f1 Diego Biurrun
2570 073b013d Michael Niedermayer
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2571
        if (s->no_rounding){
2572 bb270c08 Diego Biurrun
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2573 073b013d Michael Niedermayer
        }else{
2574 eb4b3dd3 Zdenek Kabelac
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2575
        }
2576 073b013d Michael Niedermayer
    }
2577 115329f1