mpegvideo.c 239 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
5
 *
6 7 8 9
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
10
 *
11
 * This library is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
15
 *
16 17 18
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Michael Niedermayer's avatar
Michael Niedermayer committed
19
 *
20
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
21
 */
22

Michael Niedermayer's avatar
Michael Niedermayer committed
23 24 25
/**
 * @file mpegvideo.c
 * The simplest mpeg encoder (well, it was the simplest!).
26 27
 */

Fabrice Bellard's avatar
Fabrice Bellard committed
28 29 30
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"
31
#include "faandct.h"
32
#include <limits.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
33

34 35 36 37
#ifdef USE_FASTMEMCPY
#include "fastmemcpy.h"
#endif

38 39
//#undef NDEBUG
//#include <assert.h>
40

41
#ifdef CONFIG_ENCODERS
42
static void encode_picture(MpegEncContext *s, int picture_number);
43
#endif //CONFIG_ENCODERS
44
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45
                                   DCTELEM *block, int n, int qscale);
46
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47
                                   DCTELEM *block, int n, int qscale);
48 49 50 51
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale);
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53
                                  DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55
                                  DCTELEM *block, int n, int qscale);
56
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57
#ifdef CONFIG_ENCODERS
58
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61
static int sse_mb(MpegEncContext *s);
Michael Niedermayer's avatar
Michael Niedermayer committed
62
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63
#endif //CONFIG_ENCODERS
64

Ivan Kalvachev's avatar
Ivan Kalvachev committed
65 66 67
#ifdef HAVE_XVMC
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
extern void XVMC_field_end(MpegEncContext *s);
68
extern void XVMC_decode_mb(MpegEncContext *s);
Ivan Kalvachev's avatar
Ivan Kalvachev committed
69 70
#endif

71
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
72

Fabrice Bellard's avatar
Fabrice Bellard committed
73 74 75 76 77 78

/* enable all paranoid tests for rounding, overflows, etc... */
//#define PARANOID

//#define DEBUG

79

Fabrice Bellard's avatar
Fabrice Bellard committed
80 81 82
/* for jpeg fast DCT */
#define CONST_BITS 14

83
static const uint16_t aanscales[64] = {
Fabrice Bellard's avatar
Fabrice Bellard committed
84 85 86 87 88 89 90
    /* precomputed values scaled up by 14 bits */
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
Michael Niedermayer's avatar
Michael Niedermayer committed
91 92
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
Fabrice Bellard's avatar
Fabrice Bellard committed
93 94
};

95
static const uint8_t h263_chroma_roundtab[16] = {
96
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
Fabrice Bellard's avatar
Fabrice Bellard committed
97 98 99
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
};

Michael Niedermayer's avatar
Michael Niedermayer committed
100 101 102 103 104
static const uint8_t ff_default_chroma_qscale_table[32]={
//  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
    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
};

105
#ifdef CONFIG_ENCODERS
106
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107
static uint8_t default_fcode_tab[MAX_MV*2+1];
108

Michael Niedermayer's avatar
Michael Niedermayer committed
109 110
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};

111
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
Fabrice Bellard's avatar
Fabrice Bellard committed
113
{
114
    int qscale;
115
    int shift=0;
116

117
    for(qscale=qmin; qscale<=qmax; qscale++){
118
        int i;
119
        if (dsp->fdct == ff_jpeg_fdct_islow
120
#ifdef FAAN_POSTSCALE
121
            || dsp->fdct == ff_faandct
122 123
#endif
            ) {
124
            for(i=0;i<64;i++) {
125
                const int j= dsp->idct_permutation[i];
126 127 128 129
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130 131

                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 133
                                (qscale * quant_matrix[j]));
            }
134
        } else if (dsp->fdct == fdct_ifast
135
#ifndef FAAN_POSTSCALE
136
                   || dsp->fdct == ff_faandct
137 138
#endif
                   ) {
139
            for(i=0;i<64;i++) {
140
                const int j= dsp->idct_permutation[i];
141 142 143 144
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145 146

                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 148 149 150
                                (aanscales[i] * qscale * quant_matrix[j]));
            }
        } else {
            for(i=0;i<64;i++) {
151
                const int j= dsp->idct_permutation[i];
152 153 154 155 156
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
                   So 16           <= qscale * quant_matrix[i]             <= 7905
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
                */
157
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160

161 162
                if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
                qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
163
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
164
        }
165

166
        for(i=intra; i<64; i++){
167 168 169 170 171 172 173 174
            int64_t max= 8191;
            if (dsp->fdct == fdct_ifast
#ifndef FAAN_POSTSCALE
                   || dsp->fdct == ff_faandct
#endif
                   ) {
                max= (8191LL*aanscales[i]) >> 14;
            }
175
            while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
176 177 178 179 180 181
                shift++;
            }
        }
    }
    if(shift){
        av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
Fabrice Bellard's avatar
Fabrice Bellard committed
182 183
    }
}
184 185 186 187

static inline void update_qscale(MpegEncContext *s){
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
188

189 190
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
}
191 192
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
193
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
194 195
    int i;
    int end;
196

197
    st->scantable= src_scantable;
198 199 200 201

    for(i=0; i<64; i++){
        int j;
        j = src_scantable[i];
Michael Niedermayer's avatar
Michael Niedermayer committed
202
        st->permutated[i] = permutation[j];
203 204 205
#ifdef ARCH_POWERPC
        st->inverse[j] = i;
#endif
206
    }
207

208 209 210 211 212 213 214 215 216
    end=-1;
    for(i=0; i<64; i++){
        int j;
        j = st->permutated[i];
        if(j>end) end=j;
        st->raster_end[i]= end;
    }
}

217
#ifdef CONFIG_ENCODERS
218 219 220 221 222 223 224 225 226 227 228
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
    int i;

    if(matrix){
        put_bits(pb, 1, 1);
        for(i=0;i<64;i++) {
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
        }
    }else
        put_bits(pb, 1, 0);
}
229
#endif //CONFIG_ENCODERS
230

231 232
/* init common dct for both encoder and decoder */
int DCT_common_init(MpegEncContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
233
{
234 235 236 237 238 239
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240

241
#ifdef CONFIG_ENCODERS
242
    s->dct_quantize= dct_quantize_c;
Michael Niedermayer's avatar
Michael Niedermayer committed
243
    s->denoise_dct= denoise_dct_c;
244
#endif //CONFIG_ENCODERS
245

246
#ifdef HAVE_MMX
247
    MPV_common_init_mmx(s);
248 249 250
#endif
#ifdef ARCH_ALPHA
    MPV_common_init_axp(s);
Nick Kurshev's avatar
Nick Kurshev committed
251
#endif
252 253 254
#ifdef HAVE_MLIB
    MPV_common_init_mlib(s);
#endif
255 256 257
#ifdef HAVE_MMI
    MPV_common_init_mmi(s);
#endif
258
#ifdef ARCH_ARMV4L
259
    MPV_common_init_armv4l(s);
260
#endif
261 262 263
#ifdef ARCH_POWERPC
    MPV_common_init_ppc(s);
#endif
264

265
#ifdef CONFIG_ENCODERS
266 267
    s->fast_dct_quantize= s->dct_quantize;

268 269 270 271
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
    }

272 273
#endif //CONFIG_ENCODERS

274
    /* load & permutate scantables
275
       note: only wmv uses different ones
276
    */
277 278 279 280 281 282 283
    if(s->alternate_scan){
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
    }else{
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
284 285
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286

287 288 289
    return 0;
}

290 291 292 293 294
static void copy_picture(Picture *dst, Picture *src){
    *dst = *src;
    dst->type= FF_BUFFER_TYPE_COPY;
}

295 296 297
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
    int i;

298 299 300 301 302 303 304 305
    dst->pict_type              = src->pict_type;
    dst->quality                = src->quality;
    dst->coded_picture_number   = src->coded_picture_number;
    dst->display_picture_number = src->display_picture_number;
//    dst->reference              = src->reference;
    dst->pts                    = src->pts;
    dst->interlaced_frame       = src->interlaced_frame;
    dst->top_field_first        = src->top_field_first;
306

307 308 309 310 311 312 313
    if(s->avctx->me_threshold){
        if(!src->motion_val[0])
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
        if(!src->mb_type)
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
        if(!src->ref_index[0])
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
316
            src->motion_subsample_log2, dst->motion_subsample_log2);
317 318

        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
319

320
        for(i=0; i<2; i++){
321 322 323
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);

324 325 326 327
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
            }
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329
            }
330 331
        }
    }
332 333
}

Michael Niedermayer's avatar
Michael Niedermayer committed
334
/**
Michael Niedermayer's avatar
Michael Niedermayer committed
335 336
 * allocates a Picture
 * The pixels are allocated/set by calling get_buffer() if shared=0
Michael Niedermayer's avatar
Michael Niedermayer committed
337
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
338
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339 340
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
    const int mb_array_size= s->mb_stride*s->mb_height;
341 342
    const int b8_array_size= s->b8_stride*s->mb_height*2;
    const int b4_array_size= s->b4_stride*s->mb_height*4;
343
    int i;
344

Michael Niedermayer's avatar
Michael Niedermayer committed
345 346 347 348 349 350
    if(shared){
        assert(pic->data[0]);
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
        pic->type= FF_BUFFER_TYPE_SHARED;
    }else{
        int r;
351

Michael Niedermayer's avatar
Michael Niedermayer committed
352
        assert(!pic->data[0]);
353

354
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355

Michael Niedermayer's avatar
Michael Niedermayer committed
356
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
Michael Niedermayer's avatar
Michael Niedermayer committed
358 359 360 361
            return -1;
        }

        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
363 364 365 366
            return -1;
        }

        if(pic->linesize[1] != pic->linesize[2]){
Diego Biurrun's avatar
Diego Biurrun committed
367
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
368 369 370 371 372
            return -1;
        }

        s->linesize  = pic->linesize[0];
        s->uvlinesize= pic->linesize[1];
Michael Niedermayer's avatar
Michael Niedermayer committed
373
    }
374

Michael Niedermayer's avatar
Michael Niedermayer committed
375
    if(pic->qscale_table==NULL){
376
        if (s->encoding) {
377 378 379
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
Michael Niedermayer's avatar
Michael Niedermayer committed
380
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
381

382
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
385
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386 387
        if(s->out_format == FMT_H264){
            for(i=0; i<2; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
388 389
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
                pic->motion_val[i]= pic->motion_val_base[i]+4;
390
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391
            }
392
            pic->motion_subsample_log2= 2;
393
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394
            for(i=0; i<2; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
395 396
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
                pic->motion_val[i]= pic->motion_val_base[i]+4;
397
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398
            }
399
            pic->motion_subsample_log2= 3;
400
        }
401 402 403
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
        }
404
        pic->qstride= s->mb_stride;
405
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
Michael Niedermayer's avatar
Michael Niedermayer committed
406
    }
407

408 409 410 411
    //it might be nicer if the application would keep track of these but it would require a API change
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
    s->prev_pict_types[0]= s->pict_type;
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412
        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

Michael Niedermayer's avatar
Michael Niedermayer committed
414 415 416 417 418
    return 0;
fail: //for the CHECKED_ALLOCZ macro
    return -1;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
419 420 421
/**
 * deallocates a picture
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
422 423
static void free_picture(MpegEncContext *s, Picture *pic){
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
424 425

    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
Michael Niedermayer's avatar
Michael Niedermayer committed
427 428
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
429 430 431 432 433
    av_freep(&pic->mb_var);
    av_freep(&pic->mc_mb_var);
    av_freep(&pic->mb_mean);
    av_freep(&pic->mbskip_table);
    av_freep(&pic->qscale_table);
434
    av_freep(&pic->mb_type_base);
435
    av_freep(&pic->dct_coeff);
436
    av_freep(&pic->pan_scan);
437 438
    pic->mb_type= NULL;
    for(i=0; i<2; i++){
439
        av_freep(&pic->motion_val_base[i]);
440 441
        av_freep(&pic->ref_index[i]);
    }
442

443
    if(pic->type == FF_BUFFER_TYPE_SHARED){
Michael Niedermayer's avatar
Michael Niedermayer committed
444 445 446 447
        for(i=0; i<4; i++){
            pic->base[i]=
            pic->data[i]= NULL;
        }
448
        pic->type= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
449 450 451
    }
}

452 453 454
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
    int i;

455
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
456 457 458 459
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;

     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
461 462 463 464 465 466 467 468 469
    s->rd_scratchpad=   s->me.scratchpad;
    s->b_scratchpad=    s->me.scratchpad;
    s->obmc_scratchpad= s->me.scratchpad + 16;
    if (s->encoding) {
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
        if(s->avctx->noise_reduction){
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
        }
470
    }
471
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
    s->block= s->blocks[0];

    for(i=0;i<12;i++){
        s->pblocks[i] = (short *)(&s->block[i]);
    }
    return 0;
fail:
    return -1; //free() through MPV_common_end()
}

static void free_duplicate_context(MpegEncContext *s){
    if(s==NULL) return;

    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
    av_freep(&s->me.scratchpad);
487 488
    s->rd_scratchpad=
    s->b_scratchpad=
489
    s->obmc_scratchpad= NULL;
490

491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
    av_freep(&s->dct_error_sum);
    av_freep(&s->me.map);
    av_freep(&s->me.score_map);
    av_freep(&s->blocks);
    s->block= NULL;
}

static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
#define COPY(a) bak->a= src->a
    COPY(allocated_edge_emu_buffer);
    COPY(edge_emu_buffer);
    COPY(me.scratchpad);
    COPY(rd_scratchpad);
    COPY(b_scratchpad);
    COPY(obmc_scratchpad);
    COPY(me.map);
    COPY(me.score_map);
    COPY(blocks);
    COPY(block);
    COPY(start_mb_y);
    COPY(end_mb_y);
    COPY(me.map_generation);
    COPY(pb);
    COPY(dct_error_sum);
515 516
    COPY(dct_count[0]);
    COPY(dct_count[1]);
517 518 519
#undef COPY
}

520
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521
    MpegEncContext bak;
522
    int i;
523 524 525 526 527
    //FIXME copy only needed parts
//START_TIMER
    backup_duplicate_context(&bak, dst);
    memcpy(dst, src, sizeof(MpegEncContext));
    backup_duplicate_context(dst, &bak);
528 529 530
    for(i=0;i<12;i++){
        dst->pblocks[i] = (short *)(&dst->block[i]);
    }
531 532 533 534 535 536 537 538 539 540 541 542 543 544
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
}

static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
#define COPY(a) dst->a= src->a
    COPY(pict_type);
    COPY(current_picture);
    COPY(f_code);
    COPY(b_code);
    COPY(qscale);
    COPY(lambda);
    COPY(lambda2);
    COPY(picture_in_gop_number);
    COPY(gop_picture_number);
Diego Biurrun's avatar
Diego Biurrun committed
545 546 547
    COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
    COPY(progressive_frame); //FIXME don't set in encode_header
    COPY(partitioned_frame); //FIXME don't set in encode_header
548 549 550
#undef COPY
}

Michael Niedermayer's avatar
Michael Niedermayer committed
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
/**
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
 * the changed fields will not depend upon the prior state of the MpegEncContext.
 */
static void MPV_common_defaults(MpegEncContext *s){
    s->y_dc_scale_table=
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
    s->progressive_frame= 1;
    s->progressive_sequence= 1;
    s->picture_structure= PICT_FRAME;

    s->coded_picture_number = 0;
    s->picture_number = 0;
    s->input_picture_number = 0;

    s->picture_in_gop_number = 0;
568 569 570

    s->f_code = 1;
    s->b_code = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
571 572 573 574 575 576 577 578 579 580 581 582 583 584
}

/**
 * sets the given MpegEncContext to defaults for decoding.
 * the changed fields will not depend upon the prior state of the MpegEncContext.
 */
void MPV_decode_defaults(MpegEncContext *s){
    MPV_common_defaults(s);
}

/**
 * sets the given MpegEncContext to defaults for encoding.
 * the changed fields will not depend upon the prior state of the MpegEncContext.
 */
585 586

#ifdef CONFIG_ENCODERS
587
static void MPV_encode_defaults(MpegEncContext *s){
Michael Niedermayer's avatar
Michael Niedermayer committed
588
    static int done=0;
589

Michael Niedermayer's avatar
Michael Niedermayer committed
590
    MPV_common_defaults(s);
591

Michael Niedermayer's avatar
Michael Niedermayer committed
592 593 594 595 596 597 598 599 600 601 602 603 604 605
    if(!done){
        int i;
        done=1;

        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));

        for(i=-16; i<16; i++){
            default_fcode_tab[i + MAX_MV]= 1;
        }
    }
    s->me.mv_penalty= default_mv_penalty;
    s->fcode_tab= default_fcode_tab;
}
606
#endif //CONFIG_ENCODERS
Michael Niedermayer's avatar
Michael Niedermayer committed
607

608
/**
Michael Niedermayer's avatar
Michael Niedermayer committed
609 610 611
 * init common structure for both encoder and decoder.
 * this assumes that some variables like width/height are already set
 */
612 613
int MPV_common_init(MpegEncContext *s)
{
614
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615

Michael Niedermayer's avatar
Michael Niedermayer committed
616
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
Michael Niedermayer's avatar
Michael Niedermayer committed
617 618 619 620
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
        return -1;
    }

621 622 623
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
        return -1;

624
    dsputil_init(&s->dsp, s->avctx);
625
    DCT_common_init(s);
626

627
    s->flags= s->avctx->flags;
628
    s->flags2= s->avctx->flags2;
629

Michael Niedermayer's avatar
Michael Niedermayer committed
630
    s->mb_width  = (s->width  + 15) / 16;
Fabrice Bellard's avatar
Fabrice Bellard committed
631
    s->mb_height = (s->height + 15) / 16;
632
    s->mb_stride = s->mb_width + 1;
633 634
    s->b8_stride = s->mb_width*2 + 1;
    s->b4_stride = s->mb_width*4 + 1;
635
    mb_array_size= s->mb_height * s->mb_stride;
636
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637

638 639 640 641
    /* set chroma shifts */
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
                                                    &(s->chroma_y_shift) );

642 643 644
    /* set default edge pos, will be overriden in decode_header if needed */
    s->h_edge_pos= s->mb_width*16;
    s->v_edge_pos= s->mb_height*16;
645 646

    s->mb_num = s->mb_width * s->mb_height;
647

648 649 650
    s->block_wrap[0]=
    s->block_wrap[1]=
    s->block_wrap[2]=
651
    s->block_wrap[3]= s->b8_stride;
652
    s->block_wrap[4]=
653
    s->block_wrap[5]= s->mb_stride;
654

655 656
    y_size = s->b8_stride * (2 * s->mb_height + 1);
    c_size = s->mb_stride * (s->mb_height + 1);
657
    yc_size = y_size + 2 * c_size;
658

659
    /* convert fourcc to upper case */
660
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
661
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664

665
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)
666
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668 669
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);

670
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
Michael Niedermayer's avatar
Michael Niedermayer committed
671

672 673 674 675 676 677 678
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
    for(y=0; y<s->mb_height; y++){
        for(x=0; x<s->mb_width; x++){
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
        }
    }
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679

680
    if (s->encoding) {
681
        /* Allocate MV tables */
682 683 684 685 686 687 688 689 690 691 692 693
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
694

695 696 697
        if(s->msmpeg4_version){
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
        }
698
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699 700

        /* Allocate MB type table */
701
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
702

703
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704

705 706
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707 708
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709 710
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711

712 713 714
        if(s->avctx->noise_reduction){
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
        }
715
    }
716 717
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))

718
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719

720
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721
        /* interlaced direct mode decoding tables */
722 723 724 725 726 727 728 729 730 731 732 733 734
            for(i=0; i<2; i++){
                int j, k;
                for(j=0; j<2; j++){
                    for(k=0; k<2; k++){
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
                    }
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
                }
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
735
    }
736
    if (s->out_format == FMT_H263) {
Fabrice Bellard's avatar
Fabrice Bellard committed
737
        /* ac values */
738 739 740
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
741
        s->ac_val[2] = s->ac_val[1] + c_size;
742

Fabrice Bellard's avatar
Fabrice Bellard committed
743
        /* cbp values */
744 745
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
746

747
        /* cbp, ac_pred, pred_dir */
748 749
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750
    }
751

752 753 754
    if (s->h263_pred || s->h263_plus || !s->encoding) {
        /* dc values */
        //MN: we need these for error resilience of intra-frames
755 756 757
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758 759
        s->dc_val[2] = s->dc_val[1] + c_size;
        for(i=0;i<yc_size;i++)
760
            s->dc_val_base[i] = 1024;
761 762
    }

763
    /* which mb is a intra block */
764 765
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
    memset(s->mbintra_table, 1, mb_array_size);
766

767
    /* init macroblock skip table */
768
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769
    //Note the +1 is for a quicker mpeg4 slice_end detection
770
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771

772
    s->parse_context.state= -1;
773 774 775 776 777
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
    }
778

Fabrice Bellard's avatar
Fabrice Bellard committed
779
    s->context_initialized = 1;
780 781 782 783 784 785 786 787 788 789 790 791 792 793

    s->thread_context[0]= s;
    for(i=1; i<s->avctx->thread_count; i++){
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
    }

    for(i=0; i<s->avctx->thread_count; i++){
        if(init_duplicate_context(s->thread_context[i], s) < 0)
           goto fail;
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
794 795
    return 0;
 fail:
796
    MPV_common_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
797 798 799 800 801 802
    return -1;
}

/* init common structure for both encoder and decoder */
void MPV_common_end(MpegEncContext *s)
{
803
    int i, j, k;
Fabrice Bellard's avatar
Fabrice Bellard committed
804

805 806 807 808 809 810 811
    for(i=0; i<s->avctx->thread_count; i++){
        free_duplicate_context(s->thread_context[i]);
    }
    for(i=1; i<s->avctx->thread_count; i++){
        av_freep(&s->thread_context[i]);
    }

812 813 814
    av_freep(&s->parse_context.buffer);
    s->parse_context.buffer_size=0;

815
    av_freep(&s->mb_type);
816 817 818 819 820 821 822 823 824 825 826 827
    av_freep(&s->p_mv_table_base);
    av_freep(&s->b_forw_mv_table_base);
    av_freep(&s->b_back_mv_table_base);
    av_freep(&s->b_bidir_forw_mv_table_base);
    av_freep(&s->b_bidir_back_mv_table_base);
    av_freep(&s->b_direct_mv_table_base);
    s->p_mv_table= NULL;
    s->b_forw_mv_table= NULL;
    s->b_back_mv_table= NULL;
    s->b_bidir_forw_mv_table= NULL;
    s->b_bidir_back_mv_table= NULL;
    s->b_direct_mv_table= NULL;
828 829 830 831 832 833 834 835 836 837 838 839
    for(i=0; i<2; i++){
        for(j=0; j<2; j++){
            for(k=0; k<2; k++){
                av_freep(&s->b_field_mv_table_base[i][j][k]);
                s->b_field_mv_table[i][j][k]=NULL;
            }
            av_freep(&s->b_field_select_table[i][j]);
            av_freep(&s->p_field_mv_table_base[i][j]);
            s->p_field_mv_table[i][j]=NULL;
        }
        av_freep(&s->p_field_select_table[i]);
    }
840

841 842 843
    av_freep(&s->dc_val_base);
    av_freep(&s->ac_val_base);
    av_freep(&s->coded_block_base);
844
    av_freep(&s->mbintra_table);
845 846
    av_freep(&s->cbp_table);
    av_freep(&s->pred_dir_table);
847

848
    av_freep(&s->mbskip_table);
849
    av_freep(&s->prev_pict_types);
850
    av_freep(&s->bitstream_buffer);
851 852
    s->allocated_bitstream_buffer_size=0;

853
    av_freep(&s->avctx->stats_out);
854
    av_freep(&s->ac_stats);
855
    av_freep(&s->error_status_table);
856
    av_freep(&s->mb_index2xy);
857
    av_freep(&s->lambda_table);
858 859
    av_freep(&s->q_intra_matrix);
    av_freep(&s->q_inter_matrix);
860 861
    av_freep(&s->q_intra_matrix16);
    av_freep(&s->q_inter_matrix16);
862 863
    av_freep(&s->input_picture);
    av_freep(&s->reordered_input_picture);
864
    av_freep(&s->dct_offset);
Michael Niedermayer's avatar
Michael Niedermayer committed
865

Michael Niedermayer's avatar
Michael Niedermayer committed
866 867 868 869
    if(s->picture){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
            free_picture(s, &s->picture[i]);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
870
    }
871
    av_freep(&s->picture);
Fabrice Bellard's avatar
Fabrice Bellard committed
872
    s->context_initialized = 0;
873 874 875
    s->last_picture_ptr=
    s->next_picture_ptr=
    s->current_picture_ptr= NULL;
876
    s->linesize= s->uvlinesize= 0;
877

878
    for(i=0; i<3; i++)
879
        av_freep(&s->visualization_buffer[i]);
880 881

    avcodec_default_free_buffers(s->avctx);
Fabrice Bellard's avatar
Fabrice Bellard committed
882 883
}

