mpegvideo.c 248 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
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Michael Niedermayer's avatar
Michael Niedermayer committed
21
 *
22
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
23
 */
24

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

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

36
#ifdef USE_FASTMEMCPY
37
#include "libvo/fastmemcpy.h"
38 39
#endif

40 41
//#undef NDEBUG
//#include <assert.h>
42

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

Ivan Kalvachev's avatar
Ivan Kalvachev committed
69 70 71
#ifdef HAVE_XVMC
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
extern void XVMC_field_end(MpegEncContext *s);
72
extern void XVMC_decode_mb(MpegEncContext *s);
Ivan Kalvachev's avatar
Ivan Kalvachev committed
73 74
#endif

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

Fabrice Bellard's avatar
Fabrice Bellard committed
77 78 79 80 81 82

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

//#define DEBUG

83

Fabrice Bellard's avatar
Fabrice Bellard committed
84 85 86
/* for jpeg fast DCT */
#define CONST_BITS 14

87
static const uint16_t aanscales[64] = {
Fabrice Bellard's avatar
Fabrice Bellard committed
88 89 90 91 92 93 94
    /* 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
95 96
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
Fabrice Bellard's avatar
Fabrice Bellard committed
97 98
};

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

Michael Niedermayer's avatar
Michael Niedermayer committed
104 105 106 107 108
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
};

109
#ifdef CONFIG_ENCODERS
110
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
111
static uint8_t default_fcode_tab[MAX_MV*2+1];
112

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

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

121
    for(qscale=qmin; qscale<=qmax; qscale++){
122
        int i;
123
        if (dsp->fdct == ff_jpeg_fdct_islow
124
#ifdef FAAN_POSTSCALE
125
            || dsp->fdct == ff_faandct
126 127
#endif
            ) {
128
            for(i=0;i<64;i++) {
129
                const int j= dsp->idct_permutation[i];
130 131 132 133
                /* 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 */
134 135

                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
136 137
                                (qscale * quant_matrix[j]));
            }
138
        } else if (dsp->fdct == fdct_ifast
139
#ifndef FAAN_POSTSCALE
140
                   || dsp->fdct == ff_faandct
141 142
#endif
                   ) {
143
            for(i=0;i<64;i++) {
144
                const int j= dsp->idct_permutation[i];
145 146 147 148
                /* 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 */
149 150

                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
151 152 153 154
                                (aanscales[i] * qscale * quant_matrix[j]));
            }
        } else {
            for(i=0;i<64;i++) {
155
                const int j= dsp->idct_permutation[i];
156 157 158 159 160
                /* 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
                */
161
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
162
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
163
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
164

165 166
                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]);
167
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
168
        }
169

170
        for(i=intra; i<64; i++){
171 172 173 174 175 176 177 178
            int64_t max= 8191;
            if (dsp->fdct == fdct_ifast
#ifndef FAAN_POSTSCALE
                   || dsp->fdct == ff_faandct
#endif
                   ) {
                max= (8191LL*aanscales[i]) >> 14;
            }
179
            while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
180 181 182 183 184 185
                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
186 187
    }
}
188 189 190 191

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);
192

193 194
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
}
195 196
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
197
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
198 199
    int i;
    int end;
200

201
    st->scantable= src_scantable;
202 203 204 205

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

212 213 214 215 216 217 218 219 220
    end=-1;
    for(i=0; i<64; i++){
        int j;
        j = st->permutated[i];
        if(j>end) end=j;
        st->raster_end[i]= end;
    }
}

221
#ifdef CONFIG_ENCODERS
222
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
223 224 225 226 227 228 229 230 231 232
    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);
}
233
#endif //CONFIG_ENCODERS
234

235 236 237
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
    int i;

Michael Niedermayer's avatar
Michael Niedermayer committed
238 239 240 241
    assert(p<=end);
    if(p>=end)
        return end;

242 243 244 245 246 247 248 249
    for(i=0; i<3; i++){
        uint32_t tmp= *state << 8;
        *state= tmp + *(p++);
        if(tmp == 0x100 || p==end)
            return p;
    }

    while(p<end){
Michael Niedermayer's avatar
Michael Niedermayer committed
250 251 252
        if     (p[-1] > 1      ) p+= 3;
        else if(p[-2]          ) p+= 2;
        else if(p[-3]|(p[-1]-1)) p++;
253 254 255 256 257 258
        else{
            p++;
            break;
        }
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
259
    p= FFMIN(p, end)-4;
260 261 262 263 264
    *state=  be2me_32(unaligned32(p));

    return p+4;
}

265 266
/* init common dct for both encoder and decoder */
int DCT_common_init(MpegEncContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
267
{
268 269 270 271 272
    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;
273 274
    if(s->flags & CODEC_FLAG_BITEXACT)
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
275
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
276

277
#ifdef CONFIG_ENCODERS
278
    s->dct_quantize= dct_quantize_c;
Michael Niedermayer's avatar
Michael Niedermayer committed
279
    s->denoise_dct= denoise_dct_c;
280
#endif //CONFIG_ENCODERS
281

282
#ifdef HAVE_MMX
283
    MPV_common_init_mmx(s);
284 285 286
#endif
#ifdef ARCH_ALPHA
    MPV_common_init_axp(s);
Nick Kurshev's avatar
Nick Kurshev committed
287
#endif
288 289 290
#ifdef HAVE_MLIB
    MPV_common_init_mlib(s);
#endif
291 292 293
#ifdef HAVE_MMI
    MPV_common_init_mmi(s);
#endif
294
#ifdef ARCH_ARMV4L
295
    MPV_common_init_armv4l(s);
296
#endif
297 298 299
#ifdef ARCH_POWERPC
    MPV_common_init_ppc(s);
#endif
300

301
#ifdef CONFIG_ENCODERS
302 303
    s->fast_dct_quantize= s->dct_quantize;

304 305 306 307
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
    }

308 309
#endif //CONFIG_ENCODERS

310
    /* load & permutate scantables
311
       note: only wmv uses different ones
312
    */
313 314 315 316 317 318 319
    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
320 321
    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);
322

323 324 325
    return 0;
}

326 327 328 329 330
static void copy_picture(Picture *dst, Picture *src){
    *dst = *src;
    dst->type= FF_BUFFER_TYPE_COPY;
}

331
#ifdef CONFIG_ENCODERS
332 333 334
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
    int i;

335 336 337 338 339 340 341 342
    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;
343

344 345 346 347 348 349 350
    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");
351
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
352
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
353
            src->motion_subsample_log2, dst->motion_subsample_log2);
354 355

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

357
        for(i=0; i<2; i++){
358 359 360
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);

361 362 363 364
            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]){
365
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
366
            }
367 368
        }
    }
369
}
370
#endif
371

Michael Niedermayer's avatar
Michael Niedermayer committed
372
/**
Michael Niedermayer's avatar
Michael Niedermayer committed
373 374
 * allocates a Picture
 * The pixels are allocated/set by calling get_buffer() if shared=0
Michael Niedermayer's avatar
Michael Niedermayer committed
375
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
376
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
377 378
    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;
379 380
    const int b8_array_size= s->b8_stride*s->mb_height*2;
    const int b4_array_size= s->b4_stride*s->mb_height*4;
381
    int i;
382

Michael Niedermayer's avatar
Michael Niedermayer committed
383 384 385 386 387 388
    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;
389

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

392
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
393

Michael Niedermayer's avatar
Michael Niedermayer committed
394
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
395
            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
396 397 398 399
            return -1;
        }

        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
400
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
401 402 403 404
            return -1;
        }

        if(pic->linesize[1] != pic->linesize[2]){
Diego Biurrun's avatar
Diego Biurrun committed
405
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
406 407 408 409 410
            return -1;
        }

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

Michael Niedermayer's avatar
Michael Niedermayer committed
413
    if(pic->qscale_table==NULL){
414
        if (s->encoding) {
415 416 417
            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
418
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
419

420
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
421
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
422
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
423
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
424 425
        if(s->out_format == FMT_H264){
            for(i=0; i<2; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
426 427
                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;
428
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
429
            }
430
            pic->motion_subsample_log2= 2;
431
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
432
            for(i=0; i<2; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
433 434
                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;
435
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
436
            }
437
            pic->motion_subsample_log2= 3;
438
        }
439 440 441
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
        }
442
        pic->qstride= s->mb_stride;
443
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
Michael Niedermayer's avatar
Michael Niedermayer committed
444
    }
445

446 447 448 449
    //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)
450
        pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
451

Michael Niedermayer's avatar
Michael Niedermayer committed
452 453 454 455 456
    return 0;
fail: //for the CHECKED_ALLOCZ macro
    return -1;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
457 458 459
/**
 * deallocates a picture
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
460 461
static void free_picture(MpegEncContext *s, Picture *pic){
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
462 463

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

Michael Niedermayer's avatar
Michael Niedermayer committed
467 468 469 470 471
    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);
472
    av_freep(&pic->mb_type_base);
473
    av_freep(&pic->dct_coeff);
474
    av_freep(&pic->pan_scan);
475 476
    pic->mb_type= NULL;
    for(i=0; i<2; i++){
477
        av_freep(&pic->motion_val_base[i]);
478 479
        av_freep(&pic->ref_index[i]);
    }
480

481
    if(pic->type == FF_BUFFER_TYPE_SHARED){
Michael Niedermayer's avatar
Michael Niedermayer committed
482 483 484 485
        for(i=0; i<4; i++){
            pic->base[i]=
            pic->data[i]= NULL;
        }
486
        pic->type= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
487 488 489
    }
}

490 491 492
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
    int i;

493
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
494 495
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
496 497

     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
498
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
499 500 501 502 503 504 505 506 507
    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))
        }
508
    }
509
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
    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);
525 526
    s->rd_scratchpad=
    s->b_scratchpad=
527
    s->obmc_scratchpad= NULL;
528

529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
    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);
553 554
    COPY(dct_count[0]);
    COPY(dct_count[1]);
555 556 557
#undef COPY
}

558
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
559
    MpegEncContext bak;
560
    int i;
561 562 563 564 565
    //FIXME copy only needed parts
//START_TIMER
    backup_duplicate_context(&bak, dst);
    memcpy(dst, src, sizeof(MpegEncContext));
    backup_duplicate_context(dst, &bak);
566 567 568
    for(i=0;i<12;i++){
        dst->pblocks[i] = (short *)(&dst->block[i]);
    }
569 570 571
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
}

572
#ifdef CONFIG_ENCODERS
573 574 575 576 577 578 579 580 581 582 583
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
584 585 586
    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
587 588
#undef COPY
}
589
#endif
590

Michael Niedermayer's avatar
Michael Niedermayer committed
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
/**
 * 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;
608 609 610

    s->f_code = 1;
    s->b_code = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
611 612 613 614 615 616 617 618 619 620 621 622 623 624
}

/**
 * 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.
 */
625 626

#ifdef CONFIG_ENCODERS
627
static void MPV_encode_defaults(MpegEncContext *s){
Michael Niedermayer's avatar
Michael Niedermayer committed
628
    static int done=0;
629

Michael Niedermayer's avatar
Michael Niedermayer committed
630
    MPV_common_defaults(s);
631

Michael Niedermayer's avatar
Michael Niedermayer committed
632 633 634 635 636 637 638 639 640 641 642 643 644 645
    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;
}
646
#endif //CONFIG_ENCODERS
Michael Niedermayer's avatar
Michael Niedermayer committed
647

648
/**
Michael Niedermayer's avatar
Michael Niedermayer committed
649 650 651
 * init common structure for both encoder and decoder.
 * this assumes that some variables like width/height are already set
 */
652 653
int MPV_common_init(MpegEncContext *s)
{
654
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
655

656 657 658
    s->mb_height = (s->height + 15) / 16;

    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
Michael Niedermayer's avatar
Michael Niedermayer committed
659 660 661 662
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
        return -1;
    }

663 664 665
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
        return -1;

666
    dsputil_init(&s->dsp, s->avctx);
667
    DCT_common_init(s);
668

669
    s->flags= s->avctx->flags;
670
    s->flags2= s->avctx->flags2;
671

Michael Niedermayer's avatar
Michael Niedermayer committed
672
    s->mb_width  = (s->width  + 15) / 16;
673
    s->mb_stride = s->mb_width + 1;
674 675
    s->b8_stride = s->mb_width*2 + 1;
    s->b4_stride = s->mb_width*4 + 1;
676
    mb_array_size= s->mb_height * s->mb_stride;
677
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
678

679 680 681 682
    /* set chroma shifts */
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
                                                    &(s->chroma_y_shift) );

683 684 685
    /* 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;
686 687

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

689 690 691
    s->block_wrap[0]=
    s->block_wrap[1]=
    s->block_wrap[2]=
692
    s->block_wrap[3]= s->b8_stride;
693
    s->block_wrap[4]=
694
    s->block_wrap[5]= s->mb_stride;
695

696 697
    y_size = s->b8_stride * (2 * s->mb_height + 1);
    c_size = s->mb_stride * (s->mb_height + 1);
698
    yc_size = y_size + 2 * c_size;
699

700
    /* convert fourcc to upper case */
701
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
702
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
703
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
704
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
705

706
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)
707
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
708
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
709 710
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);

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

713 714 715 716 717 718 719
    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?
720

721
    if (s->encoding) {
722
        /* Allocate MV tables */
723 724 725 726 727 728 729 730 731 732 733 734
        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;
735

736 737 738
        if(s->msmpeg4_version){
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
        }
739
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
740 741

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

744
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
745

746 747
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
748 749
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
750 751
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
752

753 754 755
        if(s->avctx->noise_reduction){
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
        }
756
    }
757 758
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))

759
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
760

761
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
762
        /* interlaced direct mode decoding tables */
763 764 765 766 767 768 769 770 771 772 773 774 775
            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
776
    }
777
    if (s->out_format == FMT_H263) {
Fabrice Bellard's avatar
Fabrice Bellard committed
778
        /* ac values */
779 780 781
        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
782
        s->ac_val[2] = s->ac_val[1] + c_size;
783

Fabrice Bellard's avatar
Fabrice Bellard committed
784
        /* cbp values */
785 786
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
787

788
        /* cbp, ac_pred, pred_dir */
789 790
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
791
    }
792

793 794 795
    if (s->h263_pred || s->h263_plus || !s->encoding) {
        /* dc values */
        //MN: we need these for error resilience of intra-frames
796 797 798
        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;
799 800
        s->dc_val[2] = s->dc_val[1] + c_size;
        for(i=0;i<yc_size;i++)
801
            s->dc_val_base[i] = 1024;
802 803
    }

804
    /* which mb is a intra block */
805 806
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
    memset(s->mbintra_table, 1, mb_array_size);
807

808
    /* init macroblock skip table */
809
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
810
    //Note the +1 is for a quicker mpeg4 slice_end detection
811
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
812

813
    s->parse_context.state= -1;
814 815 816 817 818
    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);
    }
819

Fabrice Bellard's avatar
Fabrice Bellard committed
820
    s->context_initialized = 1;
821 822 823 824 825 826 827 828 829 830 831 832 833 834

    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
835 836
    return 0;
 fail:
837
    MPV_common_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
838 839 840 841 842 843
    return -1;
}

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

846 847 848 849 850 851 852
    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]);
    }

853 854 855
    av_freep(&s->parse_context.buffer);
    s->parse_context.buffer_size=0;

856
    av_freep(&s->mb_type);
857 858 859 860 861 862 863 864 865 866 867 868
    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;
869 870 871 872 873 874 875 876 877 878 879 880
    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]);
    }
881

882 883 884
    av_freep(&s->dc_val_base);
    av_freep(&s->ac_val_base);
    av_freep(&s->coded_block_base);
885
    av_freep(&s->mbintra_table);
886 887
    av_freep(&s->cbp_table);
    av_freep(&s->pred_dir_table);
888

889
    av_freep(&s->mbskip_table);
890
    av_freep(&s->prev_pict_types);
891
    av_freep(&s->bitstream_buffer);
892 893
    s->allocated_bitstream_buffer_size=0;

894
    av_freep(&s->avctx->stats_out);
895
    av_freep(&s->ac_stats);
896
    av_freep(&s->error_status_table);
897
    av_freep(&s->mb_index2xy);
898
    av_freep(&s->lambda_table);
899 900
    av_freep(&s->q_intra_matrix);
    av_freep(&s->q_inter_matrix);
901 902
    av_freep(&s->q_intra_matrix16);
    av_freep(&s->q_inter_matrix16);
903 904
    av_freep(&s->input_picture);
    av_freep(&s->reordered_input_picture);
905
    av_freep(&s->dct_offset);
Michael Niedermayer's avatar
Michael Niedermayer committed
906

Michael Niedermayer's avatar
Michael Niedermayer committed
907 908 909 910
    if(s->picture){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
            free_picture(s, &s->picture[i]);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
911
    }
912
    av_freep(&s->picture);
Fabrice Bellard's avatar
Fabrice Bellard committed
913
    s->context_initialized = 0;
914 915 916
    s->last_picture_ptr=
    s->next_picture_ptr=
    s->current_picture_ptr= NULL;
917
    s->linesize= s->uvlinesize= 0;
918

919
    for(i=0; i<3; i++)
