mpegvideo.c 251 KB
Newer Older
glantau's avatar
glantau committed
1 2
/*
 * The simplest mpeg encoder (well, it was the simplest!)
glantau's avatar
glantau committed
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
glantau's avatar
glantau committed
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
glantau's avatar
glantau committed
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.
glantau's avatar
glantau committed
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
glantau's avatar
glantau committed
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
glantau's avatar
glantau committed
15 16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
glantau's avatar
glantau committed
17
 *
glantau's avatar
glantau committed
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
michaelni's avatar
michaelni committed
21
 *
22
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
glantau's avatar
glantau committed
23
 */
24

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

glantau's avatar
glantau committed
30 31 32
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"
michael's avatar
michael committed
33
#include "faandct.h"
34
#include <limits.h>
glantau's avatar
glantau 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
takis's avatar
takis committed
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);
michael's avatar
michael committed
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);
michael's avatar
michael committed
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,
michael's avatar
michael committed
57
                                  DCTELEM *block, int n, int qscale);
58
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
59
                                  DCTELEM *block, int n, int qscale);
kabi's avatar
kabi committed
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);
michaelni's avatar
michaelni committed
63
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
michael's avatar
michael committed
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's avatar
michael committed
66
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
67
#endif //CONFIG_ENCODERS
arpi_esp's avatar
arpi_esp committed
68

iive's avatar
iive 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);
iive's avatar
iive committed
73 74
#endif

kabi's avatar
kabi committed
75
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
arpi_esp's avatar
arpi_esp committed
76

glantau's avatar
glantau committed
77 78 79 80 81 82

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

//#define DEBUG

83

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

87
static const uint16_t aanscales[64] = {
glantau's avatar
glantau 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,
michaelni's avatar
michaelni committed
95 96
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
glantau's avatar
glantau committed
97 98
};

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

michael's avatar
michael 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;
kabi's avatar
kabi committed
111
static uint8_t default_fcode_tab[MAX_MV*2+1];
112

michaelni's avatar
michaelni 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)
glantau's avatar
glantau 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_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_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_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
michaelni's avatar
michaelni committed
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
            }
glantau's avatar
glantau 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
                shift++;
            }
        }
    }
    if(shift){
mbardiaux's avatar
mbardiaux committed
185
        av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
glantau's avatar
glantau committed
186 187
    }
}
188 189 190

static inline void update_qscale(MpegEncContext *s){
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
reimar's avatar
reimar committed
191
    s->qscale= av_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

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

michaelni's avatar
michaelni committed
201
    st->scantable= src_scantable;
202 203 204 205

    for(i=0; i<64; i++){
        int j;
        j = src_scantable[i];
michaelni's avatar
michaelni 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
mru's avatar
mru committed
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

michael's avatar
michael committed
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's avatar
michael committed
238 239 240 241
    assert(p<=end);
    if(p>=end)
        return end;

michael's avatar
michael committed
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's avatar
michael committed
250 251 252
        if     (p[-1] > 1      ) p+= 3;
        else if(p[-2]          ) p+= 2;
        else if(p[-3]|(p[-1]-1)) p++;
michael's avatar
michael committed
253 254 255 256 257 258
        else{
            p++;
            break;
        }
    }

michael's avatar
michael committed
259
    p= FFMIN(p, end)-4;
michael's avatar
michael committed
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)
glantau's avatar
glantau committed
267
{
michael's avatar
michael committed
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;
michael's avatar
michael committed
275
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
276

277
#ifdef CONFIG_ENCODERS
278
    s->dct_quantize= dct_quantize_c;
michael's avatar
michael 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);
nickols_k's avatar
nickols_k 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;

michaelni's avatar
michaelni committed
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
    */
michael's avatar
michael committed
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);
    }
michaelni's avatar
michaelni 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);
michaelni's avatar
michaelni committed
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

michaelni's avatar
michaelni committed
372
/**
michaelni's avatar
michaelni committed
373 374
 * allocates a Picture
 * The pixels are allocated/set by calling get_buffer() if shared=0
michaelni's avatar
michaelni committed
375
 */
michaelni's avatar
michaelni 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;
michaelni's avatar
michaelni committed
381
    int i;
382

michaelni's avatar
michaelni 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

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

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

michaelni's avatar
michaelni 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]);
michaelni's avatar
michaelni 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");
michaelni's avatar
michaelni committed
401 402 403 404
            return -1;
        }

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

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

michaelni's avatar
michaelni 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))
michaelni's avatar
michaelni committed
418
        }
michaelni's avatar
michaelni 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;
michaelni's avatar
michaelni committed
424 425
        if(s->out_format == FMT_H264){
            for(i=0; i<2; i++){
michael's avatar
michael 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
            }
michael's avatar
michael committed
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's avatar
michael 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))
michaelni's avatar
michaelni committed
436
            }
michael's avatar
michael committed
437
            pic->motion_subsample_log2= 3;
michaelni's avatar
michaelni committed
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))
michaelni's avatar
michaelni committed
444
    }
michaelni's avatar
michaelni committed
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

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

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

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

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

481
    if(pic->type == FF_BUFFER_TYPE_SHARED){
michaelni's avatar
michaelni committed
482 483 484 485
        for(i=0; i<4; i++){
            pic->base[i]=
            pic->data[i]= NULL;
        }
486
        pic->type= 0;
michaelni's avatar
michaelni 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)
lorenm's avatar
lorenm committed
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
}

michael's avatar
michael committed
558
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
559
    MpegEncContext bak;
michael's avatar
michael committed
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);
michael's avatar
michael committed
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's avatar
diego 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's avatar
michael 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's avatar
michael 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's avatar
michael committed
628
    static int done=0;
629

michael's avatar
michael committed
630
    MPV_common_defaults(s);
631

michael's avatar
michael 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's avatar
michael committed
647

648
/**
michael's avatar
michael 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)
{
michael's avatar
michael committed
654
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
655

lorenm's avatar
lorenm committed
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's avatar
10l  
michael 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

michaelni's avatar
michaelni 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;
michael's avatar
michael committed
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

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

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

michaelni's avatar
michaelni committed
711
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
michaelni's avatar
michaelni 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;
michaelni's avatar
 
michaelni committed
735

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

        /* Allocate MB type table */
michael's avatar
michael committed
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))
michael's avatar
michael committed
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

michael's avatar
michael committed
761
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
762
        /* interlaced direct mode decoding tables */
michael's avatar
michael committed
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))
            }
glantau's avatar
glantau committed
776
    }
michaelni's avatar
michaelni committed
777
    if (s->out_format == FMT_H263) {
glantau's avatar
glantau 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;
glantau's avatar
glantau committed
782
        s->ac_val[2] = s->ac_val[1] + c_size;
783

glantau's avatar
glantau 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

michaelni's avatar
 
michaelni committed
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

glantau's avatar
glantau 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;
    }

glantau's avatar
glantau committed
835 836
    return 0;
 fail:
837
    MPV_common_end(s);
glantau's avatar
glantau committed
838 839 840 841 842 843
    return -1;
}

/* init common structure for both encoder and decoder */
void MPV_common_end(MpegEncContext *s)
{
michael's avatar
michael committed
844
    int i, j, k;
glantau's avatar
glantau 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;
michael's avatar
michael committed
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);
michaelni's avatar
 
michaelni committed
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;

michaelni's avatar
michaelni committed
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);
michael's avatar
michael committed
903 904
    av_freep(&s->input_picture);
    av_freep(&s->reordered_input_picture);
905
    av_freep(&s->dct_offset);
michaelni's avatar
michaelni committed
906

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

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

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

925 926
#ifdef CONFIG_ENCODERS

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

michael's avatar
michael committed
934
    MPV_encode_defaults(s);
935

bcoudurier's avatar
bcoudurier committed
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:
bcoudurier's avatar
bcoudurier committed
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)){
michael's avatar
michael committed
947 948 949
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
            return -1;
        }
bcoudurier's avatar
bcoudurier committed
950 951 952 953
        break;
    default:
        if(avctx->pix_fmt != PIX_FMT_YUV420P){
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
michael's avatar
michael committed
954 955 956
            return -1;
        }
    }
romansh's avatar
 
romansh committed
957

bcoudurier's avatar
bcoudurier committed
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;
    }

glantau's avatar
glantau 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");
michaelni's avatar
 
michaelni committed
975 976
        avctx->gop_size=600;
    }
glantau's avatar
glantau 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;
michaelni's avatar
 
michaelni committed
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;
michaelni's avatar
michaelni committed
987
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
michaelni's avatar
michaelni committed
988
    s->mpeg_quant= avctx->mpeg_quant;
michael's avatar
michael committed
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

glantau's avatar
glantau 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

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

1002
    /* Fixed QSCALE */
michael's avatar
michael committed
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

michael's avatar
michael committed
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);
bcoudurier's avatar
bcoudurier committed
1017
    s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1018

michael's avatar
michael committed
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
    }
michael's avatar
michael committed
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");
michael's avatar
michael committed
1026
    }
1027

michael's avatar
michael 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's avatar
michael 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
michael's avatar
michael committed
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

michael's avatar
michael committed
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");
michaelni's avatar
michaelni committed
1048 1049
        return -1;
    }
1050

michael's avatar
michael committed
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");
michael's avatar
michael committed
1053 1054
        return -1;
    }
1055

michael's avatar
michael 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

michaelni's avatar
michaelni committed
1061
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1062
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
michaelni's avatar
michaelni committed
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");
michaelni's avatar
michaelni committed
1068 1069
        return -1;
    }
1070

michaelni's avatar
michaelni 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");
michaelni's avatar
michaelni committed
1073 1074
        return -1;
    }
michael's avatar
michael committed
1075

1076
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
michael's avatar
michael 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

michaelni's avatar
michaelni committed
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");
michaelni's avatar
michaelni committed
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's avatar
michael 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
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1098
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
1099 1100
        return -1;
    }
1101

bcoudurier's avatar
bcoudurier committed
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 1109 1110 1111 1112 1113 1114 1115 1116 1117
    if(s->flags & CODEC_FLAG_LOW_DELAY){
        if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
            av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
            return -1;
        }
        if (s->max_b_frames != 0){
            av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
            return -1;
        }
    }

1118 1119
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1120 1121 1122 1123
       && (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;
    }
1124

1125 1126
    if(s->avctx->thread_count > 1)
        s->rtp_mode= 1;
michael's avatar
michael committed
1127

michael's avatar
michael committed
1128
    if(!avctx->time_base.den || !avctx->time_base.num){
michael's avatar
michael committed
1129 1130 1131
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
        return -1;
    }
1132

1133 1134 1135 1136 1137 1138 1139 1140 1141
    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;
    }
1142

michael's avatar
michael committed
1143
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1144 1145
        av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
        avctx->b_frame_strategy = 0;
michael's avatar
michael committed
1146 1147
    }

michael's avatar
michael committed
1148
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
michael's avatar
michael committed
1149 1150
    if(i > 1){
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
michael's avatar
michael committed
1151 1152
        avctx->time_base.den /= i;
        avctx->time_base.num /= i;
michael's avatar
michael committed
1153 1154
//        return -1;
    }
1155

michaelni's avatar
michaelni committed
1156 1157 1158
    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;
michaelni's avatar
michaelni committed
1159
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
michaelni's avatar
michaelni committed
1160 1161 1162 1163 1164 1165
        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
    }
1166

michaelni's avatar
michaelni committed
1167 1168 1169 1170
    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;
1171

1172 1173
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);

1174
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
michael's avatar
michael committed
1175
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1176
        return -1;
michael's avatar
michael committed
1177 1178
    }
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
michaelni's avatar
michaelni committed
1179

glantau's avatar
glantau committed
1180 1181 1182
    switch(avctx->codec->id) {
    case CODEC_ID_MPEG1VIDEO:
        s->out_format = FMT_MPEG1;
1183
        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1184
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
glantau's avatar
glantau committed
1185
        break;
michaelni's avatar
michaelni committed
1186 1187
    case CODEC_ID_MPEG2VIDEO:
        s->out_format = FMT_MPEG1;
1188
        s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
michaelni's avatar
michaelni committed
1189
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
michael's avatar
michael committed
1190
        s->rtp_mode= 1;
michaelni's avatar
michaelni committed
1191
        break;
1192
    case CODEC_ID_LJPEG:
michael's avatar
michael committed
1193
    case CODEC_ID_JPEGLS:
glantau's avatar
glantau committed
1194 1195 1196
    case CODEC_ID_MJPEG:
        s->out_format = FMT_MJPEG;
        s->intra_only = 1; /* force intra only for jpeg */
michael's avatar
michael committed
1197
        s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1198
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
bcoudurier's avatar
bcoudurier committed
1199 1200 1201 1202 1203 1204
        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;
glantau's avatar
glantau committed
1205 1206
        if (mjpeg_init(s) < 0)
            return -1;
michaelni's avatar
michaelni committed
1207
        avctx->delay=0;
michaelni's avatar
michaelni committed
1208
        s->low_delay=1;
glantau's avatar
glantau committed
1209
        break;
1210
#ifdef CONFIG_H261_ENCODER
1211
    case CODEC_ID_H261:
1212 1213 1214 1215
        if (ff_h261_get_picture_format(s->width, s->height) < 0) {
            av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
            return -1;
        }
1216 1217 1218 1219
        s->out_format = FMT_H261;
        avctx->delay=0;
        s->low_delay=1;
        break;
1220
#endif
glantau's avatar
glantau committed
1221
    case CODEC_ID_H263:
1222
        if (h263_get_picture_format(s->width, s->height) == 7) {
1223
            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);
glantau's avatar
glantau committed
1224
            return -1;
1225
        }
glantau's avatar
glantau committed
1226
        s->out_format = FMT_H263;
1227
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
michaelni's avatar
michaelni committed
1228
        avctx->delay=0;
michaelni's avatar
michaelni committed
1229
        s->low_delay=1;
glantau's avatar
glantau committed
1230 1231 1232 1233
        break;
    case CODEC_ID_H263P:
        s->out_format = FMT_H263;
        s->h263_plus = 1;
1234
        /* Fx */
michael's avatar
michael committed
1235
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1236
        s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1237 1238 1239 1240 1241
        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;
michael's avatar
michael committed
1242
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
michael's avatar
michael committed
1243

1244
        /* /Fx */
1245
        /* These are just to be sure */
michaelni's avatar
michaelni committed
1246
        avctx->delay=0;
michaelni's avatar
michaelni committed
1247
        s->low_delay=1;
glantau's avatar
glantau committed
1248
        break;
1249 1250 1251 1252 1253 1254 1255 1256
    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;
glantau's avatar
glantau committed
1257 1258
    case CODEC_ID_RV10:
        s->out_format = FMT_H263;
michaelni's avatar
michaelni committed
1259
        avctx->delay=0;
michaelni's avatar
michaelni committed
1260
        s->low_delay=1;
glantau's avatar
glantau committed
1261
        break;
michael's avatar
michael committed
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
    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;
glantau's avatar
glantau committed
1272
    case CODEC_ID_MPEG4:
glantau's avatar
glantau committed
1273 1274 1275
        s->out_format = FMT_H263;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
michaelni's avatar
michaelni committed
1276
        s->low_delay= s->max_b_frames ? 0 : 1;
1277
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
glantau's avatar
glantau committed
1278
        break;
1279
    case CODEC_ID_MSMPEG4V1:
glantau's avatar
glantau committed
1280 1281 1282 1283
        s->out_format = FMT_H263;
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->unrestricted_mv = 1;
1284
        s->msmpeg4_version= 1;
michaelni's avatar
michaelni committed
1285
        avctx->delay=0;
michaelni's avatar
michaelni committed
1286
        s->low_delay=1;
1287 1288 1289 1290 1291 1292 1293
        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;
michaelni's avatar
michaelni committed
1294
        avctx->delay=0;
michaelni's avatar
michaelni committed
1295
        s->low_delay=1;
1296 1297 1298 1299 1300 1301 1302
        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;
michaelni's avatar
michaelni committed
1303
        s->flipflop_rounding=1;
michaelni's avatar
michaelni committed
1304
        avctx->delay=0;
michaelni's avatar
michaelni committed
1305
        s->low_delay=1;
glantau's avatar
glantau committed
1306
        break;
michaelni's avatar
 
michaelni committed
1307 1308 1309 1310 1311 1312
    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;
michaelni's avatar
michaelni committed
1313
        s->flipflop_rounding=1;
michaelni's avatar
 
michaelni committed
1314
        avctx->delay=0;
michaelni's avatar
michaelni committed
1315
        s->low_delay=1;
michaelni's avatar
 
michaelni committed
1316 1317 1318 1319 1320 1321 1322
        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;
michaelni's avatar
michaelni committed
1323
        s->flipflop_rounding=1;
michaelni's avatar
 
michaelni committed
1324
        avctx->delay=0;
michaelni's avatar
michaelni committed
1325
        s->low_delay=1;
michaelni's avatar
 
michaelni committed
1326
        break;
glantau's avatar
glantau committed
1327 1328 1329
    default:
        return -1;
    }
1330

michael's avatar
michael committed
1331
    avctx->has_b_frames= !s->low_delay;
1332

1333 1334
    s->encoding = 1;

glantau's avatar
glantau committed
1335 1336 1337
    /* init */
    if (MPV_common_init(s) < 0)
        return -1;
michael's avatar
michael committed
1338 1339 1340

    if(s->modified_quant)
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1341
    s->progressive_frame=
michael's avatar
michael committed
1342
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1343
    s->quant_precision=5;
1344

michael's avatar
michael committed
1345
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
michael's avatar
michael committed
1346
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1347

michael's avatar
michael committed
1348
#ifdef CONFIG_H261_ENCODER
1349 1350
    if (s->out_format == FMT_H261)
        ff_h261_encode_init(s);
michael's avatar
michael committed
1351
#endif
1352 1353 1354 1355
    if (s->out_format == FMT_H263)
        h263_encode_init(s);
    if(s->msmpeg4_version)
        ff_msmpeg4_encode_init(s);
michaelni's avatar
michaelni committed
1356 1357
    if (s->out_format == FMT_MPEG1)
        ff_mpeg1_encode_init(s);
1358

michael's avatar
michael committed
1359
    /* init q matrix */
1360
    for(i=0;i<64;i++) {
1361
        int j= s->dsp.idct_permutation[i];
michaelni's avatar
michaelni committed
1362
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1363 1364
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1365
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1366 1367
            s->intra_matrix[j] =
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
michaelni's avatar
michaelni committed
1368
        }else
michaelni's avatar
michaelni committed
1369
        { /* mpeg1/2 */
1370 1371
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
michaelni's avatar
michaelni committed
1372
        }
1373 1374 1375 1376
        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];
1377 1378 1379
    }

    /* precompute matrix */
1380
    /* for mjpeg, we do include qscale in the matrix */
1381
    if (s->out_format != FMT_MJPEG) {
1382
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1383
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1384
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1385
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1386 1387
    }

michaelni's avatar
michaelni committed
1388 1389
    if(ff_rate_control_init(s) < 0)
        return -1;
1390

glantau's avatar
glantau committed
1391 1392 1393 1394 1395 1396 1397
    return 0;
}

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

michaelni's avatar
michaelni committed
1398 1399
    ff_rate_control_uninit(s);

glantau's avatar
glantau committed
1400 1401 1402
    MPV_common_end(s);
    if (s->out_format == FMT_MJPEG)
        mjpeg_close(s);
1403

michaelni's avatar
michaelni committed
1404
    av_freep(&avctx->extradata);
1405

glantau's avatar
glantau committed
1406 1407 1408
    return 0;
}