884 885
#ifdef CONFIG_ENCODERS

Fabrice Bellard's avatar
Fabrice Bellard committed
886 887 888 889
/* init video encoder */
int MPV_encode_init(AVCodecContext *avctx)
{
    MpegEncContext *s = avctx->priv_data;
890
    int i;
891
    int chroma_h_shift, chroma_v_shift;
892

Michael Niedermayer's avatar
Michael Niedermayer committed
893
    MPV_encode_defaults(s);
894

895 896 897 898 899 900
    if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
        av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
        return -1;
    }

    if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902 903 904 905
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
            return -1;
        }
    }else{
906
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
907 908 909 910
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
            return -1;
        }
    }
911

Fabrice Bellard's avatar
Fabrice Bellard committed
912 913 914
    s->bit_rate = avctx->bit_rate;
    s->width = avctx->width;
    s->height = avctx->height;
915
    if(avctx->gop_size > 600){
916
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917 918
        avctx->gop_size=600;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
919
    s->gop_size = avctx->gop_size;
920
    s->avctx = avctx;
921
    s->flags= avctx->flags;
922
    s->flags2= avctx->flags2;
923
    s->max_b_frames= avctx->max_b_frames;
924
    s->codec_id= avctx->codec->id;
925 926 927 928
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
    s->strict_std_compliance= avctx->strict_std_compliance;
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
Michael Niedermayer's avatar
Michael Niedermayer committed
929
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930
    s->mpeg_quant= avctx->mpeg_quant;
931
    s->rtp_mode= !!avctx->rtp_payload_size;
932
    s->intra_dc_precision= avctx->intra_dc_precision;
933
    s->user_specified_pts = AV_NOPTS_VALUE;
934

Fabrice Bellard's avatar
Fabrice Bellard committed
935 936 937 938 939 940
    if (s->gop_size <= 1) {
        s->intra_only = 1;
        s->gop_size = 12;
    } else {
        s->intra_only = 0;
    }
941

Michael Niedermayer's avatar
Michael Niedermayer committed
942
    s->me_method = avctx->me_method;
943

944
    /* Fixed QSCALE */
945
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946

947
    s->adaptive_quant= (   s->avctx->lumi_masking
948
                        || s->avctx->dark_masking
949
                        || s->avctx->temporal_cplx_masking
950
                        || s->avctx->spatial_cplx_masking
951
                        || s->avctx->p_masking
952
                        || s->avctx->border_masking
953
                        || (s->flags&CODEC_FLAG_QP_RD))
954
                       && !s->fixed_qscale;
955

956 957 958
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959

960 961 962
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
        return -1;
963
    }
964 965

    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
967
    }
968

Michael Niedermayer's avatar
Michael Niedermayer committed
969 970 971 972
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
        return -1;
    }
973

Michael Niedermayer's avatar
Michael Niedermayer committed
974 975 976 977
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
        return -1;
    }
978 979

    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980 981
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982

983 984
        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");
    }
985 986

    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989 990
        return -1;
    }
991

992
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
994 995
        return -1;
    }
996

Michael Niedermayer's avatar
Michael Niedermayer committed
997 998 999 1000
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
        return -1;
    }
1001

1002
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004 1005 1006 1007
        return -1;
    }

    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009 1010
        return -1;
    }
1011

Michael Niedermayer's avatar
Michael Niedermayer committed
1012
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014 1015
        return -1;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
1016

1017
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
Michael Niedermayer's avatar
Michael Niedermayer committed
1018 1019 1020 1021
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
        return -1;
    }
1022

1023
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1025 1026
        return -1;
    }
1027

1028
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030 1031 1032
        return -1;
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
1033 1034 1035 1036
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
        return -1;
    }
1037

1038 1039 1040 1041
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
        return -1;
    }
1042 1043 1044

    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045 1046 1047 1048
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
        return -1;
    }
1049

1050 1051
    if(s->avctx->thread_count > 1)
        s->rtp_mode= 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1052

1053
    if(!avctx->time_base.den || !avctx->time_base.num){
Michael Niedermayer's avatar
Michael Niedermayer committed
1054 1055 1056
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
        return -1;
    }
1057

1058 1059 1060 1061 1062 1063 1064 1065 1066
    i= (INT_MAX/2+128)>>8;
    if(avctx->me_threshold >= i){
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
        return -1;
    }
    if(avctx->mb_threshold >= i){
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
        return -1;
    }
1067

1068 1069 1070 1071 1072
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
        av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass");
        return -1;
    }

1073
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
Michael Niedermayer's avatar
Michael Niedermayer committed
1074 1075
    if(i > 1){
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1076 1077
        avctx->time_base.den /= i;
        avctx->time_base.num /= i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1078 1079
//        return -1;
    }
1080

1081 1082 1083
    if(s->codec_id==CODEC_ID_MJPEG){
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
        s->inter_quant_bias= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1084
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1085 1086 1087 1088 1089 1090
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
        s->inter_quant_bias= 0;
    }else{
        s->intra_quant_bias=0;
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
    }
1091

1092 1093 1094 1095
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
        s->intra_quant_bias= avctx->intra_quant_bias;
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
        s->inter_quant_bias= avctx->inter_quant_bias;
1096

1097 1098
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);

1099
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1100
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1101
        return -1;
1102 1103
    }
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1104

Fabrice Bellard's avatar
Fabrice Bellard committed
1105 1106 1107
    switch(avctx->codec->id) {
    case CODEC_ID_MPEG1VIDEO:
        s->out_format = FMT_MPEG1;
1108 1109
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1110
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
1111 1112 1113 1114
    case CODEC_ID_MPEG2VIDEO:
        s->out_format = FMT_MPEG1;
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1115
        s->rtp_mode= 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1116
        break;
1117
    case CODEC_ID_LJPEG:
Michael Niedermayer's avatar
Michael Niedermayer committed
1118
    case CODEC_ID_JPEGLS:
Fabrice Bellard's avatar
Fabrice Bellard committed
1119 1120 1121
    case CODEC_ID_MJPEG:
        s->out_format = FMT_MJPEG;
        s->intra_only = 1; /* force intra only for jpeg */
Michael Niedermayer's avatar
Michael Niedermayer committed
1122
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1123
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1124 1125
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
        s->mjpeg_vsample[1] = 1;
1126
        s->mjpeg_vsample[2] = 1;
1127
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1128 1129
        s->mjpeg_hsample[1] = 1;
        s->mjpeg_hsample[2] = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1130 1131
        if (mjpeg_init(s) < 0)
            return -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1132
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1133
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1134
        break;
1135 1136 1137 1138 1139
    case CODEC_ID_H261:
        s->out_format = FMT_H261;
        avctx->delay=0;
        s->low_delay=1;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1140
    case CODEC_ID_H263:
1141
        if (h263_get_picture_format(s->width, s->height) == 7) {
1142
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
1143
            return -1;
1144
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1145
        s->out_format = FMT_H263;
1146
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1147
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1148
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1149 1150 1151 1152
        break;
    case CODEC_ID_H263P:
        s->out_format = FMT_H263;
        s->h263_plus = 1;
1153
        /* Fx */
Michael Niedermayer's avatar
Michael Niedermayer committed
1154
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1155 1156 1157 1158 1159 1160
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
        s->modified_quant= s->h263_aic;
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1161
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1162

1163
        /* /Fx */
1164
        /* These are just to be sure */
Michael Niedermayer's avatar
Michael Niedermayer committed
1165
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1166
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1167
        break;
1168 1169 1170 1171 1172 1173 1174 1175
    case CODEC_ID_FLV1:
        s->out_format = FMT_H263;
        s->h263_flv = 2; /* format = 1; 11-bit codes */
        s->unrestricted_mv = 1;
        s->rtp_mode=0; /* don't allow GOB */
        avctx->delay=0;
        s->low_delay=1;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1176 1177
    case CODEC_ID_RV10:
        s->out_format = FMT_H263;
Michael Niedermayer's avatar
Michael Niedermayer committed
1178
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1179
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1180
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
    case CODEC_ID_RV20:
        s->out_format = FMT_H263;
        avctx->delay=0;
        s->low_delay=1;
        s->modified_quant=1;
        s->h263_aic=1;
        s->h263_plus=1;
        s->loop_filter=1;
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
        break;
1191
    case CODEC_ID_MPEG4:
Fabrice Bellard's avatar
Fabrice Bellard committed
1192 1193 1194
        s->out_format = FMT_H263;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1195
        s->low_delay= s->max_b_frames ? 0 : 1;
1196
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1197
        break;
1198
    case CODEC_ID_MSMPEG4V1:
Fabrice Bellard's avatar
Fabrice Bellard committed
1199 1200 1201 1202
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
1203
        s->msmpeg4_version= 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1204
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1205
        s->low_delay=1;
1206 1207 1208 1209 1210 1211 1212
        break;
    case CODEC_ID_MSMPEG4V2:
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
        s->msmpeg4_version= 2;
Michael Niedermayer's avatar
Michael Niedermayer committed
1213
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1214
        s->low_delay=1;
1215 1216 1217 1218 1219 1220 1221
        break;
    case CODEC_ID_MSMPEG4V3:
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
        s->msmpeg4_version= 3;
1222
        s->flipflop_rounding=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1223
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1224
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1225
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
1226 1227 1228 1229 1230 1231
    case CODEC_ID_WMV1:
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
        s->msmpeg4_version= 4;
1232
        s->flipflop_rounding=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1233
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1234
        s->low_delay=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1235 1236 1237 1238 1239 1240 1241
        break;
    case CODEC_ID_WMV2:
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
        s->msmpeg4_version= 5;
1242
        s->flipflop_rounding=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1243
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1244
        s->low_delay=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1245
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1246 1247 1248
    default:
        return -1;
    }
1249

1250
    avctx->has_b_frames= !s->low_delay;
1251

1252 1253
    s->encoding = 1;

Fabrice Bellard's avatar
Fabrice Bellard committed
1254 1255 1256
    /* init */
    if (MPV_common_init(s) < 0)
        return -1;
1257 1258 1259

    if(s->modified_quant)
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1260
    s->progressive_frame=
1261
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1262
    s->quant_precision=5;
1263

1264
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1265
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1266

1267
#ifdef CONFIG_H261_ENCODER
1268 1269
    if (s->out_format == FMT_H261)
        ff_h261_encode_init(s);
1270
#endif
1271 1272 1273 1274
    if (s->out_format == FMT_H263)
        h263_encode_init(s);
    if(s->msmpeg4_version)
        ff_msmpeg4_encode_init(s);
1275 1276
    if (s->out_format == FMT_MPEG1)
        ff_mpeg1_encode_init(s);
1277

Michael Niedermayer's avatar
Michael Niedermayer committed
1278
    /* init q matrix */
1279
    for(i=0;i<64;i++) {
1280
        int j= s->dsp.idct_permutation[i];
1281
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1282 1283
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1284
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1285 1286
            s->intra_matrix[j] =
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1287
        }else
Michael Niedermayer's avatar
Michael Niedermayer committed
1288
        { /* mpeg1/2 */
1289 1290
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1291
        }
1292 1293 1294 1295
        if(s->avctx->intra_matrix)
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
        if(s->avctx->inter_matrix)
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1296 1297 1298
    }

    /* precompute matrix */
1299
    /* for mjpeg, we do include qscale in the matrix */
1300
    if (s->out_format != FMT_MJPEG) {
1301
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1302
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1303
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1304
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1305 1306
    }

1307 1308
    if(ff_rate_control_init(s) < 0)
        return -1;
1309

Fabrice Bellard's avatar
Fabrice Bellard committed
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
    return 0;
}

int MPV_encode_end(AVCodecContext *avctx)
{
    MpegEncContext *s = avctx->priv_data;

#ifdef STATS
    print_stats();
#endif
1320 1321 1322

    ff_rate_control_uninit(s);

Fabrice Bellard's avatar
Fabrice Bellard committed
1323 1324 1325
    MPV_common_end(s);
    if (s->out_format == FMT_MJPEG)
        mjpeg_close(s);
1326

1327
    av_freep(&avctx->extradata);
1328

Fabrice Bellard's avatar
Fabrice Bellard committed
1329 1330 1331
    return 0;
}

1332 1333
#endif //CONFIG_ENCODERS

1334
void init_rl(RLTable *rl, int use_static)
1335
{
1336 1337
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
    uint8_t index_run[MAX_RUN+1];
1338 1339
    int last, run, level, start, end, i;

1340 1341 1342 1343
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
    if(use_static && rl->max_level[0])
        return;

1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
    /* compute max_level[], max_run[] and index_run[] */
    for(last=0;last<2;last++) {
        if (last == 0) {
            start = 0;
            end = rl->last;
        } else {
            start = rl->last;
            end = rl->n;
        }

        memset(max_level, 0, MAX_RUN + 1);
        memset(max_run, 0, MAX_LEVEL + 1);
        memset(index_run, rl->n, MAX_RUN + 1);
        for(i=start;i<end;i++) {
            run = rl->table_run[i];
            level = rl->table_level[i];
            if (index_run[run] == rl->n)
                index_run[run] = i;
            if (level > max_level[run])
                max_level[run] = level;
            if (run > max_run[level])
                max_run[level] = run;
        }
1367 1368 1369 1370
        if(use_static)
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
        else
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1371
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1372 1373 1374 1375
        if(use_static)
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
        else
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1376
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1377 1378 1379 1380
        if(use_static)
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
        else
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1381 1382 1383 1384
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1385
/* draw the edges of width 'w' of an image of size width, height */
1386
//FIXME check that this is ok for mpeg4 interlaced
1387
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
Fabrice Bellard's avatar
Fabrice Bellard committed
1388
{
1389
    uint8_t *ptr, *last_line;
Fabrice Bellard's avatar
Fabrice Bellard committed
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
    int i;

    last_line = buf + (height - 1) * wrap;
    for(i=0;i<w;i++) {
        /* top and bottom */
        memcpy(buf - (i + 1) * wrap, buf, width);
        memcpy(last_line + (i + 1) * wrap, last_line, width);
    }
    /* left and right */
    ptr = buf;
    for(i=0;i<height;i++) {
        memset(ptr - w, ptr[0], w);
        memset(ptr + width, ptr[width-1], w);
        ptr += wrap;
    }
    /* corners */
    for(i=0;i<w;i++) {
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
    }
}

1414
int ff_find_unused_picture(MpegEncContext *s, int shared){
Michael Niedermayer's avatar
Michael Niedermayer committed
1415
    int i;
1416

Michael Niedermayer's avatar
Michael Niedermayer committed
1417 1418
    if(shared){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1419
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1420 1421 1422
        }
    }else{
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1423
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
Michael Niedermayer's avatar
Michael Niedermayer committed
1424 1425
        }
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1426
            if(s->picture[i].data[0]==NULL) return i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1427 1428 1429
        }
    }

1430 1431
    assert(0);
    return -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1432 1433
}

1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
static void update_noise_reduction(MpegEncContext *s){
    int intra, i;

    for(intra=0; intra<2; intra++){
        if(s->dct_count[intra] > (1<<16)){
            for(i=0; i<64; i++){
                s->dct_error_sum[intra][i] >>=1;
            }
            s->dct_count[intra] >>= 1;
        }
1444

1445 1446 1447 1448 1449 1450
        for(i=0; i<64; i++){
            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);
        }
    }
}

1451 1452 1453
/**
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
 */
1454
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
1455
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1456
    int i;
1457
    AVFrame *pic;
1458
    s->mb_skipped = 0;
1459

1460
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1461

Michael Niedermayer's avatar
Michael Niedermayer committed
1462
    /* mark&release old frames */
1463
    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
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
1465 1466 1467 1468 1469

        /* release forgotten pictures */
        /* if(mpeg124/h263) */
        if(!s->encoding){
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1470
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1471
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1472
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
Michael Niedermayer's avatar
Michael Niedermayer committed
1473 1474
                }
            }
1475
        }
1476
    }
1477 1478
alloc:
    if(!s->encoding){
Diego Biurrun's avatar
Diego Biurrun committed
1479
        /* release non reference frames */
1480 1481 1482 1483 1484 1485
        for(i=0; i<MAX_PICTURE_COUNT; i++){
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
            }
        }

1486 1487 1488 1489 1490 1491 1492
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
        else{
            i= ff_find_unused_picture(s, 0);
            pic= (AVFrame*)&s->picture[i];
        }

1493 1494
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
                        && !s->dropable ? 3 : 0;
1495

1496
        pic->coded_picture_number= s->coded_picture_number++;
1497

1498 1499
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
            return -1;
1500

1501
        s->current_picture_ptr= (Picture*)pic;
1502
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1503
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
Michael Niedermayer's avatar
Michael Niedermayer committed
1504
    }
1505

1506
    s->current_picture_ptr->pict_type= s->pict_type;
1507
//    if(s->flags && CODEC_FLAG_QSCALE)
1508
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1509
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1510

1511
    copy_picture(&s->current_picture, s->current_picture_ptr);
1512

1513
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
Michael Niedermayer's avatar
Michael Niedermayer committed
1514
    if (s->pict_type != B_TYPE) {
1515
        s->last_picture_ptr= s->next_picture_ptr;
1516 1517
        if(!s->dropable)
            s->next_picture_ptr= s->current_picture_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
1518
    }
1519
/*    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 1521
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1522 1523
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
        s->pict_type, s->dropable);*/
1524

1525 1526
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1527

1528
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1529
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
Diego Biurrun's avatar
Diego Biurrun committed
1530
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1531 1532 1533 1534 1535
        goto alloc;
    }

    assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));

1536 1537 1538 1539 1540
    if(s->picture_structure!=PICT_FRAME){
        int i;
        for(i=0; i<4; i++){
            if(s->picture_structure == PICT_BOTTOM_FIELD){
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1541
            }
1542 1543 1544 1545 1546
            s->current_picture.linesize[i] *= 2;
            s->last_picture.linesize[i] *=2;
            s->next_picture.linesize[i] *=2;
        }
    }
1547
  }
1548

1549 1550 1551
    s->hurry_up= s->avctx->hurry_up;
    s->error_resilience= avctx->error_resilience;

Diego Biurrun's avatar
Diego Biurrun committed
1552 1553
    /* set dequantizer, we can't do it during init as it might change for mpeg4
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1554 1555 1556
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1557
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1558 1559 1560 1561 1562 1563
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
    }else{
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
    }
1564

1565 1566 1567 1568 1569
    if(s->dct_error_sum){
        assert(s->avctx->noise_reduction && s->encoding);

        update_noise_reduction(s);
    }
1570

Ivan Kalvachev's avatar
Ivan Kalvachev committed
1571 1572 1573 1574
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration)
        return XVMC_field_start(s, avctx);
#endif
1575
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1576
}
1577

Fabrice Bellard's avatar
Fabrice Bellard committed
1578 1579 1580
/* generic function for encode/decode called after a frame has been coded/decoded */
void MPV_frame_end(MpegEncContext *s)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1581
    int i;
Fabrice Bellard's avatar
Fabrice Bellard committed
1582
    /* draw edge for correct motion prediction if outside */
Ivan Kalvachev's avatar
Ivan Kalvachev committed
1583 1584 1585 1586 1587 1588
#ifdef HAVE_XVMC
//just to make sure that all data is rendered.
    if(s->avctx->xvmc_acceleration){
        XVMC_field_end(s);
    }else
#endif
1589
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1590 1591 1592
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1593
    }
1594
    emms_c();
1595

1596
    s->last_pict_type    = s->pict_type;
1597
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1598 1599 1600
    if(s->pict_type!=B_TYPE){
        s->last_non_b_pict_type= s->pict_type;
    }
1601 1602
#if 0
        /* copy back current_picture variables */
Michael Niedermayer's avatar
Michael Niedermayer committed
1603 1604 1605 1606
    for(i=0; i<MAX_PICTURE_COUNT; i++){
        if(s->picture[i].data[0] == s->current_picture.data[0]){
            s->picture[i]= s->current_picture;
            break;
1607
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1608 1609
    }
    assert(i<MAX_PICTURE_COUNT);
1610
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
1611

1612
    if(s->encoding){
Diego Biurrun's avatar
Diego Biurrun committed
1613
        /* release non-reference frames */
1614 1615 1616 1617 1618
        for(i=0; i<MAX_PICTURE_COUNT; i++){
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
            }
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1619
    }
1620 1621 1622 1623 1624 1625
    // clear copies, to avoid confusion
#if 0
    memset(&s->last_picture, 0, sizeof(Picture));
    memset(&s->next_picture, 0, sizeof(Picture));
    memset(&s->current_picture, 0, sizeof(Picture));
#endif
1626
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
1627 1628
}

1629 1630 1631 1632 1633 1634 1635 1636
/**
 * draws an line from (ex, ey) -> (sx, sy).
 * @param w width of the image
 * @param h height of the image
 * @param stride stride/linesize of the image
 * @param color color of the arrow
 */
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1637
    int t, x, y, fr, f;
1638

1639 1640 1641 1642
    sx= clip(sx, 0, w-1);
    sy= clip(sy, 0, h-1);
    ex= clip(ex, 0, w-1);
    ey= clip(ey, 0, h-1);
1643

1644
    buf[sy*stride + sx]+= color;
1645

1646 1647 1648 1649 1650 1651 1652 1653 1654
    if(ABS(ex - sx) > ABS(ey - sy)){
        if(sx > ex){
            t=sx; sx=ex; ex=t;
            t=sy; sy=ey; ey=t;
        }
        buf+= sx + sy*stride;
        ex-= sx;
        f= ((ey-sy)<<16)/ex;
        for(x= 0; x <= ex; x++){
1655 1656 1657 1658
            y = (x*f)>>16;
            fr= (x*f)&0xFFFF;
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669
        }
    }else{
        if(sy > ey){
            t=sx; sx=ex; ex=t;
            t=sy; sy=ey; ey=t;
        }
        buf+= sx + sy*stride;
        ey-= sy;
        if(ey) f= ((ex-sx)<<16)/ey;
        else   f= 0;
        for(y= 0; y <= ey; y++){
1670 1671 1672 1673
            x = (y*f)>>16;
            fr= (y*f)&0xFFFF;
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
        }
    }
}

/**
 * draws an arrow from (ex, ey) -> (sx, sy).
 * @param w width of the image
 * @param h height of the image
 * @param stride stride/linesize of the image
 * @param color color of the arrow
 */
1685
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1686 1687 1688 1689 1690 1691
    int dx,dy;

    sx= clip(sx, -100, w+100);
    sy= clip(sy, -100, h+100);
    ex= clip(ex, -100, w+100);
    ey= clip(ey, -100, h+100);
1692

1693 1694
    dx= ex - sx;
    dy= ey - sy;
1695

1696 1697 1698 1699
    if(dx*dx + dy*dy > 3*3){
        int rx=  dx + dy;
        int ry= -dx + dy;
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1700

1701 1702 1703
        //FIXME subpixel accuracy
        rx= ROUNDED_DIV(rx*3<<4, length);
        ry= ROUNDED_DIV(ry*3<<4, length);
1704

1705 1706 1707 1708 1709 1710
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
    }
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
}

1711 1712 1713
/**
 * prints debuging info for the given picture.
 */
1714
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1715 1716 1717 1718 1719

    if(!pict || !pict->mb_type) return;

    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
        int x,y;
1720

1721 1722 1723 1724 1725 1726 1727
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
        switch (pict->pict_type) {
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1728
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1729
        }
