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

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

42
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
43
                                   DCTELEM *block, int n, int qscale);
44
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
45
                                   DCTELEM *block, int n, int qscale);
michael's avatar
michael committed
46 47
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale);
48 49
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale);
michael's avatar
michael committed
50 51
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
michael's avatar
michael committed
53
                                  DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55
                                  DCTELEM *block, int n, int qscale);
arpi_esp's avatar
arpi_esp committed
56

iive's avatar
iive committed
57 58
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
extern void XVMC_field_end(MpegEncContext *s);
59
extern void XVMC_decode_mb(MpegEncContext *s);
iive's avatar
iive committed
60

glantau's avatar
glantau committed
61 62 63 64 65 66

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

//#define DEBUG

67

michael's avatar
michael committed
68 69 70 71 72
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
};

73 74 75 76 77 78 79 80
const uint8_t ff_mpeg1_dc_scale_table[128]={
//  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
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
};

81

michael's avatar
michael committed
82 83 84
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
85 86 87 88
    assert(p<=end);
    if(p>=end)
        return end;

michael's avatar
michael committed
89 90 91 92 93 94 95 96
    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
97 98 99
        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
100 101 102 103 104 105
        else{
            p++;
            break;
        }
    }

michael's avatar
michael committed
106
    p= FFMIN(p, end)-4;
107
    *state= AV_RB32(p);
michael's avatar
michael committed
108 109 110 111

    return p+4;
}

112
/* init common dct for both encoder and decoder */
113
int ff_dct_common_init(MpegEncContext *s)
glantau's avatar
glantau committed
114
{
michael's avatar
michael committed
115 116 117 118 119
    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;
120 121
    if(s->flags & CODEC_FLAG_BITEXACT)
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
michael's avatar
michael committed
122
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
123

124
#if defined(HAVE_MMX)
125
    MPV_common_init_mmx(s);
126
#elif defined(ARCH_ALPHA)
127
    MPV_common_init_axp(s);
128
#elif defined(CONFIG_MLIB)
129
    MPV_common_init_mlib(s);
130
#elif defined(HAVE_MMI)
131
    MPV_common_init_mmi(s);
132
#elif defined(ARCH_ARMV4L)
133
    MPV_common_init_armv4l(s);
134
#elif defined(HAVE_ALTIVEC)
135
    MPV_common_init_altivec(s);
136
#elif defined(ARCH_BFIN)
137 138
    MPV_common_init_bfin(s);
#endif
139

140
    /* load & permutate scantables
141
       note: only wmv uses different ones
142
    */
michael's avatar
michael committed
143 144 145 146 147 148 149
    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
150 151
    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
152

153 154 155
    return 0;
}

benoit's avatar
benoit committed
156
void copy_picture(Picture *dst, Picture *src){
157 158 159 160
    *dst = *src;
    dst->type= FF_BUFFER_TYPE_COPY;
}

michaelni's avatar
michaelni committed
161
/**
michaelni's avatar
michaelni committed
162 163
 * allocates a Picture
 * The pixels are allocated/set by calling get_buffer() if shared=0
michaelni's avatar
michaelni committed
164
 */
benoit's avatar
benoit committed
165
int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
diego's avatar
diego committed
166
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
167
    const int mb_array_size= s->mb_stride*s->mb_height;
168 169
    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
170
    int i;
benoit's avatar
benoit committed
171
    int r= -1;
172

michaelni's avatar
michaelni committed
173 174 175 176 177 178
    if(shared){
        assert(pic->data[0]);
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
        pic->type= FF_BUFFER_TYPE_SHARED;
    }else{
        assert(!pic->data[0]);
179

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

michaelni's avatar
michaelni committed
182
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
183
            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
184 185 186 187
            return -1;
        }

        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
188
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
benoit's avatar
benoit committed
189
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
michaelni's avatar
michaelni committed
190 191 192 193
            return -1;
        }

        if(pic->linesize[1] != pic->linesize[2]){
diego's avatar
diego committed
194
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
benoit's avatar
benoit committed
195
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
michaelni's avatar
michaelni committed
196 197 198 199 200
            return -1;
        }

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

michaelni's avatar
michaelni committed
203
    if(pic->qscale_table==NULL){
204
        if (s->encoding) {
205 206 207
            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
208
        }
michaelni's avatar
michaelni committed
209

210
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
211
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
michael's avatar
michael committed
212 213
        CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
        pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
michaelni's avatar
michaelni committed
214 215
        if(s->out_format == FMT_H264){
            for(i=0; i<2; i++){
michael's avatar
michael committed
216 217
                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;
218
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
219
            }
michael's avatar
michael committed
220
            pic->motion_subsample_log2= 2;
221
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
222
            for(i=0; i<2; i++){
michael's avatar
michael committed
223 224
                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;
225
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
michaelni's avatar
michaelni committed
226
            }
michael's avatar
michael committed
227
            pic->motion_subsample_log2= 3;
michaelni's avatar
michaelni committed
228
        }
229 230 231
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
        }
232
        pic->qstride= s->mb_stride;
233
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
michaelni's avatar
michaelni committed
234
    }
michaelni's avatar
michaelni committed
235

diego's avatar
diego committed
236 237
    /* It might be nicer if the application would keep track of these
     * but it would require an API change. */
238
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
239
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
240
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
diego's avatar
diego committed
241
        pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
242

michaelni's avatar
michaelni committed
243 244
    return 0;
fail: //for the CHECKED_ALLOCZ macro
benoit's avatar
benoit committed
245 246
    if(r>=0)
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
michaelni's avatar
michaelni committed
247 248 249
    return -1;
}

michaelni's avatar
michaelni committed
250 251 252
/**
 * deallocates a picture
 */
michaelni's avatar
michaelni committed
253 254
static void free_picture(MpegEncContext *s, Picture *pic){
    int i;
michaelni's avatar
michaelni committed
255 256

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

michaelni's avatar
michaelni committed
260 261 262 263 264
    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
265
    av_freep(&pic->mb_type_base);
266
    av_freep(&pic->dct_coeff);
267
    av_freep(&pic->pan_scan);
michaelni's avatar
michaelni committed
268 269
    pic->mb_type= NULL;
    for(i=0; i<2; i++){
270
        av_freep(&pic->motion_val_base[i]);
michaelni's avatar
michaelni committed
271 272
        av_freep(&pic->ref_index[i]);
    }
273

274
    if(pic->type == FF_BUFFER_TYPE_SHARED){
michaelni's avatar
michaelni committed
275 276 277 278
        for(i=0; i<4; i++){
            pic->base[i]=
            pic->data[i]= NULL;
        }
279
        pic->type= 0;
michaelni's avatar
michaelni committed
280 281 282
    }
}