920
        av_freep(&s->visualization_buffer[i]);
921 922

    avcodec_default_free_buffers(s->avctx);
Fabrice Bellard's avatar
Fabrice Bellard committed
923 924
}

925 926
#ifdef CONFIG_ENCODERS

Fabrice Bellard's avatar
Fabrice Bellard committed
927 928 929 930
/* init video encoder */
int MPV_encode_init(AVCodecContext *avctx)
{
    MpegEncContext *s = avctx->priv_data;
931
    int i;
932
    int chroma_h_shift, chroma_v_shift;
933

Michael Niedermayer's avatar
Michael Niedermayer committed
934
    MPV_encode_defaults(s);
935

936 937 938 939 940 941 942 943 944
    switch (avctx->codec_id) {
    case CODEC_ID_MPEG2VIDEO:
        if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
            av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
            return -1;
        }
        break;
    case CODEC_ID_LJPEG:
    case CODEC_ID_MJPEG:
945 946
        if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
           ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
947 948 949
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
            return -1;
        }
950 951 952 953
        break;
    default:
        if(avctx->pix_fmt != PIX_FMT_YUV420P){
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
954 955 956
            return -1;
        }
    }
957

958 959 960 961 962 963 964 965 966 967 968 969
    switch (avctx->pix_fmt) {
    case PIX_FMT_YUVJ422P:
    case PIX_FMT_YUV422P:
        s->chroma_format = CHROMA_422;
        break;
    case PIX_FMT_YUVJ420P:
    case PIX_FMT_YUV420P:
    default:
        s->chroma_format = CHROMA_420;
        break;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
970 971 972
    s->bit_rate = avctx->bit_rate;
    s->width = avctx->width;
    s->height = avctx->height;
973
    if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
974
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
975 976
        avctx->gop_size=600;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
977
    s->gop_size = avctx->gop_size;
978
    s->avctx = avctx;
979
    s->flags= avctx->flags;
980
    s->flags2= avctx->flags2;
981
    s->max_b_frames= avctx->max_b_frames;
982
    s->codec_id= avctx->codec->id;
983 984 985 986
    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
987
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
988
    s->mpeg_quant= avctx->mpeg_quant;
989
    s->rtp_mode= !!avctx->rtp_payload_size;
990
    s->intra_dc_precision= avctx->intra_dc_precision;
991
    s->user_specified_pts = AV_NOPTS_VALUE;
992

Fabrice Bellard's avatar
Fabrice Bellard committed
993 994 995 996 997 998
    if (s->gop_size <= 1) {
        s->intra_only = 1;
        s->gop_size = 12;
    } else {
        s->intra_only = 0;
    }
999

Michael Niedermayer's avatar
Michael Niedermayer committed
1000
    s->me_method = avctx->me_method;
1001

1002
    /* Fixed QSCALE */
1003
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
1004

1005
    s->adaptive_quant= (   s->avctx->lumi_masking
1006
                        || s->avctx->dark_masking
1007
                        || s->avctx->temporal_cplx_masking
1008
                        || s->avctx->spatial_cplx_masking
1009
                        || s->avctx->p_masking
1010
                        || s->avctx->border_masking
1011
                        || (s->flags&CODEC_FLAG_QP_RD))
1012
                       && !s->fixed_qscale;
1013

1014 1015 1016
    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);
1017
    s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1018

1019 1020 1021
    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;
1022
    }
1023 1024

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

Michael Niedermayer's avatar
Michael Niedermayer committed
1028 1029 1030 1031
    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;
    }
1032

Michael Niedermayer's avatar
Michael Niedermayer committed
1033 1034 1035 1036
    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;
    }
1037 1038

    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1039 1040
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1041

1042 1043
        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");
    }
1044 1045

    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1046
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1047
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1048 1049
        return -1;
    }
1050

1051
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1052
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1053 1054
        return -1;
    }
1055

Michael Niedermayer's avatar
Michael Niedermayer committed
1056 1057 1058 1059
    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;
    }
1060

1061
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1062
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1063 1064 1065 1066
        return -1;
    }

    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1067
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1068 1069
        return -1;
    }
1070

Michael Niedermayer's avatar
Michael Niedermayer committed
1071
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1072
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1073 1074
        return -1;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
1075

1076
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
Michael Niedermayer's avatar
Michael Niedermayer committed
1077 1078 1079 1080
       && 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;
    }
1081

1082
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1083
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1084 1085
        return -1;
    }
1086

1087
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1088
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1089 1090 1091
        return -1;
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
1092 1093 1094 1095
    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;
    }
1096

1097 1098 1099 1100
    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;
    }
1101

1102 1103 1104 1105 1106
    if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
        av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
        return -1;
    }

1107 1108
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1109 1110 1111 1112
       && (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;
    }
1113

1114 1115
    if(s->avctx->thread_count > 1)
        s->rtp_mode= 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1116

1117
    if(!avctx->time_base.den || !avctx->time_base.num){
Michael Niedermayer's avatar
Michael Niedermayer committed
1118 1119 1120
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
        return -1;
    }
1121

1122 1123 1124 1125 1126 1127 1128 1129 1130
    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;
    }
1131

1132
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1133 1134
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
        avctx->b_frame_strategy = 0;
1135 1136
    }

1137
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
Michael Niedermayer's avatar
Michael Niedermayer committed
1138 1139
    if(i > 1){
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1140 1141
        avctx->time_base.den /= i;
        avctx->time_base.num /= i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1142 1143
//        return -1;
    }
1144

1145 1146 1147
    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
1148
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1149 1150 1151 1152 1153 1154
        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
    }
1155

1156 1157 1158 1159
    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;
1160

1161 1162
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);

1163
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1164
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1165
        return -1;
1166 1167
    }
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1168

Fabrice Bellard's avatar
Fabrice Bellard committed
1169 1170 1171
    switch(avctx->codec->id) {
    case CODEC_ID_MPEG1VIDEO:
        s->out_format = FMT_MPEG1;
1172 1173
        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
1174
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
1175 1176 1177 1178
    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);
1179
        s->rtp_mode= 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1180
        break;
1181
    case CODEC_ID_LJPEG:
Michael Niedermayer's avatar
Michael Niedermayer committed
1182
    case CODEC_ID_JPEGLS:
Fabrice Bellard's avatar
Fabrice Bellard committed
1183 1184 1185
    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
1186
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1187
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1188 1189 1190 1191 1192 1193
        s->mjpeg_vsample[0] = 2;
        s->mjpeg_vsample[1] = 2>>chroma_v_shift;
        s->mjpeg_vsample[2] = 2>>chroma_v_shift;
        s->mjpeg_hsample[0] = 2;
        s->mjpeg_hsample[1] = 2>>chroma_h_shift;
        s->mjpeg_hsample[2] = 2>>chroma_h_shift;
Fabrice Bellard's avatar
Fabrice Bellard committed
1194 1195
        if (mjpeg_init(s) < 0)
            return -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1196
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1197
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1198
        break;
1199 1200 1201 1202 1203
    case CODEC_ID_H261:
        s->out_format = FMT_H261;
        avctx->delay=0;
        s->low_delay=1;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1204
    case CODEC_ID_H263:
1205
        if (h263_get_picture_format(s->width, s->height) == 7) {
1206
            av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
Fabrice Bellard's avatar
Fabrice Bellard committed
1207
            return -1;
1208
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1209
        s->out_format = FMT_H263;
1210
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1211
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1212
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1213 1214 1215 1216
        break;
    case CODEC_ID_H263P:
        s->out_format = FMT_H263;
        s->h263_plus = 1;
1217
        /* Fx */
Michael Niedermayer's avatar
Michael Niedermayer committed
1218
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1219 1220 1221 1222 1223 1224
        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;
1225
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1226

1227
        /* /Fx */
1228
        /* These are just to be sure */
Michael Niedermayer's avatar
Michael Niedermayer committed
1229
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1230
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1231
        break;
1232 1233 1234 1235 1236 1237 1238 1239
    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
1240 1241
    case CODEC_ID_RV10:
        s->out_format = FMT_H263;
Michael Niedermayer's avatar
Michael Niedermayer committed
1242
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1243
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1244
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
    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;
1255
    case CODEC_ID_MPEG4:
Fabrice Bellard's avatar
Fabrice Bellard committed
1256 1257 1258
        s->out_format = FMT_H263;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1259
        s->low_delay= s->max_b_frames ? 0 : 1;
1260
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1261
        break;
1262
    case CODEC_ID_MSMPEG4V1:
Fabrice Bellard's avatar
Fabrice Bellard committed
1263 1264 1265 1266
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
1267
        s->msmpeg4_version= 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1268
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1269
        s->low_delay=1;
1270 1271 1272 1273 1274 1275 1276
        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
1277
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1278
        s->low_delay=1;
1279 1280 1281 1282 1283 1284 1285
        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;
1286
        s->flipflop_rounding=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1287
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1288
        s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1289
        break;
Michael Niedermayer's avatar
Michael Niedermayer committed
1290 1291 1292 1293 1294 1295
    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;
1296
        s->flipflop_rounding=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1297
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1298
        s->low_delay=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1299 1300 1301 1302 1303 1304 1305
        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;
1306
        s->flipflop_rounding=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1307
        avctx->delay=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
1308
        s->low_delay=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1309
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1310 1311 1312
    default:
        return -1;
    }
1313

1314
    avctx->has_b_frames= !s->low_delay;
1315

1316 1317
    s->encoding = 1;

Fabrice Bellard's avatar
Fabrice Bellard committed
1318 1319 1320
    /* init */
    if (MPV_common_init(s) < 0)
        return -1;
1321 1322 1323

    if(s->modified_quant)
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1324
    s->progressive_frame=
1325
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1326
    s->quant_precision=5;
1327

1328
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1329
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1330

1331
#ifdef CONFIG_H261_ENCODER
1332 1333
    if (s->out_format == FMT_H261)
        ff_h261_encode_init(s);
1334
#endif
1335 1336 1337 1338
    if (s->out_format == FMT_H263)
        h263_encode_init(s);
    if(s->msmpeg4_version)
        ff_msmpeg4_encode_init(s);
1339 1340
    if (s->out_format == FMT_MPEG1)
        ff_mpeg1_encode_init(s);
1341

Michael Niedermayer's avatar
Michael Niedermayer committed
1342
    /* init q matrix */
1343
    for(i=0;i<64;i++) {
1344
        int j= s->dsp.idct_permutation[i];
1345
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1346 1347
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1348
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1349 1350
            s->intra_matrix[j] =
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1351
        }else
Michael Niedermayer's avatar
Michael Niedermayer committed
1352
        { /* mpeg1/2 */
1353 1354
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1355
        }
1356 1357 1358 1359
        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];
1360 1361 1362
    }

    /* precompute matrix */
1363
    /* for mjpeg, we do include qscale in the matrix */
1364
    if (s->out_format != FMT_MJPEG) {
1365
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1366
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1367
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1368
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1369 1370
    }

1371 1372
    if(ff_rate_control_init(s) < 0)
        return -1;
1373

Fabrice Bellard's avatar
Fabrice Bellard committed
1374 1375 1376 1377 1378 1379 1380
    return 0;
}

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

1381 1382
    ff_rate_control_uninit(s);

Fabrice Bellard's avatar
Fabrice Bellard committed
1383 1384 1385
    MPV_common_end(s);
    if (s->out_format == FMT_MJPEG)
        mjpeg_close(s);
1386

1387
    av_freep(&avctx->extradata);
1388

Fabrice Bellard's avatar
Fabrice Bellard committed
1389 1390 1391
    return 0;
}

1392 1393
#endif //CONFIG_ENCODERS

1394
void init_rl(RLTable *rl, int use_static)
1395
{
1396 1397
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
    uint8_t index_run[MAX_RUN+1];
1398 1399
    int last, run, level, start, end, i;

1400 1401 1402 1403
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
    if(use_static && rl->max_level[0])
        return;

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
    /* 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;
        }
1427 1428 1429 1430
        if(use_static)
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
        else
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1431
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1432 1433 1434 1435
        if(use_static)
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
        else
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1436
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1437 1438 1439 1440
        if(use_static)
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
        else
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1441 1442 1443 1444
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1445
/* draw the edges of width 'w' of an image of size width, height */
1446
//FIXME check that this is ok for mpeg4 interlaced
1447
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
Fabrice Bellard's avatar
Fabrice Bellard committed
1448
{
1449
    uint8_t *ptr, *last_line;
Fabrice Bellard's avatar
Fabrice Bellard committed
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
    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 */
    }
}

1474
int ff_find_unused_picture(MpegEncContext *s, int shared){
Michael Niedermayer's avatar
Michael Niedermayer committed
1475
    int i;
1476

Michael Niedermayer's avatar
Michael Niedermayer committed
1477 1478
    if(shared){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1479
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1480 1481 1482
        }
    }else{
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1483
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
Michael Niedermayer's avatar
Michael Niedermayer committed
1484 1485
        }
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1486
            if(s->picture[i].data[0]==NULL) return i;
Michael Niedermayer's avatar
Michael Niedermayer committed
1487 1488 1489
        }
    }

1490 1491
    assert(0);
    return -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
1492 1493
}

1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
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;
        }
1504

1505 1506 1507 1508 1509 1510
        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);
        }
    }
}

1511 1512 1513
/**
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
 */
1514
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
1515
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1516
    int i;
1517
    AVFrame *pic;
1518
    s->mb_skipped = 0;
1519

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

Michael Niedermayer's avatar
Michael Niedermayer committed
1522
    /* mark&release old frames */
1523
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1524
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
1525 1526 1527 1528 1529

        /* release forgotten pictures */
        /* if(mpeg124/h263) */
        if(!s->encoding){
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1530
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1531
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1532
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
Michael Niedermayer's avatar
Michael Niedermayer committed
1533 1534
                }
            }
1535
        }
1536
    }
1537 1538
alloc:
    if(!s->encoding){
Diego Biurrun's avatar
Diego Biurrun committed
1539
        /* release non reference frames */
1540 1541 1542 1543 1544 1545
        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]);
            }
        }

1546 1547 1548 1549 1550 1551 1552
        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];
        }

1553 1554
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
                        && !s->dropable ? 3 : 0;
1555

1556
        pic->coded_picture_number= s->coded_picture_number++;
1557

1558 1559
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
            return -1;
1560

1561
        s->current_picture_ptr= (Picture*)pic;
1562
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1563
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
Michael Niedermayer's avatar
Michael Niedermayer committed
1564
    }
1565

1566
    s->current_picture_ptr->pict_type= s->pict_type;
1567
//    if(s->flags && CODEC_FLAG_QSCALE)
1568
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1569
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1570

1571
    copy_picture(&s->current_picture, s->current_picture_ptr);
1572

1573
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
Michael Niedermayer's avatar
Michael Niedermayer committed
1574
    if (s->pict_type != B_TYPE) {
1575
        s->last_picture_ptr= s->next_picture_ptr;
1576 1577
        if(!s->dropable)
            s->next_picture_ptr= s->current_picture_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
1578
    }
1579
/*    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,
1580 1581
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1582 1583
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
        s->pict_type, s->dropable);*/
1584

1585 1586
    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);
1587

1588
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1589
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
Diego Biurrun's avatar
Diego Biurrun committed
1590
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1591 1592 1593 1594 1595
        goto alloc;
    }

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

1596 1597 1598 1599 1600
    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];
1601
            }
1602 1603 1604 1605 1606
            s->current_picture.linesize[i] *= 2;
            s->last_picture.linesize[i] *=2;
            s->next_picture.linesize[i] *=2;
        }
    }
1607
  }
1608

1609 1610 1611
    s->hurry_up= s->avctx->hurry_up;
    s->error_resilience= avctx->error_resilience;

Diego Biurrun's avatar
Diego Biurrun committed
1612 1613
    /* 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 */
1614 1615 1616
    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;
1617
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1618 1619 1620 1621 1622 1623
        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;
    }
1624

1625 1626 1627 1628 1629
    if(s->dct_error_sum){
        assert(s->avctx->noise_reduction && s->encoding);

        update_noise_reduction(s);
    }
1630

Ivan Kalvachev's avatar
Ivan Kalvachev committed
1631 1632 1633 1634
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration)
        return XVMC_field_start(s, avctx);
#endif
1635
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1636
}
1637

Fabrice Bellard's avatar
Fabrice Bellard committed
1638 1639 1640
/* 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
1641
    int i;
Fabrice Bellard's avatar
Fabrice Bellard committed
1642
    /* draw edge for correct motion prediction if outside */
Ivan Kalvachev's avatar
Ivan Kalvachev committed
1643 1644 1645 1646 1647 1648
#ifdef HAVE_XVMC
//just to make sure that all data is rendered.
    if(s->avctx->xvmc_acceleration){
        XVMC_field_end(s);
    }else
#endif
1649
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1650 1651 1652
            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
1653
    }
1654
    emms_c();
1655

1656
    s->last_pict_type    = s->pict_type;
1657
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1658 1659 1660
    if(s->pict_type!=B_TYPE){
        s->last_non_b_pict_type= s->pict_type;
    }
1661 1662
#if 0
        /* copy back current_picture variables */
Michael Niedermayer's avatar
Michael Niedermayer committed
1663 1664 1665 1666
    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;