1409 1410
#endif //CONFIG_ENCODERS

1411
void init_rl(RLTable *rl, int use_static)
michaelni's avatar
michaelni committed
1412
{
kabi's avatar
kabi committed
1413 1414
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
    uint8_t index_run[MAX_RUN+1];
michaelni's avatar
michaelni committed
1415 1416
    int last, run, level, start, end, i;

1417 1418 1419 1420
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
    if(use_static && rl->max_level[0])
        return;

michaelni's avatar
michaelni committed
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
    /* 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;
        }
1444 1445 1446 1447
        if(use_static)
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
        else
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
michaelni's avatar
michaelni committed
1448
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1449 1450 1451 1452
        if(use_static)
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
        else
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
michaelni's avatar
michaelni committed
1453
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1454 1455 1456 1457
        if(use_static)
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
        else
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
michaelni's avatar
michaelni committed
1458 1459 1460 1461
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
    }
}

glantau's avatar
glantau committed
1462
/* draw the edges of width 'w' of an image of size width, height */
1463
//FIXME check that this is ok for mpeg4 interlaced
kabi's avatar
kabi committed
1464
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
glantau's avatar
glantau committed
1465
{
kabi's avatar
kabi committed
1466
    uint8_t *ptr, *last_line;
glantau's avatar
glantau committed
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
    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 */
    }
}

michael's avatar
michael committed
1491
int ff_find_unused_picture(MpegEncContext *s, int shared){
michaelni's avatar
michaelni committed
1492
    int i;
1493

michaelni's avatar
michaelni committed
1494 1495
    if(shared){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
michael's avatar
michael committed
1496
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
michaelni's avatar
michaelni committed
1497 1498 1499
        }
    }else{
        for(i=0; i<MAX_PICTURE_COUNT; i++){
michael's avatar
michael committed
1500
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
michaelni's avatar
michaelni committed
1501 1502
        }
        for(i=0; i<MAX_PICTURE_COUNT; i++){
michael's avatar
michael committed
1503
            if(s->picture[i].data[0]==NULL) return i;
michaelni's avatar
michaelni committed
1504 1505 1506
        }
    }

michael's avatar
michael committed
1507 1508
    assert(0);
    return -1;
michaelni's avatar
michaelni committed
1509 1510
}

1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
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;
        }
1521

1522 1523 1524 1525 1526 1527
        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);
        }
    }
}

michael's avatar
michael committed
1528 1529 1530
/**
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
 */
1531
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
glantau's avatar
glantau committed
1532
{
michaelni's avatar
michaelni committed
1533
    int i;
michaelni's avatar
michaelni committed
1534
    AVFrame *pic;
1535
    s->mb_skipped = 0;
michaelni's avatar
michaelni committed
1536

michaelni's avatar
michaelni committed
1537
    assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
michaelni's avatar
michaelni committed
1538

michaelni's avatar
michaelni committed
1539
    /* mark&release old frames */
michael's avatar
michael committed
1540
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1541
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
michaelni's avatar
michaelni committed
1542
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
michaelni's avatar
michaelni committed
1543 1544 1545 1546 1547

        /* release forgotten pictures */
        /* if(mpeg124/h263) */
        if(!s->encoding){
            for(i=0; i<MAX_PICTURE_COUNT; i++){
michaelni's avatar
michaelni committed
1548
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1549
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1550
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
michaelni's avatar
michaelni committed
1551 1552
                }
            }
1553
        }
1554
      }
1555
    }
1556 1557
alloc:
    if(!s->encoding){
diego's avatar
diego committed
1558
        /* release non reference frames */
michaelni's avatar
michaelni committed
1559 1560 1561 1562 1563 1564
        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's avatar
michael committed
1565 1566 1567 1568 1569 1570 1571
        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];
        }

1572 1573
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
                        && !s->dropable ? 3 : 0;
michaelni's avatar
michaelni committed
1574

michael's avatar
michael committed
1575
        pic->coded_picture_number= s->coded_picture_number++;
1576

1577 1578
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
            return -1;
1579

michael's avatar
michael committed
1580
        s->current_picture_ptr= (Picture*)pic;
1581
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
michael's avatar
michael committed
1582
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
michaelni's avatar
michaelni committed
1583
    }
1584

michaelni's avatar
michaelni committed
1585
    s->current_picture_ptr->pict_type= s->pict_type;
1586
//    if(s->flags && CODEC_FLAG_QSCALE)
1587
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1588
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
michaelni's avatar
michaelni committed
1589

1590
    copy_picture(&s->current_picture, s->current_picture_ptr);
1591

michaelni's avatar
michaelni committed
1592
    if (s->pict_type != B_TYPE) {
michaelni's avatar
michaelni committed
1593
        s->last_picture_ptr= s->next_picture_ptr;
michael's avatar
michael committed
1594 1595
        if(!s->dropable)
            s->next_picture_ptr= s->current_picture_ptr;
glantau's avatar
glantau committed
1596
    }
michael's avatar
michael committed
1597
/*    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,
1598 1599
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
michael's avatar
michael committed
1600 1601
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
        s->pict_type, s->dropable);*/
1602

1603 1604
    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);
1605

1606
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
1607
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
diego's avatar
diego committed
1608
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1609 1610 1611 1612 1613
        goto alloc;
    }

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

michaelni's avatar
michaelni committed
1614 1615 1616 1617 1618
    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];
1619
            }
michaelni's avatar
michaelni committed
1620 1621 1622 1623 1624
            s->current_picture.linesize[i] *= 2;
            s->last_picture.linesize[i] *=2;
            s->next_picture.linesize[i] *=2;
        }
    }
1625

1626 1627 1628
    s->hurry_up= s->avctx->hurry_up;
    s->error_resilience= avctx->error_resilience;

diego's avatar
diego committed
1629 1630
    /* 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 */
michael's avatar
michael committed
1631 1632 1633
    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;
michael's avatar
michael committed
1634
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
michael's avatar
michael committed
1635 1636 1637 1638 1639 1640
        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;
    }
1641

1642 1643 1644 1645 1646
    if(s->dct_error_sum){
        assert(s->avctx->noise_reduction && s->encoding);

        update_noise_reduction(s);
    }
1647

iive's avatar
iive committed
1648 1649 1650 1651
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration)
        return XVMC_field_start(s, avctx);
#endif
1652
    return 0;
glantau's avatar
glantau committed
1653
}
1654

glantau's avatar
glantau committed
1655 1656 1657
/* generic function for encode/decode called after a frame has been coded/decoded */
void MPV_frame_end(MpegEncContext *s)
{
michaelni's avatar
michaelni committed
1658
    int i;
glantau's avatar
glantau committed
1659
    /* draw edge for correct motion prediction if outside */
iive's avatar
iive committed
1660 1661 1662 1663 1664 1665
#ifdef HAVE_XVMC
//just to make sure that all data is rendered.
    if(s->avctx->xvmc_acceleration){
        XVMC_field_end(s);
    }else
#endif
1666
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
michaelni's avatar
michaelni committed
1667 1668 1669
            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);
glantau's avatar
glantau committed
1670
    }
arpi_esp's avatar
arpi_esp committed
1671
    emms_c();
1672

michaelni's avatar
michaelni committed
1673
    s->last_pict_type    = s->pict_type;
1674
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
michaelni's avatar
michaelni committed
1675 1676 1677
    if(s->pict_type!=B_TYPE){
        s->last_non_b_pict_type= s->pict_type;
    }
michaelni's avatar
michaelni committed
1678 1679
#if 0
        /* copy back current_picture variables */
michaelni's avatar
michaelni committed
1680 1681 1682 1683
    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;
1684
        }
michaelni's avatar
michaelni committed
1685 1686
    }
    assert(i<MAX_PICTURE_COUNT);
1687
#endif
michaelni's avatar
michaelni committed
1688

michaelni's avatar
michaelni committed
1689
    if(s->encoding){
diego's avatar
diego committed
1690
        /* release non-reference frames */
michaelni's avatar
michaelni committed
1691 1692 1693 1694 1695
        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]);
            }
        }
michaelni's avatar
michaelni committed
1696
    }
michaelni's avatar
michaelni committed
1697 1698 1699 1700 1701 1702
    // 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
michael's avatar
michael committed
1703
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
glantau's avatar
glantau committed
1704 1705
}

1706 1707 1708 1709 1710 1711 1712 1713
/**
 * 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's avatar
SWAP  
michael committed
1714
    int x, y, fr, f;
1715

reimar's avatar
reimar committed
1716 1717 1718 1719
    sx= av_clip(sx, 0, w-1);
    sy= av_clip(sy, 0, h-1);
    ex= av_clip(ex, 0, w-1);
    ey= av_clip(ey, 0, h-1);
1720

1721
    buf[sy*stride + sx]+= color;
1722

diego's avatar
diego committed
1723
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1724
        if(sx > ex){
diego's avatar
diego committed
1725 1726
            FFSWAP(int, sx, ex);
            FFSWAP(int, sy, ey);
1727 1728 1729 1730 1731
        }
        buf+= sx + sy*stride;
        ex-= sx;
        f= ((ey-sy)<<16)/ex;
        for(x= 0; x <= ex; x++){
1732 1733 1734 1735
            y = (x*f)>>16;
            fr= (x*f)&0xFFFF;
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1736 1737 1738
        }
    }else{
        if(sy > ey){
diego's avatar
diego committed
1739 1740
            FFSWAP(int, sx, ex);
            FFSWAP(int, sy, ey);
1741 1742 1743 1744 1745 1746
        }
        buf+= sx + sy*stride;
        ey-= sy;
        if(ey) f= ((ex-sx)<<16)/ey;
        else   f= 0;
        for(y= 0; y <= ey; y++){
1747 1748 1749 1750
            x = (y*f)>>16;
            fr= (y*f)&0xFFFF;
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
        }
    }
}

/**
 * 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
 */
1762
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1763 1764
    int dx,dy;

reimar's avatar
reimar committed
1765 1766 1767 1768
    sx= av_clip(sx, -100, w+100);
    sy= av_clip(sy, -100, h+100);
    ex= av_clip(ex, -100, w+100);
    ey= av_clip(ey, -100, h+100);
1769

1770 1771
    dx= ex - sx;
    dy= ey - sy;
1772

1773 1774 1775 1776
    if(dx*dx + dy*dy > 3*3){
        int rx=  dx + dy;
        int ry= -dx + dy;
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1777

1778 1779 1780
        //FIXME subpixel accuracy
        rx= ROUNDED_DIV(rx*3<<4, length);
        ry= ROUNDED_DIV(ry*3<<4, length);
1781

1782 1783 1784 1785 1786 1787
        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);
}

1788 1789 1790
/**
 * prints debuging info for the given picture.
 */
1791
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1792 1793 1794 1795 1796

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

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

1798 1799 1800 1801 1802 1803 1804
        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;
1805
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1806
        }
1807 1808 1809 1810 1811
        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;
1812
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1813 1814
                }
                if(s->avctx->debug&FF_DEBUG_QP){
1815
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1816 1817 1818 1819 1820
                }
                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))
1821
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1822
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1823
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1824
                    else if(IS_INTRA4x4(mb_type))
1825
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1826
                    else if(IS_INTRA16x16(mb_type))
1827
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1828
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1829
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1830
                    else if(IS_DIRECT(mb_type))
1831
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1832
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1833
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1834
                    else if(IS_GMC(mb_type))
1835
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1836
                    else if(IS_SKIP(mb_type))
1837
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1838
                    else if(!USES_LIST(mb_type, 1))
1839
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1840
                    else if(!USES_LIST(mb_type, 0))
1841
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1842 1843
                    else{
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1844
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1845
                    }
1846

1847 1848
                    //segmentation
                    if(IS_8X8(mb_type))
1849
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1850
                    else if(IS_16X8(mb_type))
1851
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1852
                    else if(IS_8X16(mb_type))
mru's avatar
mru committed
1853
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1854
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1855
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1856
                    else
1857
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1858 1859


1860
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1861
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1862
                    else
1863
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1864
                }
1865
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1866
            }
1867
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1868 1869
        }
    }
1870

1871
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1872 1873
        const int shift= 1 + s->quarter_sample;
        int mb_y;
1874 1875
        uint8_t *ptr;
        int i;
1876
        int h_chroma_shift, v_chroma_shift;
1877 1878
        const int width = s->avctx->width;
        const int height= s->avctx->height;
1879
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1880
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
michael's avatar
michael committed
1881
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1882

1883
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1884
        for(i=0; i<3; i++){
1885
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1886 1887 1888 1889
            pict->data[i]= s->visualization_buffer[i];
        }
        pict->type= FF_BUFFER_TYPE_COPY;
        ptr= pict->data[0];
1890 1891 1892 1893 1894

        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;
1895 1896 1897
                if((s->avctx->debug_mv) && pict->motion_val){
                  int type;
                  for(type=0; type<3; type++){
1898
                    int direction = 0;
1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
                    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;
                    }
1913 1914 1915
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
                        continue;

1916 1917 1918
                    if(IS_8X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<4; i++){
1919 1920
                        int sx= mb_x*16 + 4 + 8*(i&1);
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1921
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1922 1923
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1924
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1925 1926 1927 1928
                      }
                    }else if(IS_16X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<2; i++){
1929 1930
                        int sx=mb_x*16 + 8;
                        int sy=mb_y*16 + 4 + 8*i;
1931
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1932 1933
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1934

1935 1936
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1937

1938 1939 1940 1941 1942 1943 1944
                        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;
1945
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1946 1947
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1948

1949 1950
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1951

1952
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1953 1954 1955 1956
                      }
                    }else{
                      int sx= mb_x*16 + 8;
                      int sy= mb_y*16 + 8;
1957
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1958 1959
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1960
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1961
                    }
1962
                  }
michael's avatar
michael committed
1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979
                }
                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));

1980

michael's avatar
michael committed
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 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022
                    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;
                    }
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
                    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;
                        }
                    }
2038

michael's avatar
michael committed
2039 2040 2041
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
                        // hmm
                    }
2042 2043 2044 2045 2046
                }
                s->mbskip_table[mb_index]=0;
            }
        }
    }
2047 2048
}

2049 2050
#ifdef CONFIG_ENCODERS

michaelni's avatar
michaelni committed
2051 2052 2053
static int get_sae(uint8_t *src, int ref, int stride){
    int x,y;
    int acc=0;
2054

michaelni's avatar
michaelni committed
2055 2056
    for(y=0; y<16; y++){
        for(x=0; x<16; x++){
diego's avatar
diego committed
2057
            acc+= FFABS(src[x+y*stride] - ref);
michaelni's avatar
michaelni committed
2058 2059
        }
    }
2060

michaelni's avatar
michaelni committed
2061 2062 2063 2064 2065 2066
    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;
2067

michaelni's avatar
michaelni committed
2068 2069
    w= s->width &~15;
    h= s->height&~15;
2070

michaelni's avatar
michaelni committed
2071 2072 2073
    for(y=0; y<h; y+=16){
        for(x=0; x<w; x+=16){
            int offset= x + y*stride;
michael's avatar
michael committed
2074
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
michaelni's avatar
michaelni committed
2075 2076
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
            int sae = get_sae(src + offset, mean, stride);
2077

michaelni's avatar
michaelni committed
2078 2079 2080 2081 2082 2083
            acc+= sae + 500 < sad;
        }
    }
    return acc;
}

michaelni's avatar
michaelni committed
2084

michaelni's avatar
michaelni committed
2085
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2086
    AVFrame *pic=NULL;
2087
    int64_t pts;
michaelni's avatar
michaelni committed
2088
    int i;
michaelni's avatar
michaelni committed
2089
    const int encoding_delay= s->max_b_frames;
michaelni's avatar
michaelni committed
2090
    int direct=1;
2091

michael's avatar
michael committed
2092
    if(pic_arg){
2093 2094 2095
        pts= pic_arg->pts;
        pic_arg->display_picture_number= s->input_picture_number++;

2096
        if(pts != AV_NOPTS_VALUE){
michael's avatar
michael committed
2097
            if(s->user_specified_pts != AV_NOPTS_VALUE){
michael's avatar
michael committed
2098 2099
                int64_t time= pts;
                int64_t last= s->user_specified_pts;
2100 2101

                if(time <= last){
2102
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
michael's avatar
michael committed
2103 2104 2105
                    return -1;
                }
            }
2106
            s->user_specified_pts= pts;
michael's avatar
michael committed
2107 2108
        }else{
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2109
                s->user_specified_pts=
michael's avatar
michael committed
2110
                pts= s->user_specified_pts + 1;
2111
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
michael's avatar
michael committed
2112
            }else{
michael's avatar
michael committed
2113
                pts= pic_arg->display_picture_number;
michael's avatar
michael committed
2114 2115 2116 2117
            }
        }
    }

2118
  if(pic_arg){
michaelni's avatar
michaelni committed
2119 2120 2121 2122
    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;
2123

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

michaelni's avatar
michaelni committed
2126
    if(direct){
michael's avatar
michael committed
2127
        i= ff_find_unused_picture(s, 1);
michaelni's avatar
michaelni committed
2128

michaelni's avatar
michaelni committed
2129
        pic= (AVFrame*)&s->picture[i];
michaelni's avatar
michaelni committed
2130
        pic->reference= 3;
2131

michaelni's avatar
michaelni committed
2132 2133 2134 2135 2136 2137
        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{
michael's avatar
michael committed
2138
        i= ff_find_unused_picture(s, 0);
michaelni's avatar
michaelni committed
2139

michaelni's avatar
michaelni committed
2140
        pic= (AVFrame*)&s->picture[i];
michaelni's avatar
michaelni committed
2141
        pic->reference= 3;
michaelni's avatar
michaelni committed
2142

michaelni's avatar
michaelni committed
2143 2144
        alloc_picture(s, (Picture*)pic, 0);

michael's avatar
michael committed
2145 2146 2147
        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]){
michaelni's avatar
michaelni committed
2148
       // empty
michaelni's avatar
michaelni committed
2149 2150 2151
        }else{
            int h_chroma_shift, v_chroma_shift;
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2152

michaelni's avatar
michaelni committed
2153 2154 2155 2156 2157 2158 2159 2160
            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];
2161 2162 2163 2164
                uint8_t *dst= pic->data[i];

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

michaelni's avatar
michaelni committed
2166 2167 2168 2169 2170 2171 2172 2173
                if(src_stride==dst_stride)
                    memcpy(dst, src, src_stride*h);
                else{
                    while(h--){
                        memcpy(dst, src, w);
                        dst += dst_stride;
                        src += src_stride;
                    }
michaelni's avatar
michaelni committed
2174
                }
2175
            }
michaelni's avatar
michaelni committed
2176 2177
        }
    }
2178
    copy_picture_attributes(s, pic, pic_arg);
2179
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2180
  }
2181

michaelni's avatar
michaelni committed
2182 2183 2184
    /* shift buffer entries */
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
        s->input_picture[i-1]= s->input_picture[i];
2185

michaelni's avatar
michaelni committed
2186
    s->input_picture[encoding_delay]= (Picture*)pic;
michaelni's avatar
michaelni committed
2187 2188 2189

    return 0;
}
2190

michael's avatar
michael committed
2191 2192 2193
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
    int x, y, plane;
    int score=0;
michael's avatar
michael committed
2194
    int64_t score64=0;
michael's avatar
michael committed
2195 2196 2197 2198 2199 2200

    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's avatar
michael committed
2201 2202
                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);
2203