1730 1731 1732 1733 1734
        for(y=0; y<s->mb_height; y++){
            for(x=0; x<s->mb_width; x++){
                if(s->avctx->debug&FF_DEBUG_SKIP){
                    int count= s->mbskip_table[x + y*s->mb_stride];
                    if(count>9) count=9;
1735
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1736 1737
                }
                if(s->avctx->debug&FF_DEBUG_QP){
1738
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1739 1740 1741 1742 1743
                }
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
                    //Type & MV direction
                    if(IS_PCM(mb_type))
1744
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1745
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1746
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1747
                    else if(IS_INTRA4x4(mb_type))
1748
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1749
                    else if(IS_INTRA16x16(mb_type))
1750
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1751
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1752
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1753
                    else if(IS_DIRECT(mb_type))
1754
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1755
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1756
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1757
                    else if(IS_GMC(mb_type))
1758
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1759
                    else if(IS_SKIP(mb_type))
1760
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1761
                    else if(!USES_LIST(mb_type, 1))
1762
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1763
                    else if(!USES_LIST(mb_type, 0))
1764
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1765 1766
                    else{
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1767
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1768
                    }
1769

1770 1771
                    //segmentation
                    if(IS_8X8(mb_type))
1772
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1773
                    else if(IS_16X8(mb_type))
1774
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1775
                    else if(IS_8X16(mb_type))
1776
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1777
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1778
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1779
                    else
1780
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1781 1782


1783
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1784
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1785
                    else
1786
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1787
                }
1788
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1789
            }
1790
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1791 1792
        }
    }
1793

1794
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1795 1796
        const int shift= 1 + s->quarter_sample;
        int mb_y;
1797 1798
        uint8_t *ptr;
        int i;
1799
        int h_chroma_shift, v_chroma_shift;
1800 1801
        const int width = s->avctx->width;
        const int height= s->avctx->height;
1802 1803
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1804
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1805

1806
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1807
        for(i=0; i<3; i++){
1808
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1809 1810 1811 1812
            pict->data[i]= s->visualization_buffer[i];
        }
        pict->type= FF_BUFFER_TYPE_COPY;
        ptr= pict->data[0];
1813 1814 1815 1816 1817

        for(mb_y=0; mb_y<s->mb_height; mb_y++){
            int mb_x;
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
                const int mb_index= mb_x + mb_y*s->mb_stride;
1818 1819 1820
                if((s->avctx->debug_mv) && pict->motion_val){
                  int type;
                  for(type=0; type<3; type++){
1821
                    int direction = 0;
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
                    switch (type) {
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
                                continue;
                              direction = 0;
                              break;
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
                                continue;
                              direction = 0;
                              break;
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
                                continue;
                              direction = 1;
                              break;
                    }
1836 1837 1838
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
                        continue;

1839 1840 1841
                    if(IS_8X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<4; i++){
1842 1843
                        int sx= mb_x*16 + 4 + 8*(i&1);
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1844
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1845 1846
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1847
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1848 1849 1850 1851
                      }
                    }else if(IS_16X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<2; i++){
1852 1853
                        int sx=mb_x*16 + 8;
                        int sy=mb_y*16 + 4 + 8*i;
1854
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1855 1856
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1857

1858 1859
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1860

1861 1862 1863 1864 1865 1866 1867
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
                      }
                    }else if(IS_8X16(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<2; i++){
                        int sx=mb_x*16 + 4 + 8*i;
                        int sy=mb_y*16 + 8;
1868
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1869 1870
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1871

1872 1873
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1874

1875
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1876 1877 1878 1879
                      }
                    }else{
                      int sx= mb_x*16 + 8;
                      int sy= mb_y*16 + 8;
1880
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1881 1882
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1883
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1884
                    }
1885
                  }
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
                }
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
                    int y;
                    for(y=0; y<8; y++){
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
                    }
                }
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
                    int mb_type= pict->mb_type[mb_index];
                    uint64_t u,v;
                    int y;
#define COLOR(theta, r)\
u= (int)(128 + r*cos(theta*3.141592/180));\
v= (int)(128 + r*sin(theta*3.141592/180));

1903

1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945
                    u=v=128;
                    if(IS_PCM(mb_type)){
                        COLOR(120,48)
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
                        COLOR(30,48)
                    }else if(IS_INTRA4x4(mb_type)){
                        COLOR(90,48)
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
//                        COLOR(120,48)
                    }else if(IS_DIRECT(mb_type)){
                        COLOR(150,48)
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
                        COLOR(170,48)
                    }else if(IS_GMC(mb_type)){
                        COLOR(190,48)
                    }else if(IS_SKIP(mb_type)){
//                        COLOR(180,48)
                    }else if(!USES_LIST(mb_type, 1)){
                        COLOR(240,48)
                    }else if(!USES_LIST(mb_type, 0)){
                        COLOR(0,48)
                    }else{
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
                        COLOR(300,48)
                    }

                    u*= 0x0101010101010101ULL;
                    v*= 0x0101010101010101ULL;
                    for(y=0; y<8; y++){
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
                    }

                    //segmentation
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
                    }
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
                        for(y=0; y<16; y++)
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
                    }
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
                        int dm= 1 << (mv_sample_log2-2);
                        for(i=0; i<4; i++){
                            int sx= mb_x*16 + 8*(i&1);
                            int sy= mb_y*16 + 8*(i>>1);
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
                            //FIXME bidir
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
                                for(y=0; y<8; y++)
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
                        }
                    }
1961

1962 1963 1964
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
                        // hmm
                    }
1965 1966 1967 1968 1969
                }
                s->mbskip_table[mb_index]=0;
            }
        }
    }
1970 1971
}

1972 1973
#ifdef CONFIG_ENCODERS

1974 1975 1976
static int get_sae(uint8_t *src, int ref, int stride){
    int x,y;
    int acc=0;
1977

1978 1979 1980 1981 1982
    for(y=0; y<16; y++){
        for(x=0; x<16; x++){
            acc+= ABS(src[x+y*stride] - ref);
        }
    }
1983

1984 1985 1986 1987 1988 1989
    return acc;
}

static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
    int x, y, w, h;
    int acc=0;
1990

1991 1992
    w= s->width &~15;
    h= s->height&~15;
1993

1994 1995 1996
    for(y=0; y<h; y+=16){
        for(x=0; x<w; x+=16){
            int offset= x + y*stride;
1997
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1998 1999
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
            int sae = get_sae(src + offset, mean, stride);
2000

2001 2002 2003 2004 2005 2006
            acc+= sae + 500 < sad;
        }
    }
    return acc;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
2007

2008
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2009
    AVFrame *pic=NULL;
2010
    int64_t pts;
Michael Niedermayer's avatar
Michael Niedermayer committed
2011
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
2012
    const int encoding_delay= s->max_b_frames;
Michael Niedermayer's avatar
Michael Niedermayer committed
2013
    int direct=1;
2014

2015
    if(pic_arg){
2016 2017 2018
        pts= pic_arg->pts;
        pic_arg->display_picture_number= s->input_picture_number++;

2019
        if(pts != AV_NOPTS_VALUE){
2020
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2021 2022
                int64_t time= pts;
                int64_t last= s->user_specified_pts;
2023 2024

                if(time <= last){
2025
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2026 2027 2028
                    return -1;
                }
            }
2029
            s->user_specified_pts= pts;
2030 2031
        }else{
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2032
                s->user_specified_pts=
2033
                pts= s->user_specified_pts + 1;
2034
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2035
            }else{
2036
                pts= pic_arg->display_picture_number;
2037 2038 2039 2040
            }
        }
    }

2041
  if(pic_arg){
Michael Niedermayer's avatar
Michael Niedermayer committed
2042 2043 2044 2045
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
    if(pic_arg->linesize[0] != s->linesize) direct=0;
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2046

2047
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2048

Michael Niedermayer's avatar
Michael Niedermayer committed
2049
    if(direct){
2050
        i= ff_find_unused_picture(s, 1);
Michael Niedermayer's avatar
Michael Niedermayer committed
2051

2052
        pic= (AVFrame*)&s->picture[i];
2053
        pic->reference= 3;
2054

Michael Niedermayer's avatar
Michael Niedermayer committed
2055 2056 2057 2058 2059 2060
        for(i=0; i<4; i++){
            pic->data[i]= pic_arg->data[i];
            pic->linesize[i]= pic_arg->linesize[i];
        }
        alloc_picture(s, (Picture*)pic, 1);
    }else{
2061
        int offset= 16;
2062
        i= ff_find_unused_picture(s, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
2063

2064
        pic= (AVFrame*)&s->picture[i];
2065
        pic->reference= 3;
Michael Niedermayer's avatar
Michael Niedermayer committed
2066

Michael Niedermayer's avatar
Michael Niedermayer committed
2067 2068
        alloc_picture(s, (Picture*)pic, 0);

2069
        if(   pic->data[0] + offset == pic_arg->data[0]
2070 2071
           && pic->data[1] + offset == pic_arg->data[1]
           && pic->data[2] + offset == pic_arg->data[2]){
Michael Niedermayer's avatar
Michael Niedermayer committed
2072
       // empty
Michael Niedermayer's avatar
Michael Niedermayer committed
2073 2074 2075
        }else{
            int h_chroma_shift, v_chroma_shift;
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2076

Michael Niedermayer's avatar
Michael Niedermayer committed
2077 2078 2079 2080 2081 2082 2083 2084
            for(i=0; i<3; i++){
                int src_stride= pic_arg->linesize[i];
                int dst_stride= i ? s->uvlinesize : s->linesize;
                int h_shift= i ? h_chroma_shift : 0;
                int v_shift= i ? v_chroma_shift : 0;
                int w= s->width >>h_shift;
                int h= s->height>>v_shift;
                uint8_t *src= pic_arg->data[i];
2085
                uint8_t *dst= pic->data[i] + offset;
2086

Michael Niedermayer's avatar
Michael Niedermayer committed
2087 2088 2089 2090 2091 2092 2093 2094
                if(src_stride==dst_stride)
                    memcpy(dst, src, src_stride*h);
                else{
                    while(h--){
                        memcpy(dst, src, w);
                        dst += dst_stride;
                        src += src_stride;
                    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2095
                }
2096
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
2097 2098
        }
    }
2099
    copy_picture_attributes(s, pic, pic_arg);
2100
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2101
  }
2102

Michael Niedermayer's avatar
Michael Niedermayer committed
2103 2104 2105
    /* shift buffer entries */
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
        s->input_picture[i-1]= s->input_picture[i];
2106

Michael Niedermayer's avatar
Michael Niedermayer committed
2107
    s->input_picture[encoding_delay]= (Picture*)pic;
Michael Niedermayer's avatar
Michael Niedermayer committed
2108 2109 2110

    return 0;
}
2111

Michael Niedermayer's avatar
Michael Niedermayer committed
2112 2113 2114
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
    int x, y, plane;
    int score=0;
2115
    int64_t score64=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2116 2117 2118 2119 2120 2121

    for(plane=0; plane<3; plane++){
        const int stride= p->linesize[plane];
        const int bw= plane ? 1 : 2;
        for(y=0; y<s->mb_height*bw; y++){
            for(x=0; x<s->mb_width*bw; x++){
Michael Niedermayer's avatar
Michael Niedermayer committed
2122 2123
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
                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);
2124

2125 2126 2127 2128 2129 2130 2131
                switch(s->avctx->frame_skip_exp){
                    case 0: score= FFMAX(score, v); break;
                    case 1: score+= ABS(v);break;
                    case 2: score+= v*v;break;
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
                    case 4: score64+= v*v*(int64_t)(v*v);break;
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
2132 2133 2134
            }
        }
    }
2135

2136
    if(score) score64= score;
Michael Niedermayer's avatar
Michael Niedermayer committed
2137

2138
    if(score64 < s->avctx->frame_skip_threshold)
Michael Niedermayer's avatar
Michael Niedermayer committed
2139
        return 1;
2140
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
Michael Niedermayer's avatar
Michael Niedermayer committed
2141 2142 2143 2144
        return 1;
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
2145 2146 2147 2148
static int estimate_best_b_count(MpegEncContext *s){
    AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
    AVCodecContext *c= avcodec_alloc_context();
    AVFrame input[FF_MAX_B_FRAMES+2];
2149
    const int scale= s->avctx->brd_scale;
Michael Niedermayer's avatar
Michael Niedermayer committed
2150
    int i, j, out_size;
2151
    int outbuf_size= s->width * s->height; //FIXME
Michael Niedermayer's avatar
Michael Niedermayer committed
2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
    uint8_t *outbuf= av_malloc(outbuf_size);
    ImgReSampleContext *resample;
    int64_t best_rd= INT64_MAX;
    int best_b_count= -1;
    const int lambda2= s->lambda2;

    c->width = s->width >> scale;
    c->height= s->height>> scale;
    c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
    c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
    c->mb_decision= s->avctx->mb_decision;
    c->me_cmp= s->avctx->me_cmp;
    c->mb_cmp= s->avctx->mb_cmp;
    c->me_sub_cmp= s->avctx->me_sub_cmp;
    c->pix_fmt = PIX_FMT_YUV420P;
    c->time_base= s->avctx->time_base;
    c->max_b_frames= s->max_b_frames;

    if (avcodec_open(c, codec) < 0)
        return -1;

    resample= img_resample_init(c->width, c->height, s->width, s->height); //FIXME use sws

    for(i=0; i<s->max_b_frames+2; i++){
        int ysize= c->width*c->height;
        int csize= (c->width/2)*(c->height/2);

        avcodec_get_frame_defaults(&input[i]);
        input[i].data[0]= av_malloc(ysize + 2*csize);
        input[i].data[1]= input[i].data[0] + ysize;
        input[i].data[2]= input[i].data[1] + csize;
        input[i].linesize[0]= c->width;
        input[i].linesize[1]=
        input[i].linesize[2]= c->width/2;

        if(!i || s->input_picture[i-1])
            img_resample(resample, &input[i], i ? s->input_picture[i-1] : s->next_picture_ptr);
    }

    for(j=0; j<s->max_b_frames+1; j++){
        int64_t rd=0;

        if(!s->input_picture[j])
            break;

        c->error[0]= c->error[1]= c->error[2]= 0;

        input[0].pict_type= I_TYPE;
        input[0].quality= 2 * FF_QP2LAMBDA;
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2202
        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
Michael Niedermayer's avatar
Michael Niedermayer committed
2203 2204 2205 2206 2207

        for(i=0; i<s->max_b_frames+1; i++){
            int is_p= i % (j+1) == j || i==s->max_b_frames;

            input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2208
            input[i+1].quality= s->last_lambda_for[input[i+1].pict_type];
Michael Niedermayer's avatar
Michael Niedermayer committed
2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
            rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
        }

        /* get the delayed frames */
        while(out_size){
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
            rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
        }

        rd += c->error[0] + c->error[1] + c->error[2];

        if(rd < best_rd){
            best_rd= rd;
            best_b_count= j;
        }
    }

    av_freep(&outbuf);
    avcodec_close(c);
    av_freep(&c);
    img_resample_close(resample);

    for(i=0; i<s->max_b_frames+2; i++){
        av_freep(&input[i].data[0]);
    }

    return best_b_count;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
2239 2240
static void select_input_picture(MpegEncContext *s){
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
2241

Michael Niedermayer's avatar
Michael Niedermayer committed
2242 2243 2244 2245
    for(i=1; i<MAX_PICTURE_COUNT; i++)
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;

Diego Biurrun's avatar
Diego Biurrun committed
2246
    /* set next picture type & ordering */
Michael Niedermayer's avatar
Michael Niedermayer committed
2247
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2248
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2249 2250
            s->reordered_input_picture[0]= s->input_picture[0];
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2251
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2252 2253
        }else{
            int b_frames;
Michael Niedermayer's avatar
Michael Niedermayer committed
2254 2255

            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
Michael Niedermayer's avatar
Michael Niedermayer committed
2256 2257
                if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
                //FIXME check that te gop check above is +-1 correct
Michael Niedermayer's avatar
Michael Niedermayer committed
2258
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2259

Michael Niedermayer's avatar
Michael Niedermayer committed
2260 2261 2262
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
                        for(i=0; i<4; i++)
                            s->input_picture[0]->data[i]= NULL;
2263
                        s->input_picture[0]->type= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2264
                    }else{
2265
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
Michael Niedermayer's avatar
Michael Niedermayer committed
2266
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2267

Michael Niedermayer's avatar
Michael Niedermayer committed
2268 2269
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
                    }
2270

Michael Niedermayer's avatar
Michael Niedermayer committed
2271 2272
                    emms_c();
                    ff_vbv_update(s, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
2273 2274 2275 2276 2277

                    goto no_output_pic;
                }
            }

2278 2279 2280
            if(s->flags&CODEC_FLAG_PASS2){
                for(i=0; i<s->max_b_frames+1; i++){
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2281

2282
                    if(pict_num >= s->rc_context.num_entries)
2283
                        break;
2284
                    if(!s->input_picture[i]){
2285
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2286 2287
                        break;
                    }
2288

2289
                    s->input_picture[i]->pict_type=
2290
                        s->rc_context.entry[pict_num].new_pict_type;
2291 2292
                }
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
2293

2294
            if(s->avctx->b_frame_strategy==0){
2295
                b_frames= s->max_b_frames;
2296
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
Michael Niedermayer's avatar
Michael Niedermayer committed
2297
            }else if(s->avctx->b_frame_strategy==1){
2298
                for(i=1; i<s->max_b_frames+1; i++){
2299
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2300 2301
                        s->input_picture[i]->b_frame_score=
                            get_intra_count(s, s->input_picture[i  ]->data[0],
Michael Niedermayer's avatar
Michael Niedermayer committed
2302
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2303 2304
                    }
                }
2305
                for(i=0; i<s->max_b_frames+1; i++){
2306
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2307
                }
2308

2309
                b_frames= FFMAX(0, i-1);
2310

2311 2312 2313 2314
                /* reset scores */
                for(i=0; i<b_frames+1; i++){
                    s->input_picture[i]->b_frame_score=0;
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
2315 2316
            }else if(s->avctx->b_frame_strategy==2){
                b_frames= estimate_best_b_count(s);
2317
            }else{
2318
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2319
                b_frames=0;
2320
            }
2321 2322 2323 2324

            emms_c();
//static int b_count=0;
//b_count+= b_frames;
2325
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2326 2327 2328 2329 2330 2331 2332

            for(i= b_frames - 1; i>=0; i--){
                int type= s->input_picture[i]->pict_type;
                if(type && type != B_TYPE)
                    b_frames= i;
            }
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2333
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2334 2335
            }

2336
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2337 2338 2339
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
              }else{
2340 2341 2342
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
                    b_frames=0;
                s->input_picture[b_frames]->pict_type= I_TYPE;
2343
              }
2344
            }
2345

2346 2347 2348 2349 2350
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
               && b_frames
               && s->input_picture[b_frames]->pict_type== I_TYPE)
                b_frames--;

2351
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2352
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2353
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2354
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2355 2356 2357
            for(i=0; i<b_frames; i++){
                s->reordered_input_picture[i+1]= s->input_picture[i];
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2358
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2359 2360 2361
            }
        }
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2362
no_output_pic:
Michael Niedermayer's avatar
Michael Niedermayer committed
2363
    if(s->reordered_input_picture[0]){
2364
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2365

2366
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
Michael Niedermayer's avatar
Michael Niedermayer committed
2367 2368

        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
Diego Biurrun's avatar
Diego Biurrun committed
2369
            // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2370

2371
            int i= ff_find_unused_picture(s, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
2372 2373 2374 2375 2376 2377
            Picture *pic= &s->picture[i];

            /* mark us unused / free shared pic */
            for(i=0; i<4; i++)
                s->reordered_input_picture[0]->data[i]= NULL;
            s->reordered_input_picture[0]->type= 0;
2378

2379
            pic->reference              = s->reordered_input_picture[0]->reference;
2380

Michael Niedermayer's avatar
Michael Niedermayer committed
2381 2382
            alloc_picture(s, pic, 0);

2383 2384
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);

2385
            s->current_picture_ptr= pic;
Michael Niedermayer's avatar
Michael Niedermayer committed
2386
        }else{
2387 2388
            // input is not a shared pix -> reuse buffer for current_pix

2389
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
Michael Niedermayer's avatar
Michael Niedermayer committed
2390
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2391

2392
            s->current_picture_ptr= s->reordered_input_picture[0];
Michael Niedermayer's avatar
Michael Niedermayer committed
2393
            for(i=0; i<4; i++){
2394
                s->new_picture.data[i]+=16;
Michael Niedermayer's avatar
Michael Niedermayer committed
2395
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
2396
        }
2397
        copy_picture(&s->current_picture, s->current_picture_ptr);
2398

Michael Niedermayer's avatar
Michael Niedermayer committed
2399 2400 2401 2402
        s->picture_number= s->new_picture.display_picture_number;
//printf("dpn:%d\n", s->picture_number);
    }else{
       memset(&s->new_picture, 0, sizeof(Picture));
2403 2404 2405
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
2406 2407 2408 2409
int MPV_encode_picture(AVCodecContext *avctx,
                       unsigned char *buf, int buf_size, void *data)
{
    MpegEncContext *s = avctx->priv_data;
2410
    AVFrame *pic_arg = data;
2411
    int i, stuffing_count;
Fabrice Bellard's avatar
Fabrice Bellard committed
2412

2413
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2414
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2415 2416
        return -1;
    }
2417

2418
    for(i=0; i<avctx->thread_count; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
2419 2420
        int start_y= s->thread_context[i]->start_mb_y;
        int   end_y= s->thread_context[i]->  end_mb_y;
2421
        int h= s->mb_height;
2422 2423
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2424 2425 2426

        init_put_bits(&s->thread_context[i]->pb, start, end - start);
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
2427

Michael Niedermayer's avatar
Michael Niedermayer committed
2428
    s->picture_in_gop_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
2429

2430 2431
    if(load_input_picture(s, pic_arg) < 0)
        return -1;
2432

Michael Niedermayer's avatar
Michael Niedermayer committed
2433
    select_input_picture(s);
2434

2435
    /* output? */
Michael Niedermayer's avatar
Michael Niedermayer committed
2436 2437 2438 2439
    if(s->new_picture.data[0]){
        s->pict_type= s->new_picture.pict_type;
//emms_c();
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2440
        MPV_frame_start(s, avctx);
2441 2442

        encode_picture(s, s->picture_number);
2443

2444
        avctx->real_pict_num  = s->picture_number;
2445 2446 2447 2448 2449 2450
        avctx->header_bits = s->header_bits;
        avctx->mv_bits     = s->mv_bits;
        avctx->misc_bits   = s->misc_bits;
        avctx->i_tex_bits  = s->i_tex_bits;
        avctx->p_tex_bits  = s->p_tex_bits;
        avctx->i_count     = s->i_count;
2451
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2452 2453 2454 2455 2456 2457
        avctx->skip_count  = s->skip_count;

        MPV_frame_end(s);

        if (s->out_format == FMT_MJPEG)
            mjpeg_picture_trailer(s);
2458

2459 2460
        if(s->flags&CODEC_FLAG_PASS1)
            ff_write_pass1_stats(s);
2461 2462

        for(i=0; i<4; i++){
2463
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2464 2465
            avctx->error[i] += s->current_picture_ptr->error[i];
        }
2466

2467 2468
        if(s->flags&CODEC_FLAG_PASS1)
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2469
        flush_put_bits(&s->pb);
2470
        s->frame_bits  = put_bits_count(&s->pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
2471

Michael Niedermayer's avatar
Michael Niedermayer committed
2472 2473
        stuffing_count= ff_vbv_update(s, s->frame_bits);
        if(stuffing_count){
2474 2475 2476 2477 2478
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
                return -1;
            }

Michael Niedermayer's avatar
Michael Niedermayer committed
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
            switch(s->codec_id){
            case CODEC_ID_MPEG1VIDEO:
            case CODEC_ID_MPEG2VIDEO:
                while(stuffing_count--){
                    put_bits(&s->pb, 8, 0);
                }
            break;
            case CODEC_ID_MPEG4:
                put_bits(&s->pb, 16, 0);
                put_bits(&s->pb, 16, 0x1C3);
                stuffing_count -= 4;
                while(stuffing_count--){
                    put_bits(&s->pb, 8, 0xFF);
                }
            break;
            default:
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
            }
            flush_put_bits(&s->pb);
2498
            s->frame_bits  = put_bits_count(&s->pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
2499
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
2500

2501
        /* update mpeg1/2 vbv_delay for CBR */
2502 2503
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
Michael Niedermayer's avatar
Michael Niedermayer committed
2504
            int vbv_delay;
Michael Niedermayer's avatar
Michael Niedermayer committed
2505

Michael Niedermayer's avatar
Michael Niedermayer committed
2506
            assert(s->repeat_first_field==0);
2507

Michael Niedermayer's avatar
Michael Niedermayer committed
2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
            assert(vbv_delay < 0xFFFF);

            s->vbv_delay_ptr[0] &= 0xF8;
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
            s->vbv_delay_ptr[2] &= 0x07;
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
        }
        s->total_bits += s->frame_bits;
        avctx->frame_bits  = s->frame_bits;
    }else{
        assert((pbBufPtr(&s->pb) == s->pb.buf));
        s->frame_bits=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2522
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2523
    assert((s->frame_bits&7)==0);
2524

2525
    return s->frame_bits/8;
Fabrice Bellard's avatar
Fabrice Bellard committed
2526 2527
}

2528 2529
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
2530
static inline void gmc1_motion(MpegEncContext *s,
2531
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2532
                               uint8_t **ref_picture)
Michael Niedermayer's avatar
Michael Niedermayer committed
2533
{
2534
    uint8_t *ptr;
Michael Niedermayer's avatar
Michael Niedermayer committed
2535
    int offset, src_x, src_y, linesize, uvlinesize;
Michael Niedermayer's avatar
Michael Niedermayer committed
2536
    int motion_x, motion_y;
2537
    int emu=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550

    motion_x= s->sprite_offset[0][0];
    motion_y= s->sprite_offset[0][1];
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
    motion_x<<=(3-s->sprite_warping_accuracy);
    motion_y<<=(3-s->sprite_warping_accuracy);
    src_x = clip(src_x, -16, s->width);
    if (src_x == s->width)
        motion_x =0;
    src_y = clip(src_y, -16, s->height);
    if (src_y == s->height)
        motion_y =0;
2551

Michael Niedermayer's avatar
Michael Niedermayer committed
2552
    linesize = s->linesize;
Michael Niedermayer's avatar
Michael Niedermayer committed
2553
    uvlinesize = s->uvlinesize;
2554

2555
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
Michael Niedermayer's avatar
Michael Niedermayer committed
2556

2557
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2558 2559
        if(   (unsigned)src_x >= s->h_edge_pos - 17
           || (unsigned)src_y >= s->v_edge_pos - 17){
2560
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2561 2562 2563
            ptr= s->edge_emu_buffer;
        }
    }
2564

2565
    if((motion_x|motion_y)&7){
2566 2567
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2568 2569
    }else{
        int dxy;
2570

2571 2572
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
        if (s->no_rounding){
2573
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2574
        }else{
2575 2576
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
        }
2577
    }
2578

2579
    if(s->flags&CODEC_FLAG_GRAY) return;
Michael Niedermayer's avatar
Michael Niedermayer committed
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593

    motion_x= s->sprite_offset[1][0];
    motion_y= s->sprite_offset[1][1];
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
    motion_x<<=(3-s->sprite_warping_accuracy);
    motion_y<<=(3-s->sprite_warping_accuracy);
    src_x = clip(src_x, -8, s->width>>1);
    if (src_x == s->width>>1)
        motion_x =0;
    src_y = clip(src_y, -8, s->height>>1);
    if (src_y == s->height>>1)
        motion_y =0;

2594
    offset = (src_y * uvlinesize) + src_x;
Michael Niedermayer's avatar
Michael Niedermayer committed
2595
    ptr = ref_picture[1] + offset;
2596
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2597 2598
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2599
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2600 2601 2602
            ptr= s->edge_emu_buffer;
            emu=1;
        }
2603
    }
2604
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2605

Michael Niedermayer's avatar
Michael Niedermayer committed
2606
    ptr = ref_picture[2] + offset;
2607
    if(emu){
2608
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2609 2610
        ptr= s->edge_emu_buffer;
    }
2611
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2612

Michael Niedermayer's avatar
Michael Niedermayer committed
2613 2614 2615
    return;
}