1667
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1668 1669
    }
    assert(i<MAX_PICTURE_COUNT);
1670
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
1671

1672
    if(s->encoding){
Diego Biurrun's avatar
Diego Biurrun committed
1673
        /* release non-reference frames */
1674 1675 1676 1677 1678
        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
1679
    }
1680 1681 1682 1683 1684 1685
    // 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
1686
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
1687 1688
}

1689 1690 1691 1692 1693 1694 1695 1696
/**
 * 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){
Michael Niedermayer's avatar
Michael Niedermayer committed
1697
    int x, y, fr, f;
1698

1699 1700 1701 1702
    sx= clip(sx, 0, w-1);
    sy= clip(sy, 0, h-1);
    ex= clip(ex, 0, w-1);
    ey= clip(ey, 0, h-1);
1703

1704
    buf[sy*stride + sx]+= color;
1705

1706
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1707
        if(sx > ex){
Michael Niedermayer's avatar
Michael Niedermayer committed
1708 1709
            SWAP(int, sx, ex);
            SWAP(int, sy, ey);
1710 1711 1712 1713 1714
        }
        buf+= sx + sy*stride;
        ex-= sx;
        f= ((ey-sy)<<16)/ex;
        for(x= 0; x <= ex; x++){
1715 1716 1717 1718
            y = (x*f)>>16;
            fr= (x*f)&0xFFFF;
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1719 1720 1721
        }
    }else{
        if(sy > ey){
Michael Niedermayer's avatar
Michael Niedermayer committed
1722 1723
            SWAP(int, sx, ex);
            SWAP(int, sy, ey);
1724 1725 1726 1727 1728 1729
        }
        buf+= sx + sy*stride;
        ey-= sy;
        if(ey) f= ((ex-sx)<<16)/ey;
        else   f= 0;
        for(y= 0; y <= ey; y++){
1730 1731 1732 1733
            x = (y*f)>>16;
            fr= (y*f)&0xFFFF;
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
        }
    }
}

/**
 * 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
 */
1745
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1746 1747 1748 1749 1750 1751
    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);
1752

1753 1754
    dx= ex - sx;
    dy= ey - sy;
1755

1756 1757 1758 1759
    if(dx*dx + dy*dy > 3*3){
        int rx=  dx + dy;
        int ry= -dx + dy;
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1760

1761 1762 1763
        //FIXME subpixel accuracy
        rx= ROUNDED_DIV(rx*3<<4, length);
        ry= ROUNDED_DIV(ry*3<<4, length);
1764

1765 1766 1767 1768 1769 1770
        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);
}

1771 1772 1773
/**
 * prints debuging info for the given picture.
 */
1774
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1775 1776 1777 1778 1779

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

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

1781 1782 1783 1784 1785 1786 1787
        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;
1788
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1789
        }
1790 1791 1792 1793 1794
        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;
1795
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1796 1797
                }
                if(s->avctx->debug&FF_DEBUG_QP){
1798
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1799 1800 1801 1802 1803
                }
                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))
1804
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1805
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1806
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1807
                    else if(IS_INTRA4x4(mb_type))
1808
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1809
                    else if(IS_INTRA16x16(mb_type))
1810
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1811
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1812
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1813
                    else if(IS_DIRECT(mb_type))
1814
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1815
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1816
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1817
                    else if(IS_GMC(mb_type))
1818
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1819
                    else if(IS_SKIP(mb_type))
1820
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1821
                    else if(!USES_LIST(mb_type, 1))
1822
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1823
                    else if(!USES_LIST(mb_type, 0))
1824
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1825 1826
                    else{
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1827
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1828
                    }
1829

1830 1831
                    //segmentation
                    if(IS_8X8(mb_type))
1832
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1833
                    else if(IS_16X8(mb_type))
1834
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1835
                    else if(IS_8X16(mb_type))
1836
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1837
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1838
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1839
                    else
1840
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1841 1842


1843
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1844
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1845
                    else
1846
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1847
                }
1848
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1849
            }
1850
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1851 1852
        }
    }
1853

1854
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1855 1856
        const int shift= 1 + s->quarter_sample;
        int mb_y;
1857 1858
        uint8_t *ptr;
        int i;
1859
        int h_chroma_shift, v_chroma_shift;
1860 1861
        const int width = s->avctx->width;
        const int height= s->avctx->height;
1862
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1863
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
Michael Niedermayer's avatar
Michael Niedermayer committed
1864
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1865

1866
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1867
        for(i=0; i<3; i++){
1868
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1869 1870 1871 1872
            pict->data[i]= s->visualization_buffer[i];
        }
        pict->type= FF_BUFFER_TYPE_COPY;
        ptr= pict->data[0];
1873 1874 1875 1876 1877

        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;
1878 1879 1880
                if((s->avctx->debug_mv) && pict->motion_val){
                  int type;
                  for(type=0; type<3; type++){
1881
                    int direction = 0;
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
                    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;
                    }
1896 1897 1898
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
                        continue;

1899 1900 1901
                    if(IS_8X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<4; i++){
1902 1903
                        int sx= mb_x*16 + 4 + 8*(i&1);
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1904
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1905 1906
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1907
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1908 1909 1910 1911
                      }
                    }else if(IS_16X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<2; i++){
1912 1913
                        int sx=mb_x*16 + 8;
                        int sy=mb_y*16 + 4 + 8*i;
1914
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1915 1916
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1917

1918 1919
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1920

1921 1922 1923 1924 1925 1926 1927
                        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;
1928
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1929 1930
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1931

1932 1933
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1934

1935
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1936 1937 1938 1939
                      }
                    }else{
                      int sx= mb_x*16 + 8;
                      int sy= mb_y*16 + 8;
1940
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1941 1942
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1943
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1944
                    }
1945
                  }
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
                }
                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));

1963

1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005
                    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;
                    }
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
                    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;
                        }
                    }
2021

2022 2023 2024
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
                        // hmm
                    }
2025 2026 2027 2028 2029
                }
                s->mbskip_table[mb_index]=0;
            }
        }
    }
2030 2031
}

2032 2033
#ifdef CONFIG_ENCODERS

2034 2035 2036
static int get_sae(uint8_t *src, int ref, int stride){
    int x,y;
    int acc=0;
2037

2038 2039
    for(y=0; y<16; y++){
        for(x=0; x<16; x++){
2040
            acc+= FFABS(src[x+y*stride] - ref);
2041 2042
        }
    }
2043

2044 2045 2046 2047 2048 2049
    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;
2050

2051 2052
    w= s->width &~15;
    h= s->height&~15;
2053

2054 2055 2056
    for(y=0; y<h; y+=16){
        for(x=0; x<w; x+=16){
            int offset= x + y*stride;
2057
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2058 2059
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
            int sae = get_sae(src + offset, mean, stride);
2060

2061 2062 2063 2064 2065 2066
            acc+= sae + 500 < sad;
        }
    }
    return acc;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
2067

2068
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2069
    AVFrame *pic=NULL;
2070
    int64_t pts;
Michael Niedermayer's avatar
Michael Niedermayer committed
2071
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
2072
    const int encoding_delay= s->max_b_frames;
Michael Niedermayer's avatar
Michael Niedermayer committed
2073
    int direct=1;
2074

2075
    if(pic_arg){
2076 2077 2078
        pts= pic_arg->pts;
        pic_arg->display_picture_number= s->input_picture_number++;

2079
        if(pts != AV_NOPTS_VALUE){
2080
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2081 2082
                int64_t time= pts;
                int64_t last= s->user_specified_pts;
2083 2084

                if(time <= last){
2085
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2086 2087 2088
                    return -1;
                }
            }
2089
            s->user_specified_pts= pts;
2090 2091
        }else{
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2092
                s->user_specified_pts=
2093
                pts= s->user_specified_pts + 1;
2094
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2095
            }else{
2096
                pts= pic_arg->display_picture_number;
2097 2098 2099 2100
            }
        }
    }

2101
  if(pic_arg){
Michael Niedermayer's avatar
Michael Niedermayer committed
2102 2103 2104 2105
    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;
2106

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

Michael Niedermayer's avatar
Michael Niedermayer committed
2109
    if(direct){
2110
        i= ff_find_unused_picture(s, 1);
Michael Niedermayer's avatar
Michael Niedermayer committed
2111

2112
        pic= (AVFrame*)&s->picture[i];
2113
        pic->reference= 3;
2114

Michael Niedermayer's avatar
Michael Niedermayer committed
2115 2116 2117 2118 2119 2120
        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{
2121
        i= ff_find_unused_picture(s, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
2122

2123
        pic= (AVFrame*)&s->picture[i];
2124
        pic->reference= 3;
Michael Niedermayer's avatar
Michael Niedermayer committed
2125

Michael Niedermayer's avatar
Michael Niedermayer committed
2126 2127
        alloc_picture(s, (Picture*)pic, 0);

2128 2129 2130
        if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
           && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
           && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
Michael Niedermayer's avatar
Michael Niedermayer committed
2131
       // empty
Michael Niedermayer's avatar
Michael Niedermayer committed
2132 2133 2134
        }else{
            int h_chroma_shift, v_chroma_shift;
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2135

Michael Niedermayer's avatar
Michael Niedermayer committed
2136 2137 2138 2139 2140 2141 2142 2143
            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];
2144 2145 2146 2147
                uint8_t *dst= pic->data[i];

                if(!s->avctx->rc_buffer_size)
                    dst +=INPLACE_OFFSET;
2148

Michael Niedermayer's avatar
Michael Niedermayer committed
2149 2150 2151 2152 2153 2154 2155 2156
                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
2157
                }
2158
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
2159 2160
        }
    }
2161
    copy_picture_attributes(s, pic, pic_arg);
2162
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2163
  }
2164

Michael Niedermayer's avatar
Michael Niedermayer committed
2165 2166 2167
    /* shift buffer entries */
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
        s->input_picture[i-1]= s->input_picture[i];
2168

Michael Niedermayer's avatar
Michael Niedermayer committed
2169
    s->input_picture[encoding_delay]= (Picture*)pic;
Michael Niedermayer's avatar
Michael Niedermayer committed
2170 2171 2172

    return 0;
}
2173

Michael Niedermayer's avatar
Michael Niedermayer committed
2174 2175 2176
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
    int x, y, plane;
    int score=0;
2177
    int64_t score64=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2178 2179 2180 2181 2182 2183

    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
2184 2185
                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);
2186

2187 2188
                switch(s->avctx->frame_skip_exp){
                    case 0: score= FFMAX(score, v); break;
2189
                    case 1: score+= FFABS(v);break;
2190
                    case 2: score+= v*v;break;
2191
                    case 3: score64+= FFABS(v*v*(int64_t)v);break;
2192 2193
                    case 4: score64+= v*v*(int64_t)(v*v);break;
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
2194 2195 2196
            }
        }
    }
2197

2198
    if(score) score64= score;
Michael Niedermayer's avatar
Michael Niedermayer committed
2199

2200
    if(score64 < s->avctx->frame_skip_threshold)
Michael Niedermayer's avatar
Michael Niedermayer committed
2201
        return 1;
2202
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
Michael Niedermayer's avatar
Michael Niedermayer committed
2203 2204 2205 2206
        return 1;
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
2207 2208 2209 2210
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];
2211
    const int scale= s->avctx->brd_scale;
2212
    int i, j, out_size, p_lambda, b_lambda, lambda2;
2213
    int outbuf_size= s->width * s->height; //FIXME
Michael Niedermayer's avatar
Michael Niedermayer committed
2214 2215 2216
    uint8_t *outbuf= av_malloc(outbuf_size);
    int64_t best_rd= INT64_MAX;
    int best_b_count= -1;
2217

2218 2219
    assert(scale>=0 && scale <=3);

2220 2221
//    emms_c();
    p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2222
    b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2223 2224
    if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
    lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
Michael Niedermayer's avatar
Michael Niedermayer committed
2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243

    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;

    for(i=0; i<s->max_b_frames+2; i++){
        int ysize= c->width*c->height;
        int csize= (c->width/2)*(c->height/2);
2244 2245 2246 2247 2248 2249 2250 2251 2252 2253
        Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;

        if(pre_input_ptr)
            pre_input= *pre_input_ptr;

        if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
            pre_input.data[0]+=INPLACE_OFFSET;
            pre_input.data[1]+=INPLACE_OFFSET;
            pre_input.data[2]+=INPLACE_OFFSET;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
2254 2255 2256 2257 2258 2259 2260 2261 2262

        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;

2263 2264 2265 2266 2267
        if(!i || s->input_picture[i-1]){
            s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
            s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
            s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278
    }

    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;
2279
        input[0].quality= 1 * FF_QP2LAMBDA;
Michael Niedermayer's avatar
Michael Niedermayer committed
2280
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2281
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
Michael Niedermayer's avatar
Michael Niedermayer committed
2282 2283 2284 2285 2286

        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;
2287
            input[i+1].quality= is_p ? p_lambda : b_lambda;
Michael Niedermayer's avatar
Michael Niedermayer committed
2288
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2289
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
Michael Niedermayer's avatar
Michael Niedermayer committed
2290 2291 2292 2293 2294
        }

        /* get the delayed frames */
        while(out_size){
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2295
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
Michael Niedermayer's avatar
Michael Niedermayer committed
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
        }

        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);

    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
2317 2318
static void select_input_picture(MpegEncContext *s){
    int i;
Michael Niedermayer's avatar
Michael Niedermayer committed
2319

Michael Niedermayer's avatar
Michael Niedermayer committed
2320 2321 2322 2323
    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
2324
    /* set next picture type & ordering */
Michael Niedermayer's avatar
Michael Niedermayer committed
2325
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2326
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2327 2328
            s->reordered_input_picture[0]= s->input_picture[0];
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2329
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2330 2331
        }else{
            int b_frames;
Michael Niedermayer's avatar
Michael Niedermayer committed
2332 2333

            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
Michael Niedermayer's avatar
Michael Niedermayer committed
2334 2335
                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
2336
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2337

Michael Niedermayer's avatar
Michael Niedermayer committed
2338 2339 2340
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
                        for(i=0; i<4; i++)
                            s->input_picture[0]->data[i]= NULL;
2341
                        s->input_picture[0]->type= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2342
                    }else{
2343
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
Michael Niedermayer's avatar
Michael Niedermayer committed
2344
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2345

Michael Niedermayer's avatar
Michael Niedermayer committed
2346 2347
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
                    }
2348

Michael Niedermayer's avatar
Michael Niedermayer committed
2349 2350
                    emms_c();
                    ff_vbv_update(s, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
2351 2352 2353 2354 2355

                    goto no_output_pic;
                }
            }

2356 2357 2358
            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;
2359

2360
                    if(pict_num >= s->rc_context.num_entries)
2361
                        break;
2362
                    if(!s->input_picture[i]){
2363
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2364 2365
                        break;
                    }
2366

2367
                    s->input_picture[i]->pict_type=
2368
                        s->rc_context.entry[pict_num].new_pict_type;
2369 2370
                }
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
2371

2372
            if(s->avctx->b_frame_strategy==0){
2373
                b_frames= s->max_b_frames;
2374
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
Michael Niedermayer's avatar
Michael Niedermayer committed
2375
            }else if(s->avctx->b_frame_strategy==1){
2376
                for(i=1; i<s->max_b_frames+1; i++){
2377
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2378 2379
                        s->input_picture[i]->b_frame_score=
                            get_intra_count(s, s->input_picture[i  ]->data[0],
Michael Niedermayer's avatar
Michael Niedermayer committed
2380
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2381 2382
                    }
                }
2383
                for(i=0; i<s->max_b_frames+1; i++){
2384
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2385
                }
2386

2387
                b_frames= FFMAX(0, i-1);
2388

2389 2390 2391 2392
                /* 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
2393 2394
            }else if(s->avctx->b_frame_strategy==2){
                b_frames= estimate_best_b_count(s);
2395
            }else{
2396
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2397
                b_frames=0;
2398
            }
2399 2400 2401 2402

            emms_c();
//static int b_count=0;
//b_count+= b_frames;
2403
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2404 2405 2406 2407 2408 2409 2410

            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){
2411
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2412 2413
            }

2414
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2415 2416 2417
              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{
2418 2419 2420
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
                    b_frames=0;
                s->input_picture[b_frames]->pict_type= I_TYPE;
2421
              }
2422
            }
2423

2424 2425 2426 2427 2428
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
               && b_frames
               && s->input_picture[b_frames]->pict_type== I_TYPE)
                b_frames--;

2429
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2430
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2431
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2432
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2433 2434 2435
            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;
2436
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2437 2438 2439
            }
        }
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2440
no_output_pic:
Michael Niedermayer's avatar
Michael Niedermayer committed
2441
    if(s->reordered_input_picture[0]){
2442
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2443

2444
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
Michael Niedermayer's avatar
Michael Niedermayer committed
2445

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

2449
            int i= ff_find_unused_picture(s, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
2450 2451
            Picture *pic= &s->picture[i];

2452 2453 2454
            pic->reference              = s->reordered_input_picture[0]->reference;
            alloc_picture(s, pic, 0);

Michael Niedermayer's avatar
Michael Niedermayer committed
2455
            /* mark us unused / free shared pic */
2456 2457
            if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
                s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
Michael Niedermayer's avatar
Michael Niedermayer committed
2458 2459 2460
            for(i=0; i<4; i++)
                s->reordered_input_picture[0]->data[i]= NULL;
            s->reordered_input_picture[0]->type= 0;
2461

2462 2463
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);