283 284 285
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
    int i;

286
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
lorenm's avatar
lorenm committed
287 288
    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;
289

diego's avatar
diego committed
290
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
291
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
292 293 294 295 296 297 298 299 300
    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))
        }
301
    }
302
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
    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);
318 319
    s->rd_scratchpad=
    s->b_scratchpad=
320
    s->obmc_scratchpad= NULL;
321

322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
    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);
346 347
    COPY(dct_count[0]);
    COPY(dct_count[1]);
348 349 350
#undef COPY
}

michael's avatar
michael committed
351
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
352
    MpegEncContext bak;
michael's avatar
michael committed
353
    int i;
354 355 356 357 358
    //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
359 360 361
    for(i=0;i<12;i++){
        dst->pblocks[i] = (short *)(&dst->block[i]);
    }
362 363 364
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
}

michael's avatar
michael committed
365 366 367 368
/**
 * 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.
 */
benoit's avatar
benoit committed
369
void MPV_common_defaults(MpegEncContext *s){
michael's avatar
michael committed
370 371 372 373 374 375 376 377 378 379 380 381
    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;
382 383 384

    s->f_code = 1;
    s->b_code = 1;
michael's avatar
michael committed
385 386 387 388 389 390 391 392 393 394
}

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

395
/**
michael's avatar
michael committed
396 397 398
 * init common structure for both encoder and decoder.
 * this assumes that some variables like width/height are already set
 */
399 400
int MPV_common_init(MpegEncContext *s)
{
401
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
402

lorenm's avatar
lorenm committed
403 404 405
    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
406 407 408 409
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
        return -1;
    }

410 411 412
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
        return -1;

413
    dsputil_init(&s->dsp, s->avctx);
414
    ff_dct_common_init(s);
415

416
    s->flags= s->avctx->flags;
417
    s->flags2= s->avctx->flags2;
418

michaelni's avatar
michaelni committed
419
    s->mb_width  = (s->width  + 15) / 16;
420
    s->mb_stride = s->mb_width + 1;
421 422
    s->b8_stride = s->mb_width*2 + 1;
    s->b4_stride = s->mb_width*4 + 1;
423
    mb_array_size= s->mb_height * s->mb_stride;
michael's avatar
michael committed
424
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
425

426 427 428 429
    /* set chroma shifts */
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
                                                    &(s->chroma_y_shift) );

430 431 432
    /* 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;
433 434

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

436 437 438
    s->block_wrap[0]=
    s->block_wrap[1]=
    s->block_wrap[2]=
439
    s->block_wrap[3]= s->b8_stride;
440
    s->block_wrap[4]=
441
    s->block_wrap[5]= s->mb_stride;
442

443 444
    y_size = s->b8_stride * (2 * s->mb_height + 1);
    c_size = s->mb_stride * (s->mb_height + 1);
445
    yc_size = y_size + 2 * c_size;
446

michaelni's avatar
michaelni committed
447
    /* convert fourcc to upper case */
448
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
michaelni's avatar
michaelni committed
449
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
450
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
michaelni's avatar
michaelni committed
451
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
452

453
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
454
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
455
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
456 457
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);

michaelni's avatar
michaelni committed
458
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
michaelni's avatar
michaelni committed
459

460 461 462 463 464 465 466
    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?
467

468
    if (s->encoding) {
469
        /* Allocate MV tables */
470 471 472 473 474 475 476 477 478 479 480 481
        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
482

483 484 485
        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
486
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
487 488

        /* Allocate MB type table */
michael's avatar
michael committed
489
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
490

491
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
492

493 494
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
495 496
        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
497 498
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
499

500 501 502
        if(s->avctx->noise_reduction){
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
        }
503
    }
504 505
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))

506
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
507

michael's avatar
michael committed
508
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
509
        /* interlaced direct mode decoding tables */
michael's avatar
michael committed
510 511 512 513 514 515 516 517 518 519 520 521 522
            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
523
    }
michaelni's avatar
michaelni committed
524
    if (s->out_format == FMT_H263) {
glantau's avatar
glantau committed
525
        /* ac values */
526 527 528
        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
529
        s->ac_val[2] = s->ac_val[1] + c_size;
530

glantau's avatar
glantau committed
531
        /* cbp values */
532 533
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
534

michaelni's avatar
 
michaelni committed
535
        /* cbp, ac_pred, pred_dir */
536 537
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
538
    }
539

540 541 542
    if (s->h263_pred || s->h263_plus || !s->encoding) {
        /* dc values */
        //MN: we need these for error resilience of intra-frames
543 544 545
        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;
546 547
        s->dc_val[2] = s->dc_val[1] + c_size;
        for(i=0;i<yc_size;i++)
548
            s->dc_val_base[i] = 1024;
549 550
    }

551
    /* which mb is a intra block */
552 553
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
    memset(s->mbintra_table, 1, mb_array_size);
554

555
    /* init macroblock skip table */
556
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
557
    //Note the +1 is for a quicker mpeg4 slice_end detection
558
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
559

560
    s->parse_context.state= -1;
561 562
    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);
563 564
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
565
    }
566

glantau's avatar
glantau committed
567
    s->context_initialized = 1;
568 569

    s->thread_context[0]= s;
570
    threads = s->avctx->thread_count;
571 572

    for(i=1; i<threads; i++){
573 574 575 576
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
    }

577
    for(i=0; i<threads; i++){
578 579 580 581 582 583
        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
584 585
    return 0;
 fail:
586
    MPV_common_end(s);
glantau's avatar
glantau committed
587 588 589 590 591 592
    return -1;
}

/* init common structure for both encoder and decoder */
void MPV_common_end(MpegEncContext *s)
{
michael's avatar
michael committed
593
    int i, j, k;
glantau's avatar
glantau committed
594

595 596 597 598 599 600 601
    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]);
    }

602 603 604
    av_freep(&s->parse_context.buffer);
    s->parse_context.buffer_size=0;

605
    av_freep(&s->mb_type);
606 607 608 609 610 611 612 613 614 615 616 617
    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
618 619 620 621 622 623 624 625 626 627 628 629
    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]);
    }
630

631 632 633
    av_freep(&s->dc_val_base);
    av_freep(&s->ac_val_base);
    av_freep(&s->coded_block_base);
634
    av_freep(&s->mbintra_table);
michaelni's avatar
 
michaelni committed
635 636
    av_freep(&s->cbp_table);
    av_freep(&s->pred_dir_table);
637

638
    av_freep(&s->mbskip_table);
639
    av_freep(&s->prev_pict_types);
640
    av_freep(&s->bitstream_buffer);