2616
static inline void gmc_motion(MpegEncContext *s,
2617
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2618
                               uint8_t **ref_picture)
2619
{
2620
    uint8_t *ptr;
2621 2622 2623 2624 2625 2626 2627
    int linesize, uvlinesize;
    const int a= s->sprite_warping_accuracy;
    int ox, oy;

    linesize = s->linesize;
    uvlinesize = s->uvlinesize;

2628
    ptr = ref_picture[0];
2629 2630 2631 2632

    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;

2633
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2634 2635
           ox,
           oy,
2636
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2637
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2638 2639
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos, s->v_edge_pos);
2640
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2641 2642
           ox + s->sprite_delta[0][0]*8,
           oy + s->sprite_delta[1][0]*8,
2643
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2644
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2645 2646 2647 2648 2649 2650 2651 2652
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos, s->v_edge_pos);

    if(s->flags&CODEC_FLAG_GRAY) return;

    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;

2653
    ptr = ref_picture[1];
2654
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2655 2656
           ox,
           oy,
2657
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2658
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2659 2660
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2661

2662
    ptr = ref_picture[2];
2663
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2664 2665
           ox,
           oy,
2666
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2667
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2668 2669 2670 2671
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos>>1, s->v_edge_pos>>1);
}

2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683
/**
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
 * @param buf destination buffer
 * @param src source buffer
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
 * @param block_w width of block
 * @param block_h height of block
 * @param src_x x coordinate of the top left sample of the block in the source buffer
 * @param src_y y coordinate of the top left sample of the block in the source buffer
 * @param w width of the source buffer
 * @param h height of the source buffer
 */
2684
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2685 2686 2687
                                    int src_x, int src_y, int w, int h){
    int x, y;
    int start_y, start_x, end_y, end_x;
2688

2689 2690 2691
    if(src_y>= h){
        src+= (h-1-src_y)*linesize;
        src_y=h-1;
2692 2693 2694
    }else if(src_y<=-block_h){
        src+= (1-block_h-src_y)*linesize;
        src_y=1-block_h;
2695 2696 2697 2698
    }
    if(src_x>= w){
        src+= (w-1-src_x);
        src_x=w-1;
2699 2700 2701
    }else if(src_x<=-block_w){
        src+= (1-block_w-src_x);
        src_x=1-block_w;
2702 2703
    }

2704 2705 2706 2707
    start_y= FFMAX(0, -src_y);
    start_x= FFMAX(0, -src_x);
    end_y= FFMIN(block_h, h-src_y);
    end_x= FFMIN(block_w, w-src_x);
2708

2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
    // copy existing part
    for(y=start_y; y<end_y; y++){
        for(x=start_x; x<end_x; x++){
            buf[x + y*linesize]= src[x + y*linesize];
        }
    }

    //top
    for(y=0; y<start_y; y++){
        for(x=start_x; x<end_x; x++){
            buf[x + y*linesize]= buf[x + start_y*linesize];
        }
    }

    //bottom
    for(y=end_y; y<block_h; y++){
        for(x=start_x; x<end_x; x++){
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
        }
    }
2729

2730 2731 2732 2733 2734
    for(y=0; y<block_h; y++){
       //left
        for(x=0; x<start_x; x++){
            buf[x + y*linesize]= buf[start_x + y*linesize];
        }
2735

2736 2737 2738 2739 2740 2741 2742
       //right
        for(x=end_x; x<block_w; x++){
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
        }
    }
}

2743
static inline int hpel_motion(MpegEncContext *s,
2744 2745
                                  uint8_t *dest, uint8_t *src,
                                  int field_based, int field_select,
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
                                  int src_x, int src_y,
                                  int width, int height, int stride,
                                  int h_edge_pos, int v_edge_pos,
                                  int w, int h, op_pixels_func *pix_op,
                                  int motion_x, int motion_y)
{
    int dxy;
    int emu=0;

    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
    src_x += motion_x >> 1;
    src_y += motion_y >> 1;
2758

2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
    /* WARNING: do no forget half pels */
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
    if (src_x == width)
        dxy &= ~1;
    src_y = clip(src_y, -16, height);
    if (src_y == height)
        dxy &= ~2;
    src += src_y * stride + src_x;

    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2771 2772
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2773 2774 2775 2776
            src= s->edge_emu_buffer;
            emu=1;
        }
    }
2777 2778
    if(field_select)
        src += s->linesize;
2779 2780 2781
    pix_op[dxy](dest, src, stride, h);
    return emu;
}
2782

2783
static inline int hpel_motion_lowres(MpegEncContext *s,
Michael Niedermayer's avatar
Michael Niedermayer committed
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805
                                  uint8_t *dest, uint8_t *src,
                                  int field_based, int field_select,
                                  int src_x, int src_y,
                                  int width, int height, int stride,
                                  int h_edge_pos, int v_edge_pos,
                                  int w, int h, h264_chroma_mc_func *pix_op,
                                  int motion_x, int motion_y)
{
    const int lowres= s->avctx->lowres;
    const int s_mask= (2<<lowres)-1;
    int emu=0;
    int sx, sy;

    if(s->quarter_sample){
        motion_x/=2;
        motion_y/=2;
    }

    sx= motion_x & s_mask;
    sy= motion_y & s_mask;
    src_x += motion_x >> (lowres+1);
    src_y += motion_y >> (lowres+1);
2806

Michael Niedermayer's avatar
Michael Niedermayer committed
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
    src += src_y * stride + src_x;

    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
        src= s->edge_emu_buffer;
        emu=1;
    }

    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    if(field_select)
        src += s->linesize;
    pix_op[lowres](dest, src, stride, h, sx, sy);
    return emu;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
2825
/* apply one mpeg motion vector to the three components */
2826
static always_inline void mpeg_motion(MpegEncContext *s,
2827
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2828 2829
                               int field_based, int bottom_field, int field_select,
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
Fabrice Bellard's avatar
Fabrice Bellard committed
2830 2831
                               int motion_x, int motion_y, int h)
{
2832 2833
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2834 2835

#if 0
Michael Niedermayer's avatar
Michael Niedermayer committed
2836 2837 2838 2839 2840
if(s->quarter_sample)
{
    motion_x>>=1;
    motion_y>>=1;
}
Michael Niedermayer's avatar
Michael Niedermayer committed
2841
#endif
2842

2843
    v_edge_pos = s->v_edge_pos >> field_based;
2844
    linesize   = s->current_picture.linesize[0] << field_based;
2845
    uvlinesize = s->current_picture.linesize[1] << field_based;
2846

2847 2848
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
    src_x = s->mb_x* 16               + (motion_x >> 1);
2849
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2850

Fabrice Bellard's avatar
Fabrice Bellard committed
2851
    if (s->out_format == FMT_H263) {
2852 2853 2854 2855 2856
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
            mx = (motion_x>>1)|(motion_x&1);
            my = motion_y >>1;
            uvdxy = ((my & 1) << 1) | (mx & 1);
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2857
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2858 2859 2860 2861 2862
        }else{
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
            uvsrc_x = src_x>>1;
            uvsrc_y = src_y>>1;
        }
2863 2864 2865 2866 2867 2868
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
        mx = motion_x / 4;
        my = motion_y / 4;
        uvdxy = 0;
        uvsrc_x = s->mb_x*8 + mx;
        uvsrc_y = s->mb_y*8 + my;
Fabrice Bellard's avatar
Fabrice Bellard committed
2869
    } else {
2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
        if(s->chroma_y_shift){
            mx = motion_x / 2;
            my = motion_y / 2;
            uvdxy = ((my & 1) << 1) | (mx & 1);
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
        } else {
            if(s->chroma_x_shift){
            //Chroma422
                mx = motion_x / 2;
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
                uvsrc_y = src_y;
            } else {
            //Chroma444
                uvdxy = dxy;
                uvsrc_x = src_x;
                uvsrc_y = src_y;
            }
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
2890
    }
2891 2892 2893 2894 2895 2896 2897

    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;

    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2898 2899 2900 2901 2902
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
               s->codec_id == CODEC_ID_MPEG1VIDEO){
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
                return ;
            }
2903 2904 2905 2906
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
            ptr_y = s->edge_emu_buffer;
            if(!(s->flags&CODEC_FLAG_GRAY)){
Michael Niedermayer's avatar
Michael Niedermayer committed
2907
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2908
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2909
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2910
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2911 2912 2913 2914
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
                ptr_cb= uvbuf;
                ptr_cr= uvbuf+16;
            }
2915 2916
    }

2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
        dest_y += s->linesize;
        dest_cb+= s->uvlinesize;
        dest_cr+= s->uvlinesize;
    }

    if(field_select){
        ptr_y += s->linesize;
        ptr_cb+= s->uvlinesize;
        ptr_cr+= s->uvlinesize;
    }

    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2930

2931
    if(!(s->flags&CODEC_FLAG_GRAY)){
2932 2933
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2934
    }
2935
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2936 2937 2938
    if(s->out_format == FMT_H261){
        ff_h261_loop_filter(s);
    }
2939
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
2940
}
2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958

/* apply one mpeg motion vector to the three components */
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                               int field_based, int bottom_field, int field_select,
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
                               int motion_x, int motion_y, int h)
{
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
    const int lowres= s->avctx->lowres;
    const int block_s= 8>>lowres;
    const int s_mask= (2<<lowres)-1;
    const int h_edge_pos = s->h_edge_pos >> lowres;
    const int v_edge_pos = s->v_edge_pos >> lowres;
    linesize   = s->current_picture.linesize[0] << field_based;
    uvlinesize = s->current_picture.linesize[1] << field_based;

2959 2960 2961 2962
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
        motion_x/=2;
        motion_y/=2;
    }
2963

2964 2965 2966 2967
    if(field_based){
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
    }

2968 2969 2970
    sx= motion_x & s_mask;
    sy= motion_y & s_mask;
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2971
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2972

2973
    if (s->out_format == FMT_H263) {
Michael Niedermayer's avatar
Michael Niedermayer committed
2974 2975
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
        uvsrc_x = src_x>>1;
        uvsrc_y = src_y>>1;
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
        mx = motion_x / 4;
        my = motion_y / 4;
        uvsx = (2*mx) & s_mask;
        uvsy = (2*my) & s_mask;
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
    } else {
        mx = motion_x / 2;
        my = motion_y / 2;
        uvsx = mx & s_mask;
        uvsy = my & s_mask;
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2991
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004
    }

    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;

    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
            ptr_y = s->edge_emu_buffer;
            if(!(s->flags&CODEC_FLAG_GRAY)){
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3005
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3006
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3007
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3008 3009 3010 3011 3012 3013
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
                ptr_cb= uvbuf;
                ptr_cr= uvbuf+16;
            }
    }

3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
        dest_y += s->linesize;
        dest_cb+= s->uvlinesize;
        dest_cr+= s->uvlinesize;
    }

    if(field_select){
        ptr_y += s->linesize;
        ptr_cb+= s->uvlinesize;
        ptr_cr+= s->uvlinesize;
    }

3026 3027 3028
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3029

3030 3031 3032 3033 3034 3035
    if(!(s->flags&CODEC_FLAG_GRAY)){
        uvsx <<= 2 - lowres;
        uvsy <<= 2 - lowres;
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
    }
3036
    //FIXME h261 lowres loop filter
3037 3038
}

3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053
//FIXME move to dsputil, avg variant, 16x16 version
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
    int x;
    uint8_t * const top   = src[1];
    uint8_t * const left  = src[2];
    uint8_t * const mid   = src[0];
    uint8_t * const right = src[3];
    uint8_t * const bottom= src[4];
#define OBMC_FILTER(x, t, l, m, r, b)\
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
#define OBMC_FILTER4(x, t, l, m, r, b)\
    OBMC_FILTER(x         , t, l, m, r, b);\
    OBMC_FILTER(x+1       , t, l, m, r, b);\
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
3054

3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100
    x=0;
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
    x+= stride;
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
    x+= stride;
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
    x+= 2*stride;
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
    x+= 2*stride;
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
    x+= stride;
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
}

/* obmc for 1 8x8 luma block */
static inline void obmc_motion(MpegEncContext *s,
                               uint8_t *dest, uint8_t *src,
                               int src_x, int src_y,
                               op_pixels_func *pix_op,
                               int16_t mv[5][2]/* mid top left right bottom*/)
#define MID    0
{
    int i;
    uint8_t *ptr[5];
3101

3102
    assert(s->quarter_sample==0);
3103

3104 3105 3106 3107
    for(i=0; i<5; i++){
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
            ptr[i]= ptr[MID];
        }else{
3108
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3109
            hpel_motion(s, ptr[i], src, 0, 0,
3110 3111 3112 3113 3114 3115 3116 3117
                        src_x, src_y,
                        s->width, s->height, s->linesize,
                        s->h_edge_pos, s->v_edge_pos,
                        8, 8, pix_op,
                        mv[i][0], mv[i][1]);
        }
    }

3118
    put_obmc(dest, ptr, s->linesize);
3119
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3120

Michael Niedermayer's avatar
Michael Niedermayer committed
3121
static inline void qpel_motion(MpegEncContext *s,
3122
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3123 3124
                               int field_based, int bottom_field, int field_select,
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
Michael Niedermayer's avatar
Michael Niedermayer committed
3125
                               qpel_mc_func (*qpix_op)[16],
Michael Niedermayer's avatar
Michael Niedermayer committed
3126 3127
                               int motion_x, int motion_y, int h)
{
3128 3129
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3130

Michael Niedermayer's avatar
Michael Niedermayer committed
3131
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3132
    src_x = s->mb_x *  16                 + (motion_x >> 2);
Michael Niedermayer's avatar
Michael Niedermayer committed
3133 3134
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);

3135
    v_edge_pos = s->v_edge_pos >> field_based;
Michael Niedermayer's avatar
Michael Niedermayer committed
3136
    linesize = s->linesize << field_based;
3137
    uvlinesize = s->uvlinesize << field_based;
3138

3139 3140 3141
    if(field_based){
        mx= motion_x/2;
        my= motion_y>>1;
3142 3143 3144 3145
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
        mx= (motion_x>>1) + rtab[motion_x&7];
        my= (motion_y>>1) + rtab[motion_y&7];
3146
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3147 3148 3149 3150 3151 3152 3153 3154
        mx= (motion_x>>1)|(motion_x&1);
        my= (motion_y>>1)|(motion_y&1);
    }else{
        mx= motion_x/2;
        my= motion_y/2;
    }
    mx= (mx>>1)|(mx&1);
    my= (my>>1)|(my&1);
3155

3156
    uvdxy= (mx&1) | ((my&1)<<1);
3157 3158
    mx>>=1;
    my>>=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
3159

3160 3161 3162 3163 3164 3165 3166
    uvsrc_x = s->mb_x *  8                 + mx;
    uvsrc_y = s->mb_y * (8 >> field_based) + my;

    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;

3167
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3168
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3169
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3170 3171 3172
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
        ptr_y= s->edge_emu_buffer;
        if(!(s->flags&CODEC_FLAG_GRAY)){
Michael Niedermayer's avatar
Michael Niedermayer committed
3173
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3174
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3175
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3176
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3177 3178 3179 3180 3181
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
            ptr_cb= uvbuf;
            ptr_cr= uvbuf + 16;
        }
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3182

3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200
    if(!field_based)
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
    else{
        if(bottom_field){
            dest_y += s->linesize;
            dest_cb+= s->uvlinesize;
            dest_cr+= s->uvlinesize;
        }

        if(field_select){
            ptr_y  += s->linesize;
            ptr_cb += s->uvlinesize;
            ptr_cr += s->uvlinesize;
        }
        //damn interlaced mode
        //FIXME boundary mirroring is not exactly correct here
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3201
    }
3202 3203 3204
    if(!(s->flags&CODEC_FLAG_GRAY)){
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3205
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3206 3207
}

3208 3209 3210 3211 3212 3213 3214 3215
inline int ff_h263_round_chroma(int x){
    if (x >= 0)
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
    else {
        x = -x;
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
    }
}
Michael Niedermayer's avatar
Michael Niedermayer committed
3216

3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
/**
 * h263 chorma 4mv motion compensation.
 */
static inline void chroma_4mv_motion(MpegEncContext *s,
                                     uint8_t *dest_cb, uint8_t *dest_cr,
                                     uint8_t **ref_picture,
                                     op_pixels_func *pix_op,
                                     int mx, int my){
    int dxy, emu=0, src_x, src_y, offset;
    uint8_t *ptr;
3227

3228 3229 3230 3231
    /* In case of 8X8, we construct a single chroma motion vector
       with a special rounding */
    mx= ff_h263_round_chroma(mx);
    my= ff_h263_round_chroma(my);
3232

3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244
    dxy = ((my & 1) << 1) | (mx & 1);
    mx >>= 1;
    my >>= 1;

    src_x = s->mb_x * 8 + mx;
    src_y = s->mb_y * 8 + my;
    src_x = clip(src_x, -8, s->width/2);
    if (src_x == s->width/2)
        dxy &= ~1;
    src_y = clip(src_y, -8, s->height/2);
    if (src_y == s->height/2)
        dxy &= ~2;
3245

3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265
    offset = (src_y * (s->uvlinesize)) + src_x;
    ptr = ref_picture[1] + offset;
    if(s->flags&CODEC_FLAG_EMU_EDGE){
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
            ptr= s->edge_emu_buffer;
            emu=1;
        }
    }
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);

    ptr = ref_picture[2] + offset;
    if(emu){
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
        ptr= s->edge_emu_buffer;
    }
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
}

Michael Niedermayer's avatar
Michael Niedermayer committed
3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
                                     uint8_t *dest_cb, uint8_t *dest_cr,
                                     uint8_t **ref_picture,
                                     h264_chroma_mc_func *pix_op,
                                     int mx, int my){
    const int lowres= s->avctx->lowres;
    const int block_s= 8>>lowres;
    const int s_mask= (2<<lowres)-1;
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
    int emu=0, src_x, src_y, offset, sx, sy;
    uint8_t *ptr;
3278

Michael Niedermayer's avatar
Michael Niedermayer committed
3279 3280 3281 3282 3283 3284 3285 3286 3287
    if(s->quarter_sample){
        mx/=2;
        my/=2;
    }

    /* In case of 8X8, we construct a single chroma motion vector
       with a special rounding */
    mx= ff_h263_round_chroma(mx);
    my= ff_h263_round_chroma(my);
3288

Michael Niedermayer's avatar
Michael Niedermayer committed
3289 3290 3291 3292
    sx= mx & s_mask;
    sy= my & s_mask;
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3293

Michael Niedermayer's avatar
Michael Niedermayer committed
3294 3295 3296 3297 3298 3299 3300 3301 3302
    offset = src_y * s->uvlinesize + src_x;
    ptr = ref_picture[1] + offset;
    if(s->flags&CODEC_FLAG_EMU_EDGE){
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
            ptr= s->edge_emu_buffer;
            emu=1;
        }
3303
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3304 3305 3306
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3307

Michael Niedermayer's avatar
Michael Niedermayer committed
3308 3309 3310 3311 3312 3313 3314 3315
    ptr = ref_picture[2] + offset;
    if(emu){
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
        ptr= s->edge_emu_buffer;
    }
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
}

Michael Niedermayer's avatar
Michael Niedermayer committed
3316
/**
Diego Biurrun's avatar
Diego Biurrun committed
3317
 * motion compensation of a single macroblock
Michael Niedermayer's avatar
Michael Niedermayer committed
3318 3319 3320 3321 3322 3323 3324 3325 3326 3327
 * @param s context
 * @param dest_y luma destination pointer
 * @param dest_cb chroma cb/u destination pointer
 * @param dest_cr chroma cr/v destination pointer
 * @param dir direction (0->forward, 1->backward)
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
 * @param pic_op halfpel motion compensation function (average or put normally)
 * @param pic_op qpel motion compensation function (average or put normally)
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
 */
3328
static inline void MPV_motion(MpegEncContext *s,
3329
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3330
                              int dir, uint8_t **ref_picture,
Michael Niedermayer's avatar
Michael Niedermayer committed
3331
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
Fabrice Bellard's avatar
Fabrice Bellard committed
3332
{
3333
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
Fabrice Bellard's avatar
Fabrice Bellard committed
3334
    int mb_x, mb_y, i;
3335
    uint8_t *ptr, *dest;
Fabrice Bellard's avatar
Fabrice Bellard committed
3336 3337 3338 3339

    mb_x = s->mb_x;
    mb_y = s->mb_y;

3340
    if(s->obmc && s->pict_type != B_TYPE){
3341 3342
        int16_t mv_cache[4][4][2];
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3343 3344
        const int mot_stride= s->b8_stride;
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3345

3346
        assert(!s->mb_skipped);
3347

3348 3349 3350
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3351 3352 3353 3354

        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
        }else{
3355
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3356 3357 3358 3359 3360 3361
        }

        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
        }else{
3362 3363
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3364 3365 3366 3367 3368 3369
        }

        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
        }else{
3370 3371
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3372
        }
3373

3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399
        mx = 0;
        my = 0;
        for(i=0;i<4;i++) {
            const int x= (i&1)+1;
            const int y= (i>>1)+1;
            int16_t mv[5][2]= {
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
            //FIXME cleanup
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
                        ref_picture[0],
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
                        pix_op[1],
                        mv);

            mx += mv[0][0];
            my += mv[0][1];
        }
        if(!(s->flags&CODEC_FLAG_GRAY))
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);

        return;
    }