2464
            s->current_picture_ptr= pic;
Michael Niedermayer's avatar
Michael Niedermayer committed
2465
        }else{
2466 2467
            // input is not a shared pix -> reuse buffer for current_pix

2468
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
Michael Niedermayer's avatar
Michael Niedermayer committed
2469
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2470

2471
            s->current_picture_ptr= s->reordered_input_picture[0];
Michael Niedermayer's avatar
Michael Niedermayer committed
2472
            for(i=0; i<4; i++){
2473
                s->new_picture.data[i]+= INPLACE_OFFSET;
Michael Niedermayer's avatar
Michael Niedermayer committed
2474
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
2475
        }
2476
        copy_picture(&s->current_picture, s->current_picture_ptr);
2477

Michael Niedermayer's avatar
Michael Niedermayer committed
2478 2479 2480 2481
        s->picture_number= s->new_picture.display_picture_number;
//printf("dpn:%d\n", s->picture_number);
    }else{
       memset(&s->new_picture, 0, sizeof(Picture));
2482 2483 2484
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
2485 2486 2487 2488
int MPV_encode_picture(AVCodecContext *avctx,
                       unsigned char *buf, int buf_size, void *data)
{
    MpegEncContext *s = avctx->priv_data;
2489
    AVFrame *pic_arg = data;
2490
    int i, stuffing_count;
Fabrice Bellard's avatar
Fabrice Bellard committed
2491

2492
    for(i=0; i<avctx->thread_count; i++){
Michael Niedermayer's avatar
Michael Niedermayer committed
2493 2494
        int start_y= s->thread_context[i]->start_mb_y;
        int   end_y= s->thread_context[i]->  end_mb_y;
2495
        int h= s->mb_height;
2496 2497
        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);
2498 2499 2500

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

Michael Niedermayer's avatar
Michael Niedermayer committed
2502
    s->picture_in_gop_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
2503

2504 2505
    if(load_input_picture(s, pic_arg) < 0)
        return -1;
2506

Michael Niedermayer's avatar
Michael Niedermayer committed
2507
    select_input_picture(s);
2508

2509
    /* output? */
Michael Niedermayer's avatar
Michael Niedermayer committed
2510 2511 2512 2513
    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);
2514
        MPV_frame_start(s, avctx);
2515
vbv_retry:
2516 2517
        if (encode_picture(s, s->picture_number) < 0)
            return -1;
2518

2519
        avctx->real_pict_num  = s->picture_number;
2520 2521 2522 2523 2524 2525
        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;
2526
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2527 2528 2529 2530 2531 2532
        avctx->skip_count  = s->skip_count;

        MPV_frame_end(s);

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

2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555
        if(avctx->rc_buffer_size){
            RateControlContext *rcc= &s->rc_context;
            int max_size= rcc->buffer_index/3;

            if(put_bits_count(&s->pb) > max_size && s->qscale < s->avctx->qmax){
                s->next_lambda= s->lambda*(s->qscale+1) / s->qscale;
                s->mb_skipped = 0;        //done in MPV_frame_start()
                if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
                    if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
                        s->no_rounding ^= 1;
                }
//                av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
                for(i=0; i<avctx->thread_count; i++){
                    PutBitContext *pb= &s->thread_context[i]->pb;
                    init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
                }
                goto vbv_retry;
            }

            assert(s->avctx->rc_max_rate);
        }

2556 2557
        if(s->flags&CODEC_FLAG_PASS1)
            ff_write_pass1_stats(s);
2558 2559

        for(i=0; i<4; i++){
2560
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2561 2562
            avctx->error[i] += s->current_picture_ptr->error[i];
        }
2563

2564 2565
        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));
2566
        flush_put_bits(&s->pb);
2567
        s->frame_bits  = put_bits_count(&s->pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
2568

Michael Niedermayer's avatar
Michael Niedermayer committed
2569 2570
        stuffing_count= ff_vbv_update(s, s->frame_bits);
        if(stuffing_count){
2571 2572 2573 2574 2575
            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
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594
            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);
2595
            s->frame_bits  = put_bits_count(&s->pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
2596
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
2597

2598
        /* update mpeg1/2 vbv_delay for CBR */
2599 2600
        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
2601
            int vbv_delay;
Michael Niedermayer's avatar
Michael Niedermayer committed
2602

Michael Niedermayer's avatar
Michael Niedermayer committed
2603
            assert(s->repeat_first_field==0);
2604

Michael Niedermayer's avatar
Michael Niedermayer committed
2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
            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
2619
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2620
    assert((s->frame_bits&7)==0);
2621

2622
    return s->frame_bits/8;
Fabrice Bellard's avatar
Fabrice Bellard committed
2623 2624
}

2625 2626
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
2627
static inline void gmc1_motion(MpegEncContext *s,
2628
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2629
                               uint8_t **ref_picture)
Michael Niedermayer's avatar
Michael Niedermayer committed
2630
{
2631
    uint8_t *ptr;
Michael Niedermayer's avatar
Michael Niedermayer committed
2632
    int offset, src_x, src_y, linesize, uvlinesize;
Michael Niedermayer's avatar
Michael Niedermayer committed
2633
    int motion_x, motion_y;
2634
    int emu=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647

    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;
2648

Michael Niedermayer's avatar
Michael Niedermayer committed
2649
    linesize = s->linesize;
Michael Niedermayer's avatar
Michael Niedermayer committed
2650
    uvlinesize = s->uvlinesize;
2651

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

2654
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2655 2656
        if(   (unsigned)src_x >= s->h_edge_pos - 17
           || (unsigned)src_y >= s->v_edge_pos - 17){
2657
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2658 2659 2660
            ptr= s->edge_emu_buffer;
        }
    }
2661

2662
    if((motion_x|motion_y)&7){
2663 2664
        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);
2665 2666
    }else{
        int dxy;
2667

2668 2669
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
        if (s->no_rounding){
2670
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2671
        }else{
2672 2673
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
        }
2674
    }
2675

2676
    if(s->flags&CODEC_FLAG_GRAY) return;
Michael Niedermayer's avatar
Michael Niedermayer committed
2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690

    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;

2691
    offset = (src_y * uvlinesize) + src_x;
Michael Niedermayer's avatar
Michael Niedermayer committed
2692
    ptr = ref_picture[1] + offset;
2693
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2694 2695
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2696
            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);
2697 2698 2699
            ptr= s->edge_emu_buffer;
            emu=1;
        }
2700
    }
2701
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2702

Michael Niedermayer's avatar
Michael Niedermayer committed
2703
    ptr = ref_picture[2] + offset;
2704
    if(emu){
2705
        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);
2706 2707
        ptr= s->edge_emu_buffer;
    }
2708
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2709

Michael Niedermayer's avatar
Michael Niedermayer committed
2710 2711 2712
    return;
}

2713
static inline void gmc_motion(MpegEncContext *s,
2714
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2715
                               uint8_t **ref_picture)
2716
{
2717
    uint8_t *ptr;
2718 2719 2720 2721 2722 2723 2724
    int linesize, uvlinesize;
    const int a= s->sprite_warping_accuracy;
    int ox, oy;

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

2725
    ptr = ref_picture[0];
2726 2727 2728 2729

    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;

2730
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2731 2732
           ox,
           oy,
2733
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2734
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2735 2736
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos, s->v_edge_pos);
2737
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2738 2739
           ox + s->sprite_delta[0][0]*8,
           oy + s->sprite_delta[1][0]*8,
2740
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2741
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2742 2743 2744 2745 2746 2747 2748 2749
           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;

2750
    ptr = ref_picture[1];
2751
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2752 2753
           ox,
           oy,
2754
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2755
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2756 2757
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2758

2759
    ptr = ref_picture[2];
2760
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2761 2762
           ox,
           oy,
2763
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2764
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2765 2766 2767 2768
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos>>1, s->v_edge_pos>>1);
}

2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780
/**
 * 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
 */
2781
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2782 2783 2784
                                    int src_x, int src_y, int w, int h){
    int x, y;
    int start_y, start_x, end_y, end_x;
2785

2786 2787 2788
    if(src_y>= h){
        src+= (h-1-src_y)*linesize;
        src_y=h-1;
2789 2790 2791
    }else if(src_y<=-block_h){
        src+= (1-block_h-src_y)*linesize;
        src_y=1-block_h;
2792 2793 2794 2795
    }
    if(src_x>= w){
        src+= (w-1-src_x);
        src_x=w-1;
2796 2797 2798
    }else if(src_x<=-block_w){
        src+= (1-block_w-src_x);
        src_x=1-block_w;
2799 2800
    }

2801 2802 2803 2804
    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);
2805

2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
    // 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];
        }
    }
2826

2827 2828 2829 2830 2831
    for(y=0; y<block_h; y++){
       //left
        for(x=0; x<start_x; x++){
            buf[x + y*linesize]= buf[start_x + y*linesize];
        }
2832

2833 2834 2835 2836 2837 2838 2839
       //right
        for(x=end_x; x<block_w; x++){
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
        }
    }
}

2840
static inline int hpel_motion(MpegEncContext *s,
2841 2842
                                  uint8_t *dest, uint8_t *src,
                                  int field_based, int field_select,
2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854
                                  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;
2855

2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
    /* 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){
2868 2869
            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);
2870 2871 2872 2873
            src= s->edge_emu_buffer;
            emu=1;
        }
    }
2874 2875
    if(field_select)
        src += s->linesize;
2876 2877 2878
    pix_op[dxy](dest, src, stride, h);
    return emu;
}
2879

2880
static inline int hpel_motion_lowres(MpegEncContext *s,
Michael Niedermayer's avatar
Michael Niedermayer committed
2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902
                                  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);
2903

Michael Niedermayer's avatar
Michael Niedermayer committed
2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
    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
2922
/* apply one mpeg motion vector to the three components */
2923
static always_inline void mpeg_motion(MpegEncContext *s,
2924
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2925 2926
                               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
2927 2928
                               int motion_x, int motion_y, int h)
{
2929 2930
    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;
2931 2932

#if 0
Michael Niedermayer's avatar
Michael Niedermayer committed
2933 2934 2935 2936 2937
if(s->quarter_sample)
{
    motion_x>>=1;
    motion_y>>=1;
}
Michael Niedermayer's avatar
Michael Niedermayer committed
2938
#endif
2939

2940
    v_edge_pos = s->v_edge_pos >> field_based;
2941
    linesize   = s->current_picture.linesize[0] << field_based;
2942
    uvlinesize = s->current_picture.linesize[1] << field_based;
2943

2944 2945
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
    src_x = s->mb_x* 16               + (motion_x >> 1);
2946
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2947

Fabrice Bellard's avatar
Fabrice Bellard committed
2948
    if (s->out_format == FMT_H263) {
2949 2950 2951 2952 2953
        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);
2954
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2955 2956 2957 2958 2959
        }else{
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
            uvsrc_x = src_x>>1;
            uvsrc_y = src_y>>1;
        }
2960 2961 2962 2963 2964 2965
    }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
2966
    } else {
2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
        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
2987
    }
2988 2989 2990 2991 2992 2993 2994

    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){
2995 2996 2997 2998 2999
            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 ;
            }
3000 3001 3002 3003
            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
3004
                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, s->h_edge_pos>>1, s->v_edge_pos>>1);
3007
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3008 3009 3010 3011
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
                ptr_cb= uvbuf;
                ptr_cr= uvbuf+16;
            }
3012 3013
    }

3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026
    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);
3027

3028
    if(!(s->flags&CODEC_FLAG_GRAY)){
3029 3030
        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);
3031
    }
3032
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3033 3034 3035
    if(s->out_format == FMT_H261){
        ff_h261_loop_filter(s);
    }
3036
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3037
}
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055

/* 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;

3056 3057 3058 3059
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
        motion_x/=2;
        motion_y/=2;
    }
3060

3061 3062 3063 3064
    if(field_based){
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
    }

3065 3066 3067
    sx= motion_x & s_mask;
    sy= motion_y & s_mask;
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
3068
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3069

3070
    if (s->out_format == FMT_H263) {
Michael Niedermayer's avatar
Michael Niedermayer committed
3071 3072
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087
        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));
3088
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101
    }

    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;
3102
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3103
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3104
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3105 3106 3107 3108 3109 3110
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
                ptr_cb= uvbuf;
                ptr_cr= uvbuf+16;
            }
    }

3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122
    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;
    }

3123 3124 3125
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3126

3127 3128 3129 3130 3131 3132
    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);
    }
3133
    //FIXME h261 lowres loop filter
3134 3135
}

3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150
//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);
3151

3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
    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];
3198

3199
    assert(s->quarter_sample==0);
3200

3201 3202 3203 3204
    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{
3205
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3206
            hpel_motion(s, ptr[i], src, 0, 0,
3207 3208 3209 3210 3211 3212 3213 3214
                        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]);
        }
    }

3215
    put_obmc(dest, ptr, s->linesize);
3216
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3217

Michael Niedermayer's avatar
Michael Niedermayer committed
3218
static inline void qpel_motion(MpegEncContext *s,
3219
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3220 3221
                               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
3222
                               qpel_mc_func (*qpix_op)[16],
Michael Niedermayer's avatar
Michael Niedermayer committed
3223 3224
                               int motion_x, int motion_y, int h)
{
3225 3226
    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;
3227

Michael Niedermayer's avatar
Michael Niedermayer committed
3228
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3229
    src_x = s->mb_x *  16                 + (motion_x >> 2);
Michael Niedermayer's avatar
Michael Niedermayer committed
3230 3231
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);

3232
    v_edge_pos = s->v_edge_pos >> field_based;
Michael Niedermayer's avatar
Michael Niedermayer committed
3233
    linesize = s->linesize << field_based;
3234
    uvlinesize = s->uvlinesize << field_based;
3235

3236 3237 3238
    if(field_based){
        mx= motion_x/2;
        my= motion_y>>1;
3239 3240 3241 3242
    }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];
3243
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3244 3245 3246 3247 3248 3249 3250 3251
        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);
3252

3253
    uvdxy= (mx&1) | ((my&1)<<1);
3254 3255
    mx>>=1;
    my>>=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
3256

3257 3258 3259 3260 3261 3262 3263
    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;

3264
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3265
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3266
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3267 3268 3269
                         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
3270
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3271
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3272
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3273
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3274 3275 3276 3277 3278
                             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
3279

3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
    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);
3298
    }
3299 3300 3301
    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);
3302
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3303 3304
}

3305 3306 3307 3308 3309 3310 3311 3312
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
3313

3314 3315 3316 3317 3318 3319 3320 3321 3322 3323
/**
 * 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;
3324

3325 3326 3327 3328
    /* 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);
3329

3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341
    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;
3342

3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362
    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
3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374
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;
3375

Michael Niedermayer's avatar
Michael Niedermayer committed
3376 3377 3378 3379 3380 3381 3382 3383 3384
    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);
3385

Michael Niedermayer's avatar
Michael Niedermayer committed
3386 3387 3388 3389
    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));
3390

Michael Niedermayer's avatar
Michael Niedermayer committed
3391 3392 3393 3394 3395 3396 3397 3398 3399
    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;
        }
3400
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3401 3402 3403
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3404

Michael Niedermayer's avatar
Michael Niedermayer committed
3405 3406 3407 3408 3409 3410 3411 3412
    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);
}

3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424
static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
    /* fetch pixels for estimated mv 4 macroblocks ahead
     * optimized for 64byte cache lines */
    const int shift = s->quarter_sample ? 2 : 1;
    const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
    const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
    int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
    s->dsp.prefetch(pix[0]+off, s->linesize, 4);
    off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
    s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
}

Michael Niedermayer's avatar
Michael Niedermayer committed
3425
/**
Diego Biurrun's avatar
Diego Biurrun committed
3426
 * motion compensation of a single macroblock
Michael Niedermayer's avatar
Michael Niedermayer committed
3427 3428 3429 3430 3431 3432 3433 3434 3435 3436
 * @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
 */