michael's avatar
michael committed
2204 2205
                switch(s->avctx->frame_skip_exp){
                    case 0: score= FFMAX(score, v); break;
diego's avatar
diego committed
2206
                    case 1: score+= FFABS(v);break;
michael's avatar
michael committed
2207
                    case 2: score+= v*v;break;
diego's avatar
diego committed
2208
                    case 3: score64+= FFABS(v*v*(int64_t)v);break;
michael's avatar
michael committed
2209 2210
                    case 4: score64+= v*v*(int64_t)(v*v);break;
                }
michael's avatar
michael committed
2211 2212 2213
            }
        }
    }
2214

michael's avatar
michael committed
2215
    if(score) score64= score;
michael's avatar
michael committed
2216

michael's avatar
michael committed
2217
    if(score64 < s->avctx->frame_skip_threshold)
michael's avatar
michael committed
2218
        return 1;
michael's avatar
michael committed
2219
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
michael's avatar
michael committed
2220 2221 2222 2223
        return 1;
    return 0;
}

michael's avatar
michael committed
2224 2225 2226 2227
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];
2228
    const int scale= s->avctx->brd_scale;
michael's avatar
michael committed
2229
    int i, j, out_size, p_lambda, b_lambda, lambda2;
2230
    int outbuf_size= s->width * s->height; //FIXME
michael's avatar
michael committed
2231 2232 2233
    uint8_t *outbuf= av_malloc(outbuf_size);
    int64_t best_rd= INT64_MAX;
    int best_b_count= -1;
michael's avatar
michael committed
2234

2235 2236
    assert(scale>=0 && scale <=3);

michael's avatar
michael committed
2237 2238
//    emms_c();
    p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
diego's avatar
diego committed
2239
    b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
michael's avatar
michael committed
2240 2241
    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's avatar
michael committed
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260

    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);
michael's avatar
michael committed
2261 2262
        Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;

michael's avatar
michael committed
2263 2264 2265 2266 2267 2268 2269 2270
        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;

2271 2272 2273 2274 2275 2276 2277 2278 2279
        if(pre_input_ptr && (!i || s->input_picture[i-1])) {
            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;
            }

2280 2281 2282 2283
            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's avatar
michael committed
2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
    }

    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;
michael's avatar
michael committed
2295
        input[0].quality= 1 * FF_QP2LAMBDA;
michael's avatar
michael committed
2296
        out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
michael's avatar
michael committed
2297
//        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
michael's avatar
michael committed
2298 2299 2300 2301 2302

        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;
michael's avatar
michael committed
2303
            input[i+1].quality= is_p ? p_lambda : b_lambda;
michael's avatar
michael committed
2304
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
michael's avatar
michael committed
2305
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
michael's avatar
michael committed
2306 2307 2308 2309 2310
        }

        /* get the delayed frames */
        while(out_size){
            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
michael's avatar
michael committed
2311
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
michael's avatar
michael committed
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
        }

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

michaelni's avatar
michaelni committed
2333 2334
static void select_input_picture(MpegEncContext *s){
    int i;
michaelni's avatar
michaelni committed
2335

michaelni's avatar
michaelni committed
2336 2337 2338 2339
    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's avatar
diego committed
2340
    /* set next picture type & ordering */
michaelni's avatar
michaelni committed
2341
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
michaelni's avatar
michaelni committed
2342
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
michaelni's avatar
michaelni committed
2343 2344
            s->reordered_input_picture[0]= s->input_picture[0];
            s->reordered_input_picture[0]->pict_type= I_TYPE;
michael's avatar
michael committed
2345
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
michaelni's avatar
michaelni committed
2346 2347
        }else{
            int b_frames;
michael's avatar
michael committed
2348 2349

            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
michael's avatar
michael committed
2350 2351
                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
2352
//av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2353

michael's avatar
michael committed
2354 2355 2356
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
                        for(i=0; i<4; i++)
                            s->input_picture[0]->data[i]= NULL;
2357
                        s->input_picture[0]->type= 0;
michael's avatar
michael committed
2358
                    }else{
2359
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
michael's avatar
michael committed
2360
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2361

michael's avatar
michael committed
2362 2363
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
                    }
2364

michael's avatar
michael committed
2365 2366
                    emms_c();
                    ff_vbv_update(s, 0);
michael's avatar
michael committed
2367 2368 2369 2370 2371

                    goto no_output_pic;
                }
            }

michaelni's avatar
michaelni committed
2372 2373 2374
            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;
2375

2376
                    if(pict_num >= s->rc_context.num_entries)
2377
                        break;
2378
                    if(!s->input_picture[i]){
2379
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2380 2381
                        break;
                    }
2382

2383
                    s->input_picture[i]->pict_type=
2384
                        s->rc_context.entry[pict_num].new_pict_type;
michaelni's avatar
michaelni committed
2385 2386
                }
            }
michaelni's avatar
michaelni committed
2387

2388
            if(s->avctx->b_frame_strategy==0){
michaelni's avatar
michaelni committed
2389
                b_frames= s->max_b_frames;
2390
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
michael's avatar
michael committed
2391
            }else if(s->avctx->b_frame_strategy==1){
michaelni's avatar
michaelni committed
2392
                for(i=1; i<s->max_b_frames+1; i++){
2393
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2394 2395
                        s->input_picture[i]->b_frame_score=
                            get_intra_count(s, s->input_picture[i  ]->data[0],
michaelni's avatar
michaelni committed
2396
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
michaelni's avatar
michaelni committed
2397 2398
                    }
                }
2399
                for(i=0; i<s->max_b_frames+1; i++){
2400
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
michaelni's avatar
michaelni committed
2401
                }
2402

michaelni's avatar
michaelni committed
2403
                b_frames= FFMAX(0, i-1);
2404

michaelni's avatar
michaelni committed
2405 2406 2407 2408
                /* reset scores */
                for(i=0; i<b_frames+1; i++){
                    s->input_picture[i]->b_frame_score=0;
                }
michael's avatar
michael committed
2409 2410
            }else if(s->avctx->b_frame_strategy==2){
                b_frames= estimate_best_b_count(s);
michaelni's avatar
michaelni committed
2411
            }else{
2412
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
michaelni's avatar
michaelni committed
2413
                b_frames=0;
2414
            }
michaelni's avatar
michaelni committed
2415 2416 2417 2418

            emms_c();
//static int b_count=0;
//b_count+= b_frames;
2419
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2420 2421 2422 2423 2424 2425 2426

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

2430
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2431 2432 2433
              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{
2434 2435 2436
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
                    b_frames=0;
                s->input_picture[b_frames]->pict_type= I_TYPE;
2437
              }
2438
            }
2439

2440 2441 2442 2443 2444
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
               && b_frames
               && s->input_picture[b_frames]->pict_type== I_TYPE)
                b_frames--;

michaelni's avatar
michaelni committed
2445
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2446
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
michaelni's avatar
michaelni committed
2447
                s->reordered_input_picture[0]->pict_type= P_TYPE;
michael's avatar
michael committed
2448
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
michaelni's avatar
michaelni committed
2449 2450 2451
            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;
michael's avatar
michael committed
2452
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2453 2454 2455
            }
        }
    }
michael's avatar
michael committed
2456
no_output_pic:
michaelni's avatar
michaelni committed
2457
    if(s->reordered_input_picture[0]){
michaelni's avatar
michaelni committed
2458
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
michaelni's avatar
michaelni committed
2459

2460
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
michaelni's avatar
michaelni committed
2461

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

michael's avatar
michael committed
2465
            int i= ff_find_unused_picture(s, 0);
michaelni's avatar
michaelni committed
2466 2467
            Picture *pic= &s->picture[i];

2468 2469 2470
            pic->reference              = s->reordered_input_picture[0]->reference;
            alloc_picture(s, pic, 0);

michaelni's avatar
michaelni committed
2471
            /* mark us unused / free shared pic */
2472 2473
            if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
                s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
michaelni's avatar
michaelni committed
2474 2475 2476
            for(i=0; i<4; i++)
                s->reordered_input_picture[0]->data[i]= NULL;
            s->reordered_input_picture[0]->type= 0;
2477

2478 2479
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);

michaelni's avatar
michaelni committed
2480
            s->current_picture_ptr= pic;
michaelni's avatar
michaelni committed
2481
        }else{
michaelni's avatar
michaelni committed
2482 2483
            // input is not a shared pix -> reuse buffer for current_pix

2484
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
michaelni's avatar
michaelni committed
2485
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2486

michaelni's avatar
michaelni committed
2487
            s->current_picture_ptr= s->reordered_input_picture[0];
michaelni's avatar
michaelni committed
2488
            for(i=0; i<4; i++){
michael's avatar
michael committed
2489
                s->new_picture.data[i]+= INPLACE_OFFSET;
michaelni's avatar
michaelni committed
2490
            }
michaelni's avatar
michaelni committed
2491
        }
2492
        copy_picture(&s->current_picture, s->current_picture_ptr);
2493

michaelni's avatar
michaelni committed
2494 2495 2496 2497
        s->picture_number= s->new_picture.display_picture_number;
//printf("dpn:%d\n", s->picture_number);
    }else{
       memset(&s->new_picture, 0, sizeof(Picture));
2498 2499 2500
    }
}

glantau's avatar
glantau committed
2501 2502 2503 2504
int MPV_encode_picture(AVCodecContext *avctx,
                       unsigned char *buf, int buf_size, void *data)
{
    MpegEncContext *s = avctx->priv_data;
michaelni's avatar
michaelni committed
2505
    AVFrame *pic_arg = data;
michael's avatar
michael committed
2506
    int i, stuffing_count;
glantau's avatar
glantau committed
2507

2508
    for(i=0; i<avctx->thread_count; i++){
michael's avatar
michael committed
2509 2510
        int start_y= s->thread_context[i]->start_mb_y;
        int   end_y= s->thread_context[i]->  end_mb_y;
2511
        int h= s->mb_height;
2512 2513
        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);
2514 2515 2516

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

michaelni's avatar
michaelni committed
2518
    s->picture_in_gop_number++;
glantau's avatar
glantau committed
2519

2520 2521
    if(load_input_picture(s, pic_arg) < 0)
        return -1;
2522

michaelni's avatar
michaelni committed
2523
    select_input_picture(s);
2524

2525
    /* output? */
michaelni's avatar
michaelni committed
2526 2527 2528 2529
    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);
2530
        MPV_frame_start(s, avctx);
2531
vbv_retry:
takis's avatar
takis committed
2532 2533
        if (encode_picture(s, s->picture_number) < 0)
            return -1;
2534

2535
        avctx->real_pict_num  = s->picture_number;
2536 2537 2538 2539 2540 2541
        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;
2542
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2543 2544 2545 2546 2547 2548
        avctx->skip_count  = s->skip_count;

        MPV_frame_end(s);

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

2550 2551 2552 2553
        if(avctx->rc_buffer_size){
            RateControlContext *rcc= &s->rc_context;
            int max_size= rcc->buffer_index/3;

2554
            if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
michael's avatar
michael committed
2555
                s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2556 2557
                if(s->adaptive_quant){
                    int i;
michael's avatar
michael committed
2558
                    for(i=0; i<s->mb_height*s->mb_stride; i++)
2559 2560
                        s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
                }
2561 2562 2563 2564 2565
                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;
                }
michael's avatar
michael committed
2566 2567 2568 2569
                if(s->pict_type!=B_TYPE){
                    s->time_base= s->last_time_base;
                    s->last_non_b_time= s->time - s->pp_time;
                }
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580
//                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);
        }

michaelni's avatar
michaelni committed
2581 2582
        if(s->flags&CODEC_FLAG_PASS1)
            ff_write_pass1_stats(s);
michaelni's avatar
michaelni committed
2583 2584

        for(i=0; i<4; i++){
2585
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
michaelni's avatar
michaelni committed
2586 2587
            avctx->error[i] += s->current_picture_ptr->error[i];
        }
michael's avatar
michael committed
2588

2589 2590
        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));
michael's avatar
michael committed
2591
        flush_put_bits(&s->pb);
2592
        s->frame_bits  = put_bits_count(&s->pb);
michael's avatar
michael committed
2593

michael's avatar
michael committed
2594 2595
        stuffing_count= ff_vbv_update(s, s->frame_bits);
        if(stuffing_count){
2596 2597 2598 2599 2600
            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's avatar
michael committed
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619
            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);
2620
            s->frame_bits  = put_bits_count(&s->pb);
michael's avatar
michael committed
2621
        }
michael's avatar
michael committed
2622

2623
        /* update mpeg1/2 vbv_delay for CBR */
michael's avatar
michael committed
2624 2625
        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's avatar
michael committed
2626
            int vbv_delay;
michael's avatar
michael committed
2627

michael's avatar
michael committed
2628
            assert(s->repeat_first_field==0);
2629

michael's avatar
michael committed
2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643
            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's avatar
michael committed
2644
    }
michael's avatar
michael committed
2645
    assert((s->frame_bits&7)==0);
2646

michael's avatar
michael committed
2647
    return s->frame_bits/8;
glantau's avatar
glantau committed
2648 2649
}

2650 2651
#endif //CONFIG_ENCODERS

michaelni's avatar
michaelni committed
2652
static inline void gmc1_motion(MpegEncContext *s,
kabi's avatar
kabi committed
2653
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2654
                               uint8_t **ref_picture)
michaelni's avatar
michaelni committed
2655
{
kabi's avatar
kabi committed
2656
    uint8_t *ptr;
michaelni's avatar
michaelni committed
2657
    int offset, src_x, src_y, linesize, uvlinesize;
michaelni's avatar
michaelni committed
2658
    int motion_x, motion_y;
michaelni's avatar
michaelni committed
2659
    int emu=0;
michaelni's avatar
michaelni committed
2660 2661 2662 2663 2664 2665 2666

    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);
reimar's avatar
reimar committed
2667
    src_x = av_clip(src_x, -16, s->width);
michaelni's avatar
michaelni committed
2668 2669
    if (src_x == s->width)
        motion_x =0;
reimar's avatar
reimar committed
2670
    src_y = av_clip(src_y, -16, s->height);
michaelni's avatar
michaelni committed
2671 2672
    if (src_y == s->height)
        motion_y =0;
2673

michaelni's avatar
michaelni committed
2674
    linesize = s->linesize;
michaelni's avatar
michaelni committed
2675
    uvlinesize = s->uvlinesize;
2676

2677
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
michaelni's avatar
michaelni committed
2678

michaelni's avatar
michaelni committed
2679
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2680 2681
        if(   (unsigned)src_x >= s->h_edge_pos - 17
           || (unsigned)src_y >= s->v_edge_pos - 17){
2682
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
michaelni's avatar
michaelni committed
2683 2684 2685
            ptr= s->edge_emu_buffer;
        }
    }
2686

2687
    if((motion_x|motion_y)&7){
2688 2689
        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);
2690 2691
    }else{
        int dxy;
2692

2693 2694
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
        if (s->no_rounding){
2695
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2696
        }else{
2697 2698
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
        }
2699
    }
2700

2701
    if(s->flags&CODEC_FLAG_GRAY) return;
michaelni's avatar
michaelni committed
2702 2703 2704 2705 2706 2707 2708

    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);
reimar's avatar
reimar committed
2709
    src_x = av_clip(src_x, -8, s->width>>1);
michaelni's avatar
michaelni committed
2710 2711
    if (src_x == s->width>>1)
        motion_x =0;
reimar's avatar
reimar committed
2712
    src_y = av_clip(src_y, -8, s->height>>1);
michaelni's avatar
michaelni committed
2713 2714 2715
    if (src_y == s->height>>1)
        motion_y =0;

2716
    offset = (src_y * uvlinesize) + src_x;
michaelni's avatar
michaelni committed
2717
    ptr = ref_picture[1] + offset;
2718
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2719 2720
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2721
            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);
2722 2723 2724
            ptr= s->edge_emu_buffer;
            emu=1;
        }
michaelni's avatar
michaelni committed
2725
    }
2726
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2727

michaelni's avatar
michaelni committed
2728
    ptr = ref_picture[2] + offset;
michaelni's avatar
michaelni committed
2729
    if(emu){
2730
        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);
michaelni's avatar
michaelni committed
2731 2732
        ptr= s->edge_emu_buffer;
    }
2733
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2734

michaelni's avatar
michaelni committed
2735 2736 2737
    return;
}

2738
static inline void gmc_motion(MpegEncContext *s,
kabi's avatar
kabi committed
2739
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2740
                               uint8_t **ref_picture)
2741
{
kabi's avatar
kabi committed
2742
    uint8_t *ptr;
2743 2744 2745 2746 2747 2748 2749
    int linesize, uvlinesize;
    const int a= s->sprite_warping_accuracy;
    int ox, oy;

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

2750
    ptr = ref_picture[0];
2751 2752 2753 2754

    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;

2755
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2756 2757
           ox,
           oy,
2758
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2759
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2760 2761
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos, s->v_edge_pos);
2762
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2763 2764
           ox + s->sprite_delta[0][0]*8,
           oy + s->sprite_delta[1][0]*8,
2765
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2766
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2767 2768 2769 2770 2771 2772 2773 2774
           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;

2775
    ptr = ref_picture[1];
2776
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2777 2778
           ox,
           oy,
2779
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2780
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2781 2782
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2783

2784
    ptr = ref_picture[2];
2785
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2786 2787
           ox,
           oy,
2788
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2789
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2790 2791 2792 2793
           a+1, (1<<(2*a+1)) - s->no_rounding,
           s->h_edge_pos>>1, s->v_edge_pos>>1);
}

2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805
/**
 * 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
 */
2806
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2807 2808 2809
                                    int src_x, int src_y, int w, int h){
    int x, y;
    int start_y, start_x, end_y, end_x;
2810

2811 2812 2813
    if(src_y>= h){
        src+= (h-1-src_y)*linesize;
        src_y=h-1;
michaelni's avatar
michaelni committed
2814 2815 2816
    }else if(src_y<=-block_h){
        src+= (1-block_h-src_y)*linesize;
        src_y=1-block_h;
2817 2818 2819 2820
    }
    if(src_x>= w){
        src+= (w-1-src_x);
        src_x=w-1;
michaelni's avatar
michaelni committed
2821 2822 2823
    }else if(src_x<=-block_w){
        src+= (1-block_w-src_x);
        src_x=1-block_w;
2824 2825
    }

michaelni's avatar
michaelni committed
2826 2827 2828 2829
    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);
michaelni's avatar
michaelni committed
2830

2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850
    // 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];
        }
    }
2851

2852 2853 2854 2855 2856
    for(y=0; y<block_h; y++){
       //left
        for(x=0; x<start_x; x++){
            buf[x + y*linesize]= buf[start_x + y*linesize];
        }
2857

2858 2859 2860 2861 2862 2863 2864
       //right
        for(x=end_x; x<block_w; x++){
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
        }
    }
}

2865
static inline int hpel_motion(MpegEncContext *s,
2866 2867
                                  uint8_t *dest, uint8_t *src,
                                  int field_based, int field_select,
michael's avatar
michael committed
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
                                  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;
2880

michael's avatar
michael committed
2881
    /* WARNING: do no forget half pels */
reimar's avatar
reimar committed
2882
    src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
michael's avatar
michael committed
2883 2884
    if (src_x == width)
        dxy &= ~1;
reimar's avatar
reimar committed
2885
    src_y = av_clip(src_y, -16, height);
michael's avatar
michael committed
2886 2887 2888 2889 2890 2891 2892
    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){
2893 2894
            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);
michael's avatar
michael committed
2895 2896 2897 2898
            src= s->edge_emu_buffer;
            emu=1;
        }
    }
2899 2900
    if(field_select)
        src += s->linesize;