3400

Fabrice Bellard's avatar
Fabrice Bellard committed
3401 3402
    switch(s->mv_type) {
    case MV_TYPE_16X16:
Michael Niedermayer's avatar
Michael Niedermayer committed
3403
        if(s->mcsel){
3404
            if(s->real_sprite_warping_points==1){
3405 3406
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
                            ref_picture);
3407
            }else{
3408 3409
                gmc_motion(s, dest_y, dest_cb, dest_cr,
                            ref_picture);
3410
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
3411
        }else if(s->quarter_sample){
3412
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3413 3414
                        0, 0, 0,
                        ref_picture, pix_op, qpix_op,
Michael Niedermayer's avatar
Michael Niedermayer committed
3415
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
3416 3417 3418 3419
        }else if(s->mspel){
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
                        ref_picture, pix_op,
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3420 3421
        }else
        {
3422
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3423 3424
                        0, 0, 0,
                        ref_picture, pix_op,
Michael Niedermayer's avatar
Michael Niedermayer committed
3425
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3426
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3427 3428
        break;
    case MV_TYPE_8X8:
Michael Niedermayer's avatar
Michael Niedermayer committed
3429 3430 3431 3432 3433 3434 3435 3436 3437 3438
        mx = 0;
        my = 0;
        if(s->quarter_sample){
            for(i=0;i<4;i++) {
                motion_x = s->mv[dir][i][0];
                motion_y = s->mv[dir][i][1];

                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3439

Michael Niedermayer's avatar
Michael Niedermayer committed
3440 3441 3442 3443 3444 3445 3446
                /* WARNING: do no forget half pels */
                src_x = clip(src_x, -16, s->width);
                if (src_x == s->width)
                    dxy &= ~3;
                src_y = clip(src_y, -16, s->height);
                if (src_y == s->height)
                    dxy &= ~12;
3447

Michael Niedermayer's avatar
Michael Niedermayer committed
3448 3449
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3450
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3451
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3452
                        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
Michael Niedermayer's avatar
Michael Niedermayer committed
3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
                        ptr= s->edge_emu_buffer;
                    }
                }
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
                qpix_op[1][dxy](dest, ptr, s->linesize);

                mx += s->mv[dir][i][0]/2;
                my += s->mv[dir][i][1]/2;
            }
        }else{
            for(i=0;i<4;i++) {
3464
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3465
                            ref_picture[0], 0, 0,
3466 3467 3468 3469 3470
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
                            s->width, s->height, s->linesize,
                            s->h_edge_pos, s->v_edge_pos,
                            8, 8, pix_op[1],
                            s->mv[dir][i][0], s->mv[dir][i][1]);
Michael Niedermayer's avatar
Michael Niedermayer committed
3471 3472 3473

                mx += s->mv[dir][i][0];
                my += s->mv[dir][i][1];
3474
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3475
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
3476

3477 3478
        if(!(s->flags&CODEC_FLAG_GRAY))
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
Fabrice Bellard's avatar
Fabrice Bellard committed
3479 3480 3481
        break;
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
3482
            if(s->quarter_sample){
3483 3484 3485 3486 3487 3488
                for(i=0; i<2; i++){
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
                                1, i, s->field_select[dir][i],
                                ref_picture, pix_op, qpix_op,
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
                }
3489
            }else{
3490
                /* top field */
3491 3492 3493
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
                            1, 0, s->field_select[dir][0],
                            ref_picture, pix_op,
3494 3495
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
                /* bottom field */
3496 3497 3498
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
                            1, 1, s->field_select[dir][1],
                            ref_picture, pix_op,
3499 3500
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3501
        } else {
3502 3503
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
                ref_picture= s->current_picture_ptr->data;
3504
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3505

3506 3507 3508
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
                        0, 0, s->field_select[dir][0],
                        ref_picture, pix_op,
3509
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
Fabrice Bellard's avatar
Fabrice Bellard committed
3510
        }
3511
        break;
3512 3513 3514
    case MV_TYPE_16X8:
        for(i=0; i<2; i++){
            uint8_t ** ref2picture;
3515

3516
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3517 3518
                ref2picture= ref_picture;
            }else{
3519
                ref2picture= s->current_picture_ptr->data;
3520
            }
3521

3522
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3523
                        0, 0, s->field_select[dir][i],
3524
                        ref2picture, pix_op,
3525
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3526

3527
            dest_y += 16*s->linesize;
3528 3529
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3530
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3531
        break;
3532 3533
    case MV_TYPE_DMV:
        if(s->picture_structure == PICT_FRAME){
3534 3535 3536 3537 3538 3539 3540 3541
            for(i=0; i<2; i++){
                int j;
                for(j=0; j<2; j++){
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
                                1, j, j^i,
                                ref_picture, pix_op,
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
                }
3542
                pix_op = s->dsp.avg_pixels_tab;
3543
            }
3544
        }else{
3545
            for(i=0; i<2; i++){
3546
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3547 3548 3549
                            0, 0, s->picture_structure != i+1,
                            ref_picture, pix_op,
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3550

3551
                // after put we make avg of the same block
3552
                pix_op=s->dsp.avg_pixels_tab;
3553

3554 3555
                //opposite parity is always in the same frame if this is second field
                if(!s->first_field){
3556
                    ref_picture = s->current_picture_ptr->data;
3557
                }
3558
            }
3559 3560
        }
    break;
3561
    default: assert(0);
Fabrice Bellard's avatar
Fabrice Bellard committed
3562 3563 3564
    }
}

3565
/**
Diego Biurrun's avatar
Diego Biurrun committed
3566
 * motion compensation of a single macroblock
3567 3568 3569 3570 3571 3572 3573 3574 3575
 * @param s context
 * @param dest_y luma destination pointer
 * @param dest_cb chroma cb/u destination pointer
 * @param dest_cr chroma cr/v destination pointer
 * @param dir direction (0->forward, 1->backward)
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
 * @param pic_op halfpel motion compensation function (average or put normally)
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
 */
3576
static inline void MPV_motion_lowres(MpegEncContext *s,
3577
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3578
                              int dir, uint8_t **ref_picture,
3579 3580
                              h264_chroma_mc_func *pix_op)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
3581
    int mx, my;
3582 3583
    int mb_x, mb_y, i;
    const int lowres= s->avctx->lowres;
3584
    const int block_s= 8>>lowres;
3585 3586 3587 3588 3589 3590

    mb_x = s->mb_x;
    mb_y = s->mb_y;

    switch(s->mv_type) {
    case MV_TYPE_16X16:
3591
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3592 3593 3594 3595
                    0, 0, 0,
                    ref_picture, pix_op,
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
3596
    case MV_TYPE_8X8:
3597 3598 3599
        mx = 0;
        my = 0;
            for(i=0;i<4;i++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
3600
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3601
                            ref_picture[0], 0, 0,
Michael Niedermayer's avatar
Michael Niedermayer committed
3602
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3603
                            s->width, s->height, s->linesize,
Michael Niedermayer's avatar
Michael Niedermayer committed
3604 3605
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
                            block_s, block_s, pix_op,
3606 3607 3608 3609 3610 3611 3612
                            s->mv[dir][i][0], s->mv[dir][i][1]);

                mx += s->mv[dir][i][0];
                my += s->mv[dir][i][1];
            }

        if(!(s->flags&CODEC_FLAG_GRAY))
Michael Niedermayer's avatar
Michael Niedermayer committed
3613 3614
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
        break;
3615 3616
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
3617
            /* top field */
3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                        1, 0, s->field_select[dir][0],
                        ref_picture, pix_op,
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
            /* bottom field */
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                        1, 1, s->field_select[dir][1],
                        ref_picture, pix_op,
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
        } else {
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
                ref_picture= s->current_picture_ptr->data;
3630
            }
3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645

            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                        0, 0, s->field_select[dir][0],
                        ref_picture, pix_op,
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
        }
        break;
    case MV_TYPE_16X8:
        for(i=0; i<2; i++){
            uint8_t ** ref2picture;

            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
                ref2picture= ref_picture;
            }else{
                ref2picture= s->current_picture_ptr->data;
3646
            }
3647

3648
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3649 3650 3651
                        0, 0, s->field_select[dir][i],
                        ref2picture, pix_op,
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3652

3653 3654 3655
            dest_y += 2*block_s*s->linesize;
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3656
        }
3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671
        break;
    case MV_TYPE_DMV:
        if(s->picture_structure == PICT_FRAME){
            for(i=0; i<2; i++){
                int j;
                for(j=0; j<2; j++){
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                                1, j, j^i,
                                ref_picture, pix_op,
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
                }
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
            }
        }else{
            for(i=0; i<2; i++){
3672
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3673 3674 3675 3676 3677 3678 3679 3680 3681
                            0, 0, s->picture_structure != i+1,
                            ref_picture, pix_op,
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);

                // after put we make avg of the same block
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;

                //opposite parity is always in the same frame if this is second field
                if(!s->first_field){
3682
                    ref_picture = s->current_picture_ptr->data;
3683 3684 3685 3686 3687 3688
                }
            }
        }
    break;
    default: assert(0);
    }
3689
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3690 3691

/* put block[] to dest[] */
3692
static inline void put_dct(MpegEncContext *s,
3693
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
Fabrice Bellard's avatar
Fabrice Bellard committed
3694
{
3695
    s->dct_unquantize_intra(s, block, i, qscale);
3696
    s->dsp.idct_put (dest, line_size, block);
Fabrice Bellard's avatar
Fabrice Bellard committed
3697 3698 3699
}

/* add block[] to dest[] */
3700
static inline void add_dct(MpegEncContext *s,
3701
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
3702
{
3703
    if (s->block_last_index[i] >= 0) {
3704
        s->dsp.idct_add (dest, line_size, block);
3705 3706
    }
}
3707

3708
static inline void add_dequant_dct(MpegEncContext *s,
Michael Niedermayer's avatar
Michael Niedermayer committed
3709
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3710
{
Fabrice Bellard's avatar
Fabrice Bellard committed
3711
    if (s->block_last_index[i] >= 0) {
3712
        s->dct_unquantize_inter(s, block, i, qscale);
3713

3714
        s->dsp.idct_add (dest, line_size, block);
Fabrice Bellard's avatar
Fabrice Bellard committed
3715 3716 3717
    }
}

3718 3719 3720 3721 3722
/**
 * cleans dc, ac, coded_block for the current non intra MB
 */
void ff_clean_intra_table_entries(MpegEncContext *s)
{
3723
    int wrap = s->b8_stride;
3724
    int xy = s->block_index[0];
3725 3726 3727

    s->dc_val[0][xy           ] =
    s->dc_val[0][xy + 1       ] =
3728 3729 3730
    s->dc_val[0][xy     + wrap] =
    s->dc_val[0][xy + 1 + wrap] = 1024;
    /* ac pred */
3731 3732
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3733 3734 3735 3736 3737 3738 3739
    if (s->msmpeg4_version>=3) {
        s->coded_block[xy           ] =
        s->coded_block[xy + 1       ] =
        s->coded_block[xy     + wrap] =
        s->coded_block[xy + 1 + wrap] = 0;
    }
    /* chroma */
3740 3741
    wrap = s->mb_stride;
    xy = s->mb_x + s->mb_y * wrap;
3742 3743 3744
    s->dc_val[1][xy] =
    s->dc_val[2][xy] = 1024;
    /* ac pred */
3745 3746
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3747

3748
    s->mbintra_table[xy]= 0;
3749 3750
}

Fabrice Bellard's avatar
Fabrice Bellard committed
3751 3752 3753 3754 3755 3756 3757 3758 3759 3760
/* generic function called after a macroblock has been parsed by the
   decoder or after it has been encoded by the encoder.

   Important variables used:
   s->mb_intra : true if intra macroblock
   s->mv_dir   : motion vector direction
   s->mv_type  : motion vector type
   s->mv       : motion vector
   s->interlaced_dct : true if interlaced dct used (mpeg2)
 */
3761
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
Fabrice Bellard's avatar
Fabrice Bellard committed
3762
{
3763
    int mb_x, mb_y;
3764
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
3765 3766
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration){
3767
        XVMC_decode_mb(s);//xvmc uses pblocks
Ivan Kalvachev's avatar
Ivan Kalvachev committed
3768 3769 3770
        return;
    }
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3771 3772 3773 3774

    mb_x = s->mb_x;
    mb_y = s->mb_y;

3775 3776 3777 3778 3779 3780 3781 3782 3783
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
       /* save DCT coefficients */
       int i,j;
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
       for(i=0; i<6; i++)
           for(j=0; j<64; j++)
               *dct++ = block[i][s->dsp.idct_permutation[j]];
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
3784
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3785

Fabrice Bellard's avatar
Fabrice Bellard committed
3786 3787
    /* update DC predictors for P macroblocks */
    if (!s->mb_intra) {
3788
        if (s->h263_pred || s->h263_aic) {
3789
            if(s->mbintra_table[mb_xy])
3790
                ff_clean_intra_table_entries(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
3791
        } else {
3792 3793
            s->last_dc[0] =
            s->last_dc[1] =
Fabrice Bellard's avatar
Fabrice Bellard committed
3794 3795 3796
            s->last_dc[2] = 128 << s->intra_dc_precision;
        }
    }
3797
    else if (s->h263_pred || s->h263_aic)
3798
        s->mbintra_table[mb_xy]=1;
3799

3800
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3801
        uint8_t *dest_y, *dest_cb, *dest_cr;
3802
        int dct_linesize, dct_offset;
Michael Niedermayer's avatar
Michael Niedermayer committed
3803 3804
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
3805
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3806
        const int uvlinesize= s->current_picture.linesize[1];
3807 3808
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3809

Michael Niedermayer's avatar
Michael Niedermayer committed
3810 3811 3812
        /* avoid copy if macroblock skipped in last frame too */
        /* skip only during decoding as we might trash the buffers during encoding a bit */
        if(!s->encoding){
3813
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
Michael Niedermayer's avatar
Michael Niedermayer committed
3814
            const int age= s->current_picture.age;
Michael Niedermayer's avatar
Michael Niedermayer committed
3815

Michael Niedermayer's avatar
Michael Niedermayer committed
3816 3817
            assert(age);

3818 3819
            if (s->mb_skipped) {
                s->mb_skipped= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
3820
                assert(s->pict_type!=I_TYPE);
3821

3822
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
Michael Niedermayer's avatar
Michael Niedermayer committed
3823 3824
                if(*mbskip_ptr >99) *mbskip_ptr= 99;

Michael Niedermayer's avatar
Michael Niedermayer committed
3825
                /* if previous was skipped too, then nothing to do !  */
3826 3827
                if (*mbskip_ptr >= age && s->current_picture.reference){
                    return;
Michael Niedermayer's avatar
Michael Niedermayer committed
3828
                }
3829 3830 3831 3832
            } else if(!s->current_picture.reference){
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
            } else{
3833 3834
                *mbskip_ptr = 0; /* not skipped */
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
3835
        }
3836

3837
        dct_linesize = linesize << s->interlaced_dct;
3838
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3839

3840 3841 3842 3843 3844
        if(readable){
            dest_y=  s->dest[0];
            dest_cb= s->dest[1];
            dest_cr= s->dest[2];
        }else{
3845
            dest_y = s->b_scratchpad;
3846
            dest_cb= s->b_scratchpad+16*linesize;
3847
            dest_cr= s->b_scratchpad+32*linesize;
3848
        }
3849

Fabrice Bellard's avatar
Fabrice Bellard committed
3850 3851
        if (!s->mb_intra) {
            /* motion handling */
3852
            /* decoding or more than one mb_type (MC was already done otherwise) */
3853
            if(!s->encoding){
3854 3855
                if(lowres_flag){
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
Fabrice Bellard's avatar
Fabrice Bellard committed
3856

3857 3858 3859 3860 3861 3862 3863 3864
                    if (s->mv_dir & MV_DIR_FORWARD) {
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
                    }
                    if (s->mv_dir & MV_DIR_BACKWARD) {
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
                    }
                }else{
3865
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879
                        op_pix = s->dsp.put_pixels_tab;
                        op_qpix= s->dsp.put_qpel_pixels_tab;
                    }else{
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
                    }
                    if (s->mv_dir & MV_DIR_FORWARD) {
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
                        op_pix = s->dsp.avg_pixels_tab;
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
                    }
                    if (s->mv_dir & MV_DIR_BACKWARD) {
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
                    }
3880
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
3881 3882
            }

3883
            /* skip dequant / idct if we are really late ;) */
Michael Niedermayer's avatar
Michael Niedermayer committed
3884 3885 3886 3887 3888 3889 3890
            if(s->hurry_up>1) goto skip_idct;
            if(s->avctx->skip_idct){
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
                    goto skip_idct;
            }
3891

Fabrice Bellard's avatar
Fabrice Bellard committed
3892
            /* add dct residue */
Michael Niedermayer's avatar
Michael Niedermayer committed
3893
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3894
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3895 3896 3897 3898
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3899

3900
                if(!(s->flags&CODEC_FLAG_GRAY)){
Michael Niedermayer's avatar
Michael Niedermayer committed
3901 3902
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3903
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
3904
            } else if(s->codec_id != CODEC_ID_WMV2){
3905 3906 3907 3908
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
Fabrice Bellard's avatar
Fabrice Bellard committed
3909

3910
                if(!(s->flags&CODEC_FLAG_GRAY)){
3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931
                    if(s->chroma_y_shift){//Chroma420
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
                    }else{
                        //chroma422
                        dct_linesize = uvlinesize << s->interlaced_dct;
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;

                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
                        if(!s->chroma_x_shift){//Chroma444
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
                        }
                    }
                }//fi gray
            }
3932
            else{
Michael Niedermayer's avatar
Michael Niedermayer committed
3933
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3934
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3935 3936
        } else {
            /* dct only in intra block */
Michael Niedermayer's avatar
Michael Niedermayer committed
3937
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3938 3939 3940 3941
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3942 3943

                if(!(s->flags&CODEC_FLAG_GRAY)){
3944 3945
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3946 3947
                }
            }else{
3948 3949 3950 3951
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3952 3953

                if(!(s->flags&CODEC_FLAG_GRAY)){
3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973
                    if(s->chroma_y_shift){
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
                    }else{

                        dct_linesize = uvlinesize << s->interlaced_dct;
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;

                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
                        if(!s->chroma_x_shift){//Chroma444
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
                        }
                    }
                }//gray
3974
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3975
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
3976
skip_idct:
3977 3978
        if(!readable){
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3979 3980
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3981
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3982 3983 3984
    }
}

3985 3986 3987 3988 3989
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
    else                  MPV_decode_mb_internal(s, block, 0);
}

3990 3991
#ifdef CONFIG_ENCODERS

3992
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007
{
    static const char tab[64]=
        {3,2,2,1,1,1,1,1,
         1,1,1,1,1,1,1,1,
         1,1,1,1,1,1,1,1,
         0,0,0,0,0,0,0,0,
         0,0,0,0,0,0,0,0,
         0,0,0,0,0,0,0,0,
         0,0,0,0,0,0,0,0,
         0,0,0,0,0,0,0,0};
    int score=0;
    int run=0;
    int i;
    DCTELEM *block= s->block[n];
    const int last_index= s->block_last_index[n];
4008
    int skip_dc;
4009

4010 4011 4012
    if(threshold<0){
        skip_dc=0;
        threshold= -threshold;
4013 4014
    }else
        skip_dc=1;
4015

4016 4017 4018 4019
    /* are all which we could set to zero are allready zero? */
    if(last_index<=skip_dc - 1) return;

    for(i=0; i<=last_index; i++){
4020
        const int j = s->intra_scantable.permutated[i];
4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033
        const int level = ABS(block[j]);
        if(level==1){
            if(skip_dc && i==0) continue;
            score+= tab[run];
            run=0;
        }else if(level>1){
            return;
        }else{
            run++;
        }
    }
    if(score >= threshold) return;
    for(i=skip_dc; i<=last_index; i++){
4034
        const int j = s->intra_scantable.permutated[i];
4035 4036 4037 4038 4039 4040
        block[j]=0;
    }
    if(block[0]) s->block_last_index[n]= 0;
    else         s->block_last_index[n]= -1;
}

4041 4042 4043 4044 4045
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
{
    int i;
    const int maxlevel= s->max_qcoeff;
    const int minlevel= s->min_qcoeff;
4046
    int overflow=0;
4047

4048 4049 4050 4051
    if(s->mb_intra){
        i=1; //skip clipping of intra dc
    }else
        i=0;
4052

4053 4054
    for(;i<=last_index; i++){
        const int j= s->intra_scantable.permutated[i];
4055
        int level = block[j];
4056

4057 4058 4059 4060 4061 4062 4063
        if     (level>maxlevel){
            level=maxlevel;
            overflow++;
        }else if(level<minlevel){
            level=minlevel;
            overflow++;
        }
4064

Michael Niedermayer's avatar
Michael Niedermayer committed
4065
        block[j]= level;
4066
    }
4067

4068
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4069
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4070 4071
}

4072 4073
#endif //CONFIG_ENCODERS

4074 4075 4076 4077 4078
/**
 *
 * @param h is the normal height, this will be reduced automatically if needed for the last row
 */
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
Michael Niedermayer's avatar
Michael Niedermayer committed
4079
    if (s->avctx->draw_horiz_band) {
4080
        AVFrame *src;
Michael Niedermayer's avatar
Michael Niedermayer committed
4081
        int offset[4];
4082

4083 4084 4085 4086 4087 4088
        if(s->picture_structure != PICT_FRAME){
            h <<= 1;
            y <<= 1;
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
        }

4089
        h= FFMIN(h, s->avctx->height - y);
4090

4091
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4092 4093 4094 4095 4096
            src= (AVFrame*)s->current_picture_ptr;
        else if(s->last_picture_ptr)
            src= (AVFrame*)s->last_picture_ptr;
        else
            return;
4097

4098
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
Michael Niedermayer's avatar
Michael Niedermayer committed
4099 4100 4101 4102 4103 4104
            offset[0]=
            offset[1]=
            offset[2]=
            offset[3]= 0;
        }else{
            offset[0]= y * s->linesize;;
4105
            offset[1]=
4106
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
Michael Niedermayer's avatar
Michael Niedermayer committed
4107
            offset[3]= 0;
4108
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4109

Michael Niedermayer's avatar
Michael Niedermayer committed
4110 4111
        emms_c();

4112 4113
        s->avctx->draw_horiz_band(s->avctx, src, offset,
                                  y, s->picture_structure, h);
4114 4115 4116
    }
}

4117
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
Diego Biurrun's avatar
Diego Biurrun committed
4118
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4119
    const int uvlinesize= s->current_picture.linesize[1];
4120
    const int mb_size= 4 - s->avctx->lowres;
4121

4122 4123 4124 4125 4126 4127
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
    s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4128 4129
    //block_index is not used by mpeg2, so it is not affected by chroma_format

4130 4131 4132
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
Michael Niedermayer's avatar
Michael Niedermayer committed
4133

4134 4135
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
    {
4136 4137 4138
        s->dest[0] += s->mb_y *   linesize << mb_size;
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4139
    }
4140 4141
}

4142 4143
#ifdef CONFIG_ENCODERS

4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
    int x, y;
//FIXME optimize
    for(y=0; y<8; y++){
        for(x=0; x<8; x++){
            int x2, y2;
            int sum=0;
            int sqr=0;
            int count=0;

            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
                    int v= ptr[x2 + y2*stride];
                    sum += v;
                    sqr += v*v;
                    count++;
                }
            }
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
        }
    }
}