641 642
    s->allocated_bitstream_buffer_size=0;

michaelni's avatar
michaelni committed
643
    av_freep(&s->avctx->stats_out);
644
    av_freep(&s->ac_stats);
645
    av_freep(&s->error_status_table);
646
    av_freep(&s->mb_index2xy);
647
    av_freep(&s->lambda_table);
648 649
    av_freep(&s->q_intra_matrix);
    av_freep(&s->q_inter_matrix);
650 651
    av_freep(&s->q_intra_matrix16);
    av_freep(&s->q_inter_matrix16);
michael's avatar
michael committed
652 653
    av_freep(&s->input_picture);
    av_freep(&s->reordered_input_picture);
654
    av_freep(&s->dct_offset);
michaelni's avatar
michaelni committed
655

michael's avatar
michael committed
656 657 658 659
    if(s->picture){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
            free_picture(s, &s->picture[i]);
        }
glantau's avatar
glantau committed
660
    }
661
    av_freep(&s->picture);
glantau's avatar
glantau committed
662
    s->context_initialized = 0;
663 664 665
    s->last_picture_ptr=
    s->next_picture_ptr=
    s->current_picture_ptr= NULL;
michael's avatar
michael committed
666
    s->linesize= s->uvlinesize= 0;
667

668
    for(i=0; i<3; i++)
669
        av_freep(&s->visualization_buffer[i]);
michael's avatar
michael committed
670 671

    avcodec_default_free_buffers(s->avctx);
glantau's avatar
glantau committed
672 673
}

674
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
michaelni's avatar
michaelni committed
675
{
kabi's avatar
kabi committed
676 677
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
    uint8_t index_run[MAX_RUN+1];
michaelni's avatar
michaelni committed
678 679
    int last, run, level, start, end, i;

680
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
681
    if(static_store && rl->max_level[0])
682 683
        return;

michaelni's avatar
michaelni committed
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
    /* 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;
        }
707 708
        if(static_store)
            rl->max_level[last] = static_store[last];
709 710
        else
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
michaelni's avatar
michaelni committed
711
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
712 713
        if(static_store)
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
714 715
        else
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
michaelni's avatar
michaelni committed
716
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
717 718
        if(static_store)
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
719 720
        else
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
michaelni's avatar
michaelni committed
721 722 723 724
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
    }
}

725
void init_vlc_rl(RLTable *rl)
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
{
    int i, q;

    for(q=0; q<32; q++){
        int qmul= q*2;
        int qadd= (q-1)|1;

        if(q==0){
            qmul=1;
            qadd=0;
        }
        for(i=0; i<rl->vlc.table_size; i++){
            int code= rl->vlc.table[i][0];
            int len = rl->vlc.table[i][1];
            int level, run;

            if(len==0){ // illegal code
                run= 66;
                level= MAX_LEVEL;
            }else if(len<0){ //more bits needed
                run= 0;
                level= code;
            }else{
                if(code==rl->n){ //esc
                    run= 66;
                    level= 0;
                }else{
                    run=   rl->table_run  [code] + 1;
                    level= rl->table_level[code] * qmul + qadd;
                    if(code >= rl->last) run+=192;
                }
            }
            rl->rl_vlc[q][i].len= len;
            rl->rl_vlc[q][i].level= level;
            rl->rl_vlc[q][i].run= run;
        }
    }
}

michael's avatar
michael committed
765
int ff_find_unused_picture(MpegEncContext *s, int shared){
michaelni's avatar
michaelni committed
766
    int i;
767

michaelni's avatar
michaelni committed
768 769
    if(shared){
        for(i=0; i<MAX_PICTURE_COUNT; i++){
michael's avatar
michael committed
770
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
michaelni's avatar
michaelni committed
771 772 773
        }
    }else{
        for(i=0; i<MAX_PICTURE_COUNT; i++){
michael's avatar
michael committed
774
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
michaelni's avatar
michaelni committed
775 776
        }
        for(i=0; i<MAX_PICTURE_COUNT; i++){
michael's avatar
michael committed
777
            if(s->picture[i].data[0]==NULL) return i;
michaelni's avatar
michaelni committed
778 779 780
        }
    }

781
    av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
782 783 784 785 786 787 788 789 790 791 792
    /* We could return -1, but the codec would crash trying to draw into a
     * non-existing frame anyway. This is safer than waiting for a random crash.
     * Also the return of this is never useful, an encoder must only allocate
     * as much as allowed in the specification. This has no relationship to how
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
     * enough for such valid streams).
     * Plus, a decoder has to check stream validity and remove frames if too
     * many reference frames are around. Waiting for "OOM" is not correct at
     * all. Similarly, missing reference frames have to be replaced by
     * interpolated/MC frames, anything else is a bug in the codec ...
     */
793
    abort();
michael's avatar
michael committed
794
    return -1;
michaelni's avatar
michaelni committed
795 796
}

797 798 799 800 801 802 803 804 805 806
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;
        }
807

808 809 810 811 812 813
        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
814 815 816
/**
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
 */
817
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
glantau's avatar
glantau committed
818
{
michaelni's avatar
michaelni committed
819
    int i;
michaelni's avatar
michaelni committed
820
    AVFrame *pic;
821
    s->mb_skipped = 0;
michaelni's avatar
michaelni committed
822

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

michaelni's avatar
michaelni committed
825
    /* mark&release old frames */
826
    if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
827
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
michaelni's avatar
michaelni committed
828
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
michaelni's avatar
michaelni committed
829 830 831 832 833

        /* release forgotten pictures */
        /* if(mpeg124/h263) */
        if(!s->encoding){
            for(i=0; i<MAX_PICTURE_COUNT; i++){
michaelni's avatar
michaelni committed
834
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
835
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
836
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
michaelni's avatar
michaelni committed
837 838
                }
            }
839
        }
840
      }
841
    }
842 843
alloc:
    if(!s->encoding){
diego's avatar
diego committed
844
        /* release non reference frames */
michaelni's avatar
michaelni committed
845 846 847 848 849 850
        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
851
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
diego's avatar
diego committed
852
            pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
michael's avatar
michael committed
853 854 855 856 857
        else{
            i= ff_find_unused_picture(s, 0);
            pic= (AVFrame*)&s->picture[i];
        }

858 859 860 861
        pic->reference= 0;
        if (!s->dropable){
            if (s->codec_id == CODEC_ID_H264)
                pic->reference = s->picture_structure;
862
            else if (s->pict_type != FF_B_TYPE)
863 864
                pic->reference = 3;
        }
michaelni's avatar
michaelni committed
865

michael's avatar
michael committed
866
        pic->coded_picture_number= s->coded_picture_number++;
867

868 869
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
            return -1;
870

michael's avatar
michael committed
871
        s->current_picture_ptr= (Picture*)pic;
872
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
michael's avatar
michael committed
873
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
michaelni's avatar
michaelni committed
874
    }