michael's avatar
michael committed
2901 2902 2903
    pix_op[dxy](dest, src, stride, h);
    return emu;
}
2904

2905
static inline int hpel_motion_lowres(MpegEncContext *s,
michael's avatar
michael committed
2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
                                  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);
2928

michael's avatar
michael committed
2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
    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;
}

glantau's avatar
glantau committed
2947
/* apply one mpeg motion vector to the three components */
2948
static av_always_inline void mpeg_motion(MpegEncContext *s,
kabi's avatar
kabi committed
2949
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2950 2951
                               int field_based, int bottom_field, int field_select,
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
glantau's avatar
glantau committed
2952 2953
                               int motion_x, int motion_y, int h)
{
2954 2955
    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;
2956 2957

#if 0
michaelni's avatar
michaelni committed
2958 2959 2960 2961 2962
if(s->quarter_sample)
{
    motion_x>>=1;
    motion_y>>=1;
}
michaelni's avatar
michaelni committed
2963
#endif
michael's avatar
michael committed
2964

2965
    v_edge_pos = s->v_edge_pos >> field_based;
2966
    linesize   = s->current_picture.linesize[0] << field_based;
michaelni's avatar
michaelni committed
2967
    uvlinesize = s->current_picture.linesize[1] << field_based;
2968

2969 2970
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
    src_x = s->mb_x* 16               + (motion_x >> 1);
2971
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
michaelni's avatar
 
michaelni committed
2972

glantau's avatar
glantau committed
2973
    if (s->out_format == FMT_H263) {
2974 2975 2976 2977 2978
        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);
2979
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2980 2981 2982 2983 2984
        }else{
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
            uvsrc_x = src_x>>1;
            uvsrc_y = src_y>>1;
        }
2985 2986 2987 2988 2989 2990
    }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;
glantau's avatar
glantau committed
2991
    } else {
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
        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;
            }
        }
glantau's avatar
glantau committed
3012
    }
3013 3014 3015 3016 3017 3018 3019

    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){
3020 3021 3022 3023 3024
            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 ;
            }
3025 3026 3027 3028
            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's avatar
10l  
michael committed
3029
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3030
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
3031
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3032
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3033 3034 3035 3036
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
                ptr_cb= uvbuf;
                ptr_cr= uvbuf+16;
            }
3037 3038
    }

3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051
    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);
3052

3053
    if(!(s->flags&CODEC_FLAG_GRAY)){
3054 3055
        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);
3056
    }
michael's avatar
michael committed
3057
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
michael's avatar
michael committed
3058 3059 3060
    if(s->out_format == FMT_H261){
        ff_h261_loop_filter(s);
    }
michael's avatar
michael committed
3061
#endif
glantau's avatar
glantau committed
3062
}
michael's avatar
michael committed
3063 3064

/* apply one mpeg motion vector to the three components */
3065
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
michael's avatar
michael committed
3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080
                               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;

michael's avatar
michael committed
3081 3082 3083 3084
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
        motion_x/=2;
        motion_y/=2;
    }
3085

michael's avatar
michael committed
3086 3087 3088 3089
    if(field_based){
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
    }

michael's avatar
michael committed
3090 3091 3092
    sx= motion_x & s_mask;
    sy= motion_y & s_mask;
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
michael's avatar
michael committed
3093
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3094

michael's avatar
michael committed
3095
    if (s->out_format == FMT_H263) {
michael's avatar
michael committed
3096 3097
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
michael's avatar
michael committed
3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112
        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));
michael's avatar
michael committed
3113
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
michael's avatar
michael committed
3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126
    }

    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;
3127
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
michael's avatar
michael committed
3128
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3129
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
michael's avatar
michael committed
3130 3131 3132 3133 3134 3135
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
                ptr_cb= uvbuf;
                ptr_cr= uvbuf+16;
            }
    }

michael's avatar
michael committed
3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
    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;
    }

michael's avatar
michael committed
3148 3149 3150
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3151

michael's avatar
michael committed
3152 3153 3154 3155 3156 3157
    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);
    }
michael's avatar
michael committed
3158
    //FIXME h261 lowres loop filter
michael's avatar
michael committed
3159 3160
}

michael's avatar
michael committed
3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
//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);
3176

michael's avatar
michael committed
3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
    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];
3223

michael's avatar
michael committed
3224
    assert(s->quarter_sample==0);
3225

michael's avatar
michael committed
3226 3227 3228 3229
    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{
3230
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3231
            hpel_motion(s, ptr[i], src, 0, 0,
michael's avatar
michael committed
3232 3233 3234 3235 3236 3237 3238 3239
                        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]);
        }
    }

3240
    put_obmc(dest, ptr, s->linesize);
michael's avatar
michael committed
3241
}
glantau's avatar
glantau committed
3242

michaelni's avatar
michaelni committed
3243
static inline void qpel_motion(MpegEncContext *s,
kabi's avatar
kabi committed
3244
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3245 3246
                               int field_based, int bottom_field, int field_select,
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
michaelni's avatar
michaelni committed
3247
                               qpel_mc_func (*qpix_op)[16],
michaelni's avatar
michaelni committed
3248 3249
                               int motion_x, int motion_y, int h)
{
3250 3251
    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;
3252

michaelni's avatar
michaelni committed
3253
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3254
    src_x = s->mb_x *  16                 + (motion_x >> 2);
michaelni's avatar
michaelni committed
3255 3256
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);

3257
    v_edge_pos = s->v_edge_pos >> field_based;
michaelni's avatar
michaelni committed
3258
    linesize = s->linesize << field_based;
michaelni's avatar
michaelni committed
3259
    uvlinesize = s->uvlinesize << field_based;
3260

michaelni's avatar
michaelni committed
3261 3262 3263
    if(field_based){
        mx= motion_x/2;
        my= motion_y>>1;
michaelni's avatar
michaelni committed
3264 3265 3266 3267
    }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];
michaelni's avatar
michaelni committed
3268
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
michaelni's avatar
michaelni committed
3269 3270 3271 3272 3273 3274 3275 3276
        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);
michaelni's avatar
michaelni committed
3277

3278
    uvdxy= (mx&1) | ((my&1)<<1);
michaelni's avatar
michaelni committed
3279 3280
    mx>>=1;
    my>>=1;
michaelni's avatar
michaelni committed
3281

3282 3283 3284 3285 3286 3287 3288
    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;

3289
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3290
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3291
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3292 3293 3294
                         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's avatar
10l  
michael committed
3295
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3296
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3297
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3298
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3299 3300 3301 3302 3303
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
            ptr_cb= uvbuf;
            ptr_cr= uvbuf + 16;
        }
    }
michaelni's avatar
michaelni committed
3304

3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322
    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);
michaelni's avatar
michaelni committed
3323
    }
3324 3325 3326
    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);
michaelni's avatar
michaelni committed
3327
    }
michaelni's avatar
michaelni committed
3328 3329
}

michaelni's avatar
michaelni committed
3330 3331 3332 3333 3334 3335 3336 3337
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));
    }
}
michaelni's avatar
michaelni committed
3338

michael's avatar
michael committed
3339 3340 3341 3342 3343 3344 3345 3346 3347 3348
/**
 * 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;
3349

michael's avatar
michael committed
3350 3351 3352 3353
    /* 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);
3354

michael's avatar
michael committed
3355 3356 3357 3358 3359 3360
    dxy = ((my & 1) << 1) | (mx & 1);
    mx >>= 1;
    my >>= 1;

    src_x = s->mb_x * 8 + mx;
    src_y = s->mb_y * 8 + my;
reimar's avatar
reimar committed
3361
    src_x = av_clip(src_x, -8, s->width/2);
michael's avatar
michael committed
3362 3363
    if (src_x == s->width/2)
        dxy &= ~1;
reimar's avatar
reimar committed
3364
    src_y = av_clip(src_y, -8, s->height/2);
michael's avatar
michael committed
3365 3366
    if (src_y == s->height/2)
        dxy &= ~2;
3367

michael's avatar
michael committed
3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
    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's avatar
michael committed
3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399
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;
3400

michael's avatar
michael committed
3401 3402 3403 3404 3405 3406 3407 3408 3409
    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);
3410

michael's avatar
michael committed
3411 3412 3413 3414
    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));
3415

michael's avatar
michael committed
3416 3417 3418 3419 3420 3421 3422 3423 3424
    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;
        }
3425
    }
michael's avatar
michael committed
3426 3427 3428
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3429

michael's avatar
michael committed
3430 3431 3432 3433 3434 3435 3436 3437
    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);
}

3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449
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);
}

michaelni's avatar
doxy  
michaelni committed
3450
/**
diego's avatar
diego committed
3451
 * motion compensation of a single macroblock
michaelni's avatar
doxy  
michaelni committed
3452 3453 3454 3455 3456 3457 3458 3459 3460 3461
 * @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
 */
3462
static inline void MPV_motion(MpegEncContext *s,
kabi's avatar
kabi committed
3463
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3464
                              int dir, uint8_t **ref_picture,
michaelni's avatar
michaelni committed
3465
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
glantau's avatar
glantau committed
3466
{
michael's avatar
michael committed
3467
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
glantau's avatar
glantau committed
3468
    int mb_x, mb_y, i;
kabi's avatar
kabi committed
3469
    uint8_t *ptr, *dest;
glantau's avatar
glantau committed
3470 3471 3472 3473

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

3474 3475
    prefetch_motion(s, ref_picture, dir);

3476
    if(s->obmc && s->pict_type != B_TYPE){
michael's avatar
michael committed
3477 3478
        int16_t mv_cache[4][4][2];
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3479 3480
        const int mot_stride= s->b8_stride;
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
michael's avatar
michael committed
3481

3482
        assert(!s->mb_skipped);
3483

3484 3485 3486
        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);
michael's avatar
michael committed
3487 3488 3489 3490

        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{
3491
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
michael's avatar
michael committed
3492 3493 3494 3495 3496 3497
        }

        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{
3498 3499
            *(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];
michael's avatar
michael committed
3500 3501 3502 3503 3504 3505
        }

        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{
3506 3507
            *(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];
michael's avatar
michael committed
3508
        }
3509

michael's avatar
michael committed
3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
        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;
    }
3536

glantau's avatar
glantau committed
3537 3538
    switch(s->mv_type) {
    case MV_TYPE_16X16:
michaelni's avatar
michaelni committed
3539
        if(s->mcsel){
3540
            if(s->real_sprite_warping_points==1){
3541 3542
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
                            ref_picture);
3543
            }else{
3544 3545
                gmc_motion(s, dest_y, dest_cb, dest_cr,
                            ref_picture);
3546
            }
michaelni's avatar
michaelni committed
3547
        }else if(s->quarter_sample){
3548
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3549 3550
                        0, 0, 0,
                        ref_picture, pix_op, qpix_op,
michaelni's avatar
michaelni committed
3551
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
michaelni's avatar
michaelni committed
3552 3553 3554 3555
        }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);
michaelni's avatar
michaelni committed
3556 3557
        }else
        {
3558
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3559 3560
                        0, 0, 0,
                        ref_picture, pix_op,
michaelni's avatar
michaelni committed
3561
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3562
        }
glantau's avatar
glantau committed
3563 3564
        break;
    case MV_TYPE_8X8:
michaelni's avatar
michaelni committed
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
        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;
3575

michaelni's avatar
michaelni committed
3576
                /* WARNING: do no forget half pels */
reimar's avatar
reimar committed
3577
                src_x = av_clip(src_x, -16, s->width);
michaelni's avatar
michaelni committed
3578 3579
                if (src_x == s->width)
                    dxy &= ~3;
reimar's avatar
reimar committed
3580
                src_y = av_clip(src_y, -16, s->height);
michaelni's avatar
michaelni committed
3581 3582
                if (src_y == s->height)
                    dxy &= ~12;
3583

michaelni's avatar
michaelni committed
3584 3585
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3586
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3587
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3588
                        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);
michaelni's avatar
michaelni committed
3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599
                        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++) {
michael's avatar
michael committed
3600
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3601
                            ref_picture[0], 0, 0,
michael's avatar
michael committed
3602 3603 3604 3605 3606
                            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]);
michaelni's avatar
michaelni committed
3607 3608 3609

                mx += s->mv[dir][i][0];
                my += s->mv[dir][i][1];
michaelni's avatar
michaelni committed
3610
            }
glantau's avatar
glantau committed
3611
        }
michaelni's avatar
michaelni committed
3612

michael's avatar
michael committed
3613 3614
        if(!(s->flags&CODEC_FLAG_GRAY))
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
glantau's avatar
glantau committed
3615 3616 3617
        break;
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
michaelni's avatar
michaelni committed
3618
            if(s->quarter_sample){
michael's avatar
michael committed
3619 3620 3621 3622 3623 3624
                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);
                }
michaelni's avatar
michaelni committed
3625
            }else{
3626
                /* top field */
3627 3628 3629
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
                            1, 0, s->field_select[dir][0],
                            ref_picture, pix_op,
michaelni's avatar
michaelni committed
3630 3631
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
                /* bottom field */
3632 3633 3634
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
                            1, 1, s->field_select[dir][1],
                            ref_picture, pix_op,
michaelni's avatar
michaelni committed
3635 3636
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
            }
glantau's avatar
glantau committed
3637
        } else {
3638 3639
            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;
3640
            }
glantau's avatar
glantau committed
3641

3642 3643 3644
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
                        0, 0, s->field_select[dir][0],
                        ref_picture, pix_op,
3645
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
glantau's avatar
glantau committed
3646
        }
3647
        break;
michael's avatar
michael committed
3648 3649 3650
    case MV_TYPE_16X8:
        for(i=0; i<2; i++){
            uint8_t ** ref2picture;
3651

michael's avatar
michael committed
3652
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3653 3654
                ref2picture= ref_picture;
            }else{
3655
                ref2picture= s->current_picture_ptr->data;
3656
            }
3657

3658
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
3659
                        0, 0, s->field_select[dir][i],
3660
                        ref2picture, pix_op,
michael's avatar
michael committed
3661
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3662

michael's avatar
michael committed
3663
            dest_y += 16*s->linesize;
3664 3665
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3666
        }
glantau's avatar
glantau committed
3667
        break;
3668 3669
    case MV_TYPE_DMV:
        if(s->picture_structure == PICT_FRAME){
michael's avatar
michael committed
3670 3671 3672 3673 3674 3675 3676 3677
            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);
                }
3678
                pix_op = s->dsp.avg_pixels_tab;
michael's avatar
michael committed
3679
            }
3680
        }else{
michael's avatar
michael committed
3681
            for(i=0; i<2; i++){
3682
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
3683 3684 3685
                            0, 0, s->picture_structure != i+1,
                            ref_picture, pix_op,
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3686

michael's avatar
michael committed
3687
                // after put we make avg of the same block
3688
                pix_op=s->dsp.avg_pixels_tab;
3689

michael's avatar
michael committed
3690 3691
                //opposite parity is always in the same frame if this is second field
                if(!s->first_field){
3692
                    ref_picture = s->current_picture_ptr->data;
michael's avatar
michael committed
3693
                }
3694
            }
3695 3696
        }
    break;
michael's avatar
michael committed
3697
    default: assert(0);
glantau's avatar
glantau committed
3698 3699 3700
    }
}

michael's avatar
michael committed
3701
/**
diego's avatar
diego committed
3702
 * motion compensation of a single macroblock
michael's avatar
michael committed
3703 3704 3705 3706 3707 3708 3709 3710 3711
 * @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
 */
3712
static inline void MPV_motion_lowres(MpegEncContext *s,
michael's avatar
michael committed
3713
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3714
                              int dir, uint8_t **ref_picture,
michael's avatar
michael committed
3715 3716
                              h264_chroma_mc_func *pix_op)
{
michael's avatar
michael committed
3717
    int mx, my;
michael's avatar
michael committed
3718 3719
    int mb_x, mb_y, i;
    const int lowres= s->avctx->lowres;
3720
    const int block_s= 8>>lowres;
michael's avatar
michael committed
3721 3722 3723 3724 3725 3726

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

    switch(s->mv_type) {
    case MV_TYPE_16X16:
3727
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
3728 3729 3730 3731
                    0, 0, 0,
                    ref_picture, pix_op,
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
        break;
michael's avatar
michael committed
3732
    case MV_TYPE_8X8:
michael's avatar
michael committed
3733 3734 3735
        mx = 0;
        my = 0;
            for(i=0;i<4;i++) {
michael's avatar
michael committed
3736
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
michael's avatar
michael committed
3737
                            ref_picture[0], 0, 0,
michael's avatar
michael committed
3738
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
michael's avatar
michael committed
3739
                            s->width, s->height, s->linesize,
michael's avatar
michael committed
3740 3741
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
                            block_s, block_s, pix_op,
michael's avatar
michael committed
3742 3743 3744 3745 3746 3747 3748
                            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's avatar
michael committed
3749 3750
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
        break;
michael's avatar
michael committed
3751 3752
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
3753
            /* top field */
michael's avatar
michael committed
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
            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;
3766
            }
michael's avatar
michael committed
3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781

            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;
3782
            }
michael's avatar
michael committed
3783

3784
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
3785 3786 3787
                        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);
3788

michael's avatar
michael committed
3789 3790 3791
            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;
3792
        }
michael's avatar
michael committed
3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807
        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++){
3808
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
3809 3810 3811 3812 3813 3814 3815 3816 3817
                            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){
3818
                    ref_picture = s->current_picture_ptr->data;
michael's avatar
michael committed
3819 3820 3821 3822 3823 3824
                }
            }
        }
    break;
    default: assert(0);
    }
michael's avatar
michael committed
3825
}
glantau's avatar
glantau committed
3826 3827

/* put block[] to dest[] */
3828
static inline void put_dct(MpegEncContext *s,
michael's avatar
michael committed
3829
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
glantau's avatar
glantau committed
3830
{
michael's avatar
michael committed
3831
    s->dct_unquantize_intra(s, block, i, qscale);
3832
    s->dsp.idct_put (dest, line_size, block);
glantau's avatar
glantau committed
3833 3834 3835
}

/* add block[] to dest[] */
3836
static inline void add_dct(MpegEncContext *s,
kabi's avatar
kabi committed
3837
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
glantau's avatar
glantau committed
3838
{
michaelni's avatar
 
michaelni committed
3839
    if (s->block_last_index[i] >= 0) {
3840
        s->dsp.idct_add (dest, line_size, block);
michaelni's avatar
 
michaelni committed
3841 3842
    }
}
3843

3844
static inline void add_dequant_dct(MpegEncContext *s,
michael's avatar
michael committed
3845
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
michaelni's avatar
 
michaelni committed
3846
{
glantau's avatar
glantau committed
3847
    if (s->block_last_index[i] >= 0) {
michael's avatar
michael committed
3848
        s->dct_unquantize_inter(s, block, i, qscale);
3849

3850
        s->dsp.idct_add (dest, line_size, block);
glantau's avatar
glantau committed
3851 3852 3853
    }
}

michaelni's avatar
 
michaelni committed
3854 3855 3856 3857 3858
/**
 * cleans dc, ac, coded_block for the current non intra MB
 */
void ff_clean_intra_table_entries(MpegEncContext *s)
{
3859
    int wrap = s->b8_stride;
michaelni's avatar
 
michaelni committed
3860
    int xy = s->block_index[0];
3861 3862 3863

    s->dc_val[0][xy           ] =
    s->dc_val[0][xy + 1       ] =
michaelni's avatar
 
michaelni committed
3864 3865 3866
    s->dc_val[0][xy     + wrap] =
    s->dc_val[0][xy + 1 + wrap] = 1024;
    /* ac pred */
kabi's avatar
kabi committed
3867 3868
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
michaelni's avatar
 
michaelni committed
3869 3870 3871 3872 3873 3874 3875
    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 */
3876 3877
    wrap = s->mb_stride;
    xy = s->mb_x + s->mb_y * wrap;
michaelni's avatar
 
michaelni committed
3878 3879 3880
    s->dc_val[1][xy] =
    s->dc_val[2][xy] = 1024;
    /* ac pred */
kabi's avatar
kabi committed
3881 3882
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3883

3884
    s->mbintra_table[xy]= 0;
michaelni's avatar
 
michaelni committed
3885 3886
}

glantau's avatar
glantau committed
3887 3888 3889 3890 3891 3892 3893 3894 3895 3896
/* 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)
 */
3897
static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
glantau's avatar
glantau committed
3898
{
3899
    int mb_x, mb_y;
3900
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
iive's avatar
iive committed
3901 3902
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration){
3903
        XVMC_decode_mb(s);//xvmc uses pblocks
iive's avatar
iive committed
3904 3905 3906
        return;
    }
#endif
glantau's avatar
glantau committed
3907 3908 3909 3910

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

3911 3912 3913 3914 3915 3916 3917 3918 3919
    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]];
    }