4167
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
Fabrice Bellard's avatar
Fabrice Bellard committed
4168
{
4169 4170
    int16_t weight[6][64];
    DCTELEM orig[6][64];
4171 4172 4173
    const int mb_x= s->mb_x;
    const int mb_y= s->mb_y;
    int i;
4174
    int skip_dct[6];
4175
    int dct_offset   = s->linesize*8; //default for progressive frames
Michael Niedermayer's avatar
Michael Niedermayer committed
4176 4177
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    int wrap_y, wrap_c;
4178

4179
    for(i=0; i<6; i++) skip_dct[i]=0;
4180

4181
    if(s->adaptive_quant){
4182 4183
        const int last_qp= s->qscale;
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4184

4185 4186
        s->lambda= s->lambda_table[mb_xy];
        update_qscale(s);
4187

4188 4189
        if(!(s->flags&CODEC_FLAG_QP_RD)){
            s->dquant= s->qscale - last_qp;
4190

4191
            if(s->out_format==FMT_H263){
4192
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4193 4194

                if(s->codec_id==CODEC_ID_MPEG4){
4195 4196
                    if(!s->mb_intra){
                        if(s->pict_type == B_TYPE){
4197
                            if(s->dquant&1)
4198 4199 4200 4201 4202 4203 4204
                                s->dquant= (s->dquant/2)*2;
                            if(s->mv_dir&MV_DIRECT)
                                s->dquant= 0;
                        }
                        if(s->mv_type==MV_TYPE_8X8)
                            s->dquant=0;
                    }
4205
                }
4206 4207
            }
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4208
        ff_set_qscale(s, last_qp + s->dquant);
Michael Niedermayer's avatar
Michael Niedermayer committed
4209 4210
    }else if(s->flags&CODEC_FLAG_QP_RD)
        ff_set_qscale(s, s->qscale + s->dquant);
4211

Michael Niedermayer's avatar
Michael Niedermayer committed
4212 4213 4214 4215 4216 4217 4218
    wrap_y = s->linesize;
    wrap_c = s->uvlinesize;
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;

    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4219 4220 4221 4222 4223 4224 4225
        uint8_t *ebuf= s->edge_emu_buffer + 32;
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
        ptr_y= ebuf;
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
        ptr_cb= ebuf+18*wrap_y;
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
        ptr_cr= ebuf+18*wrap_y+8;
Michael Niedermayer's avatar
Michael Niedermayer committed
4226 4227
    }

4228
    if (s->mb_intra) {
4229 4230
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
            int progressive_score, interlaced_score;
4231

4232
            s->interlaced_dct=0;
4233
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4234
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4235 4236

            if(progressive_score > 0){
4237
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4238
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4239 4240
                if(progressive_score > interlaced_score){
                    s->interlaced_dct=1;
4241

4242 4243 4244 4245
                    dct_offset= wrap_y;
                    wrap_y<<=1;
                }
            }
4246
        }
4247

4248
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4249 4250 4251
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4252

4253 4254 4255 4256
        if(s->flags&CODEC_FLAG_GRAY){
            skip_dct[4]= 1;
            skip_dct[5]= 1;
        }else{
4257
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4258 4259
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
        }
4260
    }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
4261 4262
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
4263
        uint8_t *dest_y, *dest_cb, *dest_cr;
4264

4265 4266 4267
        dest_y  = s->dest[0];
        dest_cb = s->dest[1];
        dest_cr = s->dest[2];
4268

4269
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4270
            op_pix = s->dsp.put_pixels_tab;
4271
            op_qpix= s->dsp.put_qpel_pixels_tab;
Michael Niedermayer's avatar
Michael Niedermayer committed
4272
        }else{
4273 4274
            op_pix = s->dsp.put_no_rnd_pixels_tab;
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4275 4276 4277
        }

        if (s->mv_dir & MV_DIR_FORWARD) {
Michael Niedermayer's avatar
Michael Niedermayer committed
4278
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4279 4280
            op_pix = s->dsp.avg_pixels_tab;
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4281 4282
        }
        if (s->mv_dir & MV_DIR_BACKWARD) {
Michael Niedermayer's avatar
Michael Niedermayer committed
4283
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4284
        }
4285

4286 4287
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
            int progressive_score, interlaced_score;
4288 4289

            s->interlaced_dct=0;
4290
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4291
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4292

4293 4294 4295
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;

            if(progressive_score>0){
4296
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4297
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4298

4299 4300
                if(progressive_score > interlaced_score){
                    s->interlaced_dct=1;
4301

4302 4303 4304 4305
                    dct_offset= wrap_y;
                    wrap_y<<=1;
                }
            }
4306
        }
4307

4308
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4309 4310 4311
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4312

4313 4314 4315 4316
        if(s->flags&CODEC_FLAG_GRAY){
            skip_dct[4]= 1;
            skip_dct[5]= 1;
        }else{
4317 4318
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4319
        }
4320
        /* pre quantization */
4321
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4322
            //FIXME optimize
4323
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4324 4325 4326 4327 4328
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4329
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4330
    }
4331

Michael Niedermayer's avatar
Michael Niedermayer committed
4332 4333 4334 4335 4336 4337 4338 4339
    if(s->avctx->quantizer_noise_shaping){
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4340
    }
4341

4342
    /* DCT & quantize */
Michael Niedermayer's avatar
Michael Niedermayer committed
4343 4344
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
    {
4345
        for(i=0;i<6;i++) {
4346 4347
            if(!skip_dct[i]){
                int overflow;
4348
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4349
            // FIXME we could decide to change to quantizer instead of clipping
4350 4351
            // JS: I don't think that would be a good idea it could lower quality instead
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4352 4353 4354
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
            }else
                s->block_last_index[i]= -1;
4355
        }
4356 4357 4358 4359 4360 4361 4362
        if(s->avctx->quantizer_noise_shaping){
            for(i=0;i<6;i++) {
                if(!skip_dct[i]){
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
                }
            }
        }
4363

4364 4365
        if(s->luma_elim_threshold && !s->mb_intra)
            for(i=0; i<4; i++)
4366
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4367 4368
        if(s->chroma_elim_threshold && !s->mb_intra)
            for(i=4; i<6; i++)
4369
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4370 4371 4372 4373 4374 4375 4376

        if(s->flags & CODEC_FLAG_CBP_RD){
            for(i=0;i<6;i++) {
                if(s->block_last_index[i] == -1)
                    s->coded_score[i]= INT_MAX/256;
            }
        }
4377 4378
    }

4379 4380 4381 4382
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
        s->block_last_index[4]=
        s->block_last_index[5]= 0;
        s->block[4][0]=
Michael Niedermayer's avatar
Michael Niedermayer committed
4383
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4384 4385
    }

4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398
    //non c quantize code returns incorrect block_last_index FIXME
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
        for(i=0; i<6; i++){
            int j;
            if(s->block_last_index[i]>0){
                for(j=63; j>0; j--){
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
                }
                s->block_last_index[i]= j;
            }
        }
    }

4399
    /* huffman encode */
Michael Niedermayer's avatar
Michael Niedermayer committed
4400 4401
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
    case CODEC_ID_MPEG1VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
4402
    case CODEC_ID_MPEG2VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
4403 4404 4405 4406 4407 4408 4409 4410 4411
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
    case CODEC_ID_MPEG4:
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
    case CODEC_ID_MSMPEG4V2:
    case CODEC_ID_MSMPEG4V3:
    case CODEC_ID_WMV1:
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
    case CODEC_ID_WMV2:
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4412
#ifdef CONFIG_H261_ENCODER
4413 4414
    case CODEC_ID_H261:
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4415
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
4416 4417
    case CODEC_ID_H263:
    case CODEC_ID_H263P:
4418
    case CODEC_ID_FLV1:
Michael Niedermayer's avatar
Michael Niedermayer committed
4419
    case CODEC_ID_RV10:
Michael Niedermayer's avatar
Michael Niedermayer committed
4420
    case CODEC_ID_RV20:
Michael Niedermayer's avatar
Michael Niedermayer committed
4421
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4422 4423
    case CODEC_ID_MJPEG:
        mjpeg_encode_mb(s, s->block); break;
Michael Niedermayer's avatar
Michael Niedermayer committed
4424 4425
    default:
        assert(0);
4426 4427 4428
    }
}

4429 4430
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
4431 4432 4433
void ff_mpeg_flush(AVCodecContext *avctx){
    int i;
    MpegEncContext *s = avctx->priv_data;
4434 4435

    if(s==NULL || s->picture==NULL)
4436
        return;
4437

Michael Niedermayer's avatar
Michael Niedermayer committed
4438 4439 4440 4441 4442
    for(i=0; i<MAX_PICTURE_COUNT; i++){
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
    }
4443
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4444

Michael Niedermayer's avatar
Michael Niedermayer committed
4445
    s->mb_x= s->mb_y= 0;
4446

4447 4448 4449 4450 4451 4452
    s->parse_context.state= -1;
    s->parse_context.frame_start_found= 0;
    s->parse_context.overread= 0;
    s->parse_context.overread_index= 0;
    s->parse_context.index= 0;
    s->parse_context.last_index= 0;
4453
    s->bitstream_buffer_size=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
4454 4455
}

4456
#ifdef CONFIG_ENCODERS
4457
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4458
{
4459
    const uint16_t *srcw= (uint16_t*)src;
4460
    int words= length>>4;
4461 4462 4463
    int bits= length&15;
    int i;

4464
    if(length==0) return;
4465

4466 4467 4468 4469
    if(words < 16){
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
    }else if(put_bits_count(pb)&7){
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4470
    }else{
4471 4472
        for(i=0; put_bits_count(pb)&31; i++)
            put_bits(pb, 8, src[i]);
4473
        flush_put_bits(pb);
4474 4475
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
        skip_put_bytes(pb, 2*words-i);
4476
    }
4477

4478
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4479 4480
}

4481
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4482 4483 4484 4485 4486
    int i;

    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?

    /* mpeg1 */
4487
    d->mb_skip_run= s->mb_skip_run;
4488 4489
    for(i=0; i<3; i++)
        d->last_dc[i]= s->last_dc[i];
4490

4491 4492 4493 4494 4495
    /* statistics */
    d->mv_bits= s->mv_bits;
    d->i_tex_bits= s->i_tex_bits;
    d->p_tex_bits= s->p_tex_bits;
    d->i_count= s->i_count;
4496 4497
    d->f_count= s->f_count;
    d->b_count= s->b_count;
4498 4499
    d->skip_count= s->skip_count;
    d->misc_bits= s->misc_bits;
4500
    d->last_bits= 0;
4501

4502
    d->mb_skipped= 0;
4503
    d->qscale= s->qscale;
4504
    d->dquant= s->dquant;
4505 4506
}

4507
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4508 4509
    int i;

4510
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4511
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4512

4513
    /* mpeg1 */
4514
    d->mb_skip_run= s->mb_skip_run;
4515 4516
    for(i=0; i<3; i++)
        d->last_dc[i]= s->last_dc[i];
4517

4518 4519 4520 4521 4522
    /* statistics */
    d->mv_bits= s->mv_bits;
    d->i_tex_bits= s->i_tex_bits;
    d->p_tex_bits= s->p_tex_bits;
    d->i_count= s->i_count;
4523 4524
    d->f_count= s->f_count;
    d->b_count= s->b_count;
4525 4526 4527 4528
    d->skip_count= s->skip_count;
    d->misc_bits= s->misc_bits;

    d->mb_intra= s->mb_intra;
4529
    d->mb_skipped= s->mb_skipped;
4530 4531 4532
    d->mv_type= s->mv_type;
    d->mv_dir= s->mv_dir;
    d->pb= s->pb;
4533 4534 4535 4536
    if(s->data_partitioning){
        d->pb2= s->pb2;
        d->tex_pb= s->tex_pb;
    }
4537 4538 4539
    d->block= s->block;
    for(i=0; i<6; i++)
        d->block_last_index[i]= s->block_last_index[i];
4540
    d->interlaced_dct= s->interlaced_dct;
4541
    d->qscale= s->qscale;
4542 4543
}

4544
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4545 4546 4547
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
                           int *dmin, int *next_block, int motion_x, int motion_y)
{
4548 4549
    int score;
    uint8_t *dest_backup[3];
4550

4551 4552 4553 4554 4555 4556 4557 4558
    copy_context_before_encode(s, backup, type);

    s->block= s->blocks[*next_block];
    s->pb= pb[*next_block];
    if(s->data_partitioning){
        s->pb2   = pb2   [*next_block];
        s->tex_pb= tex_pb[*next_block];
    }
4559

4560 4561
    if(*next_block){
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4562 4563 4564 4565
        s->dest[0] = s->rd_scratchpad;
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
        assert(s->linesize >= 32); //FIXME
4566
    }
4567 4568

    encode_mb(s, motion_x, motion_y);
4569

4570
    score= put_bits_count(&s->pb);
4571
    if(s->data_partitioning){
4572 4573
        score+= put_bits_count(&s->pb2);
        score+= put_bits_count(&s->tex_pb);
4574
    }
4575

4576 4577
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
        MPV_decode_mb(s, s->block);
4578

4579 4580
        score *= s->lambda2;
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4581
    }
4582

4583 4584 4585 4586 4587 4588
    if(*next_block){
        memcpy(s->dest, dest_backup, sizeof(s->dest));
    }

    if(score<*dmin){
        *dmin= score;
4589 4590 4591 4592 4593
        *next_block^=1;

        copy_context_after_encode(best, s, type);
    }
}
4594

4595
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4596 4597 4598
    uint32_t *sq = squareTbl + 256;
    int acc=0;
    int x,y;
4599 4600

    if(w==16 && h==16)
4601
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
4602
    else if(w==8 && h==8)
4603
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4604

4605 4606 4607
    for(y=0; y<h; y++){
        for(x=0; x<w; x++){
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4608
        }
4609
    }
4610

Michael Niedermayer's avatar
Michael Niedermayer committed
4611
    assert(acc>=0);
4612

4613 4614
    return acc;
}
4615

4616 4617 4618 4619 4620 4621 4622 4623
static int sse_mb(MpegEncContext *s){
    int w= 16;
    int h= 16;

    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;

    if(w==16 && h==16)
4624
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
Michael Niedermayer's avatar
Michael Niedermayer committed
4625 4626 4627
        return  s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
               +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
               +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4628
      }else{
4629 4630 4631
        return  s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
               +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
               +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4632
      }
4633 4634 4635 4636 4637 4638
    else
        return  sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
               +sse(s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
               +sse(s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
}

4639 4640 4641
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;

4642

4643 4644 4645 4646 4647 4648 4649 4650 4651
    s->me.pre_pass=1;
    s->me.dia_size= s->avctx->pre_dia_size;
    s->first_slice_line=1;
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
        }
        s->first_slice_line=0;
    }
4652

4653
    s->me.pre_pass=0;
4654

4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670
    return 0;
}

static int estimate_motion_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;

    s->me.dia_size= s->avctx->dia_size;
    s->first_slice_line=1;
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
        s->mb_x=0; //for block init below
        ff_init_block_index(s);
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
            s->block_index[0]+=2;
            s->block_index[1]+=2;
            s->block_index[2]+=2;
            s->block_index[3]+=2;
4671

4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682
            /* compute motion vector & mb_type and store in context */
            if(s->pict_type==B_TYPE)
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
            else
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
        }
        s->first_slice_line=0;
    }
    return 0;
}

4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693
static int mb_var_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;
    int mb_x, mb_y;

    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
            int xx = mb_x * 16;
            int yy = mb_y * 16;
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
            int varc;
            int sum = s->dsp.pix_sum(pix, s->linesize);
4694

4695 4696 4697 4698
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;

            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4699
            s->me.mb_var_sum_temp    += varc;
4700 4701
        }
    }
4702
    return 0;
4703 4704
}

4705 4706 4707 4708 4709
static void write_slice_end(MpegEncContext *s){
    if(s->codec_id==CODEC_ID_MPEG4){
        if(s->partitioned_frame){
            ff_mpeg4_merge_partitions(s);
        }
4710

4711 4712 4713 4714 4715 4716 4717
        ff_mpeg4_stuffing(&s->pb);
    }else if(s->out_format == FMT_MJPEG){
        ff_mjpeg_stuffing(&s->pb);
    }

    align_put_bits(&s->pb);
    flush_put_bits(&s->pb);
4718

4719 4720
    if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
        s->misc_bits+= get_bits_diff(s);
4721 4722 4723 4724
}

static int encode_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;
4725
    int mb_x, mb_y, pdif = 0;
4726
    int i, j;
4727
    MpegEncContext best_s, backup_s;
4728 4729 4730
    uint8_t bit_buf[2][MAX_MB_BYTES];
    uint8_t bit_buf2[2][MAX_MB_BYTES];
    uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4731
    PutBitContext pb[2], pb2[2], tex_pb[2];
4732
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4733 4734

    for(i=0; i<2; i++){
4735 4736 4737
        init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
        init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
        init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4738
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
4739

4740 4741 4742 4743 4744 4745 4746 4747 4748
    s->last_bits= put_bits_count(&s->pb);
    s->mv_bits=0;
    s->misc_bits=0;
    s->i_tex_bits=0;
    s->p_tex_bits=0;
    s->i_count=0;
    s->f_count=0;
    s->b_count=0;
    s->skip_count=0;
4749

4750 4751 4752
    for(i=0; i<3; i++){
        /* init last dc values */
        /* note: quant matrix value (8) is implied here */
4753
        s->last_dc[i] = 128 << s->intra_dc_precision;
4754

4755
        s->current_picture.error[i] = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
4756
    }
4757 4758
    s->mb_skip_run = 0;
    memset(s->last_mv, 0, sizeof(s->last_mv));
4759

4760
    s->last_mv_dir = 0;
4761

4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
    switch(s->codec_id){
    case CODEC_ID_H263:
    case CODEC_ID_H263P:
    case CODEC_ID_FLV1:
        s->gob_index = ff_h263_get_gob_height(s);
        break;
    case CODEC_ID_MPEG4:
        if(s->partitioned_frame)
            ff_mpeg4_init_partitions(s);
        break;
4772
    }
4773

4774
    s->resync_mb_x=0;
4775
    s->resync_mb_y=0;
4776 4777 4778 4779 4780 4781
    s->first_slice_line = 1;
    s->ptr_lastgob = s->pb.buf;
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
//    printf("row %d at %X\n", s->mb_y, (int)s);
        s->mb_x=0;
        s->mb_y= mb_y;
Michael Niedermayer's avatar
Michael Niedermayer committed
4782

4783 4784
        ff_set_qscale(s, s->qscale);
        ff_init_block_index(s);
4785

4786
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4787
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4788 4789 4790 4791
            int mb_type= s->mb_type[xy];
//            int d;
            int dmin= INT_MAX;
            int dir;
4792

4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
                return -1;
            }
            if(s->data_partitioning){
                if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
                   || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
                    av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
                    return -1;
                }
            }

4805
            s->mb_x = mb_x;
4806
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4807 4808
            ff_update_block_index(s);

4809
#ifdef CONFIG_H261_ENCODER
4810 4811 4812
            if(s->codec_id == CODEC_ID_H261){
                ff_h261_reorder_mb_index(s);
                xy= s->mb_y*s->mb_stride + s->mb_x;
4813
                mb_type= s->mb_type[xy];
4814
            }
4815
#endif
4816

4817 4818 4819
            /* write gob / video packet header  */
            if(s->rtp_mode){
                int current_packet_size, is_gob_start;
4820

4821
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4822 4823 4824

                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;

4825
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4826

4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837
                switch(s->codec_id){
                case CODEC_ID_H263:
                case CODEC_ID_H263P:
                    if(!s->h263_slice_structured)
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
                    break;
                case CODEC_ID_MPEG2VIDEO:
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
                case CODEC_ID_MPEG1VIDEO:
                    if(s->mb_skip_run) is_gob_start=0;
                    break;
4838
                }
4839

4840 4841 4842
                if(is_gob_start){
                    if(s->start_mb_y != mb_y || mb_x!=0){
                        write_slice_end(s);
4843

4844 4845
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
                            ff_mpeg4_init_partitions(s);
4846 4847
                        }
                    }
4848

4849
                    assert((put_bits_count(&s->pb)&7) == 0);
4850
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4851

4852
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4853
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4854 4855 4856 4857 4858 4859 4860 4861 4862
                        int d= 100 / s->avctx->error_rate;
                        if(r % d == 0){
                            current_packet_size=0;
#ifndef ALT_BITSTREAM_WRITER
                            s->pb.buf_ptr= s->ptr_lastgob;
#endif
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
                        }
                    }
4863 4864 4865 4866 4867

                    if (s->avctx->rtp_callback){
                        int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
                    }
4868

4869 4870
                    switch(s->codec_id){
                    case CODEC_ID_MPEG4:
4871 4872
                        ff_mpeg4_encode_video_packet_header(s);
                        ff_mpeg4_clean_buffers(s);
4873 4874 4875
                    break;
                    case CODEC_ID_MPEG1VIDEO:
                    case CODEC_ID_MPEG2VIDEO:
4876 4877
                        ff_mpeg1_encode_slice_header(s);
                        ff_mpeg1_clean_buffers(s);
4878 4879 4880
                    break;
                    case CODEC_ID_H263:
                    case CODEC_ID_H263P:
4881
                        h263_encode_gob_header(s, mb_y);
4882
                    break;
4883 4884
                    }

4885
                    if(s->flags&CODEC_FLAG_PASS1){
4886
                        int bits= put_bits_count(&s->pb);
4887 4888 4889
                        s->misc_bits+= bits - s->last_bits;
                        s->last_bits= bits;
                    }
4890

4891
                    s->ptr_lastgob += current_packet_size;
4892 4893 4894 4895
                    s->first_slice_line=1;
                    s->resync_mb_x=mb_x;
                    s->resync_mb_y=mb_y;
                }
4896
            }
4897

4898 4899
            if(  (s->resync_mb_x   == s->mb_x)
               && s->resync_mb_y+1 == s->mb_y){
4900
                s->first_slice_line=0;
4901 4902
            }

4903
            s->mb_skipped=0;
4904
            s->dquant=0; //only for QP_RD
4905

Michael Niedermayer's avatar
Michael Niedermayer committed
4906
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4907
                int next_block=0;
4908
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4909 4910

                copy_context_before_encode(&backup_s, s, -1);
4911 4912
                backup_s.pb= s->pb;
                best_s.data_partitioning= s->data_partitioning;
4913
                best_s.partitioned_frame= s->partitioned_frame;
4914 4915 4916 4917
                if(s->data_partitioning){
                    backup_s.pb2= s->pb2;
                    backup_s.tex_pb= s->tex_pb;
                }
4918

4919
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4920
                    s->mv_dir = MV_DIR_FORWARD;
Michael Niedermayer's avatar
Michael Niedermayer committed
4921
                    s->mv_type = MV_TYPE_16X16;
4922
                    s->mb_intra= 0;
4923 4924
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4925
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
4926
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4927
                }
4928
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
4929 4930 4931 4932 4933 4934 4935 4936
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(i=0; i<2; i++){
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
                    }
4937
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
4938 4939
                                 &dmin, &next_block, 0, 0);
                }
4940
                if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
4941 4942 4943 4944 4945
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_16X16;
                    s->mb_intra= 0;
                    s->mv[0][0][0] = 0;
                    s->mv[0][0][1] = 0;
4946
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
4947
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
Fabrice Bellard's avatar
Fabrice Bellard committed
4948
                }
4949
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
4950
                    s->mv_dir = MV_DIR_FORWARD;
Michael Niedermayer's avatar
Michael Niedermayer committed
4951 4952 4953
                    s->mv_type = MV_TYPE_8X8;
                    s->mb_intra= 0;
                    for(i=0; i<4; i++){
4954 4955
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
Michael Niedermayer's avatar
Michael Niedermayer committed
4956
                    }
4957
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
4958
                                 &dmin, &next_block, 0, 0);
4959
                }
4960
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4961 4962 4963 4964 4965
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_16X16;
                    s->mb_intra= 0;
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4966
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
4967
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4968
                }
4969
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4970 4971 4972 4973 4974
                    s->mv_dir = MV_DIR_BACKWARD;
                    s->mv_type = MV_TYPE_16X16;
                    s->mb_intra= 0;
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4975
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
4976
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4977
                }
4978
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4979 4980 4981 4982 4983 4984 4985
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
                    s->mv_type = MV_TYPE_16X16;
                    s->mb_intra= 0;
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4986
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
4987
                                 &dmin, &next_block, 0, 0);
4988
                }
4989
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
Michael Niedermayer's avatar
Michael Niedermayer committed
4990 4991
                    int mx= s->b_direct_mv_table[xy][0];
                    int my= s->b_direct_mv_table[xy][1];
4992

4993 4994
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
4995
                    ff_mpeg4_set_direct_mv(s, mx, my);
4996
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
Michael Niedermayer's avatar
Michael Niedermayer committed
4997
                                 &dmin, &next_block, mx, my);
Michael Niedermayer's avatar
Michael Niedermayer committed
4998
                }
4999
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5000 5001 5002 5003 5004 5005 5006 5007
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(i=0; i<2; i++){
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
                    }
5008
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5009 5010
                                 &dmin, &next_block, 0, 0);
                }
5011
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5012 5013 5014 5015 5016 5017 5018 5019
                    s->mv_dir = MV_DIR_BACKWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(i=0; i<2; i++){
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
                    }
5020
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5021 5022
                                 &dmin, &next_block, 0, 0);
                }
5023
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5024 5025 5026 5027 5028 5029 5030 5031 5032 5033
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(dir=0; dir<2; dir++){
                        for(i=0; i<2; i++){
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
                        }
                    }