875

michaelni's avatar
michaelni committed
876
    s->current_picture_ptr->pict_type= s->pict_type;
877
//    if(s->flags && CODEC_FLAG_QSCALE)
878
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
879
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
michaelni's avatar
michaelni committed
880

881
    copy_picture(&s->current_picture, s->current_picture_ptr);
882

883
    if (s->pict_type != FF_B_TYPE) {
michaelni's avatar
michaelni committed
884
        s->last_picture_ptr= s->next_picture_ptr;
michael's avatar
michael committed
885 886
        if(!s->dropable)
            s->next_picture_ptr= s->current_picture_ptr;
glantau's avatar
glantau committed
887
    }
michael's avatar
michael committed
888
/*    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,
889 890
        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
891 892
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
        s->pict_type, s->dropable);*/
893

894 895
    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);
896

897
    if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
898
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
899
        assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
900 901 902
        goto alloc;
    }

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

905
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
michaelni's avatar
michaelni committed
906 907 908 909
        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];
910
            }
michaelni's avatar
michaelni committed
911 912 913 914 915
            s->current_picture.linesize[i] *= 2;
            s->last_picture.linesize[i] *=2;
            s->next_picture.linesize[i] *=2;
        }
    }
916

917 918 919
    s->hurry_up= s->avctx->hurry_up;
    s->error_resilience= avctx->error_resilience;

diego's avatar
diego committed
920
    /* set dequantizer, we can't do it during init as it might change for mpeg4
diego's avatar
diego committed
921
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
michael's avatar
michael committed
922 923 924
    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
925
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
michael's avatar
michael committed
926 927 928 929 930 931
        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;
    }
932

933 934 935 936 937
    if(s->dct_error_sum){
        assert(s->avctx->noise_reduction && s->encoding);

        update_noise_reduction(s);
    }
938

iive's avatar
iive committed
939 940 941 942
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration)
        return XVMC_field_start(s, avctx);
#endif
943
    return 0;
glantau's avatar
glantau committed
944
}
945

glantau's avatar
glantau committed
946 947 948
/* generic function for encode/decode called after a frame has been coded/decoded */
void MPV_frame_end(MpegEncContext *s)
{
michaelni's avatar
michaelni committed
949
    int i;
glantau's avatar
glantau committed
950
    /* draw edge for correct motion prediction if outside */
iive's avatar
iive committed
951 952 953 954 955 956
#ifdef HAVE_XVMC
//just to make sure that all data is rendered.
    if(s->avctx->xvmc_acceleration){
        XVMC_field_end(s);
    }else
#endif
957
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
aurel's avatar
aurel committed
958 959 960
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
            s->dsp.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
961
    }
arpi_esp's avatar
arpi_esp committed
962
    emms_c();
963

michaelni's avatar
michaelni committed
964
    s->last_pict_type    = s->pict_type;
965
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
966
    if(s->pict_type!=FF_B_TYPE){
michaelni's avatar
michaelni committed
967 968
        s->last_non_b_pict_type= s->pict_type;
    }
michaelni's avatar
michaelni committed
969 970
#if 0
        /* copy back current_picture variables */
michaelni's avatar
michaelni committed
971 972 973 974
    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;
975
        }
michaelni's avatar
michaelni committed
976 977
    }
    assert(i<MAX_PICTURE_COUNT);
978
#endif
michaelni's avatar
michaelni committed
979

michaelni's avatar
michaelni committed
980
    if(s->encoding){
diego's avatar
diego committed
981
        /* release non-reference frames */
michaelni's avatar
michaelni committed
982 983 984 985 986
        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
987
    }
michaelni's avatar
michaelni committed
988 989 990 991 992 993
    // 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
994
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
glantau's avatar
glantau committed
995 996
}

997 998 999 1000 1001 1002 1003 1004
/**
 * 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
1005
    int x, y, fr, f;
1006

reimar's avatar
reimar committed
1007 1008 1009 1010
    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);
1011

1012
    buf[sy*stride + sx]+= color;
1013

diego's avatar
diego committed
1014
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1015
        if(sx > ex){
diego's avatar
diego committed
1016 1017
            FFSWAP(int, sx, ex);
            FFSWAP(int, sy, ey);
1018 1019 1020 1021 1022
        }
        buf+= sx + sy*stride;
        ex-= sx;
        f= ((ey-sy)<<16)/ex;
        for(x= 0; x <= ex; x++){
1023 1024 1025 1026
            y = (x*f)>>16;
            fr= (x*f)&0xFFFF;
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1027 1028 1029
        }
    }else{
        if(sy > ey){
diego's avatar
diego committed
1030 1031
            FFSWAP(int, sx, ex);
            FFSWAP(int, sy, ey);
1032 1033 1034 1035 1036 1037
        }
        buf+= sx + sy*stride;
        ey-= sy;
        if(ey) f= ((ex-sx)<<16)/ey;
        else   f= 0;
        for(y= 0; y <= ey; y++){
1038 1039
            x = (y*f)>>16;
            fr= (y*f)&0xFFFF;
michael's avatar
michael committed
1040 1041
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
            buf[y*stride + x+1]+= (color*         fr )>>16;
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
        }
    }
}

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

reimar's avatar
reimar committed
1056 1057 1058 1059
    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);
1060

1061 1062
    dx= ex - sx;
    dy= ey - sy;
1063

1064 1065 1066 1067
    if(dx*dx + dy*dy > 3*3){
        int rx=  dx + dy;
        int ry= -dx + dy;
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1068

1069 1070 1071
        //FIXME subpixel accuracy
        rx= ROUNDED_DIV(rx*3<<4, length);
        ry= ROUNDED_DIV(ry*3<<4, length);
1072

1073 1074 1075 1076 1077 1078
        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);
}

1079 1080 1081
/**
 * prints debuging info for the given picture.
 */
1082
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1083 1084 1085 1086 1087

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

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

1089 1090 1091 1092 1093 1094 1095
        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;
1096
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1097
        }
1098 1099 1100 1101 1102
        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;
1103
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1104 1105
                }
                if(s->avctx->debug&FF_DEBUG_QP){
1106
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1107 1108 1109 1110 1111
                }
                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))
1112
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1113
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1114
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1115
                    else if(IS_INTRA4x4(mb_type))
1116
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1117
                    else if(IS_INTRA16x16(mb_type))