3437
static inline void MPV_motion(MpegEncContext *s,
3438
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3439
                              int dir, uint8_t **ref_picture,
Michael Niedermayer's avatar
Michael Niedermayer committed
3440
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
Fabrice Bellard's avatar
Fabrice Bellard committed
3441
{
3442
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
Fabrice Bellard's avatar
Fabrice Bellard committed
3443
    int mb_x, mb_y, i;
3444
    uint8_t *ptr, *dest;
Fabrice Bellard's avatar
Fabrice Bellard committed
3445 3446 3447 3448

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

3449 3450
    prefetch_motion(s, ref_picture, dir);

3451
    if(s->obmc && s->pict_type != B_TYPE){
3452 3453
        int16_t mv_cache[4][4][2];
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3454 3455
        const int mot_stride= s->b8_stride;
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3456

3457
        assert(!s->mb_skipped);
3458

3459 3460 3461
        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);
3462 3463 3464 3465

        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{
3466
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3467 3468 3469 3470 3471 3472
        }

        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{
3473 3474
            *(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];
3475 3476 3477 3478 3479 3480
        }

        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{
3481 3482
            *(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];
3483
        }
3484

3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510
        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;
    }
3511

Fabrice Bellard's avatar
Fabrice Bellard committed
3512 3513
    switch(s->mv_type) {
    case MV_TYPE_16X16:
Michael Niedermayer's avatar
Michael Niedermayer committed
3514
        if(s->mcsel){
3515
            if(s->real_sprite_warping_points==1){
3516 3517
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
                            ref_picture);
3518
            }else{
3519 3520
                gmc_motion(s, dest_y, dest_cb, dest_cr,
                            ref_picture);
3521
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
3522
        }else if(s->quarter_sample){
3523
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3524 3525
                        0, 0, 0,
                        ref_picture, pix_op, qpix_op,
Michael Niedermayer's avatar
Michael Niedermayer committed
3526
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
Michael Niedermayer's avatar
Michael Niedermayer committed
3527 3528 3529 3530
        }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);
3531 3532
        }else
        {
3533
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3534 3535
                        0, 0, 0,
                        ref_picture, pix_op,
Michael Niedermayer's avatar
Michael Niedermayer committed
3536
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3537
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3538 3539
        break;
    case MV_TYPE_8X8:
Michael Niedermayer's avatar
Michael Niedermayer committed
3540 3541 3542 3543 3544 3545 3546 3547 3548 3549
        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;
3550

Michael Niedermayer's avatar
Michael Niedermayer committed
3551 3552 3553 3554 3555 3556 3557
                /* 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;
3558

Michael Niedermayer's avatar
Michael Niedermayer committed
3559 3560
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3561
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3562
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3563
                        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
3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
                        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++) {
3575
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3576
                            ref_picture[0], 0, 0,
3577 3578 3579 3580 3581
                            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
3582 3583 3584

                mx += s->mv[dir][i][0];
                my += s->mv[dir][i][1];
3585
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3586
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
3587

3588 3589
        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
3590 3591 3592
        break;
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
3593
            if(s->quarter_sample){
3594 3595 3596 3597 3598 3599
                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);
                }
3600
            }else{
3601
                /* top field */
3602 3603 3604
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
                            1, 0, s->field_select[dir][0],
                            ref_picture, pix_op,
3605 3606
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
                /* bottom field */
3607 3608 3609
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
                            1, 1, s->field_select[dir][1],
                            ref_picture, pix_op,
3610 3611
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3612
        } else {
3613 3614
            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;
3615
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
3616

3617 3618 3619
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
                        0, 0, s->field_select[dir][0],
                        ref_picture, pix_op,
3620
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
Fabrice Bellard's avatar
Fabrice Bellard committed
3621
        }
3622
        break;
3623 3624 3625
    case MV_TYPE_16X8:
        for(i=0; i<2; i++){
            uint8_t ** ref2picture;
3626

3627
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3628 3629
                ref2picture= ref_picture;
            }else{
3630
                ref2picture= s->current_picture_ptr->data;
3631
            }
3632

3633
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3634
                        0, 0, s->field_select[dir][i],
3635
                        ref2picture, pix_op,
3636
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3637

3638
            dest_y += 16*s->linesize;
3639 3640
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3641
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3642
        break;
3643 3644
    case MV_TYPE_DMV:
        if(s->picture_structure == PICT_FRAME){
3645 3646 3647 3648 3649 3650 3651 3652
            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);
                }
3653
                pix_op = s->dsp.avg_pixels_tab;
3654
            }
3655
        }else{
3656
            for(i=0; i<2; i++){
3657
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3658 3659 3660
                            0, 0, s->picture_structure != i+1,
                            ref_picture, pix_op,
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3661

3662
                // after put we make avg of the same block
3663
                pix_op=s->dsp.avg_pixels_tab;
3664

3665 3666
                //opposite parity is always in the same frame if this is second field
                if(!s->first_field){
3667
                    ref_picture = s->current_picture_ptr->data;
3668
                }
3669
            }
3670 3671
        }
    break;
3672
    default: assert(0);
Fabrice Bellard's avatar
Fabrice Bellard committed
3673 3674 3675
    }
}

3676
/**
Diego Biurrun's avatar
Diego Biurrun committed
3677
 * motion compensation of a single macroblock
3678 3679 3680 3681 3682 3683 3684 3685 3686
 * @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
 */
3687
static inline void MPV_motion_lowres(MpegEncContext *s,
3688
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3689
                              int dir, uint8_t **ref_picture,
3690 3691
                              h264_chroma_mc_func *pix_op)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
3692
    int mx, my;
3693 3694
    int mb_x, mb_y, i;
    const int lowres= s->avctx->lowres;
3695
    const int block_s= 8>>lowres;
3696 3697 3698 3699 3700 3701

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

    switch(s->mv_type) {
    case MV_TYPE_16X16:
3702
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3703 3704 3705 3706
                    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
3707
    case MV_TYPE_8X8:
3708 3709 3710
        mx = 0;
        my = 0;
            for(i=0;i<4;i++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
3711
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3712
                            ref_picture[0], 0, 0,
Michael Niedermayer's avatar
Michael Niedermayer committed
3713
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3714
                            s->width, s->height, s->linesize,
Michael Niedermayer's avatar
Michael Niedermayer committed
3715 3716
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
                            block_s, block_s, pix_op,
3717 3718 3719 3720 3721 3722 3723
                            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
3724 3725
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
        break;
3726 3727
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
3728
            /* top field */
3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
            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;
3741
            }
3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756

            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;
3757
            }
3758

3759
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3760 3761 3762
                        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);
3763

3764 3765 3766
            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;
3767
        }
3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782
        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++){
3783
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3784 3785 3786 3787 3788 3789 3790 3791 3792
                            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){
3793
                    ref_picture = s->current_picture_ptr->data;
3794 3795 3796 3797 3798 3799
                }
            }
        }
    break;
    default: assert(0);
    }
3800
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3801 3802

/* put block[] to dest[] */
3803
static inline void put_dct(MpegEncContext *s,
3804
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
Fabrice Bellard's avatar
Fabrice Bellard committed
3805
{
3806
    s->dct_unquantize_intra(s, block, i, qscale);
3807
    s->dsp.idct_put (dest, line_size, block);
Fabrice Bellard's avatar
Fabrice Bellard committed
3808 3809 3810
}

/* add block[] to dest[] */
3811
static inline void add_dct(MpegEncContext *s,
3812
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
3813
{
3814
    if (s->block_last_index[i] >= 0) {
3815
        s->dsp.idct_add (dest, line_size, block);
3816 3817
    }
}
3818

3819
static inline void add_dequant_dct(MpegEncContext *s,
Michael Niedermayer's avatar
Michael Niedermayer committed
3820
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3821
{
Fabrice Bellard's avatar
Fabrice Bellard committed
3822
    if (s->block_last_index[i] >= 0) {
3823
        s->dct_unquantize_inter(s, block, i, qscale);
3824

3825
        s->dsp.idct_add (dest, line_size, block);
Fabrice Bellard's avatar
Fabrice Bellard committed
3826 3827 3828
    }
}

3829 3830 3831 3832 3833
/**
 * cleans dc, ac, coded_block for the current non intra MB
 */
void ff_clean_intra_table_entries(MpegEncContext *s)
{
3834
    int wrap = s->b8_stride;
3835
    int xy = s->block_index[0];
3836 3837 3838

    s->dc_val[0][xy           ] =
    s->dc_val[0][xy + 1       ] =
3839 3840 3841
    s->dc_val[0][xy     + wrap] =
    s->dc_val[0][xy + 1 + wrap] = 1024;
    /* ac pred */
3842 3843
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3844 3845 3846 3847 3848 3849 3850
    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 */
3851 3852
    wrap = s->mb_stride;
    xy = s->mb_x + s->mb_y * wrap;
3853 3854 3855
    s->dc_val[1][xy] =
    s->dc_val[2][xy] = 1024;
    /* ac pred */
3856 3857
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3858

3859
    s->mbintra_table[xy]= 0;
3860 3861
}

Fabrice Bellard's avatar
Fabrice Bellard committed
3862 3863 3864 3865 3866 3867 3868 3869 3870 3871
/* 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)
 */
3872
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
Fabrice Bellard's avatar
Fabrice Bellard committed
3873
{
3874
    int mb_x, mb_y;
3875
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
3876 3877
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration){
3878
        XVMC_decode_mb(s);//xvmc uses pblocks
Ivan Kalvachev's avatar
Ivan Kalvachev committed
3879 3880 3881
        return;
    }
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3882 3883 3884 3885

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

3886 3887 3888 3889 3890 3891 3892 3893 3894
    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
3895
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3896

Fabrice Bellard's avatar
Fabrice Bellard committed
3897 3898
    /* update DC predictors for P macroblocks */
    if (!s->mb_intra) {
3899
        if (s->h263_pred || s->h263_aic) {
3900
            if(s->mbintra_table[mb_xy])
3901
                ff_clean_intra_table_entries(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
3902
        } else {
3903 3904
            s->last_dc[0] =
            s->last_dc[1] =
Fabrice Bellard's avatar
Fabrice Bellard committed
3905 3906 3907
            s->last_dc[2] = 128 << s->intra_dc_precision;
        }
    }
3908
    else if (s->h263_pred || s->h263_aic)
3909
        s->mbintra_table[mb_xy]=1;
3910

3911
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3912
        uint8_t *dest_y, *dest_cb, *dest_cr;
3913
        int dct_linesize, dct_offset;
Michael Niedermayer's avatar
Michael Niedermayer committed
3914 3915
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
3916
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3917
        const int uvlinesize= s->current_picture.linesize[1];
3918 3919
        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;
3920

Michael Niedermayer's avatar
Michael Niedermayer committed
3921 3922 3923
        /* 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){
3924
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
Michael Niedermayer's avatar
Michael Niedermayer committed
3925
            const int age= s->current_picture.age;
Michael Niedermayer's avatar
Michael Niedermayer committed
3926

Michael Niedermayer's avatar
Michael Niedermayer committed
3927 3928
            assert(age);

3929 3930
            if (s->mb_skipped) {
                s->mb_skipped= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
3931
                assert(s->pict_type!=I_TYPE);
3932

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

Michael Niedermayer's avatar
Michael Niedermayer committed
3936
                /* if previous was skipped too, then nothing to do !  */
3937 3938
                if (*mbskip_ptr >= age && s->current_picture.reference){
                    return;
Michael Niedermayer's avatar
Michael Niedermayer committed
3939
                }
3940 3941 3942 3943
            } 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{
3944 3945
                *mbskip_ptr = 0; /* not skipped */
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
3946
        }
3947

3948
        dct_linesize = linesize << s->interlaced_dct;
3949
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3950

3951 3952 3953 3954 3955
        if(readable){
            dest_y=  s->dest[0];
            dest_cb= s->dest[1];
            dest_cr= s->dest[2];
        }else{
3956
            dest_y = s->b_scratchpad;
3957
            dest_cb= s->b_scratchpad+16*linesize;
3958
            dest_cr= s->b_scratchpad+32*linesize;
3959
        }
3960

Fabrice Bellard's avatar
Fabrice Bellard committed
3961 3962
        if (!s->mb_intra) {
            /* motion handling */
3963
            /* decoding or more than one mb_type (MC was already done otherwise) */
3964
            if(!s->encoding){
3965 3966
                if(lowres_flag){
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
Fabrice Bellard's avatar
Fabrice Bellard committed
3967

3968 3969 3970 3971 3972 3973 3974 3975
                    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{
3976
                    op_qpix= s->me.qpel_put;
3977
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
3978 3979 3980 3981 3982 3983 3984
                        op_pix = s->dsp.put_pixels_tab;
                    }else{
                        op_pix = s->dsp.put_no_rnd_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;
3985
                        op_qpix= s->me.qpel_avg;
3986 3987 3988 3989
                    }
                    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);
                    }
3990
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
3991 3992
            }

3993
            /* skip dequant / idct if we are really late ;) */
Michael Niedermayer's avatar
Michael Niedermayer committed
3994 3995 3996 3997 3998 3999 4000
            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;
            }
4001

Fabrice Bellard's avatar
Fabrice Bellard committed
4002
            /* add dct residue */
Michael Niedermayer's avatar
Michael Niedermayer committed
4003
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
4004
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
4005 4006 4007 4008
                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);
4009

4010
                if(!(s->flags&CODEC_FLAG_GRAY)){
4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021
                    if (s->chroma_y_shift){
                        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);
                    }else{
                        dct_linesize >>= 1;
                        dct_offset >>=1;
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
                    }
4022
                }
Michael Niedermayer's avatar
Michael Niedermayer committed
4023
            } else if(s->codec_id != CODEC_ID_WMV2){
4024 4025 4026 4027
                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
4028

4029
                if(!(s->flags&CODEC_FLAG_GRAY)){
4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
                    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
            }
4051
            else{
Michael Niedermayer's avatar
Michael Niedermayer committed
4052
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4053
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
4054 4055
        } else {
            /* dct only in intra block */
Michael Niedermayer's avatar
Michael Niedermayer committed
4056
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4057 4058 4059 4060
                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);
4061 4062

                if(!(s->flags&CODEC_FLAG_GRAY)){
4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073
                    if(s->chroma_y_shift){
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
                    }else{
                        dct_offset >>=1;
                        dct_linesize >>=1;
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
                    }
4074 4075
                }
            }else{
4076 4077 4078 4079
                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]);
4080 4081

                if(!(s->flags&CODEC_FLAG_GRAY)){
4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101
                    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
4102
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
4103
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4104
skip_idct:
4105 4106
        if(!readable){
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
4107 4108
            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);
4109
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
4110 4111 4112
    }
}

4113 4114 4115 4116 4117
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);
}

4118 4119
#ifdef CONFIG_ENCODERS

4120
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135
{
    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];
4136
    int skip_dc;
4137

4138 4139 4140
    if(threshold<0){
        skip_dc=0;
        threshold= -threshold;
4141 4142
    }else
        skip_dc=1;
4143

4144 4145 4146 4147
    /* 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++){
4148
        const int j = s->intra_scantable.permutated[i];
4149
        const int level = FFABS(block[j]);
4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161
        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++){
4162
        const int j = s->intra_scantable.permutated[i];
4163 4164 4165 4166 4167 4168
        block[j]=0;
    }
    if(block[0]) s->block_last_index[n]= 0;
    else         s->block_last_index[n]= -1;
}

4169 4170 4171 4172 4173
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;
4174
    int overflow=0;
4175

4176 4177 4178 4179
    if(s->mb_intra){
        i=1; //skip clipping of intra dc
    }else
        i=0;
4180

4181 4182
    for(;i<=last_index; i++){
        const int j= s->intra_scantable.permutated[i];
4183
        int level = block[j];
4184

4185 4186 4187 4188 4189 4190 4191
        if     (level>maxlevel){
            level=maxlevel;
            overflow++;
        }else if(level<minlevel){
            level=minlevel;
            overflow++;
        }
4192

Michael Niedermayer's avatar
Michael Niedermayer committed
4193
        block[j]= level;
4194
    }
4195

4196
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4197
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4198 4199
}

4200 4201
#endif //CONFIG_ENCODERS

4202 4203 4204 4205 4206
/**
 *
 * @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
4207
    if (s->avctx->draw_horiz_band) {
4208
        AVFrame *src;
Michael Niedermayer's avatar
Michael Niedermayer committed
4209
        int offset[4];
4210

4211 4212 4213 4214 4215 4216
        if(s->picture_structure != PICT_FRAME){
            h <<= 1;
            y <<= 1;
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
        }

4217
        h= FFMIN(h, s->avctx->height - y);
4218

4219
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4220 4221 4222 4223 4224
            src= (AVFrame*)s->current_picture_ptr;
        else if(s->last_picture_ptr)
            src= (AVFrame*)s->last_picture_ptr;
        else
            return;
4225

4226
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
Michael Niedermayer's avatar
Michael Niedermayer committed
4227 4228 4229 4230 4231 4232
            offset[0]=
            offset[1]=
            offset[2]=
            offset[3]= 0;
        }else{
            offset[0]= y * s->linesize;;
4233
            offset[1]=
4234
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
Michael Niedermayer's avatar
Michael Niedermayer committed
4235
            offset[3]= 0;
4236
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4237

Michael Niedermayer's avatar
Michael Niedermayer committed
4238 4239
        emms_c();

4240 4241
        s->avctx->draw_horiz_band(s->avctx, src, offset,
                                  y, s->picture_structure, h);
4242 4243 4244
    }
}

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

4250 4251 4252 4253 4254 4255
    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;
4256 4257
    //block_index is not used by mpeg2, so it is not affected by chroma_format

4258 4259 4260
    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
4261

4262 4263
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
    {
4264 4265 4266
        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);
4267
    }
4268 4269
}

4270 4271
#ifdef CONFIG_ENCODERS

4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294
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;
        }
    }
}

4295
static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
Fabrice Bellard's avatar
Fabrice Bellard committed
4296
{
4297 4298
    int16_t weight[8][64];
    DCTELEM orig[8][64];
4299 4300 4301
    const int mb_x= s->mb_x;
    const int mb_y= s->mb_y;
    int i;
4302
    int skip_dct[8];
4303
    int dct_offset   = s->linesize*8; //default for progressive frames
Michael Niedermayer's avatar
Michael Niedermayer committed
4304 4305
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    int wrap_y, wrap_c;
4306

4307
    for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4308

4309
    if(s->adaptive_quant){
4310 4311
        const int last_qp= s->qscale;
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4312

4313 4314
        s->lambda= s->lambda_table[mb_xy];
        update_qscale(s);
4315

4316 4317
        if(!(s->flags&CODEC_FLAG_QP_RD)){
            s->dquant= s->qscale - last_qp;
4318

4319
            if(s->out_format==FMT_H263){
4320
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4321 4322

                if(s->codec_id==CODEC_ID_MPEG4){
4323 4324
                    if(!s->mb_intra){
                        if(s->pict_type == B_TYPE){
4325
                            if(s->dquant&1)
4326 4327 4328 4329 4330 4331 4332
                                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;
                    }
4333
                }
4334 4335
            }
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4336
        ff_set_qscale(s, last_qp + s->dquant);
Michael Niedermayer's avatar
Michael Niedermayer committed
4337 4338
    }else if(s->flags&CODEC_FLAG_QP_RD)
        ff_set_qscale(s, s->qscale + s->dquant);
4339

Michael Niedermayer's avatar
Michael Niedermayer committed
4340 4341 4342
    wrap_y = s->linesize;
    wrap_c = s->uvlinesize;
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4343 4344
    ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
    ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
Michael Niedermayer's avatar
Michael Niedermayer committed
4345 4346

    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4347 4348 4349
        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;
4350
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4351
        ptr_cb= ebuf+18*wrap_y;
4352
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4353
        ptr_cr= ebuf+18*wrap_y+8;
Michael Niedermayer's avatar
Michael Niedermayer committed
4354 4355
    }

4356
    if (s->mb_intra) {
4357 4358
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
            int progressive_score, interlaced_score;
4359

4360
            s->interlaced_dct=0;
4361
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4362
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4363 4364

            if(progressive_score > 0){
4365
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4366
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4367 4368
                if(progressive_score > interlaced_score){
                    s->interlaced_dct=1;
4369

4370 4371
                    dct_offset= wrap_y;
                    wrap_y<<=1;
4372 4373
                    if (s->chroma_format == CHROMA_422)
                        wrap_c<<=1;
4374 4375
                }
            }
4376
        }
4377

4378
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4379 4380 4381
        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);
4382

4383 4384 4385 4386
        if(s->flags&CODEC_FLAG_GRAY){
            skip_dct[4]= 1;
            skip_dct[5]= 1;
        }else{
4387
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4388
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4389 4390 4391 4392
            if(!s->chroma_y_shift){ /* 422 */
                s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
                s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
            }