5034
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5035 5036 5037
                                 &dmin, &next_block, 0, 0);
                }
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5038
                    s->mv_dir = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
5039
                    s->mv_type = MV_TYPE_16X16;
5040 5041 5042
                    s->mb_intra= 1;
                    s->mv[0][0][0] = 0;
                    s->mv[0][0][1] = 0;
5043
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5044
                                 &dmin, &next_block, 0, 0);
5045 5046 5047 5048 5049 5050
                    if(s->h263_pred || s->h263_aic){
                        if(best_s.mb_intra)
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
                        else
                            ff_clean_intra_table_entries(s); //old mode?
                    }
Michael Niedermayer's avatar
Michael Niedermayer committed
5051
                }
5052 5053 5054 5055 5056

                if(s->flags & CODEC_FLAG_QP_RD){
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
                        const int last_qp= backup_s.qscale;
                        int dquant, dir, qp, dc[6];
5057
                        DCTELEM ac[6][16];
5058
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5059

5060 5061 5062 5063 5064 5065 5066 5067 5068 5069
                        assert(backup_s.dquant == 0);

                        //FIXME intra
                        s->mv_dir= best_s.mv_dir;
                        s->mv_type = MV_TYPE_16X16;
                        s->mb_intra= best_s.mb_intra;
                        s->mv[0][0][0] = best_s.mv[0][0][0];
                        s->mv[0][0][1] = best_s.mv[0][0][1];
                        s->mv[1][0][0] = best_s.mv[1][0][0];
                        s->mv[1][0][1] = best_s.mv[1][0][1];
5070

5071
                        dir= s->pict_type == B_TYPE ? 2 : 1;
5072
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
5073 5074 5075 5076 5077
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
                            qp= last_qp + dquant;
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
                                break;
                            backup_s.dquant= dquant;
5078
                            if(s->mb_intra && s->dc_val[0]){
5079 5080 5081 5082
                                for(i=0; i<6; i++){
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
                                }
5083
                            }
5084

5085
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5086
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5087
                            if(best_s.qscale != qp){
5088
                                if(s->mb_intra && s->dc_val[0]){
5089 5090 5091 5092
                                    for(i=0; i<6; i++){
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
                                    }
5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105
                                }
                                if(dir > 0 && dquant==dir){
                                    dquant= 0;
                                    dir= -dir;
                                }else
                                    break;
                            }
                        }
                        qp= best_s.qscale;
                        s->current_picture.qscale_table[xy]= qp;
                    }
                }

5106
                copy_context_after_encode(s, &best_s, -1);
5107

5108
                pb_bits_count= put_bits_count(&s->pb);
5109 5110 5111
                flush_put_bits(&s->pb);
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
                s->pb= backup_s.pb;
5112

5113
                if(s->data_partitioning){
5114
                    pb2_bits_count= put_bits_count(&s->pb2);
5115 5116 5117
                    flush_put_bits(&s->pb2);
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
                    s->pb2= backup_s.pb2;
5118

5119
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
5120 5121 5122 5123
                    flush_put_bits(&s->tex_pb);
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
                    s->tex_pb= backup_s.tex_pb;
                }
5124
                s->last_bits= put_bits_count(&s->pb);
5125

5126 5127
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
                    ff_h263_update_motion_val(s);
5128

5129 5130 5131 5132
                if(next_block==0){ //FIXME 16 vs linesize16
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5133 5134 5135 5136
                }

                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
                    MPV_decode_mb(s, s->block);
Fabrice Bellard's avatar
Fabrice Bellard committed
5137
            } else {
5138 5139
                int motion_x, motion_y;
                s->mv_type=MV_TYPE_16X16;
5140
                // only one MB-Type possible
5141

5142
                switch(mb_type){
5143
                case CANDIDATE_MB_TYPE_INTRA:
5144
                    s->mv_dir = 0;
5145
                    s->mb_intra= 1;
5146 5147
                    motion_x= s->mv[0][0][0] = 0;
                    motion_y= s->mv[0][0][1] = 0;
5148
                    break;
5149
                case CANDIDATE_MB_TYPE_INTER:
5150 5151 5152 5153
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mb_intra= 0;
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5154
                    break;
5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166
                case CANDIDATE_MB_TYPE_INTER_I:
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(i=0; i<2; i++){
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
                    }
                    motion_x = motion_y = 0;
                    break;
                case CANDIDATE_MB_TYPE_INTER4V:
5167 5168 5169 5170
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_8X8;
                    s->mb_intra= 0;
                    for(i=0; i<4; i++){
5171 5172
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5173 5174 5175
                    }
                    motion_x= motion_y= 0;
                    break;
5176
                case CANDIDATE_MB_TYPE_DIRECT:
5177 5178
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
5179 5180
                    motion_x=s->b_direct_mv_table[xy][0];
                    motion_y=s->b_direct_mv_table[xy][1];
Michael Niedermayer's avatar
Michael Niedermayer committed
5181
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5182
                    break;
5183
                case CANDIDATE_MB_TYPE_BIDIR:
5184
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5185
                    s->mb_intra= 0;
5186 5187 5188 5189 5190 5191
                    motion_x=0;
                    motion_y=0;
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5192
                    break;
5193
                case CANDIDATE_MB_TYPE_BACKWARD:
5194 5195 5196 5197
                    s->mv_dir = MV_DIR_BACKWARD;
                    s->mb_intra= 0;
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5198
                    break;
5199
                case CANDIDATE_MB_TYPE_FORWARD:
5200 5201 5202 5203 5204
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mb_intra= 0;
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
//                    printf(" %d %d ", motion_x, motion_y);
5205
                    break;
5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240
                case CANDIDATE_MB_TYPE_FORWARD_I:
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(i=0; i<2; i++){
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
                    }
                    motion_x=motion_y=0;
                    break;
                case CANDIDATE_MB_TYPE_BACKWARD_I:
                    s->mv_dir = MV_DIR_BACKWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(i=0; i<2; i++){
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
                    }
                    motion_x=motion_y=0;
                    break;
                case CANDIDATE_MB_TYPE_BIDIR_I:
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
                    s->mv_type = MV_TYPE_FIELD;
                    s->mb_intra= 0;
                    for(dir=0; dir<2; dir++){
                        for(i=0; i<2; i++){
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
                        }
                    }
                    motion_x=motion_y=0;
                    break;
5241
                default:
5242
                    motion_x=motion_y=0; //gcc warning fix
5243
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5244
                }
5245

5246
                encode_mb(s, motion_x, motion_y);
5247

5248
                // RAL: Update last macroblock type
5249
                s->last_mv_dir = s->mv_dir;
5250

5251 5252
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
                    ff_h263_update_motion_val(s);
5253

5254
                MPV_decode_mb(s, s->block);
Fabrice Bellard's avatar
Fabrice Bellard committed
5255
            }
5256

5257 5258 5259 5260 5261
            /* clean the MV table in IPS frames for direct mode in B frames */
            if(s->mb_intra /* && I,P,S_TYPE */){
                s->p_mv_table[xy][0]=0;
                s->p_mv_table[xy][1]=0;
            }
5262

5263 5264 5265 5266 5267 5268
            if(s->flags&CODEC_FLAG_PSNR){
                int w= 16;
                int h= 16;

                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
Michael Niedermayer's avatar
Michael Niedermayer committed
5269

5270
                s->current_picture.error[0] += sse(
5271 5272
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
                    s->dest[0], w, h, s->linesize);
5273
                s->current_picture.error[1] += sse(
5274 5275
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
5276
                s->current_picture.error[2] += sse(
5277 5278
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
5279
            }
5280 5281 5282 5283
            if(s->loop_filter){
                if(s->out_format == FMT_H263)
                    ff_h263_loop_filter(s);
            }
5284
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
Fabrice Bellard's avatar
Fabrice Bellard committed
5285 5286
        }
    }
5287

5288
    //not beautiful here but we must write it before flushing so it has to be here
5289
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5290
        msmpeg4_encode_ext_header(s);
5291

5292 5293
    write_slice_end(s);

5294
    /* Send the last GOB if RTP */
5295
    if (s->avctx->rtp_callback) {
5296
        int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5297
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5298
        /* Call the RTP callback to send the last GOB */
5299
        emms_c();
5300
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5301
    }
5302 5303 5304 5305 5306 5307

    return 0;
}

#define MERGE(field) dst->field += src->field; src->field=0
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5308 5309 5310
    MERGE(me.scene_change_score);
    MERGE(me.mc_mb_var_sum_temp);
    MERGE(me.mb_var_sum_temp);
5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327
}

static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
    int i;

    MERGE(dct_count[0]); //note, the other dct vars are not part of the context
    MERGE(dct_count[1]);
    MERGE(mv_bits);
    MERGE(i_tex_bits);
    MERGE(p_tex_bits);
    MERGE(i_count);
    MERGE(f_count);
    MERGE(b_count);
    MERGE(skip_count);
    MERGE(misc_bits);
    MERGE(error_count);
    MERGE(padding_bug_score);
5328 5329 5330
    MERGE(current_picture.error[0]);
    MERGE(current_picture.error[1]);
    MERGE(current_picture.error[2]);
5331 5332 5333 5334 5335 5336 5337

    if(dst->avctx->noise_reduction){
        for(i=0; i<64; i++){
            MERGE(dct_error_sum[0][i]);
            MERGE(dct_error_sum[1][i]);
        }
    }
5338

5339 5340 5341 5342 5343 5344
    assert(put_bits_count(&src->pb) % 8 ==0);
    assert(put_bits_count(&dst->pb) % 8 ==0);
    ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
    flush_put_bits(&dst->pb);
}

5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369
static void estimate_qp(MpegEncContext *s, int dry_run){
    if (!s->fixed_qscale)
        s->current_picture_ptr->quality=
        s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);

    if(s->adaptive_quant){
        switch(s->codec_id){
        case CODEC_ID_MPEG4:
            ff_clean_mpeg4_qscales(s);
            break;
        case CODEC_ID_H263:
        case CODEC_ID_H263P:
        case CODEC_ID_FLV1:
            ff_clean_h263_qscales(s);
            break;
        }

        s->lambda= s->lambda_table[0];
        //FIXME broken
    }else
        s->lambda= s->current_picture.quality;
//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
    update_qscale(s);
}

5370 5371
static void encode_picture(MpegEncContext *s, int picture_number)
{
5372
    int i;
5373 5374 5375
    int bits;

    s->picture_number = picture_number;
5376

5377
    /* Reset the average MB variance */
5378 5379
    s->me.mb_var_sum_temp    =
    s->me.mc_mb_var_sum_temp = 0;
5380 5381 5382 5383

    /* we need to initialize some time vars before we can encode b-frames */
    // RAL: Condition added for MPEG1VIDEO
    if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5384
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
5385

5386
    s->me.scene_change_score=0;
5387

5388
//    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5389

5390 5391 5392 5393 5394
    if(s->pict_type==I_TYPE){
        if(s->msmpeg4_version >= 3) s->no_rounding=1;
        else                        s->no_rounding=0;
    }else if(s->pict_type!=B_TYPE){
        if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5395
            s->no_rounding ^= 1;
5396
    }
5397

5398
    if(s->flags & CODEC_FLAG_PASS2){
5399
        estimate_qp(s, 1);
5400 5401
        ff_get_2pass_fcode(s);
    }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5402
        if(s->pict_type==B_TYPE)
5403
            s->lambda= s->last_lambda_for[s->pict_type];
5404
        else
5405
            s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5406 5407
        update_qscale(s);
    }
5408

5409
    s->mb_intra=0; //for the rate distortion & bit compare functions
5410
    for(i=1; i<s->avctx->thread_count; i++){
5411
        ff_update_duplicate_context(s->thread_context[i], s);
5412
    }
5413 5414 5415

    ff_init_me(s);

5416 5417
    /* Estimate motion for every MB */
    if(s->pict_type != I_TYPE){
5418 5419
        s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
        s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5420
        if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5421 5422 5423 5424 5425 5426 5427 5428 5429 5430
            if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
                s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
            }
        }

        s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
    }else /* if(s->pict_type == I_TYPE) */{
        /* I-Frame */
        for(i=0; i<s->mb_stride*s->mb_height; i++)
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5431

5432 5433
        if(!s->fixed_qscale){
            /* finding spatial complexity for I-frame rate control */
5434
            s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5435 5436
        }
    }
5437 5438 5439
    for(i=1; i<s->avctx->thread_count; i++){
        merge_context_after_me(s, s->thread_context[i]);
    }
5440 5441
    s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
    s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
5442 5443
    emms_c();

5444
    if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460
        s->pict_type= I_TYPE;
        for(i=0; i<s->mb_stride*s->mb_height; i++)
            s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
    }

    if(!s->umvplus){
        if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
            s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);

            if(s->flags & CODEC_FLAG_INTERLACED_ME){
                int a,b;
                a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
                b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
                s->f_code= FFMAX(s->f_code, FFMAX(a,b));
            }
5461

5462 5463 5464
            ff_fix_long_p_mvs(s);
            ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
5465
                int j;
5466 5467
                for(i=0; i<2; i++){
                    for(j=0; j<2; j++)
5468
                        ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489
                                        s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
                }
            }
        }

        if(s->pict_type==B_TYPE){
            int a, b;

            a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
            b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
            s->f_code = FFMAX(a, b);

            a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
            b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
            s->b_code = FFMAX(a, b);

            ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
            ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
            ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
            ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
            if(s->flags & CODEC_FLAG_INTERLACED_ME){
5490
                int dir, j;
5491 5492 5493
                for(dir=0; dir<2; dir++){
                    for(i=0; i<2; i++){
                        for(j=0; j<2; j++){
5494
                            int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5495
                                          : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5496
                            ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5497 5498 5499 5500 5501 5502 5503 5504
                                            s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
                        }
                    }
                }
            }
        }
    }

5505
    estimate_qp(s, 0);
5506 5507

    if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5508
        s->qscale= 3; //reduce clipping problems
5509

5510 5511 5512 5513 5514 5515
    if (s->out_format == FMT_MJPEG) {
        /* for mjpeg, we do include qscale in the matrix */
        s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
        for(i=1;i<64;i++){
            int j= s->dsp.idct_permutation[i];

Michael Niedermayer's avatar
Michael Niedermayer committed
5516
            s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3) & 0xFF;
5517
        }
5518
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5519
                       s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5520 5521
        s->qscale= 8;
    }
5522

5523
    //FIXME var duplication
5524
    s->current_picture_ptr->key_frame=
5525
    s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5526
    s->current_picture_ptr->pict_type=
5527 5528 5529 5530 5531 5532 5533 5534 5535 5536
    s->current_picture.pict_type= s->pict_type;

    if(s->current_picture.key_frame)
        s->picture_in_gop_number=0;

    s->last_bits= put_bits_count(&s->pb);
    switch(s->out_format) {
    case FMT_MJPEG:
        mjpeg_picture_header(s);
        break;
5537
#ifdef CONFIG_H261_ENCODER
5538 5539 5540
    case FMT_H261:
        ff_h261_encode_picture_header(s, picture_number);
        break;
5541
#endif
5542
    case FMT_H263:
5543
        if (s->codec_id == CODEC_ID_WMV2)
5544
            ff_wmv2_encode_picture_header(s, picture_number);
5545
        else if (s->h263_msmpeg4)
5546 5547 5548
            msmpeg4_encode_picture_header(s, picture_number);
        else if (s->h263_pred)
            mpeg4_encode_picture_header(s, picture_number);
5549
#ifdef CONFIG_RV10_ENCODER
5550
        else if (s->codec_id == CODEC_ID_RV10)
5551
            rv10_encode_picture_header(s, picture_number);
5552 5553
#endif
#ifdef CONFIG_RV20_ENCODER
5554
        else if (s->codec_id == CODEC_ID_RV20)
Michael Niedermayer's avatar
Michael Niedermayer committed
5555
            rv20_encode_picture_header(s, picture_number);
5556
#endif
5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571
        else if (s->codec_id == CODEC_ID_FLV1)
            ff_flv_encode_picture_header(s, picture_number);
        else
            h263_encode_picture_header(s, picture_number);
        break;
    case FMT_MPEG1:
        mpeg1_encode_picture_header(s, picture_number);
        break;
    case FMT_H264:
        break;
    default:
        assert(0);
    }
    bits= put_bits_count(&s->pb);
    s->header_bits= bits - s->last_bits;
5572

5573 5574 5575 5576 5577 5578 5579 5580
    for(i=1; i<s->avctx->thread_count; i++){
        update_duplicate_context_after_me(s->thread_context[i], s);
    }
    s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
    for(i=1; i<s->avctx->thread_count; i++){
        merge_context_after_encode(s, s->thread_context[i]);
    }
    emms_c();
Fabrice Bellard's avatar
Fabrice Bellard committed
5581 5582
}

5583 5584
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
5585
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5586 5587 5588
    const int intra= s->mb_intra;
    int i;

5589 5590
    s->dct_count[intra]++;

5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608
    for(i=0; i<64; i++){
        int level= block[i];

        if(level){
            if(level>0){
                s->dct_error_sum[intra][i] += level;
                level -= s->dct_offset[intra][i];
                if(level<0) level=0;
            }else{
                s->dct_error_sum[intra][i] -= level;
                level += s->dct_offset[intra][i];
                if(level>0) level=0;
            }
            block[i]= level;
        }
    }
}

5609 5610
#ifdef CONFIG_ENCODERS

5611
static int dct_quantize_trellis_c(MpegEncContext *s,
5612 5613 5614
                        DCTELEM *block, int n,
                        int qscale, int *overflow){
    const int *qmat;
5615
    const uint8_t *scantable= s->intra_scantable.scantable;
5616
    const uint8_t *perm_scantable= s->intra_scantable.permutated;
5617 5618 5619 5620 5621 5622
    int max=0;
    unsigned int threshold1, threshold2;
    int bias=0;
    int run_tab[65];
    int level_tab[65];
    int score_tab[65];
5623 5624
    int survivor[65];
    int survivor_count;
5625 5626 5627
    int last_run=0;
    int last_level=0;
    int last_score= 0;
5628
    int last_i;
5629
    int coeff[2][64];
5630
    int coeff_count[64];
5631
    int qmul, qadd, start_i, last_non_zero, i, dc;
5632 5633 5634
    const int esc_length= s->ac_esc_length;
    uint8_t * length;
    uint8_t * last_length;
5635
    const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5636

5637
    s->dsp.fdct (block);
5638

5639
    if(s->dct_error_sum)
Michael Niedermayer's avatar
Michael Niedermayer committed
5640
        s->denoise_dct(s, block);
5641 5642
    qmul= qscale*16;
    qadd= ((qscale-1)|1)*8;
5643

5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656
    if (s->mb_intra) {
        int q;
        if (!s->h263_aic) {
            if (n < 4)
                q = s->y_dc_scale;
            else
                q = s->c_dc_scale;
            q = q << 3;
        } else{
            /* For AIC we skip quant/dequant of INTRADC */
            q = 1 << 3;
            qadd=0;
        }
5657

5658 5659 5660 5661 5662
        /* note: block[0] is assumed to be positive */
        block[0] = (block[0] + (q >> 1)) / q;
        start_i = 1;
        last_non_zero = 0;
        qmat = s->q_intra_matrix[qscale];
5663
        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5664 5665 5666 5667 5668 5669 5670 5671 5672 5673
            bias= 1<<(QMAT_SHIFT-1);
        length     = s->intra_ac_vlc_length;
        last_length= s->intra_ac_vlc_last_length;
    } else {
        start_i = 0;
        last_non_zero = -1;
        qmat = s->q_inter_matrix[qscale];
        length     = s->inter_ac_vlc_length;
        last_length= s->inter_ac_vlc_last_length;
    }
5674
    last_i= start_i;
5675 5676 5677

    threshold1= (1<<QMAT_SHIFT) - bias - 1;
    threshold2= (threshold1<<1);
5678

5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689
    for(i=63; i>=start_i; i--) {
        const int j = scantable[i];
        int level = block[j] * qmat[j];

        if(((unsigned)(level+threshold1))>threshold2){
            last_non_zero = i;
            break;
        }
    }

    for(i=start_i; i<=last_non_zero; i++) {
5690
        const int j = scantable[i];
5691
        int level = block[j] * qmat[j];
5692 5693 5694 5695 5696 5697

//        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
//           || bias-level >= (1<<(QMAT_SHIFT - 3))){
        if(((unsigned)(level+threshold1))>threshold2){
            if(level>0){
                level= (bias + level)>>QMAT_SHIFT;
5698 5699
                coeff[0][i]= level;
                coeff[1][i]= level-1;
5700
//                coeff[2][k]= level-2;
5701 5702
            }else{
                level= (bias - level)>>QMAT_SHIFT;
5703 5704
                coeff[0][i]= -level;
                coeff[1][i]= -level+1;
5705
//                coeff[2][k]= -level+2;
5706
            }
5707 5708
            coeff_count[i]= FFMIN(level, 2);
            assert(coeff_count[i]);
5709 5710
            max |=level;
        }else{
5711 5712
            coeff[0][i]= (level>>31)|1;
            coeff_count[i]= 1;
5713 5714
        }
    }
5715

5716
    *overflow= s->max_qcoeff < max; //overflow might have happened
5717

5718 5719 5720 5721 5722
    if(last_non_zero < start_i){
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
        return last_non_zero;
    }

5723 5724 5725
    score_tab[start_i]= 0;
    survivor[0]= start_i;
    survivor_count= 1;
5726

5727 5728 5729
    for(i=start_i; i<=last_non_zero; i++){
        int level_index, j;
        const int dct_coeff= ABS(block[ scantable[i] ]);
5730
        const int zero_distoration= dct_coeff*dct_coeff;
5731
        int best_score=256*256*256*120;
5732 5733 5734
        for(level_index=0; level_index < coeff_count[i]; level_index++){
            int distoration;
            int level= coeff[level_index][i];
Michael Niedermayer's avatar
Michael Niedermayer committed
5735
            const int alevel= ABS(level);
5736
            int unquant_coeff;
5737

5738 5739 5740
            assert(level);

            if(s->out_format == FMT_H263){
Michael Niedermayer's avatar
Michael Niedermayer committed
5741
                unquant_coeff= alevel*qmul + qadd;
5742
            }else{ //MPEG1
5743
                j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5744
                if(s->mb_intra){
Michael Niedermayer's avatar
Michael Niedermayer committed
5745
                        unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
5746 5747
                        unquant_coeff =   (unquant_coeff - 1) | 1;
                }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
5748
                        unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5749 5750 5751 5752
                        unquant_coeff =   (unquant_coeff - 1) | 1;
                }
                unquant_coeff<<= 3;
            }
5753

5754
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5755 5756
            level+=64;
            if((level&(~127)) == 0){
5757 5758
                for(j=survivor_count-1; j>=0; j--){
                    int run= i - survivor[j];
5759
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5760
                    score += score_tab[i-run];
5761

5762
                    if(score < best_score){
5763
                        best_score= score;
5764 5765 5766 5767 5768 5769
                        run_tab[i+1]= run;
                        level_tab[i+1]= level-64;
                    }
                }

                if(s->out_format == FMT_H263){
5770 5771
                    for(j=survivor_count-1; j>=0; j--){
                        int run= i - survivor[j];
5772
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5773
                        score += score_tab[i-run];
5774 5775 5776 5777 5778
                        if(score < last_score){
                            last_score= score;
                            last_run= run;
                            last_level= level-64;
                            last_i= i+1;
5779 5780 5781 5782 5783
                        }
                    }
                }
            }else{
                distoration += esc_length*lambda;
5784 5785
                for(j=survivor_count-1; j>=0; j--){
                    int run= i - survivor[j];
5786
                    int score= distoration + score_tab[i-run];
5787

5788
                    if(score < best_score){
5789
                        best_score= score;
5790 5791 5792 5793 5794 5795
                        run_tab[i+1]= run;
                        level_tab[i+1]= level-64;
                    }
                }

                if(s->out_format == FMT_H263){
5796 5797
                  for(j=survivor_count-1; j>=0; j--){
                        int run= i - survivor[j];
5798
                        int score= distoration + score_tab[i-run];
5799 5800 5801 5802 5803
                        if(score < last_score){
                            last_score= score;
                            last_run= run;
                            last_level= level-64;
                            last_i= i+1;
5804 5805 5806 5807 5808
                        }
                    }
                }
            }
        }
5809

5810 5811
        score_tab[i+1]= best_score;

5812
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5813 5814 5815 5816 5817 5818 5819 5820 5821 5822
        if(last_non_zero <= 27){
            for(; survivor_count; survivor_count--){
                if(score_tab[ survivor[survivor_count-1] ] <= best_score)
                    break;
            }
        }else{
            for(; survivor_count; survivor_count--){
                if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
                    break;
            }
5823
        }
5824 5825

        survivor[ survivor_count++ ]= i+1;
5826
    }