1118
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1119
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1120
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1121
                    else if(IS_DIRECT(mb_type))
1122
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1123
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1124
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1125
                    else if(IS_GMC(mb_type))
1126
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1127
                    else if(IS_SKIP(mb_type))
1128
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1129
                    else if(!USES_LIST(mb_type, 1))
1130
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1131
                    else if(!USES_LIST(mb_type, 0))
1132
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1133 1134
                    else{
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1135
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1136
                    }
1137

1138 1139
                    //segmentation
                    if(IS_8X8(mb_type))
1140
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1141
                    else if(IS_16X8(mb_type))
1142
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1143
                    else if(IS_8X16(mb_type))
mru's avatar
mru committed
1144
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1145
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1146
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1147
                    else
1148
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1149 1150


1151
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1152
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1153
                    else
1154
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1155
                }
1156
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1157
            }
1158
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1159 1160
        }
    }
1161

1162
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1163 1164
        const int shift= 1 + s->quarter_sample;
        int mb_y;
1165 1166
        uint8_t *ptr;
        int i;
1167
        int h_chroma_shift, v_chroma_shift, block_height;
1168 1169
        const int width = s->avctx->width;
        const int height= s->avctx->height;
1170
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1171
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
michael's avatar
michael committed
1172
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1173

1174
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1175
        for(i=0; i<3; i++){
1176
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1177 1178 1179 1180
            pict->data[i]= s->visualization_buffer[i];
        }
        pict->type= FF_BUFFER_TYPE_COPY;
        ptr= pict->data[0];
1181
        block_height = 16>>v_chroma_shift;
1182 1183 1184 1185 1186

        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;
1187 1188 1189
                if((s->avctx->debug_mv) && pict->motion_val){
                  int type;
                  for(type=0; type<3; type++){
1190
                    int direction = 0;
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
                    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;
                    }
1205 1206 1207
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
                        continue;

1208 1209 1210
                    if(IS_8X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<4; i++){
1211 1212
                        int sx= mb_x*16 + 4 + 8*(i&1);
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1213
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1214 1215
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1216
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1217 1218 1219 1220
                      }
                    }else if(IS_16X8(pict->mb_type[mb_index])){
                      int i;
                      for(i=0; i<2; i++){
1221 1222
                        int sx=mb_x*16 + 8;
                        int sy=mb_y*16 + 4 + 8*i;
1223
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1224 1225
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1226

1227 1228
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1229

1230 1231 1232 1233 1234 1235 1236
                        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;
1237
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1238 1239
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1240

1241 1242
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
                            my*=2;
1243

1244
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1245 1246 1247 1248
                      }
                    }else{
                      int sx= mb_x*16 + 8;
                      int sy= mb_y*16 + 8;
1249
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1250 1251
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1252
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1253
                    }
1254
                  }
michael's avatar
michael committed
1255 1256 1257 1258
                }
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
                    int y;
1259 1260 1261
                    for(y=0; y<block_height; y++){
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
michael's avatar
michael committed
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
                    }
                }
                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));

1272

michael's avatar
michael committed
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
                    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;
1301 1302 1303
                    for(y=0; y<block_height; y++){
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
michael's avatar
michael committed
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
                    }

                    //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;
                    }
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
                    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;
                        }
                    }
1330

michael's avatar
michael committed
1331 1332 1333
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
                        // hmm
                    }
1334 1335 1336 1337 1338
                }
                s->mbskip_table[mb_index]=0;
            }
        }
    }
1339 1340
}

1341
static inline int hpel_motion_lowres(MpegEncContext *s,
michael's avatar
michael committed
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
                                  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);
1364

michael's avatar
michael committed
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
    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
1383
/* apply one mpeg motion vector to the three components */
benoit's avatar
benoit committed
1384
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
kabi's avatar
kabi committed
1385
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1386
                               int field_based, int bottom_field, int field_select,
benoit's avatar
benoit committed
1387
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
glantau's avatar
glantau committed
1388 1389
                               int motion_x, int motion_y, int h)
{
1390
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
benoit's avatar
benoit committed
1391 1392 1393 1394 1395 1396
    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;
1397
    linesize   = s->current_picture.linesize[0] << field_based;
michaelni's avatar
michaelni committed
1398
    uvlinesize = s->current_picture.linesize[1] << field_based;
1399

1400
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
benoit's avatar
benoit committed
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
        motion_x/=2;
        motion_y/=2;
    }

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

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

michael's avatar
michael committed
1414
    if (s->out_format == FMT_H263) {
michael's avatar
michael committed
1415 1416
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
michael's avatar
michael committed
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
        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
1432
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
michael's avatar
michael committed
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
    }

    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;
1444
            if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
michael's avatar
michael committed
1445
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1446
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
michael's avatar
michael committed
1447
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1448
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
michael's avatar
michael committed
1449 1450 1451 1452 1453 1454
                                 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
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
    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
1467 1468 1469
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1470

1471
    if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
michael's avatar
michael committed
1472 1473 1474 1475 1476
        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
1477
    //FIXME h261 lowres loop filter
michael's avatar
michael committed
1478 1479
}

michael's avatar
michael committed
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
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;
1492

michael's avatar
michael committed
1493 1494 1495 1496 1497 1498 1499 1500 1501
    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);
1502

michael's avatar
michael committed
1503 1504 1505 1506
    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));
1507

michael's avatar
michael committed
1508 1509 1510 1511 1512 1513 1514 1515 1516
    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;
        }
1517
    }
michael's avatar
michael committed
1518 1519 1520
    sx <<= 2 - lowres;
    sy <<= 2 - lowres;
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1521

michael's avatar
michael committed
1522 1523 1524 1525 1526 1527 1528 1529
    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);
}

michaelni's avatar
doxy  
michaelni committed
1530
/**
diego's avatar
diego committed
1531
 * motion compensation of a single macroblock
michaelni's avatar
doxy  
michaelni committed
1532 1533 1534 1535 1536 1537 1538 1539 1540
 * @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
 */
benoit's avatar
benoit committed
1541
static inline void MPV_motion_lowres(MpegEncContext *s,
kabi's avatar
kabi committed
1542
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1543
                              int dir, uint8_t **ref_picture,
benoit's avatar
benoit committed
1544
                              h264_chroma_mc_func *pix_op)