4393
        }
4394
    }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
4395 4396
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
4397
        uint8_t *dest_y, *dest_cb, *dest_cr;
4398

4399 4400 4401
        dest_y  = s->dest[0];
        dest_cb = s->dest[1];
        dest_cr = s->dest[2];
4402

4403
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4404
            op_pix = s->dsp.put_pixels_tab;
4405
            op_qpix= s->dsp.put_qpel_pixels_tab;
Michael Niedermayer's avatar
Michael Niedermayer committed
4406
        }else{
4407 4408
            op_pix = s->dsp.put_no_rnd_pixels_tab;
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4409 4410 4411
        }

        if (s->mv_dir & MV_DIR_FORWARD) {
Michael Niedermayer's avatar
Michael Niedermayer committed
4412
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4413 4414
            op_pix = s->dsp.avg_pixels_tab;
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4415 4416
        }
        if (s->mv_dir & MV_DIR_BACKWARD) {
Michael Niedermayer's avatar
Michael Niedermayer committed
4417
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4418
        }
4419

4420 4421
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
            int progressive_score, interlaced_score;
4422 4423

            s->interlaced_dct=0;
4424
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4425
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4426

4427 4428 4429
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;

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

4433 4434
                if(progressive_score > interlaced_score){
                    s->interlaced_dct=1;
4435

4436 4437
                    dct_offset= wrap_y;
                    wrap_y<<=1;
4438 4439
                    if (s->chroma_format == CHROMA_422)
                        wrap_c<<=1;
4440 4441
                }
            }
4442
        }
4443

4444
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4445 4446 4447
        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);
4448

4449 4450 4451 4452
        if(s->flags&CODEC_FLAG_GRAY){
            skip_dct[4]= 1;
            skip_dct[5]= 1;
        }else{
4453 4454
            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);
4455 4456 4457 4458
            if(!s->chroma_y_shift){ /* 422 */
                s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
                s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
            }
4459
        }
4460
        /* pre quantization */
4461
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4462
            //FIXME optimize
4463
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4464 4465 4466 4467 4468
            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;
4469 4470 4471 4472
            if(!s->chroma_y_shift){ /* 422 */
                if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1;
                if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1;
            }
4473
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
4474
    }
4475

Michael Niedermayer's avatar
Michael Niedermayer committed
4476 4477 4478 4479 4480 4481 4482
    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);
4483 4484 4485 4486 4487
        if(!s->chroma_y_shift){ /* 422 */
            if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
            if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
        }
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4488
    }
4489

4490
    /* DCT & quantize */
Michael Niedermayer's avatar
Michael Niedermayer committed
4491 4492
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
    {
4493
        for(i=0;i<mb_block_count;i++) {
4494 4495
            if(!skip_dct[i]){
                int overflow;
4496
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4497
            // FIXME we could decide to change to quantizer instead of clipping
4498 4499
            // 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
4500 4501 4502
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
            }else
                s->block_last_index[i]= -1;
4503
        }
4504
        if(s->avctx->quantizer_noise_shaping){
4505
            for(i=0;i<mb_block_count;i++) {
4506 4507 4508 4509 4510
                if(!skip_dct[i]){
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
                }
            }
        }
4511

4512 4513
        if(s->luma_elim_threshold && !s->mb_intra)
            for(i=0; i<4; i++)
4514
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4515
        if(s->chroma_elim_threshold && !s->mb_intra)
4516
            for(i=4; i<mb_block_count; i++)
4517
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4518 4519

        if(s->flags & CODEC_FLAG_CBP_RD){
4520
            for(i=0;i<mb_block_count;i++) {
4521 4522 4523 4524
                if(s->block_last_index[i] == -1)
                    s->coded_score[i]= INT_MAX/256;
            }
        }
4525 4526
    }

4527 4528 4529 4530
    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
4531
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4532 4533
    }

4534 4535
    //non c quantize code returns incorrect block_last_index FIXME
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4536
        for(i=0; i<mb_block_count; i++){
4537 4538 4539 4540 4541 4542 4543 4544 4545 4546
            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;
            }
        }
    }

4547
    /* huffman encode */
Michael Niedermayer's avatar
Michael Niedermayer committed
4548 4549
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
    case CODEC_ID_MPEG1VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
4550
    case CODEC_ID_MPEG2VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
4551 4552 4553 4554 4555 4556 4557 4558 4559
        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;
4560
#ifdef CONFIG_H261_ENCODER
4561 4562
    case CODEC_ID_H261:
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4563
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
4564 4565
    case CODEC_ID_H263:
    case CODEC_ID_H263P:
4566
    case CODEC_ID_FLV1:
Michael Niedermayer's avatar
Michael Niedermayer committed
4567
    case CODEC_ID_RV10:
Michael Niedermayer's avatar
Michael Niedermayer committed
4568
    case CODEC_ID_RV20:
Michael Niedermayer's avatar
Michael Niedermayer committed
4569
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4570 4571
    case CODEC_ID_MJPEG:
        mjpeg_encode_mb(s, s->block); break;
Michael Niedermayer's avatar
Michael Niedermayer committed
4572 4573
    default:
        assert(0);
4574 4575 4576
    }
}

4577 4578 4579 4580 4581 4582
static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
{
    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
}

4583 4584
#endif //CONFIG_ENCODERS

Michael Niedermayer's avatar
Michael Niedermayer committed
4585 4586 4587
void ff_mpeg_flush(AVCodecContext *avctx){
    int i;
    MpegEncContext *s = avctx->priv_data;
4588 4589

    if(s==NULL || s->picture==NULL)
4590
        return;
4591

Michael Niedermayer's avatar
Michael Niedermayer committed
4592 4593 4594 4595 4596
    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]);
    }
4597
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4598

Michael Niedermayer's avatar
Michael Niedermayer committed
4599
    s->mb_x= s->mb_y= 0;
4600

4601 4602 4603 4604 4605 4606
    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;
4607
    s->bitstream_buffer_size=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
4608 4609
}

4610
#ifdef CONFIG_ENCODERS
4611
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4612
{
4613
    const uint16_t *srcw= (uint16_t*)src;
4614
    int words= length>>4;
4615 4616 4617
    int bits= length&15;
    int i;

4618
    if(length==0) return;
4619

4620 4621 4622 4623
    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]));
4624
    }else{
4625 4626
        for(i=0; put_bits_count(pb)&31; i++)
            put_bits(pb, 8, src[i]);
4627
        flush_put_bits(pb);
4628 4629
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
        skip_put_bytes(pb, 2*words-i);
4630
    }
4631

4632
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4633 4634
}

4635
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4636 4637 4638 4639 4640
    int i;

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

    /* mpeg1 */
4641
    d->mb_skip_run= s->mb_skip_run;
4642 4643
    for(i=0; i<3; i++)
        d->last_dc[i]= s->last_dc[i];
4644

4645 4646 4647 4648 4649
    /* 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;
4650 4651
    d->f_count= s->f_count;
    d->b_count= s->b_count;
4652 4653
    d->skip_count= s->skip_count;
    d->misc_bits= s->misc_bits;
4654
    d->last_bits= 0;
4655

4656
    d->mb_skipped= 0;
4657
    d->qscale= s->qscale;
4658
    d->dquant= s->dquant;
4659 4660
}

4661
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4662 4663
    int i;

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

4667
    /* mpeg1 */
4668
    d->mb_skip_run= s->mb_skip_run;
4669 4670
    for(i=0; i<3; i++)
        d->last_dc[i]= s->last_dc[i];
4671

4672 4673 4674 4675 4676
    /* 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;
4677 4678
    d->f_count= s->f_count;
    d->b_count= s->b_count;
4679 4680 4681 4682
    d->skip_count= s->skip_count;
    d->misc_bits= s->misc_bits;

    d->mb_intra= s->mb_intra;
4683
    d->mb_skipped= s->mb_skipped;
4684 4685 4686
    d->mv_type= s->mv_type;
    d->mv_dir= s->mv_dir;
    d->pb= s->pb;
4687 4688 4689 4690
    if(s->data_partitioning){
        d->pb2= s->pb2;
        d->tex_pb= s->tex_pb;
    }
4691
    d->block= s->block;
4692
    for(i=0; i<8; i++)
4693
        d->block_last_index[i]= s->block_last_index[i];
4694
    d->interlaced_dct= s->interlaced_dct;
4695
    d->qscale= s->qscale;
4696 4697
}

4698
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4699 4700 4701
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
                           int *dmin, int *next_block, int motion_x, int motion_y)
{
4702 4703
    int score;
    uint8_t *dest_backup[3];
4704

4705 4706 4707 4708 4709 4710 4711 4712
    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];
    }
4713

4714 4715
    if(*next_block){
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4716 4717 4718 4719
        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
4720
    }
4721 4722

    encode_mb(s, motion_x, motion_y);
4723

4724
    score= put_bits_count(&s->pb);
4725
    if(s->data_partitioning){
4726 4727
        score+= put_bits_count(&s->pb2);
        score+= put_bits_count(&s->tex_pb);
4728
    }
4729

4730 4731
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
        MPV_decode_mb(s, s->block);
4732

4733 4734
        score *= s->lambda2;
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4735
    }
4736

4737 4738 4739 4740 4741 4742
    if(*next_block){
        memcpy(s->dest, dest_backup, sizeof(s->dest));
    }

    if(score<*dmin){
        *dmin= score;
4743 4744 4745 4746 4747
        *next_block^=1;

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

4749
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4750 4751 4752
    uint32_t *sq = squareTbl + 256;
    int acc=0;
    int x,y;
4753 4754

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

4759 4760 4761
    for(y=0; y<h; y++){
        for(x=0; x<w; x++){
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4762
        }
4763
    }
4764

Michael Niedermayer's avatar
Michael Niedermayer committed
4765
    assert(acc>=0);
4766

4767 4768
    return acc;
}
4769

4770 4771 4772 4773 4774 4775 4776 4777
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)
4778
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
Michael Niedermayer's avatar
Michael Niedermayer committed
4779 4780 4781
        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);
4782
      }else{
4783 4784 4785
        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);
4786
      }
4787 4788 4789 4790 4791 4792
    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);
}

4793 4794 4795
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;

4796

4797 4798 4799 4800 4801 4802 4803 4804 4805
    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;
    }
4806

4807
    s->me.pre_pass=0;
4808

4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824
    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;
4825

4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836
            /* 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;
}

4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847
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);
4848

4849 4850 4851 4852
            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;
4853
            s->me.mb_var_sum_temp    += varc;
4854 4855
        }
    }
4856
    return 0;
4857 4858
}

4859 4860 4861 4862 4863
static void write_slice_end(MpegEncContext *s){
    if(s->codec_id==CODEC_ID_MPEG4){
        if(s->partitioned_frame){
            ff_mpeg4_merge_partitions(s);
        }
4864

4865 4866 4867 4868 4869 4870 4871
        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);
4872

4873 4874
    if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
        s->misc_bits+= get_bits_diff(s);
4875 4876 4877 4878
}

static int encode_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;
4879
    int mb_x, mb_y, pdif = 0;
4880
    int i, j;
4881
    MpegEncContext best_s, backup_s;
4882 4883 4884
    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];
4885
    PutBitContext pb[2], pb2[2], tex_pb[2];
4886
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4887 4888

    for(i=0; i<2; i++){
4889 4890 4891
        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);
4892
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
4893

4894 4895 4896 4897 4898 4899 4900 4901 4902
    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;
4903

4904 4905 4906
    for(i=0; i<3; i++){
        /* init last dc values */
        /* note: quant matrix value (8) is implied here */
4907
        s->last_dc[i] = 128 << s->intra_dc_precision;
4908

4909
        s->current_picture.error[i] = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
4910
    }
4911 4912
    s->mb_skip_run = 0;
    memset(s->last_mv, 0, sizeof(s->last_mv));
4913

4914
    s->last_mv_dir = 0;
4915

4916 4917 4918 4919 4920 4921 4922 4923 4924 4925
    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;
4926
    }
4927

4928
    s->resync_mb_x=0;
4929
    s->resync_mb_y=0;
4930 4931 4932 4933 4934 4935
    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
4936

4937 4938
        ff_set_qscale(s, s->qscale);
        ff_init_block_index(s);
4939

4940
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4941
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4942 4943 4944 4945
            int mb_type= s->mb_type[xy];
//            int d;
            int dmin= INT_MAX;
            int dir;
4946

4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958
            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;
                }
            }

4959
            s->mb_x = mb_x;
4960
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4961 4962
            ff_update_block_index(s);

4963
#ifdef CONFIG_H261_ENCODER
4964 4965 4966
            if(s->codec_id == CODEC_ID_H261){
                ff_h261_reorder_mb_index(s);
                xy= s->mb_y*s->mb_stride + s->mb_x;
4967
                mb_type= s->mb_type[xy];
4968
            }
4969
#endif
4970

4971 4972 4973
            /* write gob / video packet header  */
            if(s->rtp_mode){
                int current_packet_size, is_gob_start;
4974

4975
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4976 4977 4978

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

4979
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4980

4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
                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;
4992
                }
4993

4994 4995 4996
                if(is_gob_start){
                    if(s->start_mb_y != mb_y || mb_x!=0){
                        write_slice_end(s);
4997

4998 4999
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
                            ff_mpeg4_init_partitions(s);
5000 5001
                        }
                    }
5002

5003
                    assert((put_bits_count(&s->pb)&7) == 0);
5004
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
5005

5006
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
5007
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
5008 5009 5010 5011 5012 5013 5014 5015 5016
                        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);
                        }
                    }
5017 5018 5019 5020 5021

                    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);
                    }
5022

5023 5024
                    switch(s->codec_id){
                    case CODEC_ID_MPEG4:
5025 5026
                        ff_mpeg4_encode_video_packet_header(s);
                        ff_mpeg4_clean_buffers(s);
5027 5028 5029
                    break;
                    case CODEC_ID_MPEG1VIDEO:
                    case CODEC_ID_MPEG2VIDEO:
5030 5031
                        ff_mpeg1_encode_slice_header(s);
                        ff_mpeg1_clean_buffers(s);
5032 5033 5034
                    break;
                    case CODEC_ID_H263:
                    case CODEC_ID_H263P:
5035
                        h263_encode_gob_header(s, mb_y);
5036
                    break;
5037 5038
                    }

5039
                    if(s->flags&CODEC_FLAG_PASS1){
5040
                        int bits= put_bits_count(&s->pb);
5041 5042 5043
                        s->misc_bits+= bits - s->last_bits;
                        s->last_bits= bits;
                    }
5044