michaelni's avatar
michaelni committed
3920
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3921

glantau's avatar
glantau committed
3922 3923
    /* update DC predictors for P macroblocks */
    if (!s->mb_intra) {
3924
        if (s->h263_pred || s->h263_aic) {
michaelni's avatar
 
michaelni committed
3925
            if(s->mbintra_table[mb_xy])
michaelni's avatar
 
michaelni committed
3926
                ff_clean_intra_table_entries(s);
glantau's avatar
glantau committed
3927
        } else {
michaelni's avatar
 
michaelni committed
3928 3929
            s->last_dc[0] =
            s->last_dc[1] =
glantau's avatar
glantau committed
3930 3931 3932
            s->last_dc[2] = 128 << s->intra_dc_precision;
        }
    }
3933
    else if (s->h263_pred || s->h263_aic)
michaelni's avatar
 
michaelni committed
3934
        s->mbintra_table[mb_xy]=1;
3935

3936
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
kabi's avatar
kabi committed
3937
        uint8_t *dest_y, *dest_cb, *dest_cr;
michaelni's avatar
 
michaelni committed
3938
        int dct_linesize, dct_offset;
michaelni's avatar
michaelni committed
3939 3940
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
3941
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
michaelni's avatar
michaelni committed
3942
        const int uvlinesize= s->current_picture.linesize[1];
michael's avatar
michael committed
3943 3944
        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;
3945

michaelni's avatar
michaelni committed
3946 3947 3948
        /* 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){
kabi's avatar
kabi committed
3949
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
michaelni's avatar
michaelni committed
3950
            const int age= s->current_picture.age;
michaelni's avatar
michaelni committed
3951

michaelni's avatar
michaelni committed
3952 3953
            assert(age);

3954 3955
            if (s->mb_skipped) {
                s->mb_skipped= 0;
michaelni's avatar
michaelni committed
3956
                assert(s->pict_type!=I_TYPE);
3957

3958
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
michaelni's avatar
michaelni committed
3959 3960
                if(*mbskip_ptr >99) *mbskip_ptr= 99;

michaelni's avatar
michaelni committed
3961
                /* if previous was skipped too, then nothing to do !  */
3962 3963
                if (*mbskip_ptr >= age && s->current_picture.reference){
                    return;
michaelni's avatar
michaelni committed
3964
                }
3965 3966 3967 3968
            } 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{
3969 3970
                *mbskip_ptr = 0; /* not skipped */
            }
michaelni's avatar
michaelni committed
3971
        }
3972

3973
        dct_linesize = linesize << s->interlaced_dct;
michael's avatar
michael committed
3974
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3975

3976 3977 3978 3979 3980
        if(readable){
            dest_y=  s->dest[0];
            dest_cb= s->dest[1];
            dest_cr= s->dest[2];
        }else{
3981
            dest_y = s->b_scratchpad;
michael's avatar
michael committed
3982
            dest_cb= s->b_scratchpad+16*linesize;
3983
            dest_cr= s->b_scratchpad+32*linesize;
3984
        }
michael's avatar
michael committed
3985

glantau's avatar
glantau committed
3986 3987
        if (!s->mb_intra) {
            /* motion handling */
3988
            /* decoding or more than one mb_type (MC was already done otherwise) */
3989
            if(!s->encoding){
michael's avatar
michael committed
3990 3991
                if(lowres_flag){
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
glantau's avatar
glantau committed
3992

michael's avatar
michael committed
3993 3994 3995 3996 3997 3998 3999 4000
                    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{
4001
                    op_qpix= s->me.qpel_put;
4002
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
michael's avatar
michael committed
4003 4004 4005 4006 4007 4008 4009
                        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;
4010
                        op_qpix= s->me.qpel_avg;
michael's avatar
michael committed
4011 4012 4013 4014
                    }
                    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);
                    }
4015
                }
glantau's avatar
glantau committed
4016 4017
            }

michaelni's avatar
 
michaelni committed
4018
            /* skip dequant / idct if we are really late ;) */
michael's avatar
michael committed
4019 4020 4021 4022 4023 4024 4025
            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;
            }
michaelni's avatar
 
michaelni committed
4026

glantau's avatar
glantau committed
4027
            /* add dct residue */
michaelni's avatar
michaelni committed
4028
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
michaelni's avatar
michaelni committed
4029
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
michael's avatar
michael committed
4030 4031 4032 4033
                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);
michaelni's avatar
 
michaelni committed
4034

michaelni's avatar
 
michaelni committed
4035
                if(!(s->flags&CODEC_FLAG_GRAY)){
bcoudurier's avatar
bcoudurier committed
4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046
                    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);
                    }
michaelni's avatar
 
michaelni committed
4047
                }
michaelni's avatar
michaelni committed
4048
            } else if(s->codec_id != CODEC_ID_WMV2){
michael's avatar
michael committed
4049 4050 4051 4052
                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);
glantau's avatar
glantau committed
4053

michaelni's avatar
 
michaelni committed
4054
                if(!(s->flags&CODEC_FLAG_GRAY)){
4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075
                    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
            }
michaelni's avatar
michaelni committed
4076
            else{
michaelni's avatar
michaelni committed
4077
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
michaelni's avatar
 
michaelni committed
4078
            }
glantau's avatar
glantau committed
4079 4080
        } else {
            /* dct only in intra block */
michaelni's avatar
michaelni committed
4081
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
michael's avatar
michael committed
4082 4083 4084 4085
                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);
michaelni's avatar
michaelni committed
4086 4087

                if(!(s->flags&CODEC_FLAG_GRAY)){
bcoudurier's avatar
bcoudurier committed
4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098
                    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);
                    }
michaelni's avatar
michaelni committed
4099 4100
                }
            }else{
michael's avatar
michael committed
4101 4102 4103 4104
                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]);
michaelni's avatar
michaelni committed
4105 4106

                if(!(s->flags&CODEC_FLAG_GRAY)){
4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
                    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
michaelni's avatar
 
michaelni committed
4127
            }
glantau's avatar
glantau committed
4128
        }
michael's avatar
michael committed
4129
skip_idct:
4130 4131
        if(!readable){
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
4132 4133
            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);
4134
        }
glantau's avatar
glantau committed
4135 4136 4137
    }
}

michael's avatar
michael committed
4138 4139 4140 4141 4142
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);
}

4143 4144
#ifdef CONFIG_ENCODERS

4145
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
michaelni's avatar
 
michaelni committed
4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160
{
    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];
4161
    int skip_dc;
michaelni's avatar
 
michaelni committed
4162

4163 4164 4165
    if(threshold<0){
        skip_dc=0;
        threshold= -threshold;
4166 4167
    }else
        skip_dc=1;
4168

michaelni's avatar
 
michaelni committed
4169 4170 4171 4172
    /* 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++){
4173
        const int j = s->intra_scantable.permutated[i];
diego's avatar
diego committed
4174
        const int level = FFABS(block[j]);
michaelni's avatar
 
michaelni committed
4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186
        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++){
4187
        const int j = s->intra_scantable.permutated[i];
michaelni's avatar
 
michaelni committed
4188 4189 4190 4191 4192 4193
        block[j]=0;
    }
    if(block[0]) s->block_last_index[n]= 0;
    else         s->block_last_index[n]= -1;
}

4194 4195 4196 4197 4198
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;
4199
    int overflow=0;
4200

4201 4202 4203 4204
    if(s->mb_intra){
        i=1; //skip clipping of intra dc
    }else
        i=0;
4205

4206 4207
    for(;i<=last_index; i++){
        const int j= s->intra_scantable.permutated[i];
4208
        int level = block[j];
4209

4210 4211 4212 4213 4214 4215 4216
        if     (level>maxlevel){
            level=maxlevel;
            overflow++;
        }else if(level<minlevel){
            level=minlevel;
            overflow++;
        }
4217

michaelni's avatar
michaelni committed
4218
        block[j]= level;
michaelni's avatar
michaelni committed
4219
    }
4220

4221
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4222
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
michaelni's avatar
michaelni committed
4223 4224
}

4225 4226
#endif //CONFIG_ENCODERS

4227 4228 4229 4230 4231
/**
 *
 * @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){
michaelni's avatar
michaelni committed
4232
    if (s->avctx->draw_horiz_band) {
4233
        AVFrame *src;
michaelni's avatar
michaelni committed
4234
        int offset[4];
4235

4236 4237 4238 4239 4240 4241
        if(s->picture_structure != PICT_FRAME){
            h <<= 1;
            y <<= 1;
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
        }

4242
        h= FFMIN(h, s->avctx->height - y);
4243

4244
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4245 4246 4247 4248 4249
            src= (AVFrame*)s->current_picture_ptr;
        else if(s->last_picture_ptr)
            src= (AVFrame*)s->last_picture_ptr;
        else
            return;
4250

michaelni's avatar
michaelni committed
4251
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
michaelni's avatar
michaelni committed
4252 4253 4254 4255 4256 4257
            offset[0]=
            offset[1]=
            offset[2]=
            offset[3]= 0;
        }else{
            offset[0]= y * s->linesize;;
4258
            offset[1]=
4259
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
michaelni's avatar
michaelni committed
4260
            offset[3]= 0;
4261
        }
michaelni's avatar
michaelni committed
4262

michaelni's avatar
michaelni committed
4263 4264
        emms_c();

4265 4266
        s->avctx->draw_horiz_band(s->avctx, src, offset,
                                  y, s->picture_structure, h);
4267 4268 4269
    }
}

4270
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
diego's avatar
diego committed
4271
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4272
    const int uvlinesize= s->current_picture.linesize[1];
michael's avatar
michael committed
4273
    const int mb_size= 4 - s->avctx->lowres;
4274

4275 4276 4277 4278 4279 4280
    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;
4281 4282
    //block_index is not used by mpeg2, so it is not affected by chroma_format

michael's avatar
michael committed
4283 4284 4285
    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's avatar
michael committed
4286

4287 4288
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
    {
michael's avatar
michael committed
4289 4290 4291
        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);
4292
    }
4293 4294
}

4295 4296
#ifdef CONFIG_ENCODERS

michael's avatar
michael committed
4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319
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;
        }
    }
}

4320
static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
glantau's avatar
glantau committed
4321
{
bcoudurier's avatar
bcoudurier committed
4322 4323
    int16_t weight[8][64];
    DCTELEM orig[8][64];
4324 4325 4326
    const int mb_x= s->mb_x;
    const int mb_y= s->mb_y;
    int i;
bcoudurier's avatar
bcoudurier committed
4327
    int skip_dct[8];
michaelni's avatar
michaelni committed
4328
    int dct_offset   = s->linesize*8; //default for progressive frames
michael's avatar
michael committed
4329 4330
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    int wrap_y, wrap_c;
4331

michael's avatar
michael committed
4332
    for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct;
4333

4334
    if(s->adaptive_quant){
4335 4336
        const int last_qp= s->qscale;
        const int mb_xy= mb_x + mb_y*s->mb_stride;
michaelni's avatar
michaelni committed
4337

4338 4339
        s->lambda= s->lambda_table[mb_xy];
        update_qscale(s);
4340

4341
        if(!(s->flags&CODEC_FLAG_QP_RD)){
michael's avatar
michael committed
4342
            s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
4343
            s->dquant= s->qscale - last_qp;
4344

4345
            if(s->out_format==FMT_H263){
reimar's avatar
reimar committed
4346
                s->dquant= av_clip(s->dquant, -2, 2);
4347 4348

                if(s->codec_id==CODEC_ID_MPEG4){
4349 4350
                    if(!s->mb_intra){
                        if(s->pict_type == B_TYPE){
aurel's avatar
aurel committed
4351
                            if(s->dquant&1 || s->mv_dir&MV_DIRECT)
4352 4353 4354 4355 4356
                                s->dquant= 0;
                        }
                        if(s->mv_type==MV_TYPE_8X8)
                            s->dquant=0;
                    }
4357
                }
4358 4359
            }
        }
michael's avatar
michael committed
4360
        ff_set_qscale(s, last_qp + s->dquant);
michael's avatar
michael committed
4361 4362
    }else if(s->flags&CODEC_FLAG_QP_RD)
        ff_set_qscale(s, s->qscale + s->dquant);
4363

michael's avatar
michael committed
4364 4365 4366
    wrap_y = s->linesize;
    wrap_c = s->uvlinesize;
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
bcoudurier's avatar
bcoudurier committed
4367 4368
    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's avatar
michael committed
4369 4370

    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4371 4372 4373
        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;
bcoudurier's avatar
bcoudurier committed
4374
        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);
4375
        ptr_cb= ebuf+18*wrap_y;
bcoudurier's avatar
bcoudurier committed
4376
        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);
4377
        ptr_cr= ebuf+18*wrap_y+8;
michael's avatar
michael committed
4378 4379
    }

4380
    if (s->mb_intra) {
michaelni's avatar
michaelni committed
4381 4382
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
            int progressive_score, interlaced_score;
michael's avatar
michael committed
4383

michael's avatar
michael committed
4384
            s->interlaced_dct=0;
4385
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
michael's avatar
michael committed
4386
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
michael's avatar
michael committed
4387 4388

            if(progressive_score > 0){
4389
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
michael's avatar
michael committed
4390
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
michael's avatar
michael committed
4391 4392
                if(progressive_score > interlaced_score){
                    s->interlaced_dct=1;
4393

michael's avatar
michael committed
4394 4395
                    dct_offset= wrap_y;
                    wrap_y<<=1;
bcoudurier's avatar
bcoudurier committed
4396 4397
                    if (s->chroma_format == CHROMA_422)
                        wrap_c<<=1;
michael's avatar
michael committed
4398 4399
                }
            }
michaelni's avatar
michaelni committed
4400
        }
4401

4402
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
michael's avatar
michael committed
4403 4404 4405
        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);
4406

michaelni's avatar
 
michaelni committed
4407 4408 4409 4410
        if(s->flags&CODEC_FLAG_GRAY){
            skip_dct[4]= 1;
            skip_dct[5]= 1;
        }else{
4411
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
michael's avatar
michael committed
4412
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
bcoudurier's avatar
bcoudurier committed
4413 4414 4415 4416
            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);
            }
michael's avatar
michael committed
4417
        }
4418
    }else{
michaelni's avatar
michaelni committed
4419 4420
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
kabi's avatar
kabi committed
4421
        uint8_t *dest_y, *dest_cb, *dest_cr;
4422

4423 4424 4425
        dest_y  = s->dest[0];
        dest_cb = s->dest[1];
        dest_cr = s->dest[2];
4426

4427
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4428
            op_pix = s->dsp.put_pixels_tab;
4429
            op_qpix= s->dsp.put_qpel_pixels_tab;
michaelni's avatar
michaelni committed
4430
        }else{
4431 4432
            op_pix = s->dsp.put_no_rnd_pixels_tab;
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4433 4434 4435
        }

        if (s->mv_dir & MV_DIR_FORWARD) {
michaelni's avatar
michaelni committed
4436
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4437 4438
            op_pix = s->dsp.avg_pixels_tab;
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4439 4440
        }
        if (s->mv_dir & MV_DIR_BACKWARD) {
michaelni's avatar
michaelni committed
4441
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4442
        }
4443

michaelni's avatar
michaelni committed
4444 4445
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
            int progressive_score, interlaced_score;
michael's avatar
michael committed
4446 4447

            s->interlaced_dct=0;
4448
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
michael's avatar
michael committed
4449
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4450

michael's avatar
michael committed
4451 4452 4453
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;

            if(progressive_score>0){
4454
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
michael's avatar
michael committed
4455
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4456

michael's avatar
michael committed
4457 4458
                if(progressive_score > interlaced_score){
                    s->interlaced_dct=1;
4459

michael's avatar
michael committed
4460 4461
                    dct_offset= wrap_y;
                    wrap_y<<=1;
bcoudurier's avatar
bcoudurier committed
4462 4463
                    if (s->chroma_format == CHROMA_422)
                        wrap_c<<=1;
michael's avatar
michael committed
4464 4465
                }
            }
michaelni's avatar
michaelni committed
4466
        }
4467

4468
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4469 4470 4471
        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);
4472

michaelni's avatar
 
michaelni committed
4473 4474 4475 4476
        if(s->flags&CODEC_FLAG_GRAY){
            skip_dct[4]= 1;
            skip_dct[5]= 1;
        }else{
4477 4478
            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);
bcoudurier's avatar
bcoudurier committed
4479 4480 4481 4482
            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);
            }
michaelni's avatar
 
michaelni committed
4483
        }
4484
        /* pre quantization */
4485
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
michaelni's avatar
michaelni committed
4486
            //FIXME optimize
4487
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
michael's avatar
michael committed
4488 4489 4490 4491 4492
            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;
bcoudurier's avatar
bcoudurier committed
4493 4494 4495 4496
            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;
            }
michaelni's avatar
 
michaelni committed
4497
        }
michael's avatar
michael committed
4498
    }
4499

michael's avatar
michael committed
4500 4501 4502 4503 4504 4505 4506
    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);
bcoudurier's avatar
bcoudurier committed
4507 4508 4509 4510 4511
        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);
4512
    }
4513

4514
    /* DCT & quantize */
michael's avatar
michael committed
4515 4516
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
    {
bcoudurier's avatar
bcoudurier committed
4517
        for(i=0;i<mb_block_count;i++) {
michaelni's avatar
 
michaelni committed
4518 4519
            if(!skip_dct[i]){
                int overflow;
4520
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4521
            // FIXME we could decide to change to quantizer instead of clipping
4522 4523
            // 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
michaelni's avatar
 
michaelni committed
4524 4525 4526
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
            }else
                s->block_last_index[i]= -1;
4527
        }
michael's avatar
michael committed
4528
        if(s->avctx->quantizer_noise_shaping){
bcoudurier's avatar
bcoudurier committed
4529
            for(i=0;i<mb_block_count;i++) {
michael's avatar
michael committed
4530 4531 4532 4533 4534
                if(!skip_dct[i]){
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
                }
            }
        }
4535

michaelni's avatar
 
michaelni committed
4536 4537
        if(s->luma_elim_threshold && !s->mb_intra)
            for(i=0; i<4; i++)
4538
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
michaelni's avatar
 
michaelni committed
4539
        if(s->chroma_elim_threshold && !s->mb_intra)
bcoudurier's avatar
bcoudurier committed
4540
            for(i=4; i<mb_block_count; i++)
4541
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4542 4543

        if(s->flags & CODEC_FLAG_CBP_RD){
bcoudurier's avatar
bcoudurier committed
4544
            for(i=0;i<mb_block_count;i++) {
4545 4546 4547 4548
                if(s->block_last_index[i] == -1)
                    s->coded_score[i]= INT_MAX/256;
            }
        }
4549 4550
    }