glantau's avatar
glantau committed
1545
{
benoit's avatar
benoit committed
1546
    int mx, my;
glantau's avatar
glantau committed
1547
    int mb_x, mb_y, i;
benoit's avatar
benoit committed
1548 1549
    const int lowres= s->avctx->lowres;
    const int block_s= 8>>lowres;
glantau's avatar
glantau committed
1550 1551 1552 1553 1554 1555

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

    switch(s->mv_type) {
    case MV_TYPE_16X16:
benoit's avatar
benoit committed
1556 1557 1558 1559
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
                    0, 0, 0,
                    ref_picture, pix_op,
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
glantau's avatar
glantau committed
1560 1561
        break;
    case MV_TYPE_8X8:
michaelni's avatar
michaelni committed
1562 1563 1564
        mx = 0;
        my = 0;
            for(i=0;i<4;i++) {
benoit's avatar
benoit committed
1565
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1566
                            ref_picture[0], 0, 0,
benoit's avatar
benoit committed
1567
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
michael's avatar
michael committed
1568
                            s->width, s->height, s->linesize,
benoit's avatar
benoit committed
1569 1570
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
                            block_s, block_s, pix_op,
michael's avatar
michael committed
1571
                            s->mv[dir][i][0], s->mv[dir][i][1]);
michaelni's avatar
michaelni committed
1572 1573 1574

                mx += s->mv[dir][i][0];
                my += s->mv[dir][i][1];
michaelni's avatar
michaelni committed
1575
            }
michaelni's avatar
michaelni committed
1576

1577
        if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
benoit's avatar
benoit committed
1578
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
glantau's avatar
glantau committed
1579 1580 1581
        break;
    case MV_TYPE_FIELD:
        if (s->picture_structure == PICT_FRAME) {
benoit's avatar
benoit committed
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
            /* top field */
            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);
glantau's avatar
glantau committed
1592
        } else {
1593
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1594
                ref_picture= s->current_picture_ptr->data;
1595
            }
glantau's avatar
glantau committed
1596

benoit's avatar
benoit committed
1597
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1598 1599
                        0, 0, s->field_select[dir][0],
                        ref_picture, pix_op,
benoit's avatar
benoit committed
1600
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
glantau's avatar
glantau committed
1601
        }
1602
        break;
michael's avatar
michael committed
1603 1604 1605
    case MV_TYPE_16X8:
        for(i=0; i<2; i++){
            uint8_t ** ref2picture;
1606

1607
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1608 1609
                ref2picture= ref_picture;
            }else{
1610
                ref2picture= s->current_picture_ptr->data;
1611
            }
1612

benoit's avatar
benoit committed
1613
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
1614
                        0, 0, s->field_select[dir][i],
1615
                        ref2picture, pix_op,
benoit's avatar
benoit committed
1616
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1617

benoit's avatar
benoit committed
1618 1619 1620
            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;
1621
        }
glantau's avatar
glantau committed
1622
        break;
1623 1624
    case MV_TYPE_DMV:
        if(s->picture_structure == PICT_FRAME){
michael's avatar
michael committed
1625 1626 1627
            for(i=0; i<2; i++){
                int j;
                for(j=0; j<2; j++){
benoit's avatar
benoit committed
1628
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
1629 1630
                                1, j, j^i,
                                ref_picture, pix_op,
benoit's avatar
benoit committed
1631
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
michael's avatar
michael committed
1632
                }
benoit's avatar
benoit committed
1633
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
michael's avatar
michael committed
1634
            }
1635
        }else{
michael's avatar
michael committed
1636
            for(i=0; i<2; i++){
benoit's avatar
benoit committed
1637
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
michael's avatar
michael committed
1638 1639
                            0, 0, s->picture_structure != i+1,
                            ref_picture, pix_op,
benoit's avatar
benoit committed
1640
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1641

michael's avatar
michael committed
1642
                // after put we make avg of the same block
benoit's avatar
benoit committed
1643
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1644

michael's avatar
michael committed
1645 1646
                //opposite parity is always in the same frame if this is second field
                if(!s->first_field){
1647
                    ref_picture = s->current_picture_ptr->data;
michael's avatar
michael committed
1648
                }
1649
            }
1650 1651
        }
    break;
michael's avatar
michael committed
1652
    default: assert(0);
glantau's avatar
glantau committed
1653 1654 1655
    }
}