5045
                    s->ptr_lastgob += current_packet_size;
5046 5047 5048 5049
                    s->first_slice_line=1;
                    s->resync_mb_x=mb_x;
                    s->resync_mb_y=mb_y;
                }
5050
            }
5051

5052 5053
            if(  (s->resync_mb_x   == s->mb_x)
               && s->resync_mb_y+1 == s->mb_y){
5054
                s->first_slice_line=0;
5055 5056
            }

5057
            s->mb_skipped=0;
5058
            s->dquant=0; //only for QP_RD
5059

Michael Niedermayer's avatar
Michael Niedermayer committed
5060
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5061
                int next_block=0;
5062
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5063 5064

                copy_context_before_encode(&backup_s, s, -1);
5065 5066
                backup_s.pb= s->pb;
                best_s.data_partitioning= s->data_partitioning;
5067
                best_s.partitioned_frame= s->partitioned_frame;
5068 5069 5070 5071
                if(s->data_partitioning){
                    backup_s.pb2= s->pb2;
                    backup_s.tex_pb= s->tex_pb;
                }
5072

5073
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
5074
                    s->mv_dir = MV_DIR_FORWARD;
Michael Niedermayer's avatar
Michael Niedermayer committed
5075
                    s->mv_type = MV_TYPE_16X16;
5076
                    s->mb_intra= 0;
5077 5078
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
5079
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5080
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5081
                }
5082
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5083 5084 5085 5086 5087 5088 5089 5090
                    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];
                    }
5091
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5092 5093
                                 &dmin, &next_block, 0, 0);
                }
5094
                if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5095 5096 5097 5098 5099
                    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;
5100
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5101
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
Fabrice Bellard's avatar
Fabrice Bellard committed
5102
                }
5103
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5104
                    s->mv_dir = MV_DIR_FORWARD;
Michael Niedermayer's avatar
Michael Niedermayer committed
5105 5106 5107
                    s->mv_type = MV_TYPE_8X8;
                    s->mb_intra= 0;
                    for(i=0; i<4; i++){
5108 5109
                        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
5110
                    }
5111
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5112
                                 &dmin, &next_block, 0, 0);
5113
                }
5114
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5115 5116 5117 5118 5119
                    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];
5120
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5121
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5122
                }
5123
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5124 5125 5126 5127 5128
                    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];
5129
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5130
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5131
                }
5132
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5133 5134 5135 5136 5137 5138 5139
                    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];
5140
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5141
                                 &dmin, &next_block, 0, 0);
5142
                }
5143
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
Michael Niedermayer's avatar
Michael Niedermayer committed
5144 5145
                    int mx= s->b_direct_mv_table[xy][0];
                    int my= s->b_direct_mv_table[xy][1];
5146

5147 5148
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
5149
                    ff_mpeg4_set_direct_mv(s, mx, my);
5150
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
Michael Niedermayer's avatar
Michael Niedermayer committed
5151
                                 &dmin, &next_block, mx, my);
Michael Niedermayer's avatar
Michael Niedermayer committed
5152
                }
5153
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5154 5155 5156 5157 5158 5159 5160 5161
                    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];
                    }
5162
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5163 5164
                                 &dmin, &next_block, 0, 0);
                }
5165
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5166 5167 5168 5169 5170 5171 5172 5173
                    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];
                    }
5174
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5175 5176
                                 &dmin, &next_block, 0, 0);
                }
5177
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5178 5179 5180 5181 5182 5183 5184 5185 5186 5187
                    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];
                        }
                    }
5188
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5189 5190 5191
                                 &dmin, &next_block, 0, 0);
                }
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5192
                    s->mv_dir = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
5193
                    s->mv_type = MV_TYPE_16X16;
5194 5195 5196
                    s->mb_intra= 1;
                    s->mv[0][0][0] = 0;
                    s->mv[0][0][1] = 0;
5197
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5198
                                 &dmin, &next_block, 0, 0);
5199 5200 5201 5202 5203 5204
                    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
5205
                }
5206 5207 5208 5209 5210

                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];
5211
                        DCTELEM ac[6][16];
5212
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5213

5214 5215 5216 5217 5218 5219 5220 5221 5222 5223
                        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];
5224

5225
                        dir= s->pict_type == B_TYPE ? 2 : 1;
5226
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
5227 5228 5229 5230 5231
                        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;
5232
                            if(s->mb_intra && s->dc_val[0]){
5233 5234 5235 5236
                                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);
                                }
5237
                            }
5238

5239
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5240
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5241
                            if(best_s.qscale != qp){
5242
                                if(s->mb_intra && s->dc_val[0]){
5243 5244 5245 5246
                                    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);
                                    }
5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259
                                }
                                if(dir > 0 && dquant==dir){
                                    dquant= 0;
                                    dir= -dir;
                                }else
                                    break;
                            }
                        }
                        qp= best_s.qscale;
                        s->current_picture.qscale_table[xy]= qp;
                    }
                }

5260
                copy_context_after_encode(s, &best_s, -1);
5261

5262
                pb_bits_count= put_bits_count(&s->pb);
5263 5264 5265
                flush_put_bits(&s->pb);
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
                s->pb= backup_s.pb;
5266

5267
                if(s->data_partitioning){
5268
                    pb2_bits_count= put_bits_count(&s->pb2);
5269 5270 5271
                    flush_put_bits(&s->pb2);
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
                    s->pb2= backup_s.pb2;
5272

5273
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
5274 5275 5276 5277
                    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;
                }
5278
                s->last_bits= put_bits_count(&s->pb);
5279

5280 5281
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
                    ff_h263_update_motion_val(s);
5282

5283 5284 5285 5286
                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);
5287 5288 5289 5290
                }

                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
                    MPV_decode_mb(s, s->block);
Fabrice Bellard's avatar
Fabrice Bellard committed
5291
            } else {
5292 5293
                int motion_x, motion_y;
                s->mv_type=MV_TYPE_16X16;
5294
                // only one MB-Type possible
5295

5296
                switch(mb_type){
5297
                case CANDIDATE_MB_TYPE_INTRA:
5298
                    s->mv_dir = 0;
5299
                    s->mb_intra= 1;
5300 5301
                    motion_x= s->mv[0][0][0] = 0;
                    motion_y= s->mv[0][0][1] = 0;
5302
                    break;
5303
                case CANDIDATE_MB_TYPE_INTER:
5304 5305 5306 5307
                    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];
5308
                    break;
5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
                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:
5321 5322 5323 5324
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_8X8;
                    s->mb_intra= 0;
                    for(i=0; i<4; i++){
5325 5326
                        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];
5327 5328 5329
                    }
                    motion_x= motion_y= 0;
                    break;
5330
                case CANDIDATE_MB_TYPE_DIRECT:
5331 5332
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
5333 5334
                    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
5335
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5336
                    break;
5337
                case CANDIDATE_MB_TYPE_BIDIR:
5338
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5339
                    s->mb_intra= 0;
5340 5341 5342 5343 5344 5345
                    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];
5346
                    break;
5347
                case CANDIDATE_MB_TYPE_BACKWARD:
5348 5349 5350 5351
                    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];
5352
                    break;
5353
                case CANDIDATE_MB_TYPE_FORWARD:
5354 5355 5356 5357 5358
                    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);
5359
                    break;
5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394
                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;
5395
                default:
5396
                    motion_x=motion_y=0; //gcc warning fix
5397
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5398
                }
5399

5400
                encode_mb(s, motion_x, motion_y);
5401

5402
                // RAL: Update last macroblock type
5403
                s->last_mv_dir = s->mv_dir;
5404

5405 5406
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
                    ff_h263_update_motion_val(s);
5407

5408
                MPV_decode_mb(s, s->block);
Fabrice Bellard's avatar
Fabrice Bellard committed
5409
            }
5410

5411 5412 5413 5414 5415
            /* 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;
            }
5416

5417 5418 5419 5420 5421 5422
            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
5423

5424
                s->current_picture.error[0] += sse(
5425 5426
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
                    s->dest[0], w, h, s->linesize);
5427
                s->current_picture.error[1] += sse(
5428 5429
                    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);
5430
                s->current_picture.error[2] += sse(
5431 5432
                    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);
5433
            }
5434 5435 5436 5437
            if(s->loop_filter){
                if(s->out_format == FMT_H263)
                    ff_h263_loop_filter(s);
            }
5438
//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
5439 5440
        }
    }
5441

5442
    //not beautiful here but we must write it before flushing so it has to be here
5443
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5444
        msmpeg4_encode_ext_header(s);
5445

5446 5447
    write_slice_end(s);

5448
    /* Send the last GOB if RTP */
5449
    if (s->avctx->rtp_callback) {
5450
        int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5451
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5452
        /* Call the RTP callback to send the last GOB */
5453
        emms_c();
5454
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5455
    }
5456 5457 5458 5459 5460 5461

    return 0;
}

#define MERGE(field) dst->field += src->field; src->field=0
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5462 5463 5464
    MERGE(me.scene_change_score);
    MERGE(me.mc_mb_var_sum_temp);
    MERGE(me.mb_var_sum_temp);
5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481
}

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);
5482 5483 5484
    MERGE(current_picture.error[0]);
    MERGE(current_picture.error[1]);
    MERGE(current_picture.error[2]);
5485 5486 5487 5488 5489 5490 5491

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

5493 5494 5495 5496 5497 5498
    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);
}

5499
static int estimate_qp(MpegEncContext *s, int dry_run){
5500 5501 5502 5503 5504
    if (s->next_lambda){
        s->current_picture_ptr->quality=
        s->current_picture.quality = s->next_lambda;
        if(!dry_run) s->next_lambda= 0;
    } else if (!s->fixed_qscale) {
5505 5506
        s->current_picture_ptr->quality=
        s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5507 5508 5509
        if (s->current_picture.quality < 0)
            return -1;
    }
5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528

    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);
5529
    return 0;
5530 5531
}

5532
static int encode_picture(MpegEncContext *s, int picture_number)
5533
{
5534
    int i;
5535 5536 5537
    int bits;

    s->picture_number = picture_number;
5538

5539
    /* Reset the average MB variance */
5540 5541
    s->me.mb_var_sum_temp    =
    s->me.mc_mb_var_sum_temp = 0;
5542 5543 5544 5545

    /* 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))
5546
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
5547

5548
    s->me.scene_change_score=0;
5549

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

5552 5553 5554 5555 5556
    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)
5557
            s->no_rounding ^= 1;
5558
    }
5559

5560
    if(s->flags & CODEC_FLAG_PASS2){
5561 5562
        if (estimate_qp(s,1) < 0)
            return -1;
5563 5564
        ff_get_2pass_fcode(s);
    }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5565
        if(s->pict_type==B_TYPE)
5566
            s->lambda= s->last_lambda_for[s->pict_type];
5567
        else
5568
            s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5569 5570
        update_qscale(s);
    }
5571

5572
    s->mb_intra=0; //for the rate distortion & bit compare functions
5573
    for(i=1; i<s->avctx->thread_count; i++){
5574
        ff_update_duplicate_context(s->thread_context[i], s);
5575
    }
5576 5577 5578

    ff_init_me(s);

5579 5580
    /* Estimate motion for every MB */
    if(s->pict_type != I_TYPE){
5581 5582
        s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
        s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5583
        if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5584 5585 5586 5587 5588 5589 5590 5591 5592 5593
            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;
5594

5595 5596
        if(!s->fixed_qscale){
            /* finding spatial complexity for I-frame rate control */
5597
            s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5598 5599
        }
    }
5600 5601 5602
    for(i=1; i<s->avctx->thread_count; i++){
        merge_context_after_me(s, s->thread_context[i]);
    }
5603 5604
    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;
5605 5606
    emms_c();

5607
    if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623
        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));
            }
5624

5625 5626 5627
            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){
5628
                int j;
5629 5630
                for(i=0; i<2; i++){
                    for(j=0; j<2; j++)
5631
                        ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652
                                        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){
5653
                int dir, j;
5654 5655 5656
                for(dir=0; dir<2; dir++){
                    for(i=0; i<2; i++){
                        for(j=0; j<2; j++){
5657
                            int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5658
                                          : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5659
                            ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5660 5661 5662 5663 5664 5665 5666 5667
                                            s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
                        }
                    }
                }
            }
        }
    }

5668 5669
    if (estimate_qp(s, 0) < 0)
        return -1;
5670 5671

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

5674 5675 5676 5677 5678 5679
    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];

5680
            s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5681
        }
5682
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5683
                       s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5684 5685
        s->qscale= 8;
    }
5686

5687
    //FIXME var duplication
5688
    s->current_picture_ptr->key_frame=
5689
    s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5690
    s->current_picture_ptr->pict_type=
5691 5692 5693 5694 5695 5696 5697 5698 5699 5700
    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;
5701
#ifdef CONFIG_H261_ENCODER
5702 5703 5704
    case FMT_H261:
        ff_h261_encode_picture_header(s, picture_number);
        break;
5705
#endif
5706
    case FMT_H263:
5707
        if (s->codec_id == CODEC_ID_WMV2)
5708
            ff_wmv2_encode_picture_header(s, picture_number);
5709
        else if (s->h263_msmpeg4)
5710 5711 5712
            msmpeg4_encode_picture_header(s, picture_number);
        else if (s->h263_pred)
            mpeg4_encode_picture_header(s, picture_number);
5713
#ifdef CONFIG_RV10_ENCODER
5714
        else if (s->codec_id == CODEC_ID_RV10)
5715
            rv10_encode_picture_header(s, picture_number);
5716 5717
#endif
#ifdef CONFIG_RV20_ENCODER
5718
        else if (s->codec_id == CODEC_ID_RV20)
Michael Niedermayer's avatar
Michael Niedermayer committed
5719
            rv20_encode_picture_header(s, picture_number);
5720
#endif
5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735
        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;
5736

5737 5738 5739 5740 5741 5742 5743 5744
    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();
5745
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
5746 5747
}

Michael Niedermayer's avatar
Michael Niedermayer committed
5748
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5749 5750 5751
    const int intra= s->mb_intra;
    int i;

5752 5753
    s->dct_count[intra]++;

5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771
    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;
        }
    }
}

5772
static int dct_quantize_trellis_c(MpegEncContext *s,
5773 5774 5775
                        DCTELEM *block, int n,
                        int qscale, int *overflow){
    const int *qmat;
5776
    const uint8_t *scantable= s->intra_scantable.scantable;
5777
    const uint8_t *perm_scantable= s->intra_scantable.permutated;
5778 5779 5780 5781 5782 5783
    int max=0;
    unsigned int threshold1, threshold2;
    int bias=0;
    int run_tab[65];
    int level_tab[65];
    int score_tab[65];
5784 5785
    int survivor[65];
    int survivor_count;
5786 5787 5788
    int last_run=0;
    int last_level=0;
    int last_score= 0;
5789
    int last_i;
5790
    int coeff[2][64];
5791
    int coeff_count[64];
5792
    int qmul, qadd, start_i, last_non_zero, i, dc;
5793 5794 5795
    const int esc_length= s->ac_esc_length;
    uint8_t * length;
    uint8_t * last_length;
5796
    const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5797

5798
    s->dsp.fdct (block);
5799

5800
    if(s->dct_error_sum)
Michael Niedermayer's avatar
Michael Niedermayer committed
5801
        s->denoise_dct(s, block);
5802 5803
    qmul= qscale*16;
    qadd= ((qscale-1)|1)*8;
5804

5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817
    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;
        }
5818