5827

5828
    if(s->out_format != FMT_H263){
5829
        last_score= 256*256*256*120;
5830
        for(i= survivor[0]; i<=last_non_zero + 1; i++){
5831
            int score= score_tab[i];
5832 5833
            if(i) score += lambda*2; //FIXME exacter?

5834 5835 5836 5837 5838 5839
            if(score < last_score){
                last_score= score;
                last_i= i;
                last_level= level_tab[i];
                last_run= run_tab[i];
            }
5840 5841
        }
    }
5842

5843
    s->coded_score[n] = last_score;
5844

Michael Niedermayer's avatar
Michael Niedermayer committed
5845
    dc= ABS(block[0]);
5846
    last_non_zero= last_i - 1;
5847
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5848

5849 5850
    if(last_non_zero < start_i)
        return last_non_zero;
5851

5852 5853 5854
    if(last_non_zero == 0 && start_i == 0){
        int best_level= 0;
        int best_score= dc * dc;
5855

5856
        for(i=0; i<coeff_count[0]; i++){
5857
            int level= coeff[i][0];
Michael Niedermayer's avatar
Michael Niedermayer committed
5858 5859
            int alevel= ABS(level);
            int unquant_coeff, score, distortion;
5860 5861

            if(s->out_format == FMT_H263){
Michael Niedermayer's avatar
Michael Niedermayer committed
5862
                    unquant_coeff= (alevel*qmul + qadd)>>3;
5863
            }else{ //MPEG1
Michael Niedermayer's avatar
Michael Niedermayer committed
5864 5865
                    unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
                    unquant_coeff =   (unquant_coeff - 1) | 1;
5866 5867 5868 5869
            }
            unquant_coeff = (unquant_coeff + 4) >> 3;
            unquant_coeff<<= 3 + 3;

Michael Niedermayer's avatar
Michael Niedermayer committed
5870
            distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5871
            level+=64;
Michael Niedermayer's avatar
Michael Niedermayer committed
5872 5873
            if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
            else                    score= distortion + esc_length*lambda;
5874

5875 5876
            if(score < best_score){
                best_score= score;
5877
                best_level= level - 64;
5878 5879 5880
            }
        }
        block[0]= best_level;
5881 5882 5883
        s->coded_score[n] = best_score - dc*dc;
        if(best_level == 0) return -1;
        else                return last_non_zero;
5884
    }
5885

5886 5887
    i= last_i;
    assert(last_level);
5888 5889

    block[ perm_scantable[last_non_zero] ]= last_level;
5890
    i -= last_run + 1;
5891

5892 5893
    for(; i>start_i; i -= run_tab[i] + 1){
        block[ perm_scantable[i-1] ]= level_tab[i];
5894 5895 5896 5897 5898
    }

    return last_non_zero;
}

5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924
//#define REFINE_STATS 1
static int16_t basis[64][64];

static void build_basis(uint8_t *perm){
    int i, j, x, y;
    emms_c();
    for(i=0; i<8; i++){
        for(j=0; j<8; j++){
            for(y=0; y<8; y++){
                for(x=0; x<8; x++){
                    double s= 0.25*(1<<BASIS_SHIFT);
                    int index= 8*i + j;
                    int perm_index= perm[index];
                    if(i==0) s*= sqrt(0.5);
                    if(j==0) s*= sqrt(0.5);
                    basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
                }
            }
        }
    }
}

static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
                        DCTELEM *block, int16_t *weight, DCTELEM *orig,
                        int n, int qscale){
    int16_t rem[64];
5925
    DCTELEM d1[64] __align16;
5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950
    const int *qmat;
    const uint8_t *scantable= s->intra_scantable.scantable;
    const uint8_t *perm_scantable= s->intra_scantable.permutated;
//    unsigned int threshold1, threshold2;
//    int bias=0;
    int run_tab[65];
    int prev_run=0;
    int prev_level=0;
    int qmul, qadd, start_i, last_non_zero, i, dc;
    uint8_t * length;
    uint8_t * last_length;
    int lambda;
    int rle_index, run, q, sum;
#ifdef REFINE_STATS
static int count=0;
static int after_last=0;
static int to_zero=0;
static int from_zero=0;
static int raise=0;
static int lower=0;
static int messed_sign=0;
#endif

    if(basis[0][0] == 0)
        build_basis(s->dsp.idct_permutation);
5951

5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986
    qmul= qscale*2;
    qadd= (qscale-1)|1;
    if (s->mb_intra) {
        if (!s->h263_aic) {
            if (n < 4)
                q = s->y_dc_scale;
            else
                q = s->c_dc_scale;
        } else{
            /* For AIC we skip quant/dequant of INTRADC */
            q = 1;
            qadd=0;
        }
        q <<= RECON_SHIFT-3;
        /* note: block[0] is assumed to be positive */
        dc= block[0]*q;
//        block[0] = (block[0] + (q >> 1)) / q;
        start_i = 1;
        qmat = s->q_intra_matrix[qscale];
//        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
//            bias= 1<<(QMAT_SHIFT-1);
        length     = s->intra_ac_vlc_length;
        last_length= s->intra_ac_vlc_last_length;
    } else {
        dc= 0;
        start_i = 0;
        qmat = s->q_inter_matrix[qscale];
        length     = s->inter_ac_vlc_length;
        last_length= s->inter_ac_vlc_last_length;
    }
    last_non_zero = s->block_last_index[n];

#ifdef REFINE_STATS
{START_TIMER
#endif
5987 5988
    dc += (1<<(RECON_SHIFT-1));
    for(i=0; i<64; i++){
5989
        rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME  use orig dirrectly instead of copying to rem[]
5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004
    }
#ifdef REFINE_STATS
STOP_TIMER("memset rem[]")}
#endif
    sum=0;
    for(i=0; i<64; i++){
        int one= 36;
        int qns=4;
        int w;

        w= ABS(weight[i]) + qns*one;
        w= 15 + (48*qns*one + w/2)/w; // 16 .. 63

        weight[i] = w;
//        w=weight[i] = (63*qns + (w/2)) / w;
6005

6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019
        assert(w>0);
        assert(w<(1<<6));
        sum += w*w;
    }
    lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
#ifdef REFINE_STATS
{START_TIMER
#endif
    run=0;
    rle_index=0;
    for(i=start_i; i<=last_non_zero; i++){
        int j= perm_scantable[i];
        const int level= block[j];
        int coeff;
6020

6021 6022 6023 6024 6025 6026
        if(level){
            if(level<0) coeff= qmul*level - qadd;
            else        coeff= qmul*level + qadd;
            run_tab[rle_index++]=run;
            run=0;

6027
            s->dsp.add_8x8basis(rem, basis[j], coeff);
6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040
        }else{
            run++;
        }
    }
#ifdef REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("init rem[]")
}
}

{START_TIMER
#endif
    for(;;){
6041
        int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6042 6043
        int best_coeff=0;
        int best_change=0;
6044
        int run2, best_unquant_change=0, analyze_gradient;
6045 6046 6047
#ifdef REFINE_STATS
{START_TIMER
#endif
6048 6049 6050 6051 6052 6053 6054 6055
        analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;

        if(analyze_gradient){
#ifdef REFINE_STATS
{START_TIMER
#endif
            for(i=0; i<64; i++){
                int w= weight[i];
6056

6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068
                d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
            }
#ifdef REFINE_STATS
STOP_TIMER("rem*w*w")}
{START_TIMER
#endif
            s->dsp.fdct(d1);
#ifdef REFINE_STATS
STOP_TIMER("dct")}
#endif
        }

6069 6070 6071 6072 6073
        if(start_i){
            const int level= block[0];
            int change, old_coeff;

            assert(s->mb_intra);
6074

6075
            old_coeff= q*level;
6076

6077 6078 6079
            for(change=-1; change<=1; change+=2){
                int new_level= level + change;
                int score, new_coeff;
6080

6081 6082 6083 6084
                new_coeff= q*new_level;
                if(new_coeff >= 2048 || new_coeff < 0)
                    continue;

6085
                score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6086 6087 6088 6089 6090 6091 6092 6093
                if(score<best_score){
                    best_score= score;
                    best_coeff= 0;
                    best_change= change;
                    best_unquant_change= new_coeff - old_coeff;
                }
            }
        }
6094

6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117
        run=0;
        rle_index=0;
        run2= run_tab[rle_index++];
        prev_level=0;
        prev_run=0;

        for(i=start_i; i<64; i++){
            int j= perm_scantable[i];
            const int level= block[j];
            int change, old_coeff;

            if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
                break;

            if(level){
                if(level<0) old_coeff= qmul*level - qadd;
                else        old_coeff= qmul*level + qadd;
                run2= run_tab[rle_index++]; //FIXME ! maybe after last
            }else{
                old_coeff=0;
                run2--;
                assert(run2>=0 || i >= last_non_zero );
            }
6118

6119 6120 6121
            for(change=-1; change<=1; change+=2){
                int new_level= level + change;
                int score, new_coeff, unquant_change;
6122

6123 6124 6125 6126 6127 6128 6129 6130 6131 6132
                score=0;
                if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
                   continue;

                if(new_level){
                    if(new_level<0) new_coeff= qmul*new_level - qadd;
                    else            new_coeff= qmul*new_level + qadd;
                    if(new_coeff >= 2048 || new_coeff <= -2048)
                        continue;
                    //FIXME check for overflow
6133

6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144
                    if(level){
                        if(level < 63 && level > -63){
                            if(i < last_non_zero)
                                score +=   length[UNI_AC_ENC_INDEX(run, new_level+64)]
                                         - length[UNI_AC_ENC_INDEX(run, level+64)];
                            else
                                score +=   last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
                                         - last_length[UNI_AC_ENC_INDEX(run, level+64)];
                        }
                    }else{
                        assert(ABS(new_level)==1);
6145

6146 6147 6148 6149 6150 6151
                        if(analyze_gradient){
                            int g= d1[ scantable[i] ];
                            if(g && (g^new_level) >= 0)
                                continue;
                        }

6152 6153 6154
                        if(i < last_non_zero){
                            int next_i= i + run2 + 1;
                            int next_level= block[ perm_scantable[next_i] ] + 64;
6155

6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181
                            if(next_level&(~127))
                                next_level= 0;

                            if(next_i < last_non_zero)
                                score +=   length[UNI_AC_ENC_INDEX(run, 65)]
                                         + length[UNI_AC_ENC_INDEX(run2, next_level)]
                                         - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
                            else
                                score +=  length[UNI_AC_ENC_INDEX(run, 65)]
                                        + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
                                        - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
                        }else{
                            score += last_length[UNI_AC_ENC_INDEX(run, 65)];
                            if(prev_level){
                                score +=  length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
                                        - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
                            }
                        }
                    }
                }else{
                    new_coeff=0;
                    assert(ABS(level)==1);

                    if(i < last_non_zero){
                        int next_i= i + run2 + 1;
                        int next_level= block[ perm_scantable[next_i] ] + 64;
6182

6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201
                        if(next_level&(~127))
                            next_level= 0;

                        if(next_i < last_non_zero)
                            score +=   length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
                                     - length[UNI_AC_ENC_INDEX(run2, next_level)]
                                     - length[UNI_AC_ENC_INDEX(run, 65)];
                        else
                            score +=   last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
                                     - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
                                     - length[UNI_AC_ENC_INDEX(run, 65)];
                    }else{
                        score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
                        if(prev_level){
                            score +=  last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
                                    - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
                        }
                    }
                }
6202

6203 6204 6205 6206
                score *= lambda;

                unquant_change= new_coeff - old_coeff;
                assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6207

6208
                score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231
                if(score<best_score){
                    best_score= score;
                    best_coeff= i;
                    best_change= change;
                    best_unquant_change= unquant_change;
                }
            }
            if(level){
                prev_level= level + 64;
                if(prev_level&(~127))
                    prev_level= 0;
                prev_run= run;
                run=0;
            }else{
                run++;
            }
        }
#ifdef REFINE_STATS
STOP_TIMER("iterative step")}
#endif

        if(best_change){
            int j= perm_scantable[ best_coeff ];
6232

6233
            block[j] += best_change;
6234

6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272
            if(best_coeff > last_non_zero){
                last_non_zero= best_coeff;
                assert(block[j]);
#ifdef REFINE_STATS
after_last++;
#endif
            }else{
#ifdef REFINE_STATS
if(block[j]){
    if(block[j] - best_change){
        if(ABS(block[j]) > ABS(block[j] - best_change)){
            raise++;
        }else{
            lower++;
        }
    }else{
        from_zero++;
    }
}else{
    to_zero++;
}
#endif
                for(; last_non_zero>=start_i; last_non_zero--){
                    if(block[perm_scantable[last_non_zero]])
                        break;
                }
            }
#ifdef REFINE_STATS
count++;
if(256*256*256*64 % count == 0){
    printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
}
#endif
            run=0;
            rle_index=0;
            for(i=start_i; i<=last_non_zero; i++){
                int j= perm_scantable[i];
                const int level= block[j];
6273

6274 6275 6276 6277 6278 6279 6280
                 if(level){
                     run_tab[rle_index++]=run;
                     run=0;
                 }else{
                     run++;
                 }
            }
6281

6282
            s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296
        }else{
            break;
        }
    }
#ifdef REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("iterative search")
}
}
#endif

    return last_non_zero;
}

6297
static int dct_quantize_c(MpegEncContext *s,
Fabrice Bellard's avatar
Fabrice Bellard committed
6298
                        DCTELEM *block, int n,
6299
                        int qscale, int *overflow)
Fabrice Bellard's avatar
Fabrice Bellard committed
6300
{
6301
    int i, j, level, last_non_zero, q, start_i;
Fabrice Bellard's avatar
Fabrice Bellard committed
6302
    const int *qmat;
6303
    const uint8_t *scantable= s->intra_scantable.scantable;
6304 6305 6306
    int bias;
    int max=0;
    unsigned int threshold1, threshold2;
6307

6308
    s->dsp.fdct (block);
Fabrice Bellard's avatar
Fabrice Bellard committed
6309

6310
    if(s->dct_error_sum)
Michael Niedermayer's avatar
Michael Niedermayer committed
6311
        s->denoise_dct(s, block);
6312

Fabrice Bellard's avatar
Fabrice Bellard committed
6313
    if (s->mb_intra) {
6314 6315 6316 6317 6318 6319 6320 6321 6322
        if (!s->h263_aic) {
            if (n < 4)
                q = s->y_dc_scale;
            else
                q = s->c_dc_scale;
            q = q << 3;
        } else
            /* For AIC we skip quant/dequant of INTRADC */
            q = 1 << 3;
6323

Fabrice Bellard's avatar
Fabrice Bellard committed
6324 6325
        /* note: block[0] is assumed to be positive */
        block[0] = (block[0] + (q >> 1)) / q;
6326
        start_i = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
6327
        last_non_zero = 0;
6328
        qmat = s->q_intra_matrix[qscale];
Michael Niedermayer's avatar
Michael Niedermayer committed
6329
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
Fabrice Bellard's avatar
Fabrice Bellard committed
6330
    } else {
6331
        start_i = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
6332
        last_non_zero = -1;
6333
        qmat = s->q_inter_matrix[qscale];
Michael Niedermayer's avatar
Michael Niedermayer committed
6334
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
Fabrice Bellard's avatar
Fabrice Bellard committed
6335
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
6336 6337
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
    threshold2= (threshold1<<1);
6338 6339 6340
    for(i=63;i>=start_i;i--) {
        j = scantable[i];
        level = block[j] * qmat[j];
Fabrice Bellard's avatar
Fabrice Bellard committed
6341

6342 6343 6344 6345 6346 6347 6348 6349
        if(((unsigned)(level+threshold1))>threshold2){
            last_non_zero = i;
            break;
        }else{
            block[j]=0;
        }
    }
    for(i=start_i; i<=last_non_zero; i++) {
6350
        j = scantable[i];
6351
        level = block[j] * qmat[j];
Fabrice Bellard's avatar
Fabrice Bellard committed
6352

6353 6354
//        if(   bias+level >= (1<<QMAT_SHIFT)
//           || bias-level >= (1<<QMAT_SHIFT)){
6355 6356
        if(((unsigned)(level+threshold1))>threshold2){
            if(level>0){
Michael Niedermayer's avatar
Michael Niedermayer committed
6357
                level= (bias + level)>>QMAT_SHIFT;
6358 6359
                block[j]= level;
            }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
6360
                level= (bias - level)>>QMAT_SHIFT;
6361 6362 6363 6364 6365
                block[j]= -level;
            }
            max |=level;
        }else{
            block[j]=0;
Fabrice Bellard's avatar
Fabrice Bellard committed
6366 6367
        }
    }
6368
    *overflow= s->max_qcoeff < max; //overflow might have happened
6369

6370
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6371
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6372
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6373

Fabrice Bellard's avatar
Fabrice Bellard committed
6374 6375 6376
    return last_non_zero;
}

6377 6378
#endif //CONFIG_ENCODERS

6379
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6380
                                   DCTELEM *block, int n, int qscale)
Fabrice Bellard's avatar
Fabrice Bellard committed
6381
{
6382
    int i, level, nCoeffs;
6383
    const uint16_t *quant_matrix;
Fabrice Bellard's avatar
Fabrice Bellard committed
6384

6385
    nCoeffs= s->block_last_index[n];
6386 6387

    if (n < 4)
6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404
        block[0] = block[0] * s->y_dc_scale;
    else
        block[0] = block[0] * s->c_dc_scale;
    /* XXX: only mpeg1 */
    quant_matrix = s->intra_matrix;
    for(i=1;i<=nCoeffs;i++) {
        int j= s->intra_scantable.permutated[i];
        level = block[j];
        if (level) {
            if (level < 0) {
                level = -level;
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
                level = (level - 1) | 1;
                level = -level;
            } else {
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
                level = (level - 1) | 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
6405
            }
6406
            block[j] = level;
Fabrice Bellard's avatar
Fabrice Bellard committed
6407
        }
6408 6409 6410
    }
}

6411
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6412 6413 6414 6415 6416 6417
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
    const uint16_t *quant_matrix;

    nCoeffs= s->block_last_index[n];
6418

6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433
    quant_matrix = s->inter_matrix;
    for(i=0; i<=nCoeffs; i++) {
        int j= s->intra_scantable.permutated[i];
        level = block[j];
        if (level) {
            if (level < 0) {
                level = -level;
                level = (((level << 1) + 1) * qscale *
                         ((int) (quant_matrix[j]))) >> 4;
                level = (level - 1) | 1;
                level = -level;
            } else {
                level = (((level << 1) + 1) * qscale *
                         ((int) (quant_matrix[j]))) >> 4;
                level = (level - 1) | 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
6434
            }
6435
            block[j] = level;
Fabrice Bellard's avatar
Fabrice Bellard committed
6436 6437 6438
        }
    }
}
6439

6440
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6441 6442 6443
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
6444
    const uint16_t *quant_matrix;
6445

6446 6447
    if(s->alternate_scan) nCoeffs= 63;
    else nCoeffs= s->block_last_index[n];
6448 6449

    if (n < 4)
6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469
        block[0] = block[0] * s->y_dc_scale;
    else
        block[0] = block[0] * s->c_dc_scale;
    quant_matrix = s->intra_matrix;
    for(i=1;i<=nCoeffs;i++) {
        int j= s->intra_scantable.permutated[i];
        level = block[j];
        if (level) {
            if (level < 0) {
                level = -level;
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
                level = -level;
            } else {
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
            }
            block[j] = level;
        }
    }
}

6470
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6471 6472 6473 6474 6475 6476 6477 6478
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
    const uint16_t *quant_matrix;
    int sum=-1;

    if(s->alternate_scan) nCoeffs= 63;
    else nCoeffs= s->block_last_index[n];
6479

6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500
    quant_matrix = s->inter_matrix;
    for(i=0; i<=nCoeffs; i++) {
        int j= s->intra_scantable.permutated[i];
        level = block[j];
        if (level) {
            if (level < 0) {
                level = -level;
                level = (((level << 1) + 1) * qscale *
                         ((int) (quant_matrix[j]))) >> 4;
                level = -level;
            } else {
                level = (((level << 1) + 1) * qscale *
                         ((int) (quant_matrix[j]))) >> 4;
            }
            block[j] = level;
            sum+=level;
        }
    }
    block[63]^=sum&1;
}

6501
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6502 6503 6504 6505
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
    int nCoeffs;
6506

6507
    assert(s->block_last_index[n]>=0);
6508

6509
    qmul = qscale << 1;
6510

6511
    if (!s->h263_aic) {
6512
        if (n < 4)
6513 6514 6515
            block[0] = block[0] * s->y_dc_scale;
        else
            block[0] = block[0] * s->c_dc_scale;
6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531
        qadd = (qscale - 1) | 1;
    }else{
        qadd = 0;
    }
    if(s->ac_pred)
        nCoeffs=63;
    else
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];

    for(i=1; i<=nCoeffs; i++) {
        level = block[i];
        if (level) {
            if (level < 0) {
                level = level * qmul - qadd;
            } else {
                level = level * qmul + qadd;
6532
            }
6533
            block[i] = level;
6534 6535 6536 6537
        }
    }
}

6538
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6539 6540 6541
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
6542
    int nCoeffs;
6543

6544
    assert(s->block_last_index[n]>=0);
6545

6546 6547
    qadd = (qscale - 1) | 1;
    qmul = qscale << 1;
6548

6549
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6550

6551
    for(i=0; i<=nCoeffs; i++) {
6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562
        level = block[i];
        if (level) {
            if (level < 0) {
                level = level * qmul - qadd;
            } else {
                level = level * qmul + qadd;
            }
            block[i] = level;
        }
    }
}
Fabrice Bellard's avatar
Fabrice Bellard committed
6563

6564
#ifdef CONFIG_ENCODERS
Fabrice Bellard's avatar
Fabrice Bellard committed
6565 6566 6567 6568 6569 6570 6571 6572
AVCodec h263_encoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6573
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6574 6575 6576 6577 6578 6579 6580 6581 6582 6583
};

AVCodec h263p_encoder = {
    "h263p",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263P,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6584
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6585 6586
};

6587 6588 6589 6590 6591 6592 6593 6594
AVCodec flv_encoder = {
    "flv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6595
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6596 6597
};

Fabrice Bellard's avatar
Fabrice Bellard committed
6598 6599 6600 6601 6602 6603 6604 6605
AVCodec rv10_encoder = {
    "rv10",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV10,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6606
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6607 6608
};

Michael Niedermayer's avatar
Michael Niedermayer committed
6609 6610 6611 6612 6613 6614 6615 6616
AVCodec rv20_encoder = {
    "rv20",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV20,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6617
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Michael Niedermayer's avatar
Michael Niedermayer committed
6618 6619
};

6620 6621
AVCodec mpeg4_encoder = {
    "mpeg4",
Fabrice Bellard's avatar
Fabrice Bellard committed
6622
    CODEC_TYPE_VIDEO,
6623
    CODEC_ID_MPEG4,
Fabrice Bellard's avatar
Fabrice Bellard committed
6624 6625 6626 6627
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6628
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6629
    .capabilities= CODEC_CAP_DELAY,
Fabrice Bellard's avatar
Fabrice Bellard committed
6630 6631
};

6632 6633 6634 6635 6636 6637 6638 6639
AVCodec msmpeg4v1_encoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6640
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6641 6642 6643 6644 6645 6646 6647 6648 6649 6650
};

AVCodec msmpeg4v2_encoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6651
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6652 6653 6654
};

AVCodec msmpeg4v3_encoder = {
Fabrice Bellard's avatar
Fabrice Bellard committed
6655 6656
    "msmpeg4",
    CODEC_TYPE_VIDEO,
6657
    CODEC_ID_MSMPEG4V3,
Fabrice Bellard's avatar
Fabrice Bellard committed
6658 6659 6660 6661
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6662
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6663
};
Michael Niedermayer's avatar
Michael Niedermayer committed
6664 6665 6666 6667 6668 6669 6670 6671 6672

AVCodec wmv1_encoder = {
    "wmv1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6673
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Michael Niedermayer's avatar
Michael Niedermayer committed
6674 6675
};

6676 6677 6678 6679 6680 6681 6682 6683
AVCodec mjpeg_encoder = {
    "mjpeg",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MJPEG,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6684
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, -1},
6685
};
6686 6687

#endif //CONFIG_ENCODERS