benoit's avatar
benoit committed
1656 1657 1658
/* put block[] to dest[] */
static inline void put_dct(MpegEncContext *s,
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
michael's avatar
michael committed
1659
{
benoit's avatar
benoit committed
1660 1661 1662
    s->dct_unquantize_intra(s, block, i, qscale);
    s->dsp.idct_put (dest, line_size, block);
}
michael's avatar
michael committed
1663

benoit's avatar
benoit committed
1664 1665 1666 1667 1668 1669 1670 1671
/* add block[] to dest[] */
static inline void add_dct(MpegEncContext *s,
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
{
    if (s->block_last_index[i] >= 0) {
        s->dsp.idct_add (dest, line_size, block);
    }
}
1672

1673
static inline void add_dequant_dct(MpegEncContext *s,
michael's avatar
michael committed
1674
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
michaelni's avatar
 
michaelni committed
1675
{
glantau's avatar
glantau committed
1676
    if (s->block_last_index[i] >= 0) {
michael's avatar
michael committed
1677
        s->dct_unquantize_inter(s, block, i, qscale);
1678

1679
        s->dsp.idct_add (dest, line_size, block);
glantau's avatar
glantau committed
1680 1681 1682
    }
}

michaelni's avatar
 
michaelni committed
1683 1684 1685 1686 1687
/**
 * cleans dc, ac, coded_block for the current non intra MB
 */
void ff_clean_intra_table_entries(MpegEncContext *s)
{
1688
    int wrap = s->b8_stride;
michaelni's avatar
 
michaelni committed
1689
    int xy = s->block_index[0];
1690 1691 1692

    s->dc_val[0][xy           ] =
    s->dc_val[0][xy + 1       ] =
michaelni's avatar
 
michaelni committed
1693 1694 1695
    s->dc_val[0][xy     + wrap] =
    s->dc_val[0][xy + 1 + wrap] = 1024;
    /* ac pred */
kabi's avatar
kabi committed
1696 1697
    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
1698 1699 1700 1701 1702 1703 1704
    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 */
1705 1706
    wrap = s->mb_stride;
    xy = s->mb_x + s->mb_y * wrap;
michaelni's avatar
 
michaelni committed
1707 1708 1709
    s->dc_val[1][xy] =
    s->dc_val[2][xy] = 1024;
    /* ac pred */
kabi's avatar
kabi committed
1710 1711
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1712

1713
    s->mbintra_table[xy]= 0;
michaelni's avatar
 
michaelni committed
1714 1715
}

glantau's avatar
glantau committed
1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
/* 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)
 */
1726 1727
static av_always_inline
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
benoit's avatar
benoit committed
1728
                            int lowres_flag, int is_mpeg12)
glantau's avatar
glantau committed
1729
{
1730
    int mb_x, mb_y;
1731
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
iive's avatar
iive committed
1732 1733
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration){
1734
        XVMC_decode_mb(s);//xvmc uses pblocks
iive's avatar
iive committed
1735 1736 1737
        return;
    }
#endif
glantau's avatar
glantau committed
1738 1739 1740 1741

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

1742 1743 1744 1745 1746 1747 1748 1749 1750
    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
1751
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1752

glantau's avatar
glantau committed
1753 1754
    /* update DC predictors for P macroblocks */
    if (!s->mb_intra) {
benoit's avatar
benoit committed
1755
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
michaelni's avatar
 
michaelni committed
1756
            if(s->mbintra_table[mb_xy])
michaelni's avatar
 
michaelni committed
1757
                ff_clean_intra_table_entries(s);
glantau's avatar
glantau committed
1758
        } else {
michaelni's avatar
 
michaelni committed
1759 1760
            s->last_dc[0] =
            s->last_dc[1] =
glantau's avatar
glantau committed
1761 1762 1763
            s->last_dc[2] = 128 << s->intra_dc_precision;
        }
    }
benoit's avatar
benoit committed
1764
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
michaelni's avatar
 
michaelni committed
1765
        s->mbintra_table[mb_xy]=1;
1766

1767
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
kabi's avatar
kabi committed
1768
        uint8_t *dest_y, *dest_cb, *dest_cr;
michaelni's avatar
 
michaelni committed
1769
        int dct_linesize, dct_offset;
michaelni's avatar
michaelni committed
1770 1771
        op_pixels_func (*op_pix)[4];
        qpel_mc_func (*op_qpix)[16];
1772
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
michaelni's avatar
michaelni committed
1773
        const int uvlinesize= s->current_picture.linesize[1];
1774
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
michael's avatar
michael committed
1775
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1776

michaelni's avatar
michaelni committed
1777 1778 1779
        /* 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
1780
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
michaelni's avatar
michaelni committed
1781
            const int age= s->current_picture.age;
michaelni's avatar
michaelni committed
1782

michaelni's avatar
michaelni committed
1783 1784
            assert(age);

1785 1786
            if (s->mb_skipped) {
                s->mb_skipped= 0;
1787
                assert(s->pict_type!=FF_I_TYPE);
1788

1789
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
michaelni's avatar
michaelni committed
1790 1791
                if(*mbskip_ptr >99) *mbskip_ptr= 99;

michaelni's avatar
michaelni committed
1792
                /* if previous was skipped too, then nothing to do !  */
1793 1794
                if (*mbskip_ptr >= age && s->current_picture.reference){
                    return;
michaelni's avatar
michaelni committed
1795
                }
1796 1797 1798 1799
            } 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{
1800 1801
                *mbskip_ptr = 0; /* not skipped */
            }
michaelni's avatar
michaelni committed
1802
        }
1803

1804
        dct_linesize = linesize << s->interlaced_dct;
michael's avatar
michael committed
1805
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1806

1807 1808 1809 1810 1811
        if(readable){
            dest_y=  s->dest[0];
            dest_cb= s->dest[1];
            dest_cr= s->dest[2];
        }else{
1812
            dest_y = s->b_scratchpad;
michael's avatar
michael committed
1813
            dest_cb= s->b_scratchpad+16*linesize;
1814
            dest_cr= s->b_scratchpad+32*linesize;
1815
        }
michael's avatar
michael committed
1816

glantau's avatar
glantau committed
1817 1818
        if (!s->mb_intra) {
            /* motion handling */
1819
            /* decoding or more than one mb_type (MC was already done otherwise) */
1820
            if(!s->encoding){
michael's avatar
michael committed
1821 1822
                if(lowres_flag){
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
glantau's avatar
glantau committed
1823

michael's avatar
michael committed
1824 1825 1826 1827 1828 1829 1830 1831
                    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{
1832
                    op_qpix= s->me.qpel_put;
1833
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
michael's avatar
michael committed
1834 1835 1836 1837 1838 1839 1840
                        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;
1841
                        op_qpix= s->me.qpel_avg;
michael's avatar
michael committed
1842 1843 1844 1845
                    }
                    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);
                    }
1846
                }
glantau's avatar
glantau committed
1847 1848
            }

michaelni's avatar
 
michaelni committed
1849
            /* skip dequant / idct if we are really late ;) */
michael's avatar
michael committed
1850 1851
            if(s->hurry_up>1) goto skip_idct;
            if(s->avctx->skip_idct){
1852 1853
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
michael's avatar
michael committed
1854 1855 1856
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
                    goto skip_idct;
            }
michaelni's avatar
 
michaelni committed
1857

glantau's avatar
glantau committed
1858
            /* add dct residue */
michaelni's avatar
michaelni committed
1859
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
michaelni's avatar
michaelni committed
1860
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
michael's avatar
michael committed
1861 1862 1863 1864
                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
1865

1866
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
bcoudurier's avatar
bcoudurier committed
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
                    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
1878
                }
benoit's avatar
benoit committed
1879
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
michael's avatar
michael committed
1880 1881 1882 1883
                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
1884

1885
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
                    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
            }
1907
            else if (ENABLE_WMV2) {
michaelni's avatar
michaelni committed
1908
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
michaelni's avatar
 
michaelni committed
1909
            }
glantau's avatar
glantau committed
1910 1911
        } else {
            /* dct only in intra block */
michaelni's avatar
michaelni committed
1912
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
michael's avatar
michael committed
1913 1914 1915 1916
                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
1917

1918
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
bcoudurier's avatar
bcoudurier committed
1919 1920 1921 1922 1923 1924 1925 1926 1927
                    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);
benoit's avatar
benoit committed
1928
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
michaelni's avatar
michaelni committed
1929 1930 1931
                    }
                }
            }else{
benoit's avatar
benoit committed
1932 1933 1934 1935
                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]);
michael's avatar
michael committed
1936

1937
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
benoit's avatar
benoit committed
1938 1939 1940 1941
                    if(s->chroma_y_shift){
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
                    }else{
michael's avatar
michael committed
1942

benoit's avatar
benoit committed
1943 1944
                        dct_linesize = uvlinesize << s->interlaced_dct;
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
michaelni's avatar
michaelni committed
1945

benoit's avatar
benoit committed
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
                        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
1958
            }
michaelni's avatar
michaelni committed
1959
        }
benoit's avatar
benoit committed
1960 1961 1962 1963 1964
skip_idct:
        if(!readable){
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
            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);
1965
        }
michaelni's avatar
michaelni committed
1966 1967 1968
    }
}