5819 5820 5821 5822 5823
        /* 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];
5824
        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5825 5826 5827 5828 5829 5830 5831 5832 5833 5834
            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;
    }
5835
    last_i= start_i;
5836 5837 5838

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

5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850
    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++) {
5851
        const int j = scantable[i];
5852
        int level = block[j] * qmat[j];
5853 5854 5855 5856 5857 5858

//        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;
5859 5860
                coeff[0][i]= level;
                coeff[1][i]= level-1;
5861
//                coeff[2][k]= level-2;
5862 5863
            }else{
                level= (bias - level)>>QMAT_SHIFT;
5864 5865
                coeff[0][i]= -level;
                coeff[1][i]= -level+1;
5866
//                coeff[2][k]= -level+2;
5867
            }
5868 5869
            coeff_count[i]= FFMIN(level, 2);
            assert(coeff_count[i]);
5870 5871
            max |=level;
        }else{
5872 5873
            coeff[0][i]= (level>>31)|1;
            coeff_count[i]= 1;
5874 5875
        }
    }
5876

5877
    *overflow= s->max_qcoeff < max; //overflow might have happened
5878

5879 5880 5881 5882 5883
    if(last_non_zero < start_i){
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
        return last_non_zero;
    }

5884 5885 5886
    score_tab[start_i]= 0;
    survivor[0]= start_i;
    survivor_count= 1;
5887

5888 5889
    for(i=start_i; i<=last_non_zero; i++){
        int level_index, j;
5890
        const int dct_coeff= FFABS(block[ scantable[i] ]);
5891
        const int zero_distoration= dct_coeff*dct_coeff;
5892
        int best_score=256*256*256*120;
5893 5894 5895
        for(level_index=0; level_index < coeff_count[i]; level_index++){
            int distoration;
            int level= coeff[level_index][i];
5896
            const int alevel= FFABS(level);
5897
            int unquant_coeff;
5898

5899 5900 5901
            assert(level);

            if(s->out_format == FMT_H263){
Michael Niedermayer's avatar
Michael Niedermayer committed
5902
                unquant_coeff= alevel*qmul + qadd;
5903
            }else{ //MPEG1
5904
                j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5905
                if(s->mb_intra){
Michael Niedermayer's avatar
Michael Niedermayer committed
5906
                        unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
5907 5908
                        unquant_coeff =   (unquant_coeff - 1) | 1;
                }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
5909
                        unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5910 5911 5912 5913
                        unquant_coeff =   (unquant_coeff - 1) | 1;
                }
                unquant_coeff<<= 3;
            }
5914

5915
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5916 5917
            level+=64;
            if((level&(~127)) == 0){
5918 5919
                for(j=survivor_count-1; j>=0; j--){
                    int run= i - survivor[j];
5920
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5921
                    score += score_tab[i-run];
5922

5923
                    if(score < best_score){
5924
                        best_score= score;
5925 5926 5927 5928 5929 5930
                        run_tab[i+1]= run;
                        level_tab[i+1]= level-64;
                    }
                }

                if(s->out_format == FMT_H263){
5931 5932
                    for(j=survivor_count-1; j>=0; j--){
                        int run= i - survivor[j];
5933
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5934
                        score += score_tab[i-run];
5935 5936 5937 5938 5939
                        if(score < last_score){
                            last_score= score;
                            last_run= run;
                            last_level= level-64;
                            last_i= i+1;
5940 5941 5942 5943 5944
                        }
                    }
                }
            }else{
                distoration += esc_length*lambda;
5945 5946
                for(j=survivor_count-1; j>=0; j--){
                    int run= i - survivor[j];
5947
                    int score= distoration + score_tab[i-run];
5948

5949
                    if(score < best_score){
5950
                        best_score= score;
5951 5952 5953 5954 5955 5956
                        run_tab[i+1]= run;
                        level_tab[i+1]= level-64;
                    }
                }

                if(s->out_format == FMT_H263){
5957 5958
                  for(j=survivor_count-1; j>=0; j--){
                        int run= i - survivor[j];
5959
                        int score= distoration + score_tab[i-run];
5960 5961 5962 5963 5964
                        if(score < last_score){
                            last_score= score;
                            last_run= run;
                            last_level= level-64;
                            last_i= i+1;
5965 5966 5967 5968 5969
                        }
                    }
                }
            }
        }
5970

5971 5972
        score_tab[i+1]= best_score;

5973
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5974 5975 5976 5977 5978 5979 5980 5981 5982 5983
        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;
            }
5984
        }
5985 5986

        survivor[ survivor_count++ ]= i+1;
5987
    }
5988

5989
    if(s->out_format != FMT_H263){
5990
        last_score= 256*256*256*120;
5991
        for(i= survivor[0]; i<=last_non_zero + 1; i++){
5992
            int score= score_tab[i];
5993 5994
            if(i) score += lambda*2; //FIXME exacter?

5995 5996 5997 5998 5999 6000
            if(score < last_score){
                last_score= score;
                last_i= i;
                last_level= level_tab[i];
                last_run= run_tab[i];
            }
6001 6002
        }
    }
6003

6004
    s->coded_score[n] = last_score;
6005

6006
    dc= FFABS(block[0]);
6007
    last_non_zero= last_i - 1;
6008
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
6009

6010 6011
    if(last_non_zero < start_i)
        return last_non_zero;
6012

6013 6014 6015
    if(last_non_zero == 0 && start_i == 0){
        int best_level= 0;
        int best_score= dc * dc;
6016

6017
        for(i=0; i<coeff_count[0]; i++){
6018
            int level= coeff[i][0];
6019
            int alevel= FFABS(level);
Michael Niedermayer's avatar
Michael Niedermayer committed
6020
            int unquant_coeff, score, distortion;
6021 6022

            if(s->out_format == FMT_H263){
Michael Niedermayer's avatar
Michael Niedermayer committed
6023
                    unquant_coeff= (alevel*qmul + qadd)>>3;
6024
            }else{ //MPEG1
Michael Niedermayer's avatar
Michael Niedermayer committed
6025 6026
                    unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
                    unquant_coeff =   (unquant_coeff - 1) | 1;
6027 6028 6029 6030
            }
            unquant_coeff = (unquant_coeff + 4) >> 3;
            unquant_coeff<<= 3 + 3;

Michael Niedermayer's avatar
Michael Niedermayer committed
6031
            distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
6032
            level+=64;
Michael Niedermayer's avatar
Michael Niedermayer committed
6033 6034
            if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
            else                    score= distortion + esc_length*lambda;
6035

6036 6037
            if(score < best_score){
                best_score= score;
6038
                best_level= level - 64;
6039 6040 6041
            }
        }
        block[0]= best_level;
6042 6043 6044
        s->coded_score[n] = best_score - dc*dc;
        if(best_level == 0) return -1;
        else                return last_non_zero;
6045
    }
6046

6047 6048
    i= last_i;
    assert(last_level);
6049 6050

    block[ perm_scantable[last_non_zero] ]= last_level;
6051
    i -= last_run + 1;
6052

6053 6054
    for(; i>start_i; i -= run_tab[i] + 1){
        block[ perm_scantable[i-1] ]= level_tab[i];
6055 6056 6057 6058 6059
    }

    return last_non_zero;
}

6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085
//#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];
6086
    DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111
    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);
6112

6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147
    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
6148 6149
    dc += (1<<(RECON_SHIFT-1));
    for(i=0; i<64; i++){
6150
        rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME  use orig dirrectly instead of copying to rem[]
6151 6152 6153 6154 6155 6156 6157 6158 6159 6160
    }
#ifdef REFINE_STATS
STOP_TIMER("memset rem[]")}
#endif
    sum=0;
    for(i=0; i<64; i++){
        int one= 36;
        int qns=4;
        int w;

6161
        w= FFABS(weight[i]) + qns*one;
6162 6163 6164 6165
        w= 15 + (48*qns*one + w/2)/w; // 16 .. 63

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

6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180
        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;
6181

6182 6183 6184 6185 6186 6187
        if(level){
            if(level<0) coeff= qmul*level - qadd;
            else        coeff= qmul*level + qadd;
            run_tab[rle_index++]=run;
            run=0;

6188
            s->dsp.add_8x8basis(rem, basis[j], coeff);
6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201
        }else{
            run++;
        }
    }
#ifdef REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("init rem[]")
}
}

{START_TIMER
#endif
    for(;;){
6202
        int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6203 6204
        int best_coeff=0;
        int best_change=0;
6205
        int run2, best_unquant_change=0, analyze_gradient;
6206 6207 6208
#ifdef REFINE_STATS
{START_TIMER
#endif
6209 6210 6211 6212 6213 6214 6215 6216
        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];
6217

6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229
                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
        }

6230 6231 6232 6233 6234
        if(start_i){
            const int level= block[0];
            int change, old_coeff;

            assert(s->mb_intra);
6235

6236
            old_coeff= q*level;
6237

6238 6239 6240
            for(change=-1; change<=1; change+=2){
                int new_level= level + change;
                int score, new_coeff;
6241

6242 6243 6244 6245
                new_coeff= q*new_level;
                if(new_coeff >= 2048 || new_coeff < 0)
                    continue;

6246
                score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6247 6248 6249 6250 6251 6252 6253 6254
                if(score<best_score){
                    best_score= score;
                    best_coeff= 0;
                    best_change= change;
                    best_unquant_change= new_coeff - old_coeff;
                }
            }
        }
6255

6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278
        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 );
            }
6279

6280 6281 6282
            for(change=-1; change<=1; change+=2){
                int new_level= level + change;
                int score, new_coeff, unquant_change;
6283

6284
                score=0;
6285
                if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
6286 6287 6288 6289 6290 6291 6292 6293
                   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
6294

6295 6296 6297 6298 6299 6300 6301 6302 6303 6304
                    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{
6305
                        assert(FFABS(new_level)==1);
6306

6307 6308 6309 6310 6311 6312
                        if(analyze_gradient){
                            int g= d1[ scantable[i] ];
                            if(g && (g^new_level) >= 0)
                                continue;
                        }

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

6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337
                            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;
6338
                    assert(FFABS(level)==1);
6339 6340 6341 6342

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

6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362
                        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)];
                        }
                    }
                }
6363

6364 6365 6366 6367
                score *= lambda;

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

6369
                score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392
                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 ];
6393

6394
            block[j] += best_change;
6395

6396 6397 6398 6399 6400 6401 6402 6403 6404 6405
            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){
6406
        if(FFABS(block[j]) > FFABS(block[j] - best_change)){
6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433
            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];
6434

6435 6436 6437 6438 6439 6440 6441
                 if(level){
                     run_tab[rle_index++]=run;
                     run=0;
                 }else{
                     run++;
                 }
            }
6442

6443
            s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457
        }else{
            break;
        }
    }
#ifdef REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("iterative search")
}
}
#endif

    return last_non_zero;
}

6458
static int dct_quantize_c(MpegEncContext *s,
Fabrice Bellard's avatar
Fabrice Bellard committed
6459
                        DCTELEM *block, int n,
6460
                        int qscale, int *overflow)
Fabrice Bellard's avatar
Fabrice Bellard committed
6461
{
6462
    int i, j, level, last_non_zero, q, start_i;
Fabrice Bellard's avatar
Fabrice Bellard committed
6463
    const int *qmat;
6464
    const uint8_t *scantable= s->intra_scantable.scantable;
6465 6466 6467
    int bias;
    int max=0;
    unsigned int threshold1, threshold2;
6468

6469
    s->dsp.fdct (block);
Fabrice Bellard's avatar
Fabrice Bellard committed
6470

6471
    if(s->dct_error_sum)
Michael Niedermayer's avatar
Michael Niedermayer committed
6472
        s->denoise_dct(s, block);
6473

Fabrice Bellard's avatar
Fabrice Bellard committed
6474
    if (s->mb_intra) {
6475 6476 6477 6478 6479 6480 6481 6482 6483
        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;
6484

Fabrice Bellard's avatar
Fabrice Bellard committed
6485 6486
        /* note: block[0] is assumed to be positive */
        block[0] = (block[0] + (q >> 1)) / q;
6487
        start_i = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
6488
        last_non_zero = 0;
6489
        qmat = s->q_intra_matrix[qscale];
Michael Niedermayer's avatar
Michael Niedermayer committed
6490
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
Fabrice Bellard's avatar
Fabrice Bellard committed
6491
    } else {
6492
        start_i = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
6493
        last_non_zero = -1;
6494
        qmat = s->q_inter_matrix[qscale];
Michael Niedermayer's avatar
Michael Niedermayer committed
6495
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
Fabrice Bellard's avatar
Fabrice Bellard committed
6496
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
6497 6498
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
    threshold2= (threshold1<<1);
6499 6500 6501
    for(i=63;i>=start_i;i--) {
        j = scantable[i];
        level = block[j] * qmat[j];
Fabrice Bellard's avatar
Fabrice Bellard committed
6502

6503 6504 6505 6506 6507 6508 6509 6510
        if(((unsigned)(level+threshold1))>threshold2){
            last_non_zero = i;
            break;
        }else{
            block[j]=0;
        }
    }
    for(i=start_i; i<=last_non_zero; i++) {
6511
        j = scantable[i];
6512
        level = block[j] * qmat[j];
Fabrice Bellard's avatar
Fabrice Bellard committed
6513

6514 6515
//        if(   bias+level >= (1<<QMAT_SHIFT)
//           || bias-level >= (1<<QMAT_SHIFT)){
6516 6517
        if(((unsigned)(level+threshold1))>threshold2){
            if(level>0){
Michael Niedermayer's avatar
Michael Niedermayer committed
6518
                level= (bias + level)>>QMAT_SHIFT;
6519 6520
                block[j]= level;
            }else{
Michael Niedermayer's avatar
Michael Niedermayer committed
6521
                level= (bias - level)>>QMAT_SHIFT;
6522 6523 6524 6525 6526
                block[j]= -level;
            }
            max |=level;
        }else{
            block[j]=0;
Fabrice Bellard's avatar
Fabrice Bellard committed
6527 6528
        }
    }
6529
    *overflow= s->max_qcoeff < max; //overflow might have happened
6530

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

Fabrice Bellard's avatar
Fabrice Bellard committed
6535 6536 6537
    return last_non_zero;
}

6538 6539
#endif //CONFIG_ENCODERS

6540
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6541
                                   DCTELEM *block, int n, int qscale)
Fabrice Bellard's avatar
Fabrice Bellard committed
6542
{
6543
    int i, level, nCoeffs;
6544
    const uint16_t *quant_matrix;
Fabrice Bellard's avatar
Fabrice Bellard committed
6545

6546
    nCoeffs= s->block_last_index[n];
6547 6548

    if (n < 4)
6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565
        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
6566
            }
6567
            block[j] = level;
Fabrice Bellard's avatar
Fabrice Bellard committed
6568
        }
6569 6570 6571
    }
}

6572
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6573 6574 6575 6576 6577 6578
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
    const uint16_t *quant_matrix;

    nCoeffs= s->block_last_index[n];
6579

6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594
    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
6595
            }
6596
            block[j] = level;
Fabrice Bellard's avatar
Fabrice Bellard committed
6597 6598 6599
        }
    }
}
6600

6601
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6602 6603 6604
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
6605
    const uint16_t *quant_matrix;
6606

6607 6608
    if(s->alternate_scan) nCoeffs= 63;
    else nCoeffs= s->block_last_index[n];
6609 6610

    if (n < 4)
6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630
        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;
        }
    }
}

6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
                                   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];

    if (n < 4)
        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;
            sum+=level;
        }
    }
    block[63]^=sum&1;
}

6664
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6665 6666 6667 6668 6669 6670 6671 6672
                                   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];
6673

6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694
    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;
}

6695
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6696 6697 6698 6699
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
    int nCoeffs;
6700

6701
    assert(s->block_last_index[n]>=0);
6702

6703
    qmul = qscale << 1;
6704

6705
    if (!s->h263_aic) {
6706
        if (n < 4)
6707 6708 6709
            block[0] = block[0] * s->y_dc_scale;
        else
            block[0] = block[0] * s->c_dc_scale;
6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725
        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;
6726
            }
6727
            block[i] = level;
6728 6729 6730 6731
        }
    }
}

6732
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6733 6734 6735
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
6736
    int nCoeffs;
6737

6738
    assert(s->block_last_index[n]>=0);
6739

6740 6741
    qadd = (qscale - 1) | 1;
    qmul = qscale << 1;
6742

6743
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6744

6745
    for(i=0; i<=nCoeffs; i++) {
6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756
        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
6757

6758
#ifdef CONFIG_ENCODERS
Fabrice Bellard's avatar
Fabrice Bellard committed
6759 6760 6761 6762 6763 6764 6765 6766
AVCodec h263_encoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6767
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6768 6769 6770 6771 6772 6773 6774 6775 6776 6777
};

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

6781 6782 6783 6784 6785 6786 6787 6788
AVCodec flv_encoder = {
    "flv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6789
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6790 6791
};

Fabrice Bellard's avatar
Fabrice Bellard committed
6792 6793 6794 6795 6796 6797 6798 6799
AVCodec rv10_encoder = {
    "rv10",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV10,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6800
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6801 6802
};

Michael Niedermayer's avatar
Michael Niedermayer committed
6803 6804 6805 6806 6807 6808 6809 6810
AVCodec rv20_encoder = {
    "rv20",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV20,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6811
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Michael Niedermayer's avatar
Michael Niedermayer committed
6812 6813
};

6814 6815
AVCodec mpeg4_encoder = {
    "mpeg4",
Fabrice Bellard's avatar
Fabrice Bellard committed
6816
    CODEC_TYPE_VIDEO,
6817
    CODEC_ID_MPEG4,
Fabrice Bellard's avatar
Fabrice Bellard committed
6818 6819 6820 6821
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6822
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6823
    .capabilities= CODEC_CAP_DELAY,
Fabrice Bellard's avatar
Fabrice Bellard committed
6824 6825
};

6826 6827 6828 6829 6830 6831 6832 6833
AVCodec msmpeg4v1_encoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6834
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6835 6836 6837 6838 6839 6840 6841 6842 6843 6844
};

AVCodec msmpeg4v2_encoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6845
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6846 6847 6848
};

AVCodec msmpeg4v3_encoder = {
Fabrice Bellard's avatar
Fabrice Bellard committed
6849 6850
    "msmpeg4",
    CODEC_TYPE_VIDEO,
6851
    CODEC_ID_MSMPEG4V3,
Fabrice Bellard's avatar
Fabrice Bellard committed
6852 6853 6854 6855
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6856
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
Fabrice Bellard's avatar
Fabrice Bellard committed
6857
};
Michael Niedermayer's avatar
Michael Niedermayer committed
6858 6859 6860 6861 6862 6863 6864 6865 6866

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

6870 6871 6872 6873 6874 6875 6876 6877
AVCodec mjpeg_encoder = {
    "mjpeg",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MJPEG,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
6878
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1},
6879
};
6880 6881

#endif //CONFIG_ENCODERS