michaelni's avatar
 
michaelni committed
4551 4552 4553 4554
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
        s->block_last_index[4]=
        s->block_last_index[5]= 0;
        s->block[4][0]=
michaelni's avatar
bugs  
michaelni committed
4555
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
michaelni's avatar
 
michaelni committed
4556 4557
    }

michael's avatar
michael committed
4558 4559
    //non c quantize code returns incorrect block_last_index FIXME
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
bcoudurier's avatar
bcoudurier committed
4560
        for(i=0; i<mb_block_count; i++){
michael's avatar
michael committed
4561 4562 4563 4564 4565 4566 4567 4568 4569 4570
            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;
            }
        }
    }

4571
    /* huffman encode */
michaelni's avatar
michaelni committed
4572 4573
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
    case CODEC_ID_MPEG1VIDEO:
michaelni's avatar
michaelni committed
4574
    case CODEC_ID_MPEG2VIDEO:
michaelni's avatar
michaelni committed
4575 4576 4577 4578 4579 4580 4581 4582 4583
        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;
michael's avatar
michael committed
4584
#ifdef CONFIG_H261_ENCODER
4585 4586
    case CODEC_ID_H261:
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
michael's avatar
michael committed
4587
#endif
michaelni's avatar
michaelni committed
4588 4589
    case CODEC_ID_H263:
    case CODEC_ID_H263P:
4590
    case CODEC_ID_FLV1:
michaelni's avatar
michaelni committed
4591
    case CODEC_ID_RV10:
michael's avatar
michael committed
4592
    case CODEC_ID_RV20:
michaelni's avatar
michaelni committed
4593
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
michaelni's avatar
michaelni committed
4594 4595
    case CODEC_ID_MJPEG:
        mjpeg_encode_mb(s, s->block); break;
michaelni's avatar
michaelni committed
4596 4597
    default:
        assert(0);
4598 4599 4600
    }
}

4601
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
bcoudurier's avatar
bcoudurier committed
4602 4603 4604 4605 4606
{
    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);
}

4607 4608
#endif //CONFIG_ENCODERS

michaelni's avatar
michaelni committed
4609 4610 4611
void ff_mpeg_flush(AVCodecContext *avctx){
    int i;
    MpegEncContext *s = avctx->priv_data;
4612 4613

    if(s==NULL || s->picture==NULL)
michael's avatar
michael committed
4614
        return;
4615

michaelni's avatar
michaelni committed
4616 4617 4618 4619 4620
    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]);
    }
michael's avatar
michael committed
4621
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4622

michael's avatar
michael committed
4623
    s->mb_x= s->mb_y= 0;
4624

4625 4626 4627 4628 4629 4630
    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;
4631
    s->bitstream_buffer_size=0;
4632
    s->pp_time=0;
michaelni's avatar
michaelni committed
4633 4634
}

4635
#ifdef CONFIG_ENCODERS
kabi's avatar
kabi committed
4636
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4637
{
4638
    const uint16_t *srcw= (uint16_t*)src;
4639
    int words= length>>4;
4640 4641 4642
    int bits= length&15;
    int i;

michaelni's avatar
 
michaelni committed
4643
    if(length==0) return;
4644

michael's avatar
michael committed
4645 4646 4647 4648
    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]));
4649
    }else{
michael's avatar
michael committed
4650 4651
        for(i=0; put_bits_count(pb)&31; i++)
            put_bits(pb, 8, src[i]);
4652
        flush_put_bits(pb);
michael's avatar
michael committed
4653 4654
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
        skip_put_bytes(pb, 2*words-i);
4655
    }
4656

michael's avatar
michael committed
4657
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4658 4659
}

michaelni's avatar
 
michaelni committed
4660
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4661 4662 4663 4664 4665
    int i;

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

    /* mpeg1 */
michaelni's avatar
michaelni committed
4666
    d->mb_skip_run= s->mb_skip_run;
4667 4668
    for(i=0; i<3; i++)
        d->last_dc[i]= s->last_dc[i];
4669

4670 4671 4672 4673 4674
    /* 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;
4675 4676
    d->f_count= s->f_count;
    d->b_count= s->b_count;
4677 4678
    d->skip_count= s->skip_count;
    d->misc_bits= s->misc_bits;
michaelni's avatar
michaelni committed
4679
    d->last_bits= 0;
4680

4681
    d->mb_skipped= 0;
michaelni's avatar
michaelni committed
4682
    d->qscale= s->qscale;
4683
    d->dquant= s->dquant;
4684 4685
}

michaelni's avatar
 
michaelni committed
4686
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4687 4688
    int i;

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

4692
    /* mpeg1 */
michaelni's avatar
michaelni committed
4693
    d->mb_skip_run= s->mb_skip_run;
4694 4695
    for(i=0; i<3; i++)
        d->last_dc[i]= s->last_dc[i];
4696

4697 4698 4699 4700 4701
    /* 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;
4702 4703
    d->f_count= s->f_count;
    d->b_count= s->b_count;
4704 4705 4706 4707
    d->skip_count= s->skip_count;
    d->misc_bits= s->misc_bits;

    d->mb_intra= s->mb_intra;
4708
    d->mb_skipped= s->mb_skipped;
4709 4710 4711
    d->mv_type= s->mv_type;
    d->mv_dir= s->mv_dir;
    d->pb= s->pb;
michaelni's avatar
 
michaelni committed
4712 4713 4714 4715
    if(s->data_partitioning){
        d->pb2= s->pb2;
        d->tex_pb= s->tex_pb;
    }
4716
    d->block= s->block;
bcoudurier's avatar
bcoudurier committed
4717
    for(i=0; i<8; i++)
4718
        d->block_last_index[i]= s->block_last_index[i];
michaelni's avatar
michaelni committed
4719
    d->interlaced_dct= s->interlaced_dct;
michaelni's avatar
michaelni committed
4720
    d->qscale= s->qscale;
4721 4722
}

4723
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
michaelni's avatar
 
michaelni committed
4724 4725 4726
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
                           int *dmin, int *next_block, int motion_x, int motion_y)
{
4727 4728
    int score;
    uint8_t *dest_backup[3];
4729

michaelni's avatar
 
michaelni committed
4730 4731 4732 4733 4734 4735 4736 4737
    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];
    }
4738

4739 4740
    if(*next_block){
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4741 4742 4743 4744
        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
4745
    }
michaelni's avatar
 
michaelni committed
4746 4747

    encode_mb(s, motion_x, motion_y);
4748

alex's avatar
alex committed
4749
    score= put_bits_count(&s->pb);
michaelni's avatar
 
michaelni committed
4750
    if(s->data_partitioning){
alex's avatar
alex committed
4751 4752
        score+= put_bits_count(&s->pb2);
        score+= put_bits_count(&s->tex_pb);
michaelni's avatar
 
michaelni committed
4753
    }
4754

4755 4756
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
        MPV_decode_mb(s, s->block);
michaelni's avatar
 
michaelni committed
4757

4758 4759
        score *= s->lambda2;
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4760
    }
4761

4762 4763 4764 4765 4766 4767
    if(*next_block){
        memcpy(s->dest, dest_backup, sizeof(s->dest));
    }

    if(score<*dmin){
        *dmin= score;
michaelni's avatar
 
michaelni committed
4768 4769 4770 4771 4772
        *next_block^=1;

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

4774
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
mru's avatar
mru committed
4775
    uint32_t *sq = ff_squareTbl + 256;
4776 4777
    int acc=0;
    int x,y;
4778 4779

    if(w==16 && h==16)
michael's avatar
michael committed
4780
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
michaelni's avatar
michaelni committed
4781
    else if(w==8 && h==8)
michael's avatar
michael committed
4782
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4783

4784 4785 4786
    for(y=0; y<h; y++){
        for(x=0; x<w; x++){
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4787
        }
4788
    }
4789

michaelni's avatar
michaelni committed
4790
    assert(acc>=0);
4791

4792 4793
    return acc;
}
4794

4795 4796 4797 4798 4799 4800 4801 4802
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)
4803
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
michael's avatar
michael committed
4804 4805 4806
        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);
4807
      }else{
michael's avatar
michael committed
4808 4809 4810
        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);
4811
      }
4812 4813 4814 4815 4816 4817
    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);
}

4818 4819 4820
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;

4821

4822 4823 4824 4825 4826 4827 4828 4829 4830
    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;
    }
4831

4832
    s->me.pre_pass=0;
4833

4834 4835 4836 4837 4838 4839
    return 0;
}

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

4840 4841
    ff_check_alignment();

4842 4843 4844 4845 4846 4847 4848 4849 4850 4851
    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;
4852

4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863
            /* 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;
}

4864 4865 4866 4867
static int mb_var_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;
    int mb_x, mb_y;

4868 4869
    ff_check_alignment();

4870 4871 4872 4873 4874 4875 4876
    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);
4877

4878 4879 4880 4881
            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;
4882
            s->me.mb_var_sum_temp    += varc;
4883 4884
        }
    }
4885
    return 0;
4886 4887
}

4888 4889 4890 4891 4892
static void write_slice_end(MpegEncContext *s){
    if(s->codec_id==CODEC_ID_MPEG4){
        if(s->partitioned_frame){
            ff_mpeg4_merge_partitions(s);
        }
4893

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

4902 4903
    if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
        s->misc_bits+= get_bits_diff(s);
4904 4905 4906 4907
}

static int encode_thread(AVCodecContext *c, void *arg){
    MpegEncContext *s= arg;
michaelni's avatar
michaelni committed
4908
    int mb_x, mb_y, pdif = 0;
michael's avatar
michael committed
4909
    int i, j;
4910
    MpegEncContext best_s, backup_s;
4911 4912 4913
    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];
michaelni's avatar
 
michaelni committed
4914
    PutBitContext pb[2], pb2[2], tex_pb[2];
4915
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
michaelni's avatar
 
michaelni committed
4916

4917 4918
    ff_check_alignment();

michaelni's avatar
 
michaelni committed
4919
    for(i=0; i<2; i++){
4920 4921 4922
        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);
michaelni's avatar
 
michaelni committed
4923
    }
glantau's avatar
glantau committed
4924

4925 4926 4927 4928 4929 4930 4931 4932 4933
    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;
4934

4935 4936 4937
    for(i=0; i<3; i++){
        /* init last dc values */
        /* note: quant matrix value (8) is implied here */
4938
        s->last_dc[i] = 128 << s->intra_dc_precision;
4939

4940
        s->current_picture.error[i] = 0;
michaelni's avatar
michaelni committed
4941
    }
4942 4943
    s->mb_skip_run = 0;
    memset(s->last_mv, 0, sizeof(s->last_mv));
4944

4945
    s->last_mv_dir = 0;
michaelni's avatar
michaelni committed
4946

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

4959
    s->resync_mb_x=0;
4960
    s->resync_mb_y=0;
4961 4962 4963 4964 4965 4966
    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;
michaelni's avatar
michaelni committed
4967

4968 4969
        ff_set_qscale(s, s->qscale);
        ff_init_block_index(s);
4970

4971
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4972
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4973 4974 4975 4976
            int mb_type= s->mb_type[xy];
//            int d;
            int dmin= INT_MAX;
            int dir;
michael's avatar
michael committed
4977

4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989
            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;
                }
            }

4990
            s->mb_x = mb_x;
4991
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4992 4993
            ff_update_block_index(s);

michael's avatar
michael committed
4994
#ifdef CONFIG_H261_ENCODER
4995 4996 4997
            if(s->codec_id == CODEC_ID_H261){
                ff_h261_reorder_mb_index(s);
                xy= s->mb_y*s->mb_stride + s->mb_x;
michael's avatar
michael committed
4998
                mb_type= s->mb_type[xy];
4999
            }
michael's avatar
michael committed
5000
#endif
5001

5002 5003 5004
            /* write gob / video packet header  */
            if(s->rtp_mode){
                int current_packet_size, is_gob_start;
5005

5006
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
5007 5008 5009

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

5010
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
5011

5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022
                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;
michael's avatar
michael committed
5023
                }
5024

5025 5026 5027
                if(is_gob_start){
                    if(s->start_mb_y != mb_y || mb_x!=0){
                        write_slice_end(s);
5028

5029 5030
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
                            ff_mpeg4_init_partitions(s);
michael's avatar
michael committed
5031 5032
                        }
                    }
5033

alex's avatar
alex committed
5034
                    assert((put_bits_count(&s->pb)&7) == 0);
michael's avatar
michael committed
5035
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
5036

michael's avatar
michael committed
5037
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
5038
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
michael's avatar
michael committed
5039 5040 5041 5042 5043 5044 5045 5046 5047
                        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);
                        }
                    }
5048 5049 5050 5051 5052

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

michael's avatar
michael committed
5054 5055
                    switch(s->codec_id){
                    case CODEC_ID_MPEG4:
michaelni's avatar
 
michaelni committed
5056 5057
                        ff_mpeg4_encode_video_packet_header(s);
                        ff_mpeg4_clean_buffers(s);
michael's avatar
michael committed
5058 5059 5060
                    break;
                    case CODEC_ID_MPEG1VIDEO:
                    case CODEC_ID_MPEG2VIDEO:
michaelni's avatar
michaelni committed
5061 5062
                        ff_mpeg1_encode_slice_header(s);
                        ff_mpeg1_clean_buffers(s);
michael's avatar
michael committed
5063 5064 5065
                    break;
                    case CODEC_ID_H263:
                    case CODEC_ID_H263P:
5066
                        h263_encode_gob_header(s, mb_y);
michael's avatar
michael committed
5067
                    break;
michaelni's avatar
michaelni committed
5068 5069
                    }

michael's avatar
michael committed
5070
                    if(s->flags&CODEC_FLAG_PASS1){
alex's avatar
alex committed
5071
                        int bits= put_bits_count(&s->pb);
michael's avatar
michael committed
5072 5073 5074
                        s->misc_bits+= bits - s->last_bits;
                        s->last_bits= bits;
                    }
5075

michael's avatar
michael committed
5076
                    s->ptr_lastgob += current_packet_size;
michaelni's avatar
 
michaelni committed
5077 5078 5079 5080
                    s->first_slice_line=1;
                    s->resync_mb_x=mb_x;
                    s->resync_mb_y=mb_y;
                }
5081
            }
michaelni's avatar
 
michaelni committed
5082

5083 5084
            if(  (s->resync_mb_x   == s->mb_x)
               && s->resync_mb_y+1 == s->mb_y){
5085
                s->first_slice_line=0;
michaelni's avatar
 
michaelni committed
5086 5087
            }

5088
            s->mb_skipped=0;
5089
            s->dquant=0; //only for QP_RD
5090

michael's avatar
michael committed
5091
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5092
                int next_block=0;
michaelni's avatar
 
michaelni committed
5093
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5094 5095

                copy_context_before_encode(&backup_s, s, -1);
michaelni's avatar
 
michaelni committed
5096 5097
                backup_s.pb= s->pb;
                best_s.data_partitioning= s->data_partitioning;
5098
                best_s.partitioned_frame= s->partitioned_frame;
michaelni's avatar
 
michaelni committed
5099 5100 5101 5102
                if(s->data_partitioning){
                    backup_s.pb2= s->pb2;
                    backup_s.tex_pb= s->tex_pb;
                }
5103

michael's avatar
michael committed
5104
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
5105
                    s->mv_dir = MV_DIR_FORWARD;
michaelni's avatar
michaelni committed
5106
                    s->mv_type = MV_TYPE_16X16;
5107
                    s->mb_intra= 0;
5108 5109
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
5110
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
michaelni's avatar
 
michaelni committed
5111
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5112
                }
5113
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
michael's avatar
michael committed
5114 5115 5116 5117 5118 5119 5120 5121
                    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];
                    }
5122
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
michael's avatar
michael committed
5123 5124
                                 &dmin, &next_block, 0, 0);
                }
5125
                if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5126 5127 5128 5129 5130
                    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;
5131
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5132
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
glantau's avatar
glantau committed
5133
                }
5134
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5135
                    s->mv_dir = MV_DIR_FORWARD;
michaelni's avatar
michaelni committed
5136 5137 5138
                    s->mv_type = MV_TYPE_8X8;
                    s->mb_intra= 0;
                    for(i=0; i<4; i++){
5139 5140
                        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];
michaelni's avatar
michaelni committed
5141
                    }
5142
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
michaelni's avatar
 
michaelni committed
5143
                                 &dmin, &next_block, 0, 0);
5144
                }
michael's avatar
michael committed
5145
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5146 5147 5148 5149 5150
                    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];
5151
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
michaelni's avatar
 
michaelni committed
5152
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5153
                }
michael's avatar
michael committed
5154
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5155 5156 5157 5158 5159
                    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];
5160
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
michaelni's avatar
 
michaelni committed
5161
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5162
                }
michael's avatar
michael committed
5163
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5164 5165 5166 5167 5168 5169 5170
                    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];
5171
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
michaelni's avatar
 
michaelni committed
5172
                                 &dmin, &next_block, 0, 0);
5173
                }
5174
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
michael's avatar
michael committed
5175 5176 5177 5178 5179 5180 5181 5182
                    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];
                    }
5183
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
michael's avatar
michael committed
5184 5185
                                 &dmin, &next_block, 0, 0);
                }
5186
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
michael's avatar
michael committed
5187 5188 5189 5190 5191 5192 5193 5194
                    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];
                    }
5195
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
michael's avatar
michael committed
5196 5197
                                 &dmin, &next_block, 0, 0);
                }
5198
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
michael's avatar
michael committed
5199 5200 5201 5202 5203 5204 5205 5206 5207 5208
                    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];
                        }
                    }
5209
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
michael's avatar
michael committed
5210 5211 5212
                                 &dmin, &next_block, 0, 0);
                }
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5213
                    s->mv_dir = 0;
michaelni's avatar
michaelni committed
5214
                    s->mv_type = MV_TYPE_16X16;
5215 5216 5217
                    s->mb_intra= 1;
                    s->mv[0][0][0] = 0;
                    s->mv[0][0][1] = 0;
5218
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
michaelni's avatar
 
michaelni committed
5219
                                 &dmin, &next_block, 0, 0);
5220 5221 5222 5223 5224 5225
                    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?
                    }
michaelni's avatar
michaelni committed
5226
                }
5227

5228 5229
                if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
                    if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
5230
                        const int last_qp= backup_s.qscale;
michael's avatar
michael committed
5231
                        int qpi, qp, dc[6];
5232
                        DCTELEM ac[6][16];
michael's avatar
michael committed
5233
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5234
                        static const int dquant_tab[4]={-1,1,-2,2};
5235

5236 5237 5238 5239 5240 5241 5242 5243 5244 5245
                        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];
5246

5247
                        qpi = s->pict_type == B_TYPE ? 2 : 0;
michael's avatar
michael committed
5248 5249
                        for(; qpi<4; qpi++){
                            int dquant= dquant_tab[qpi];
5250 5251
                            qp= last_qp + dquant;
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5252
                                continue;
5253
                            backup_s.dquant= dquant;
michael's avatar
michael committed
5254
                            if(s->mb_intra && s->dc_val[0]){
5255 5256 5257 5258
                                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);
                                }
5259
                            }
5260