benoit's avatar
benoit committed
1969
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
benoit's avatar
benoit committed
1970 1971 1972 1973 1974 1975 1976 1977
#ifndef CONFIG_SMALL
    if(s->out_format == FMT_MPEG1) {
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
        else                 MPV_decode_mb_internal(s, block, 0, 1);
    } else
#endif
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
    else                  MPV_decode_mb_internal(s, block, 0, 0);
michael's avatar
michael committed
1978 1979
}

benoit's avatar
benoit committed
1980 1981 1982 1983 1984 1985 1986 1987
/**
 *
 * @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){
    if (s->avctx->draw_horiz_band) {
        AVFrame *src;
        int offset[4];
michael's avatar
michael committed
1988

benoit's avatar
benoit committed
1989 1990 1991 1992
        if(s->picture_structure != PICT_FRAME){
            h <<= 1;
            y <<= 1;
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
michael's avatar
michael committed
1993 1994
        }

benoit's avatar
benoit committed
1995
        h= FFMIN(h, s->avctx->height - y);
michael's avatar
michael committed
1996

1997
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
benoit's avatar
benoit committed
1998 1999 2000 2001 2002
            src= (AVFrame*)s->current_picture_ptr;
        else if(s->last_picture_ptr)
            src= (AVFrame*)s->last_picture_ptr;
        else
            return;
2003

2004
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
benoit's avatar
benoit committed
2005 2006 2007 2008
            offset[0]=
            offset[1]=
            offset[2]=
            offset[3]= 0;
michael's avatar
michael committed
2009
        }else{
michael's avatar
michael committed
2010
            offset[0]= y * s->linesize;
benoit's avatar
benoit committed
2011 2012 2013
            offset[1]=
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
            offset[3]= 0;
michael's avatar
michael committed
2014
        }
2015

benoit's avatar
benoit committed
2016
        emms_c();
michael's avatar
michael committed
2017

benoit's avatar
benoit committed
2018 2019 2020 2021
        s->avctx->draw_horiz_band(s->avctx, src, offset,
                                  y, s->picture_structure, h);
    }
}
2022

benoit's avatar
benoit committed
2023 2024 2025 2026
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
    const int uvlinesize= s->current_picture.linesize[1];
    const int mb_size= 4 - s->avctx->lowres;
michael's avatar
michael committed
2027

benoit's avatar
benoit committed
2028 2029 2030 2031 2032 2033 2034
    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;
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2035

benoit's avatar
benoit committed
2036 2037 2038
    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));
2039

2040
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
benoit's avatar
benoit committed
2041 2042 2043 2044
    {
        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);
michael's avatar
michael committed
2045 2046
    }
}
2047

benoit's avatar
benoit committed
2048 2049 2050
void ff_mpeg_flush(AVCodecContext *avctx){
    int i;
    MpegEncContext *s = avctx->priv_data;
michael's avatar
michael committed
2051

benoit's avatar
benoit committed
2052 2053
    if(s==NULL || s->picture==NULL)
        return;
michael's avatar
michael committed
2054

benoit's avatar
benoit committed
2055 2056 2057 2058
    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]);
glantau's avatar
glantau committed
2059
    }
benoit's avatar
benoit committed
2060
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2061

benoit's avatar
benoit committed
2062
    s->mb_x= s->mb_y= 0;
michaelni's avatar
michaelni committed
2063

benoit's avatar
benoit committed
2064 2065 2066 2067 2068 2069 2070 2071
    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;
    s->bitstream_buffer_size=0;
    s->pp_time=0;
glantau's avatar
glantau committed
2072 2073
}

2074
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2075
                                   DCTELEM *block, int n, int qscale)
glantau's avatar
glantau committed
2076
{
arpi_esp's avatar
arpi_esp committed
2077
    int i, level, nCoeffs;
kabi's avatar
kabi committed
2078
    const uint16_t *quant_matrix;
glantau's avatar
glantau committed
2079

2080
    nCoeffs= s->block_last_index[n];
2081 2082

    if (n < 4)
michael's avatar
michael committed
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
        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
2100
            }
michael's avatar
michael committed
2101
            block[j] = level;
glantau's avatar
glantau committed
2102
        }
michael's avatar
michael committed
2103 2104 2105
    }
}

2106
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
michael's avatar
michael committed
2107 2108 2109 2110 2111 2112
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
    const uint16_t *quant_matrix;

    nCoeffs= s->block_last_index[n];
2113

michael's avatar
michael committed
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
    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
2129
            }
michael's avatar
michael committed
2130
            block[j] = level;
glantau's avatar
glantau committed
2131 2132 2133
        }
    }
}
2134

2135
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2136 2137 2138
                                   DCTELEM *block, int n, int qscale)
{
    int i, level, nCoeffs;
kabi's avatar
kabi committed
2139
    const uint16_t *quant_matrix;
2140

2141 2142
    if(s->alternate_scan) nCoeffs= 63;
    else nCoeffs= s->block_last_index[n];
2143 2144

    if (n < 4)
michael's avatar
michael committed
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
        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;
        }
    }
}

2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
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;
}

2198
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
michael's avatar
michael committed
2199 2200 2201 2202 2203 2204 2205 2206
                                   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];
2207

michael's avatar
michael committed
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
    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;
}

2229
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
michael's avatar
michael committed
2230 2231 2232 2233
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
    int nCoeffs;
2234

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

michael's avatar
michael committed
2237
    qmul = qscale << 1;
2238

michael's avatar
michael committed
2239
    if (!s->h263_aic) {
2240
        if (n < 4)
2241 2242 2243
            block[0] = block[0] * s->y_dc_scale;
        else
            block[0] = block[0] * s->c_dc_scale;
michael's avatar
michael committed
2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
        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;
2260
            }
michael's avatar
michael committed
2261
            block[i] = level;
2262 2263 2264 2265
        }
    }
}

2266
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2267 2268 2269
                                  DCTELEM *block, int n, int qscale)
{
    int i, level, qmul, qadd;
arpi_esp's avatar
arpi_esp committed
2270
    int nCoeffs;
2271

2272
    assert(s->block_last_index[n]>=0);
2273

2274 2275
    qadd = (qscale - 1) | 1;
    qmul = qscale << 1;
2276

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

michael's avatar
michael committed
2279
    for(i=0; i<=nCoeffs; i++) {
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
        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
2291

2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
/**
 * set qscale and update qscale dependent variables.
 */
void ff_set_qscale(MpegEncContext * s, int qscale)
{
    if (qscale < 1)
        qscale = 1;
    else if (qscale > 31)
        qscale = 31;

    s->qscale = qscale;
    s->chroma_qscale= s->chroma_qscale_table[qscale];

    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
}