5261
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
michael's avatar
michael committed
5262
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5263
                            if(best_s.qscale != qp){
michael's avatar
michael committed
5264
                                if(s->mb_intra && s->dc_val[0]){
5265 5266 5267 5268
                                    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);
                                    }
5269 5270 5271 5272 5273
                                }
                            }
                        }
                    }
                }
5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
                    int mx= s->b_direct_mv_table[xy][0];
                    int my= s->b_direct_mv_table[xy][1];

                    backup_s.dquant = 0;
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
                    ff_mpeg4_set_direct_mv(s, mx, my);
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
                                 &dmin, &next_block, mx, my);
                }
5285 5286 5287 5288 5289 5290 5291 5292
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT0){
                    backup_s.dquant = 0;
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
                    ff_mpeg4_set_direct_mv(s, 0, 0);
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
                                 &dmin, &next_block, 0, 0);
                }
michael's avatar
michael committed
5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325
                if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
                    int coded=0;
                    for(i=0; i<6; i++)
                        coded |= s->block_last_index[i];
                    if(coded){
                        int mx,my;
                        memcpy(s->mv, best_s.mv, sizeof(s->mv));
                        if(best_s.mv_dir & MV_DIRECT){
                            mx=my=0; //FIXME find the one we actually used
                            ff_mpeg4_set_direct_mv(s, mx, my);
                        }else if(best_s.mv_dir&MV_DIR_BACKWARD){
                            mx= s->mv[1][0][0];
                            my= s->mv[1][0][1];
                        }else{
                            mx= s->mv[0][0][0];
                            my= s->mv[0][0][1];
                        }

                        s->mv_dir= best_s.mv_dir;
                        s->mv_type = best_s.mv_type;
                        s->mb_intra= 0;
/*                        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];*/
                        backup_s.dquant= 0;
                        s->skipdct=1;
                        encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
                                        &dmin, &next_block, mx, my);
                        s->skipdct=0;
                    }
                }

5326
                s->current_picture.qscale_table[xy]= best_s.qscale;
5327

5328
                copy_context_after_encode(s, &best_s, -1);
5329

alex's avatar
alex committed
5330
                pb_bits_count= put_bits_count(&s->pb);
michaelni's avatar
 
michaelni committed
5331 5332 5333
                flush_put_bits(&s->pb);
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
                s->pb= backup_s.pb;
5334

michaelni's avatar
 
michaelni committed
5335
                if(s->data_partitioning){
alex's avatar
alex committed
5336
                    pb2_bits_count= put_bits_count(&s->pb2);
michaelni's avatar
 
michaelni committed
5337 5338 5339
                    flush_put_bits(&s->pb2);
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
                    s->pb2= backup_s.pb2;
5340

alex's avatar
alex committed
5341
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
michaelni's avatar
 
michaelni committed
5342 5343 5344 5345
                    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;
                }
alex's avatar
alex committed
5346
                s->last_bits= put_bits_count(&s->pb);
5347

5348 5349
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
                    ff_h263_update_motion_val(s);
5350

5351 5352 5353 5354
                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);
5355 5356 5357 5358
                }

                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
                    MPV_decode_mb(s, s->block);
glantau's avatar
glantau committed
5359
            } else {
5360
                int motion_x = 0, motion_y = 0;
5361
                s->mv_type=MV_TYPE_16X16;
5362
                // only one MB-Type possible
5363

5364
                switch(mb_type){
michael's avatar
michael committed
5365
                case CANDIDATE_MB_TYPE_INTRA:
5366
                    s->mv_dir = 0;
5367
                    s->mb_intra= 1;
5368 5369
                    motion_x= s->mv[0][0][0] = 0;
                    motion_y= s->mv[0][0][1] = 0;
5370
                    break;
michael's avatar
michael committed
5371
                case CANDIDATE_MB_TYPE_INTER:
5372 5373 5374 5375
                    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];
5376
                    break;
michael's avatar
michael committed
5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387
                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];
                    }
                    break;
                case CANDIDATE_MB_TYPE_INTER4V:
michaelni's avatar
 
michaelni committed
5388 5389 5390 5391
                    s->mv_dir = MV_DIR_FORWARD;
                    s->mv_type = MV_TYPE_8X8;
                    s->mb_intra= 0;
                    for(i=0; i<4; i++){
5392 5393
                        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];
michaelni's avatar
 
michaelni committed
5394 5395
                    }
                    break;
michael's avatar
michael committed
5396
                case CANDIDATE_MB_TYPE_DIRECT:
5397 5398
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
5399 5400
                    motion_x=s->b_direct_mv_table[xy][0];
                    motion_y=s->b_direct_mv_table[xy][1];
michaelni's avatar
michaelni committed
5401
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5402
                    break;
michael's avatar
10l  
michael committed
5403 5404 5405 5406 5407
                case CANDIDATE_MB_TYPE_DIRECT0:
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                    s->mb_intra= 0;
                    ff_mpeg4_set_direct_mv(s, 0, 0);
                    break;
michael's avatar
michael committed
5408
                case CANDIDATE_MB_TYPE_BIDIR:
5409
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5410
                    s->mb_intra= 0;
5411 5412 5413 5414
                    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];
5415
                    break;
michael's avatar
michael committed
5416
                case CANDIDATE_MB_TYPE_BACKWARD:
5417 5418 5419 5420
                    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];
5421
                    break;
michael's avatar
michael committed
5422
                case CANDIDATE_MB_TYPE_FORWARD:
5423 5424 5425 5426 5427
                    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);
5428
                    break;
michael's avatar
michael committed
5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460
                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];
                    }
                    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];
                    }
                    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];
                        }
                    }
                    break;
5461
                default:
5462
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5463
                }
5464

5465
                encode_mb(s, motion_x, motion_y);
5466

5467
                // RAL: Update last macroblock type
5468
                s->last_mv_dir = s->mv_dir;
5469

5470 5471
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
                    ff_h263_update_motion_val(s);
5472

5473
                MPV_decode_mb(s, s->block);
glantau's avatar
glantau committed
5474
            }
5475

5476 5477 5478 5479 5480
            /* 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;
            }
5481

5482 5483 5484 5485 5486 5487
            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;
michaelni's avatar
michaelni committed
5488

5489
                s->current_picture.error[0] += sse(
5490 5491
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
                    s->dest[0], w, h, s->linesize);
5492
                s->current_picture.error[1] += sse(
5493 5494
                    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);
5495
                s->current_picture.error[2] += sse(
5496 5497
                    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);
5498
            }
michael's avatar
michael committed
5499 5500 5501 5502
            if(s->loop_filter){
                if(s->out_format == FMT_H263)
                    ff_h263_loop_filter(s);
            }
alex's avatar
alex committed
5503
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
glantau's avatar
glantau committed
5504 5505
        }
    }
michaelni's avatar
michaelni committed
5506

5507
    //not beautiful here but we must write it before flushing so it has to be here
michaelni's avatar
 
michaelni committed
5508
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
arpi_esp's avatar
arpi_esp committed
5509
        msmpeg4_encode_ext_header(s);
michaelni's avatar
 
michaelni committed
5510

5511 5512
    write_slice_end(s);

5513
    /* Send the last GOB if RTP */
michael's avatar
michael committed
5514
    if (s->avctx->rtp_callback) {
5515
        int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5516
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5517
        /* Call the RTP callback to send the last GOB */
5518
        emms_c();
5519
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5520
    }
5521 5522 5523 5524 5525 5526

    return 0;
}

#define MERGE(field) dst->field += src->field; src->field=0
static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5527 5528 5529
    MERGE(me.scene_change_score);
    MERGE(me.mc_mb_var_sum_temp);
    MERGE(me.mb_var_sum_temp);
5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546
}

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);
5547 5548 5549
    MERGE(current_picture.error[0]);
    MERGE(current_picture.error[1]);
    MERGE(current_picture.error[2]);
5550 5551 5552 5553 5554 5555 5556

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

5558 5559 5560 5561 5562 5563
    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);
}

takis's avatar
takis committed
5564
static int estimate_qp(MpegEncContext *s, int dry_run){
5565 5566 5567 5568 5569
    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) {
5570 5571
        s->current_picture_ptr->quality=
        s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
takis's avatar
takis committed
5572 5573 5574
        if (s->current_picture.quality < 0)
            return -1;
    }
5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593

    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);
5594
    return 0;
5595 5596
}

takis's avatar
takis committed
5597
static int encode_picture(MpegEncContext *s, int picture_number)
5598
{
5599
    int i;
5600 5601 5602
    int bits;

    s->picture_number = picture_number;
5603

5604
    /* Reset the average MB variance */
5605 5606
    s->me.mb_var_sum_temp    =
    s->me.mc_mb_var_sum_temp = 0;
5607 5608 5609 5610

    /* 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))
michael's avatar
michael committed
5611
        ff_set_mpeg4_time(s, s->picture_number);  //FIXME rename and use has_b_frames or similar
5612

5613
    s->me.scene_change_score=0;
5614

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

5617 5618 5619 5620 5621
    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)
5622
            s->no_rounding ^= 1;
5623
    }
5624

michael's avatar
michael committed
5625
    if(s->flags & CODEC_FLAG_PASS2){
takis's avatar
takis committed
5626 5627
        if (estimate_qp(s,1) < 0)
            return -1;
michael's avatar
michael committed
5628 5629
        ff_get_2pass_fcode(s);
    }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5630
        if(s->pict_type==B_TYPE)
5631
            s->lambda= s->last_lambda_for[s->pict_type];
5632
        else
5633
            s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5634 5635
        update_qscale(s);
    }
5636

5637
    s->mb_intra=0; //for the rate distortion & bit compare functions
5638
    for(i=1; i<s->avctx->thread_count; i++){
michael's avatar
michael committed
5639
        ff_update_duplicate_context(s->thread_context[i], s);
5640
    }
michael's avatar
michael committed
5641 5642 5643

    ff_init_me(s);

5644 5645
    /* Estimate motion for every MB */
    if(s->pict_type != I_TYPE){
5646
        s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5647
        s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
5648
        if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5649 5650 5651 5652 5653 5654 5655 5656 5657 5658
            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;
5659

5660 5661
        if(!s->fixed_qscale){
            /* finding spatial complexity for I-frame rate control */
5662
            s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5663 5664
        }
    }
5665 5666 5667
    for(i=1; i<s->avctx->thread_count; i++){
        merge_context_after_me(s, s->thread_context[i]);
    }
5668 5669
    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;
5670 5671
    emms_c();

5672
    if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688
        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));
            }
5689

5690 5691 5692
            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){
5693
                int j;
5694 5695
                for(i=0; i<2; i++){
                    for(j=0; j<2; j++)
5696
                        ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717
                                        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){
5718
                int dir, j;
5719 5720 5721
                for(dir=0; dir<2; dir++){
                    for(i=0; i<2; i++){
                        for(j=0; j<2; j++){
5722
                            int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5723
                                          : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5724
                            ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5725 5726 5727 5728 5729 5730 5731 5732
                                            s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
                        }
                    }
                }
            }
        }
    }

takis's avatar
takis committed
5733 5734
    if (estimate_qp(s, 0) < 0)
        return -1;
5735 5736

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

5739 5740 5741 5742 5743 5744
    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];

reimar's avatar
reimar committed
5745
            s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5746
        }
5747
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5748
                       s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5749 5750
        s->qscale= 8;
    }
5751

5752
    //FIXME var duplication
5753
    s->current_picture_ptr->key_frame=
5754
    s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5755
    s->current_picture_ptr->pict_type=
5756 5757 5758 5759 5760 5761 5762 5763 5764 5765
    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;
michael's avatar
michael committed
5766
#ifdef CONFIG_H261_ENCODER
5767 5768 5769
    case FMT_H261:
        ff_h261_encode_picture_header(s, picture_number);
        break;
michael's avatar
michael committed
5770
#endif
5771
    case FMT_H263:
5772
        if (s->codec_id == CODEC_ID_WMV2)
5773
            ff_wmv2_encode_picture_header(s, picture_number);
5774
        else if (s->h263_msmpeg4)
5775 5776 5777
            msmpeg4_encode_picture_header(s, picture_number);
        else if (s->h263_pred)
            mpeg4_encode_picture_header(s, picture_number);
michael's avatar
michael committed
5778
#ifdef CONFIG_RV10_ENCODER
5779
        else if (s->codec_id == CODEC_ID_RV10)
5780
            rv10_encode_picture_header(s, picture_number);
michael's avatar
michael committed
5781 5782
#endif
#ifdef CONFIG_RV20_ENCODER
5783
        else if (s->codec_id == CODEC_ID_RV20)
michael's avatar
michael committed
5784
            rv20_encode_picture_header(s, picture_number);
michael's avatar
michael committed
5785
#endif
5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800
        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;
5801

5802 5803 5804 5805 5806 5807 5808 5809
    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();
5810
    return 0;
glantau's avatar
glantau committed
5811 5812
}

michael's avatar
michael committed
5813
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5814 5815 5816
    const int intra= s->mb_intra;
    int i;

5817 5818
    s->dct_count[intra]++;

5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836
    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;
        }
    }
}

5837
static int dct_quantize_trellis_c(MpegEncContext *s,
michaelni's avatar
michaelni committed
5838 5839 5840
                        DCTELEM *block, int n,
                        int qscale, int *overflow){
    const int *qmat;
kabi's avatar
kabi committed
5841
    const uint8_t *scantable= s->intra_scantable.scantable;
michael's avatar
michael committed
5842
    const uint8_t *perm_scantable= s->intra_scantable.permutated;
michaelni's avatar
michaelni committed
5843 5844 5845 5846 5847 5848
    int max=0;
    unsigned int threshold1, threshold2;
    int bias=0;
    int run_tab[65];
    int level_tab[65];
    int score_tab[65];
michael's avatar
michael committed
5849 5850
    int survivor[65];
    int survivor_count;
michaelni's avatar
michaelni committed
5851 5852 5853
    int last_run=0;
    int last_level=0;
    int last_score= 0;
michael's avatar
michael committed
5854
    int last_i;
michael's avatar
michael committed
5855
    int coeff[2][64];
michaelni's avatar
michaelni committed
5856
    int coeff_count[64];
5857
    int qmul, qadd, start_i, last_non_zero, i, dc;
michaelni's avatar
michaelni committed
5858 5859 5860
    const int esc_length= s->ac_esc_length;
    uint8_t * length;
    uint8_t * last_length;
5861
    const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5862

5863
    s->dsp.fdct (block);
5864

5865
    if(s->dct_error_sum)
michael's avatar
michael committed
5866
        s->denoise_dct(s, block);
michaelni's avatar
michaelni committed
5867 5868
    qmul= qscale*16;
    qadd= ((qscale-1)|1)*8;
michaelni's avatar
michaelni committed
5869

michaelni's avatar
michaelni committed
5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882
    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;
        }
5883

michaelni's avatar
michaelni committed
5884 5885 5886 5887 5888
        /* 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];
5889
        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
michaelni's avatar
michaelni committed
5890 5891 5892 5893 5894 5895 5896 5897 5898 5899
            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;
    }
michael's avatar
michael committed
5900
    last_i= start_i;
michaelni's avatar
michaelni committed
5901 5902 5903

    threshold1= (1<<QMAT_SHIFT) - bias - 1;
    threshold2= (threshold1<<1);
michaelni's avatar
michaelni committed
5904

michael's avatar
michael committed
5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915
    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++) {
michaelni's avatar
michaelni committed
5916
        const int j = scantable[i];
michael's avatar
michael committed
5917
        int level = block[j] * qmat[j];
michaelni's avatar
michaelni committed
5918 5919 5920 5921 5922 5923

//        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;
michael's avatar
michael committed
5924 5925
                coeff[0][i]= level;
                coeff[1][i]= level-1;
michaelni's avatar
michaelni committed
5926
//                coeff[2][k]= level-2;
michaelni's avatar
michaelni committed
5927 5928
            }else{
                level= (bias - level)>>QMAT_SHIFT;
michael's avatar
michael committed
5929 5930
                coeff[0][i]= -level;
                coeff[1][i]= -level+1;
michaelni's avatar
michaelni committed
5931
//                coeff[2][k]= -level+2;
michaelni's avatar
michaelni committed
5932
            }
michael's avatar
michael committed
5933 5934
            coeff_count[i]= FFMIN(level, 2);
            assert(coeff_count[i]);
michaelni's avatar
michaelni committed
5935 5936
            max |=level;
        }else{
michael's avatar
michael committed
5937 5938
            coeff[0][i]= (level>>31)|1;
            coeff_count[i]= 1;
michaelni's avatar
michaelni committed
5939 5940
        }
    }
5941

5942
    *overflow= s->max_qcoeff < max; //overflow might have happened
5943

michaelni's avatar
michaelni committed
5944 5945 5946 5947 5948
    if(last_non_zero < start_i){
        memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
        return last_non_zero;
    }

michael's avatar
michael committed
5949 5950 5951
    score_tab[start_i]= 0;
    survivor[0]= start_i;
    survivor_count= 1;
5952

michael's avatar
michael committed
5953 5954
    for(i=start_i; i<=last_non_zero; i++){
        int level_index, j;
diego's avatar
diego committed
5955
        const int dct_coeff= FFABS(block[ scantable[i] ]);
michaelni's avatar
michaelni committed
5956
        const int zero_distoration= dct_coeff*dct_coeff;
michaelni's avatar
michaelni committed
5957
        int best_score=256*256*256*120;
michaelni's avatar
michaelni committed
5958 5959 5960
        for(level_index=0; level_index < coeff_count[i]; level_index++){
            int distoration;
            int level= coeff[level_index][i];
diego's avatar
diego committed
5961
            const int alevel= FFABS(level);
michaelni's avatar
michaelni committed
5962
            int unquant_coeff;
5963

michaelni's avatar
michaelni committed
5964 5965 5966
            assert(level);

            if(s->out_format == FMT_H263){
michael's avatar
michael committed
5967
                unquant_coeff= alevel*qmul + qadd;
michaelni's avatar
michaelni committed
5968
            }else{ //MPEG1
michael's avatar
michael committed
5969
                j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
michaelni's avatar
michaelni committed
5970
                if(s->mb_intra){
michael's avatar
michael committed
5971
                        unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
michaelni's avatar
michaelni committed
5972 5973
                        unquant_coeff =   (unquant_coeff - 1) | 1;
                }else{
michael's avatar
michael committed
5974
                        unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
michaelni's avatar
michaelni committed
5975 5976 5977 5978
                        unquant_coeff =   (unquant_coeff - 1) | 1;
                }
                unquant_coeff<<= 3;
            }
michaelni's avatar
michaelni committed
5979

michael's avatar
michael committed
5980
            distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
michaelni's avatar
michaelni committed
5981 5982
            level+=64;
            if((level&(~127)) == 0){
michael's avatar
michael committed
5983 5984
                for(j=survivor_count-1; j>=0; j--){
                    int run= i - survivor[j];
michaelni's avatar
michaelni committed
5985
                    int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
michaelni's avatar
michaelni committed
5986
                    score += score_tab[i-run];
5987

michaelni's avatar
michaelni committed
5988
                    if(score < best_score){
michael's avatar
michael committed
5989
                        best_score= score;
michaelni's avatar
michaelni committed
5990 5991 5992 5993 5994 5995
                        run_tab[i+1]= run;
                        level_tab[i+1]= level-64;
                    }
                }

                if(s->out_format == FMT_H263){
michael's avatar
michael committed
5996 5997
                    for(j=survivor_count-1; j>=0; j--){
                        int run= i - survivor[j];
michaelni's avatar
michaelni committed
5998
                        int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
michaelni's avatar
michaelni committed
5999
                        score += score_tab[i-run];
michaelni's avatar
michaelni committed
6000 6001 6002 6003 6004
                        if(score < last_score){
                            last_score= score;
                            last_run= run;
                            last_level= level-64;
                            last_i= i+1;
michaelni's avatar
michaelni committed
6005 6006 6007 6008 6009
                        }
                    }
                }
            }else{
                distoration += esc_length*lambda;
michael's avatar
michael committed
6010 6011
                for(j=survivor_count-1; j>=0; j--){
                    int run= i - survivor[j];
michaelni's avatar
michaelni committed
6012
                    int score= distoration + score_tab[i-run];
6013

michaelni's avatar
michaelni committed
6014
                    if(score < best_score){
michael's avatar
michael committed
6015
                        best_score= score;
michaelni's avatar
michaelni committed
6016 6017 6018 6019 6020 6021
                        run_tab[i+1]= run;
                        level_tab[i+1]= level-64;
                    }
                }

                if(s->out_format == FMT_H263){
michael's avatar
michael committed
6022 6023
                  for(j=survivor_count-1; j>=0; j--){
                        int run= i - survivor[j];
michaelni's avatar
michaelni committed
6024
                        int score= distoration + score_tab[i-run];
michaelni's avatar
michaelni committed
6025 6026 6027 6028 6029
                        if(score < last_score){
                            last_score= score;
                            last_run= run;
                            last_level= level-64;
                            last_i= i+1;
michaelni's avatar
michaelni committed
6030 6031 6032 6033 6034
                        }
                    }
                }
            }
        }
6035

michael's avatar
michael committed
6036 6037
        score_tab[i+1]= best_score;

michaelni's avatar
michaelni committed
6038
        //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
michael's avatar
michael committed
6039 6040 6041 6042 6043 6044 6045 6046 6047 6048
        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;
            }
6049
        }
michael's avatar
michael committed
6050 6051

        survivor[ survivor_count++ ]= i+1;
michaelni's avatar
michaelni committed
6052
    }
michaelni's avatar
michaelni committed
6053

michaelni's avatar
michaelni committed
6054
    if(s->out_format != FMT_H263){
michaelni's avatar
michaelni committed
6055
        last_score= 256*256*256*120;
michael's avatar
michael committed
6056
        for(i= survivor[0]; i<=last_non_zero + 1; i++){
michaelni's avatar
michaelni committed
6057
            int score= score_tab[i];
michaelni's avatar
michaelni committed
6058 6059
            if(i) score += lambda*2; //FIXME exacter?

michaelni's avatar
michaelni committed
6060 6061 6062 6063 6064 6065
            if(score < last_score){
                last_score= score;
                last_i= i;
                last_level= level_tab[i];
                last_run= run_tab[i];
            }
michaelni's avatar
michaelni committed
6066 6067
        }
    }
6068

michael's avatar
michael committed
6069
    s->coded_score[n] = last_score;
6070

diego's avatar
diego committed
6071
    dc= FFABS(block[0]);
michael's avatar
michael committed
6072
    last_non_zero= last_i - 1;
michaelni's avatar
michaelni committed
6073
    memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
6074

michaelni's avatar
michaelni committed
6075 6076
    if(last_non_zero < start_i)
        return last_non_zero;
6077

6078 6079 6080
    if(last_non_zero == 0 && start_i == 0){
        int best_level= 0;
        int best_score= dc * dc;
6081

6082
        for(i=0; i<coeff_count[0]; i++){
6083
            int level= coeff[i][0];
diego's avatar
diego committed
6084
            int alevel= FFABS(level);
michael's avatar
michael committed
6085
            int unquant_coeff, score, distortion;
6086 6087

            if(s->out_format == FMT_H263){
michael's avatar
michael committed
6088
                    unquant_coeff= (alevel*qmul + qadd)>>3;
6089
            }else{ //MPEG1
michael's avatar
michael committed
6090 6091
                    unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
                    unquant_coeff =   (unquant_coeff - 1) | 1;
6092 6093 6094 6095
            }
            unquant_coeff = (unquant_coeff + 4) >> 3;
            unquant_coeff<<= 3 + 3;

michael's avatar
michael committed
6096
            distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
6097
            level+=64;
michael's avatar
michael committed
6098 6099
            if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
            else                    score= distortion + esc_length*lambda;
6100

6101 6102
            if(score < best_score){
                best_score= score;
6103
                best_level= level - 64;
6104 6105 6106
            }
        }
        block[0]= best_level;
6107 6108 6109
        s->coded_score[n] = best_score - dc*dc;
        if(best_level == 0) return -1;
        else                return last_non_zero;
6110
    }
6111

michaelni's avatar
michaelni committed
6112 6113
    i= last_i;
    assert(last_level);
michael's avatar
michael committed
6114 6115

    block[ perm_scantable[last_non_zero] ]= last_level;
michaelni's avatar
michaelni committed
6116
    i -= last_run + 1;
6117

michael's avatar
michael committed
6118 6119
    for(; i>start_i; i -= run_tab[i] + 1){
        block[ perm_scantable[i-1] ]= level_tab[i];
michaelni's avatar
michaelni committed
6120 6121 6122 6123 6124
    }

    return last_non_zero;
}

michael's avatar
michael committed
6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150
//#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];
6151
    DECLARE_ALIGNED_16(DCTELEM, d1[64]);
michael's avatar
michael committed
6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163
    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;
6164
    int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
michael's avatar
michael committed
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176
#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);
6177

michael's avatar
michael committed
6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212
    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
6213 6214
    dc += (1<<(RECON_SHIFT-1));
    for(i=0; i<64; i++){
6215
        rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME  use orig dirrectly instead of copying to rem[]
michael's avatar
michael committed
6216 6217 6218 6219 6220 6221 6222 6223 6224 6225
    }
#ifdef REFINE_STATS
STOP_TIMER("memset rem[]")}
#endif
    sum=0;
    for(i=0; i<64; i++){
        int one= 36;
        int qns=4;
        int w;

diego's avatar
diego committed
6226
        w= FFABS(weight[i]) + qns*one;
michael's avatar
michael committed
6227 6228 6229 6230
        w= 15 + (48*qns*one + w/2)/w; // 16 .. 63

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

michael's avatar
michael committed
6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245
        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;
6246

michael's avatar
michael committed
6247 6248 6249 6250 6251 6252
        if(level){
            if(level<0) coeff= qmul*level - qadd;
            else        coeff= qmul*level + qadd;
            run_tab[rle_index++]=run;
            run=0;

6253
            s->dsp.add_8x8basis(rem, basis[j], coeff);
michael's avatar
michael committed
6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266
        }else{
            run++;
        }
    }
#ifdef REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("init rem[]")
}
}

{START_TIMER
#endif
    for(;;){
6267
        int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
michael's avatar
michael committed
6268 6269
        int best_coeff=0;
        int best_change=0;
6270
        int run2, best_unquant_change=0, analyze_gradient;
michael's avatar
michael committed
6271 6272 6273
#ifdef REFINE_STATS
{START_TIMER
#endif
6274 6275 6276 6277 6278 6279 6280 6281
        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];
6282

6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294
                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
        }

michael's avatar
michael committed
6295 6296 6297 6298 6299
        if(start_i){
            const int level= block[0];
            int change, old_coeff;

            assert(s->mb_intra);
6300

michael's avatar
michael committed
6301
            old_coeff= q*level;
6302

michael's avatar
michael committed
6303 6304 6305
            for(change=-1; change<=1; change+=2){
                int new_level= level + change;
                int score, new_coeff;
6306

michael's avatar
michael committed
6307 6308 6309 6310
                new_coeff= q*new_level;
                if(new_coeff >= 2048 || new_coeff < 0)
                    continue;

6311
                score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
michael's avatar
michael committed
6312 6313 6314 6315 6316 6317 6318 6319
                if(score<best_score){
                    best_score= score;
                    best_coeff= 0;
                    best_change= change;
                    best_unquant_change= new_coeff - old_coeff;
                }
            }
        }
6320

michael's avatar
michael committed
6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343
        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 );
            }
6344

michael's avatar
michael committed
6345 6346 6347
            for(change=-1; change<=1; change+=2){
                int new_level= level + change;
                int score, new_coeff, unquant_change;
6348

michael's avatar
michael committed
6349
                score=0;
diego's avatar
diego committed
6350
                if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
michael's avatar
michael committed
6351 6352 6353 6354 6355 6356 6357 6358
                   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
6359

michael's avatar
michael committed
6360 6361 6362 6363 6364 6365 6366 6367 6368 6369
                    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{
diego's avatar
diego committed
6370
                        assert(FFABS(new_level)==1);
6371

6372 6373 6374 6375 6376 6377
                        if(analyze_gradient){
                            int g= d1[ scantable[i] ];
                            if(g && (g^new_level) >= 0)
                                continue;
                        }

michael's avatar
michael committed
6378 6379 6380
                        if(i < last_non_zero){
                            int next_i= i + run2 + 1;
                            int next_level= block[ perm_scantable[next_i] ] + 64;
6381

michael's avatar
michael committed
6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402
                            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;
diego's avatar
diego committed
6403
                    assert(FFABS(level)==1);
michael's avatar
michael committed
6404 6405 6406 6407

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

michael's avatar
michael committed
6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427
                        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)];
                        }
                    }
                }
6428

michael's avatar
michael committed
6429 6430 6431 6432
                score *= lambda;

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

6434
                score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
michael's avatar
michael committed
6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457
                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 ];
6458

michael's avatar
michael committed
6459
            block[j] += best_change;
6460

michael's avatar
michael committed
6461 6462 6463 6464 6465 6466 6467 6468 6469 6470
            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){
diego's avatar
diego committed
6471
        if(FFABS(block[j]) > FFABS(block[j] - best_change)){
michael's avatar
michael committed
6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498
            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];
6499

michael's avatar
michael committed
6500 6501 6502 6503 6504 6505 6506
                 if(level){
                     run_tab[rle_index++]=run;
                     run=0;
                 }else{
                     run++;
                 }
            }
6507

6508
            s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
michael's avatar
michael committed
6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522
        }else{
            break;
        }
    }
#ifdef REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("iterative search")
}
}
#endif

    return last_non_zero;
}

6523
static int dct_quantize_c(MpegEncContext *s,
glantau's avatar
glantau committed
6524
                        DCTELEM *block, int n,
6525
                        int qscale, int *overflow)
glantau's avatar
glantau committed
6526
{
michael's avatar
michael committed
6527
    int i, j, level, last_non_zero, q, start_i;
glantau's avatar
glantau committed
6528
    const int *qmat;
kabi's avatar
kabi committed
6529
    const uint8_t *scantable= s->intra_scantable.scantable;
6530 6531 6532
    int bias;
    int max=0;
    unsigned int threshold1, threshold2;
6533

6534
    s->dsp.fdct (block);
glantau's avatar
glantau committed
6535

6536
    if(s->dct_error_sum)
michael's avatar
michael committed
6537
        s->denoise_dct(s, block);
6538

glantau's avatar
glantau committed
6539
    if (s->mb_intra) {
6540 6541 6542 6543 6544 6545 6546 6547 6548
        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;
6549

glantau's avatar
glantau committed
6550 6551
        /* note: block[0] is assumed to be positive */
        block[0] = (block[0] + (q >> 1)) / q;
michael's avatar
michael committed
6552
        start_i = 1;
glantau's avatar
glantau committed
6553
        last_non_zero = 0;
6554
        qmat = s->q_intra_matrix[qscale];
michaelni's avatar
michaelni committed
6555
        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
glantau's avatar
glantau committed
6556
    } else {
michael's avatar
michael committed
6557
        start_i = 0;
glantau's avatar
glantau committed
6558
        last_non_zero = -1;
6559
        qmat = s->q_inter_matrix[qscale];
michaelni's avatar
michaelni committed
6560
        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
glantau's avatar
glantau committed
6561
    }
michaelni's avatar
michaelni committed
6562 6563
    threshold1= (1<<QMAT_SHIFT) - bias - 1;
    threshold2= (threshold1<<1);
michael's avatar
michael committed
6564 6565 6566
    for(i=63;i>=start_i;i--) {
        j = scantable[i];
        level = block[j] * qmat[j];
glantau's avatar
glantau committed
6567

michael's avatar
michael committed
6568 6569 6570 6571 6572 6573 6574 6575
        if(((unsigned)(level+threshold1))>threshold2){
            last_non_zero = i;
            break;
        }else{
            block[j]=0;
        }
    }
    for(i=start_i; i<=last_non_zero; i++) {
michaelni's avatar
michaelni committed
6576
        j = scantable[i];
michael's avatar
michael committed
6577
        level = block[j] * qmat[j];
glantau's avatar
glantau committed
6578

michaelni's avatar
michaelni committed
6579 6580
//        if(   bias+level >= (1<<QMAT_SHIFT)
//           || bias-level >= (1<<QMAT_SHIFT)){
6581 6582
        if(((unsigned)(level+threshold1))>threshold2){
            if(level>0){
michaelni's avatar
michaelni committed
6583
                level= (bias + level)>>QMAT_SHIFT;
6584 6585
                block[j]= level;
            }else{
michaelni's avatar
michaelni committed
6586
                level= (bias - level)>>QMAT_SHIFT;
6587 6588 6589 6590 6591
                block[j]= -level;
            }
            max |=level;
        }else{
            block[j]=0;
glantau's avatar
glantau committed
6592 6593
        }
    }
6594
    *overflow= s->max_qcoeff < max; //overflow might have happened
6595

michaelni's avatar
michaelni committed
6596
    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6597
    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6598
        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
michaelni's avatar
michaelni committed
6599

glantau's avatar
glantau committed
6600 6601 6602
    return last_non_zero;
}

6603 6604
#endif //CONFIG_ENCODERS

6605
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6606
                                   DCTELEM *block, int n, int qscale)
glantau's avatar
glantau committed
6607
{
arpi_esp's avatar
arpi_esp committed
6608
    int i, level, nCoeffs;
kabi's avatar
kabi committed
6609
    const uint16_t *quant_matrix;
glantau's avatar
glantau committed
6610

6611
    nCoeffs= s->block_last_index[n];
6612 6613

    if (n < 4)
michael's avatar
michael committed
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;
    /* 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;
glantau's avatar
glantau committed
6631
            }
michael's avatar
michael committed
6632
            block[j] = level;
glantau's avatar
glantau committed
6633
        }
michael's avatar
michael committed
6634 6635 6636
    }
}

6637
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
michael's avatar
michael committed
6638 6639 6640 6641 6642 6643
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
    const uint16_t *quant_matrix;

    nCoeffs= s->block_last_index[n];
6644

michael's avatar
michael committed
6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659
    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;
glantau's avatar
glantau committed
6660
            }
michael's avatar
michael committed
6661
            block[j] = level;
glantau's avatar
glantau committed
6662 6663 6664
        }
    }
}
6665

6666
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6667 6668 6669
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
kabi's avatar
kabi committed
6670
    const uint16_t *quant_matrix;
6671

6672 6673
    if(s->alternate_scan) nCoeffs= 63;
    else nCoeffs= s->block_last_index[n];
6674 6675

    if (n < 4)
michael's avatar
michael committed
6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695
        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;
        }
    }
}

6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728
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;
}

6729
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
michael's avatar
michael committed
6730 6731 6732 6733 6734 6735 6736 6737
                                   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];
6738

michael's avatar
michael committed
6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759
    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;
}

6760
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
michael's avatar
michael committed
6761 6762 6763 6764
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
    int nCoeffs;
6765

michael's avatar
michael committed
6766
    assert(s->block_last_index[n]>=0);
6767

michael's avatar
michael committed
6768
    qmul = qscale << 1;
6769

michael's avatar
michael committed
6770
    if (!s->h263_aic) {
6771
        if (n < 4)
6772 6773 6774
            block[0] = block[0] * s->y_dc_scale;
        else
            block[0] = block[0] * s->c_dc_scale;
michael's avatar
michael committed
6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790
        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;
6791
            }
michael's avatar
michael committed
6792
            block[i] = level;
6793 6794 6795 6796
        }
    }
}

6797
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6798 6799 6800
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
arpi_esp's avatar
arpi_esp committed
6801
    int nCoeffs;
6802

6803
    assert(s->block_last_index[n]>=0);
6804

6805 6806
    qadd = (qscale - 1) | 1;
    qmul = qscale << 1;
6807

michael's avatar
michael committed
6808
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6809

michael's avatar
michael committed
6810
    for(i=0; i<=nCoeffs; i++) {
6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821
        level = block[i];
        if (level) {
            if (level < 0) {
                level = level * qmul - qadd;
            } else {
                level = level * qmul + qadd;
            }
            block[i] = level;
        }
    }
}
glantau's avatar
glantau committed
6822

6823
#ifdef CONFIG_ENCODERS
glantau's avatar
glantau committed
6824 6825 6826 6827 6828 6829 6830 6831
AVCodec h263_encoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6832
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
glantau's avatar
glantau committed
6833 6834 6835 6836 6837 6838 6839 6840 6841 6842
};

AVCodec h263p_encoder = {
    "h263p",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263P,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6843
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
glantau's avatar
glantau committed
6844 6845
};

6846 6847 6848 6849 6850 6851 6852 6853
AVCodec flv_encoder = {
    "flv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6854
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6855 6856
};

glantau's avatar
glantau committed
6857 6858 6859 6860 6861 6862 6863 6864
AVCodec rv10_encoder = {
    "rv10",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV10,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6865
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
glantau's avatar
glantau committed
6866 6867
};

michael's avatar
michael committed
6868 6869 6870 6871 6872 6873 6874 6875
AVCodec rv20_encoder = {
    "rv20",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV20,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6876
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
michael's avatar
michael committed
6877 6878
};

glantau's avatar
glantau committed
6879 6880
AVCodec mpeg4_encoder = {
    "mpeg4",
glantau's avatar
glantau committed
6881
    CODEC_TYPE_VIDEO,
glantau's avatar
glantau committed
6882
    CODEC_ID_MPEG4,
glantau's avatar
glantau committed
6883 6884 6885 6886
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6887
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6888
    .capabilities= CODEC_CAP_DELAY,
glantau's avatar
glantau committed
6889 6890
};

6891 6892 6893 6894 6895 6896 6897 6898
AVCodec msmpeg4v1_encoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6899
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6900 6901 6902 6903 6904 6905 6906 6907 6908 6909
};

AVCodec msmpeg4v2_encoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6910
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6911 6912 6913
};

AVCodec msmpeg4v3_encoder = {
glantau's avatar
glantau committed
6914 6915
    "msmpeg4",
    CODEC_TYPE_VIDEO,
6916
    CODEC_ID_MSMPEG4V3,
glantau's avatar
glantau committed
6917 6918 6919 6920
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6921
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
glantau's avatar
glantau committed
6922
};
michaelni's avatar
 
michaelni committed
6923 6924 6925 6926 6927 6928 6929 6930 6931

AVCodec wmv1_encoder = {
    "wmv1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV1,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
michael's avatar
michael committed
6932
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
michaelni's avatar
 
michaelni committed
6933 6934
};

michaelni's avatar
michaelni committed
6935 6936 6937 6938 6939 6940 6941 6942
AVCodec mjpeg_encoder = {
    "mjpeg",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MJPEG,
    sizeof(MpegEncContext),
    MPV_encode_init,
    MPV_encode_picture,
    MPV_encode_end,
bcoudurier's avatar
bcoudurier committed
6943
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, -1},
michaelni's avatar
michaelni committed
6944
};
6945 6946

#endif //CONFIG_ENCODERS