Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ f62a9a46

History | View | Annotate | Download (89.2 KB)

1
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
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
23
 */
24

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

    
30
#include "avcodec.h"
31
#include "dsputil.h"
32
#include "mpegvideo.h"
33
#include "mpegvideo_common.h"
34
#include "mjpegenc.h"
35
#include "msmpeg4.h"
36
#include "faandct.h"
37
#include <limits.h>
38

    
39
//#undef NDEBUG
40
//#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);
46
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
47
                                   DCTELEM *block, int n, int qscale);
48
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
49
                                   DCTELEM *block, int n, int qscale);
50
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53
                                  DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55
                                  DCTELEM *block, int n, int qscale);
56
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57

    
58
#ifdef HAVE_XVMC
59
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
60
extern void XVMC_field_end(MpegEncContext *s);
61
extern void XVMC_decode_mb(MpegEncContext *s);
62
#endif
63

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

    
66

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

    
70
//#define DEBUG
71

    
72

    
73
static const uint8_t ff_default_chroma_qscale_table[32]={
74
//  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
75
    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
76
};
77

    
78
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
79
    int i;
80
    int end;
81

    
82
    st->scantable= src_scantable;
83

    
84
    for(i=0; i<64; i++){
85
        int j;
86
        j = src_scantable[i];
87
        st->permutated[i] = permutation[j];
88
#ifdef ARCH_POWERPC
89
        st->inverse[j] = i;
90
#endif
91
    }
92

    
93
    end=-1;
94
    for(i=0; i<64; i++){
95
        int j;
96
        j = st->permutated[i];
97
        if(j>end) end=j;
98
        st->raster_end[i]= end;
99
    }
100
}
101

    
102
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
103
    int i;
104

    
105
    assert(p<=end);
106
    if(p>=end)
107
        return end;
108

    
109
    for(i=0; i<3; i++){
110
        uint32_t tmp= *state << 8;
111
        *state= tmp + *(p++);
112
        if(tmp == 0x100 || p==end)
113
            return p;
114
    }
115

    
116
    while(p<end){
117
        if     (p[-1] > 1      ) p+= 3;
118
        else if(p[-2]          ) p+= 2;
119
        else if(p[-3]|(p[-1]-1)) p++;
120
        else{
121
            p++;
122
            break;
123
        }
124
    }
125

    
126
    p= FFMIN(p, end)-4;
127
    *state= AV_RB32(p);
128

    
129
    return p+4;
130
}
131

    
132
/* init common dct for both encoder and decoder */
133
static int DCT_common_init(MpegEncContext *s)
134
{
135
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
136
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
137
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
138
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
139
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
140
    if(s->flags & CODEC_FLAG_BITEXACT)
141
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
142
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
143

    
144
#if defined(HAVE_MMX)
145
    MPV_common_init_mmx(s);
146
#elif defined(ARCH_ALPHA)
147
    MPV_common_init_axp(s);
148
#elif defined(HAVE_MLIB)
149
    MPV_common_init_mlib(s);
150
#elif defined(HAVE_MMI)
151
    MPV_common_init_mmi(s);
152
#elif defined(ARCH_ARMV4L)
153
    MPV_common_init_armv4l(s);
154
#elif defined(HAVE_ALTIVEC)
155
    MPV_common_init_altivec(s);
156
#elif defined(ARCH_BFIN)
157
    MPV_common_init_bfin(s);
158
#endif
159

    
160
    /* load & permutate scantables
161
       note: only wmv uses different ones
162
    */
163
    if(s->alternate_scan){
164
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
165
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
166
    }else{
167
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
168
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
169
    }
170
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
171
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
172

    
173
    return 0;
174
}
175

    
176
void copy_picture(Picture *dst, Picture *src){
177
    *dst = *src;
178
    dst->type= FF_BUFFER_TYPE_COPY;
179
}
180

    
181
/**
182
 * allocates a Picture
183
 * The pixels are allocated/set by calling get_buffer() if shared=0
184
 */
185
int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
186
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
187
    const int mb_array_size= s->mb_stride*s->mb_height;
188
    const int b8_array_size= s->b8_stride*s->mb_height*2;
189
    const int b4_array_size= s->b4_stride*s->mb_height*4;
190
    int i;
191
    int r= -1;
192

    
193
    if(shared){
194
        assert(pic->data[0]);
195
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
196
        pic->type= FF_BUFFER_TYPE_SHARED;
197
    }else{
198
        assert(!pic->data[0]);
199

    
200
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
201

    
202
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
203
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
204
            return -1;
205
        }
206

    
207
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
208
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
209
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
210
            return -1;
211
        }
212

    
213
        if(pic->linesize[1] != pic->linesize[2]){
214
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
215
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
216
            return -1;
217
        }
218

    
219
        s->linesize  = pic->linesize[0];
220
        s->uvlinesize= pic->linesize[1];
221
    }
222

    
223
    if(pic->qscale_table==NULL){
224
        if (s->encoding) {
225
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
226
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
227
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
228
        }
229

    
230
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
231
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
232
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
233
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
234
        if(s->out_format == FMT_H264){
235
            for(i=0; i<2; i++){
236
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
237
                pic->motion_val[i]= pic->motion_val_base[i]+4;
238
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
239
            }
240
            pic->motion_subsample_log2= 2;
241
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
242
            for(i=0; i<2; i++){
243
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
244
                pic->motion_val[i]= pic->motion_val_base[i]+4;
245
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
246
            }
247
            pic->motion_subsample_log2= 3;
248
        }
249
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
250
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
251
        }
252
        pic->qstride= s->mb_stride;
253
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
254
    }
255

    
256
    /* It might be nicer if the application would keep track of these
257
     * but it would require an API change. */
258
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
259
    s->prev_pict_types[0]= s->pict_type;
260
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
261
        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.
262

    
263
    return 0;
264
fail: //for the CHECKED_ALLOCZ macro
265
    if(r>=0)
266
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
267
    return -1;
268
}
269

    
270
/**
271
 * deallocates a picture
272
 */
273
static void free_picture(MpegEncContext *s, Picture *pic){
274
    int i;
275

    
276
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
277
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
278
    }
279

    
280
    av_freep(&pic->mb_var);
281
    av_freep(&pic->mc_mb_var);
282
    av_freep(&pic->mb_mean);
283
    av_freep(&pic->mbskip_table);
284
    av_freep(&pic->qscale_table);
285
    av_freep(&pic->mb_type_base);
286
    av_freep(&pic->dct_coeff);
287
    av_freep(&pic->pan_scan);
288
    pic->mb_type= NULL;
289
    for(i=0; i<2; i++){
290
        av_freep(&pic->motion_val_base[i]);
291
        av_freep(&pic->ref_index[i]);
292
    }
293

    
294
    if(pic->type == FF_BUFFER_TYPE_SHARED){
295
        for(i=0; i<4; i++){
296
            pic->base[i]=
297
            pic->data[i]= NULL;
298
        }
299
        pic->type= 0;
300
    }
301
}
302

    
303
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
304
    int i;
305

    
306
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
307
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
308
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
309

    
310
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
311
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
312
    s->rd_scratchpad=   s->me.scratchpad;
313
    s->b_scratchpad=    s->me.scratchpad;
314
    s->obmc_scratchpad= s->me.scratchpad + 16;
315
    if (s->encoding) {
316
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
317
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
318
        if(s->avctx->noise_reduction){
319
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
320
        }
321
    }
322
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
323
    s->block= s->blocks[0];
324

    
325
    for(i=0;i<12;i++){
326
        s->pblocks[i] = (short *)(&s->block[i]);
327
    }
328
    return 0;
329
fail:
330
    return -1; //free() through MPV_common_end()
331
}
332

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

    
336
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
337
    av_freep(&s->me.scratchpad);
338
    s->rd_scratchpad=
339
    s->b_scratchpad=
340
    s->obmc_scratchpad= NULL;
341

    
342
    av_freep(&s->dct_error_sum);
343
    av_freep(&s->me.map);
344
    av_freep(&s->me.score_map);
345
    av_freep(&s->blocks);
346
    s->block= NULL;
347
}
348

    
349
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
350
#define COPY(a) bak->a= src->a
351
    COPY(allocated_edge_emu_buffer);
352
    COPY(edge_emu_buffer);
353
    COPY(me.scratchpad);
354
    COPY(rd_scratchpad);
355
    COPY(b_scratchpad);
356
    COPY(obmc_scratchpad);
357
    COPY(me.map);
358
    COPY(me.score_map);
359
    COPY(blocks);
360
    COPY(block);
361
    COPY(start_mb_y);
362
    COPY(end_mb_y);
363
    COPY(me.map_generation);
364
    COPY(pb);
365
    COPY(dct_error_sum);
366
    COPY(dct_count[0]);
367
    COPY(dct_count[1]);
368
#undef COPY
369
}
370

    
371
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
372
    MpegEncContext bak;
373
    int i;
374
    //FIXME copy only needed parts
375
//START_TIMER
376
    backup_duplicate_context(&bak, dst);
377
    memcpy(dst, src, sizeof(MpegEncContext));
378
    backup_duplicate_context(dst, &bak);
379
    for(i=0;i<12;i++){
380
        dst->pblocks[i] = (short *)(&dst->block[i]);
381
    }
382
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
383
}
384

    
385
/**
386
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
387
 * the changed fields will not depend upon the prior state of the MpegEncContext.
388
 */
389
void MPV_common_defaults(MpegEncContext *s){
390
    s->y_dc_scale_table=
391
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
392
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
393
    s->progressive_frame= 1;
394
    s->progressive_sequence= 1;
395
    s->picture_structure= PICT_FRAME;
396

    
397
    s->coded_picture_number = 0;
398
    s->picture_number = 0;
399
    s->input_picture_number = 0;
400

    
401
    s->picture_in_gop_number = 0;
402

    
403
    s->f_code = 1;
404
    s->b_code = 1;
405
}
406

    
407
/**
408
 * sets the given MpegEncContext to defaults for decoding.
409
 * the changed fields will not depend upon the prior state of the MpegEncContext.
410
 */
411
void MPV_decode_defaults(MpegEncContext *s){
412
    MPV_common_defaults(s);
413
}
414

    
415
/**
416
 * init common structure for both encoder and decoder.
417
 * this assumes that some variables like width/height are already set
418
 */
419
int MPV_common_init(MpegEncContext *s)
420
{
421
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
422

    
423
    s->mb_height = (s->height + 15) / 16;
424

    
425
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
426
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
427
        return -1;
428
    }
429

    
430
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
431
        return -1;
432

    
433
    dsputil_init(&s->dsp, s->avctx);
434
    DCT_common_init(s);
435

    
436
    s->flags= s->avctx->flags;
437
    s->flags2= s->avctx->flags2;
438

    
439
    s->mb_width  = (s->width  + 15) / 16;
440
    s->mb_stride = s->mb_width + 1;
441
    s->b8_stride = s->mb_width*2 + 1;
442
    s->b4_stride = s->mb_width*4 + 1;
443
    mb_array_size= s->mb_height * s->mb_stride;
444
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
445

    
446
    /* set chroma shifts */
447
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
448
                                                    &(s->chroma_y_shift) );
449

    
450
    /* set default edge pos, will be overriden in decode_header if needed */
451
    s->h_edge_pos= s->mb_width*16;
452
    s->v_edge_pos= s->mb_height*16;
453

    
454
    s->mb_num = s->mb_width * s->mb_height;
455

    
456
    s->block_wrap[0]=
457
    s->block_wrap[1]=
458
    s->block_wrap[2]=
459
    s->block_wrap[3]= s->b8_stride;
460
    s->block_wrap[4]=
461
    s->block_wrap[5]= s->mb_stride;
462

    
463
    y_size = s->b8_stride * (2 * s->mb_height + 1);
464
    c_size = s->mb_stride * (s->mb_height + 1);
465
    yc_size = y_size + 2 * c_size;
466

    
467
    /* convert fourcc to upper case */
468
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
469
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
470
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
471
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
472

    
473
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
474
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
475
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
476
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
477

    
478
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
479

    
480
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
481
    for(y=0; y<s->mb_height; y++){
482
        for(x=0; x<s->mb_width; x++){
483
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
484
        }
485
    }
486
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
487

    
488
    if (s->encoding) {
489
        /* Allocate MV tables */
490
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
491
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
492
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
493
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
494
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
495
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
496
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
497
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
498
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
499
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
500
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
501
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
502

    
503
        if(s->msmpeg4_version){
504
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
505
        }
506
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
507

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

    
511
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
512

    
513
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
514
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
515
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
516
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
517
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
518
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
519

    
520
        if(s->avctx->noise_reduction){
521
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
522
        }
523
    }
524
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
525

    
526
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
527

    
528
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
529
        /* interlaced direct mode decoding tables */
530
            for(i=0; i<2; i++){
531
                int j, k;
532
                for(j=0; j<2; j++){
533
                    for(k=0; k<2; k++){
534
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
535
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
536
                    }
537
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
538
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
539
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
540
                }
541
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
542
            }
543
    }
544
    if (s->out_format == FMT_H263) {
545
        /* ac values */
546
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
547
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
548
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
549
        s->ac_val[2] = s->ac_val[1] + c_size;
550

    
551
        /* cbp values */
552
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
553
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
554

    
555
        /* cbp, ac_pred, pred_dir */
556
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
557
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
558
    }
559

    
560
    if (s->h263_pred || s->h263_plus || !s->encoding) {
561
        /* dc values */
562
        //MN: we need these for error resilience of intra-frames
563
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
564
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
565
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
566
        s->dc_val[2] = s->dc_val[1] + c_size;
567
        for(i=0;i<yc_size;i++)
568
            s->dc_val_base[i] = 1024;
569
    }
570

    
571
    /* which mb is a intra block */
572
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
573
    memset(s->mbintra_table, 1, mb_array_size);
574

    
575
    /* init macroblock skip table */
576
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
577
    //Note the +1 is for a quicker mpeg4 slice_end detection
578
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
579

    
580
    s->parse_context.state= -1;
581
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
582
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
583
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
584
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
585
    }
586

    
587
    s->context_initialized = 1;
588

    
589
    s->thread_context[0]= s;
590
    /* h264 does thread context setup itself, but it needs context[0]
591
     * to be fully initialized for the error resilience code */
592
    threads = s->codec_id == CODEC_ID_H264 ? 1 : s->avctx->thread_count;
593

    
594
    for(i=1; i<threads; i++){
595
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
596
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
597
    }
598

    
599
    for(i=0; i<threads; i++){
600
        if(init_duplicate_context(s->thread_context[i], s) < 0)
601
           goto fail;
602
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
603
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
604
    }
605

    
606
    return 0;
607
 fail:
608
    MPV_common_end(s);
609
    return -1;
610
}
611

    
612
/* init common structure for both encoder and decoder */
613
void MPV_common_end(MpegEncContext *s)
614
{
615
    int i, j, k;
616

    
617
    for(i=0; i<s->avctx->thread_count; i++){
618
        free_duplicate_context(s->thread_context[i]);
619
    }
620
    for(i=1; i<s->avctx->thread_count; i++){
621
        av_freep(&s->thread_context[i]);
622
    }
623

    
624
    av_freep(&s->parse_context.buffer);
625
    s->parse_context.buffer_size=0;
626

    
627
    av_freep(&s->mb_type);
628
    av_freep(&s->p_mv_table_base);
629
    av_freep(&s->b_forw_mv_table_base);
630
    av_freep(&s->b_back_mv_table_base);
631
    av_freep(&s->b_bidir_forw_mv_table_base);
632
    av_freep(&s->b_bidir_back_mv_table_base);
633
    av_freep(&s->b_direct_mv_table_base);
634
    s->p_mv_table= NULL;
635
    s->b_forw_mv_table= NULL;
636
    s->b_back_mv_table= NULL;
637
    s->b_bidir_forw_mv_table= NULL;
638
    s->b_bidir_back_mv_table= NULL;
639
    s->b_direct_mv_table= NULL;
640
    for(i=0; i<2; i++){
641
        for(j=0; j<2; j++){
642
            for(k=0; k<2; k++){
643
                av_freep(&s->b_field_mv_table_base[i][j][k]);
644
                s->b_field_mv_table[i][j][k]=NULL;
645
            }
646
            av_freep(&s->b_field_select_table[i][j]);
647
            av_freep(&s->p_field_mv_table_base[i][j]);
648
            s->p_field_mv_table[i][j]=NULL;
649
        }
650
        av_freep(&s->p_field_select_table[i]);
651
    }
652

    
653
    av_freep(&s->dc_val_base);
654
    av_freep(&s->ac_val_base);
655
    av_freep(&s->coded_block_base);
656
    av_freep(&s->mbintra_table);
657
    av_freep(&s->cbp_table);
658
    av_freep(&s->pred_dir_table);
659

    
660
    av_freep(&s->mbskip_table);
661
    av_freep(&s->prev_pict_types);
662
    av_freep(&s->bitstream_buffer);
663
    s->allocated_bitstream_buffer_size=0;
664

    
665
    av_freep(&s->avctx->stats_out);
666
    av_freep(&s->ac_stats);
667
    av_freep(&s->error_status_table);
668
    av_freep(&s->mb_index2xy);
669
    av_freep(&s->lambda_table);
670
    av_freep(&s->q_intra_matrix);
671
    av_freep(&s->q_inter_matrix);
672
    av_freep(&s->q_intra_matrix16);
673
    av_freep(&s->q_inter_matrix16);
674
    av_freep(&s->input_picture);
675
    av_freep(&s->reordered_input_picture);
676
    av_freep(&s->dct_offset);
677

    
678
    if(s->picture){
679
        for(i=0; i<MAX_PICTURE_COUNT; i++){
680
            free_picture(s, &s->picture[i]);
681
        }
682
    }
683
    av_freep(&s->picture);
684
    s->context_initialized = 0;
685
    s->last_picture_ptr=
686
    s->next_picture_ptr=
687
    s->current_picture_ptr= NULL;
688
    s->linesize= s->uvlinesize= 0;
689

    
690
    for(i=0; i<3; i++)
691
        av_freep(&s->visualization_buffer[i]);
692

    
693
    avcodec_default_free_buffers(s->avctx);
694
}
695

    
696
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
697
{
698
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
699
    uint8_t index_run[MAX_RUN+1];
700
    int last, run, level, start, end, i;
701

    
702
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
703
    if(static_store && rl->max_level[0])
704
        return;
705

    
706
    /* compute max_level[], max_run[] and index_run[] */
707
    for(last=0;last<2;last++) {
708
        if (last == 0) {
709
            start = 0;
710
            end = rl->last;
711
        } else {
712
            start = rl->last;
713
            end = rl->n;
714
        }
715

    
716
        memset(max_level, 0, MAX_RUN + 1);
717
        memset(max_run, 0, MAX_LEVEL + 1);
718
        memset(index_run, rl->n, MAX_RUN + 1);
719
        for(i=start;i<end;i++) {
720
            run = rl->table_run[i];
721
            level = rl->table_level[i];
722
            if (index_run[run] == rl->n)
723
                index_run[run] = i;
724
            if (level > max_level[run])
725
                max_level[run] = level;
726
            if (run > max_run[level])
727
                max_run[level] = run;
728
        }
729
        if(static_store)
730
            rl->max_level[last] = static_store[last];
731
        else
732
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
733
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
734
        if(static_store)
735
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
736
        else
737
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
738
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
739
        if(static_store)
740
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
741
        else
742
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
743
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
744
    }
745
}
746

    
747
void init_vlc_rl(RLTable *rl, int use_static)
748
{
749
    int i, q;
750

    
751
    /* Return if static table is already initialized */
752
    if(use_static && rl->rl_vlc[0])
753
        return;
754

    
755
    init_vlc(&rl->vlc, 9, rl->n + 1,
756
             &rl->table_vlc[0][1], 4, 2,
757
             &rl->table_vlc[0][0], 4, 2, use_static);
758

    
759

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

    
764
        if(q==0){
765
            qmul=1;
766
            qadd=0;
767
        }
768
        if(use_static)
769
            rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
770
        else
771
            rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
772
        for(i=0; i<rl->vlc.table_size; i++){
773
            int code= rl->vlc.table[i][0];
774
            int len = rl->vlc.table[i][1];
775
            int level, run;
776

    
777
            if(len==0){ // illegal code
778
                run= 66;
779
                level= MAX_LEVEL;
780
            }else if(len<0){ //more bits needed
781
                run= 0;
782
                level= code;
783
            }else{
784
                if(code==rl->n){ //esc
785
                    run= 66;
786
                    level= 0;
787
                }else{
788
                    run=   rl->table_run  [code] + 1;
789
                    level= rl->table_level[code] * qmul + qadd;
790
                    if(code >= rl->last) run+=192;
791
                }
792
            }
793
            rl->rl_vlc[q][i].len= len;
794
            rl->rl_vlc[q][i].level= level;
795
            rl->rl_vlc[q][i].run= run;
796
        }
797
    }
798
}
799

    
800
/* draw the edges of width 'w' of an image of size width, height */
801
//FIXME check that this is ok for mpeg4 interlaced
802
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
803
{
804
    uint8_t *ptr, *last_line;
805
    int i;
806

    
807
    last_line = buf + (height - 1) * wrap;
808
    for(i=0;i<w;i++) {
809
        /* top and bottom */
810
        memcpy(buf - (i + 1) * wrap, buf, width);
811
        memcpy(last_line + (i + 1) * wrap, last_line, width);
812
    }
813
    /* left and right */
814
    ptr = buf;
815
    for(i=0;i<height;i++) {
816
        memset(ptr - w, ptr[0], w);
817
        memset(ptr + width, ptr[width-1], w);
818
        ptr += wrap;
819
    }
820
    /* corners */
821
    for(i=0;i<w;i++) {
822
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
823
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
824
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
825
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
826
    }
827
}
828

    
829
int ff_find_unused_picture(MpegEncContext *s, int shared){
830
    int i;
831

    
832
    if(shared){
833
        for(i=0; i<MAX_PICTURE_COUNT; i++){
834
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
835
        }
836
    }else{
837
        for(i=0; i<MAX_PICTURE_COUNT; i++){
838
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
839
        }
840
        for(i=0; i<MAX_PICTURE_COUNT; i++){
841
            if(s->picture[i].data[0]==NULL) return i;
842
        }
843
    }
844

    
845
    assert(0);
846
    return -1;
847
}
848

    
849
static void update_noise_reduction(MpegEncContext *s){
850
    int intra, i;
851

    
852
    for(intra=0; intra<2; intra++){
853
        if(s->dct_count[intra] > (1<<16)){
854
            for(i=0; i<64; i++){
855
                s->dct_error_sum[intra][i] >>=1;
856
            }
857
            s->dct_count[intra] >>= 1;
858
        }
859

    
860
        for(i=0; i<64; i++){
861
            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);
862
        }
863
    }
864
}
865

    
866
/**
867
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
868
 */
869
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
870
{
871
    int i;
872
    AVFrame *pic;
873
    s->mb_skipped = 0;
874

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

    
877
    /* mark&release old frames */
878
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
879
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
880
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
881

    
882
        /* release forgotten pictures */
883
        /* if(mpeg124/h263) */
884
        if(!s->encoding){
885
            for(i=0; i<MAX_PICTURE_COUNT; i++){
886
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
887
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
888
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
889
                }
890
            }
891
        }
892
      }
893
    }
894
alloc:
895
    if(!s->encoding){
896
        /* release non reference frames */
897
        for(i=0; i<MAX_PICTURE_COUNT; i++){
898
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
899
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
900
            }
901
        }
902

    
903
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
904
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
905
        else{
906
            i= ff_find_unused_picture(s, 0);
907
            pic= (AVFrame*)&s->picture[i];
908
        }
909

    
910
        pic->reference= 0;
911
        if (!s->dropable){
912
            if (s->codec_id == CODEC_ID_H264)
913
                pic->reference = s->picture_structure;
914
            else if (s->pict_type != B_TYPE)
915
                pic->reference = 3;
916
        }
917

    
918
        pic->coded_picture_number= s->coded_picture_number++;
919

    
920
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
921
            return -1;
922

    
923
        s->current_picture_ptr= (Picture*)pic;
924
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
925
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
926
    }
927

    
928
    s->current_picture_ptr->pict_type= s->pict_type;
929
//    if(s->flags && CODEC_FLAG_QSCALE)
930
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
931
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
932

    
933
    copy_picture(&s->current_picture, s->current_picture_ptr);
934

    
935
    if (s->pict_type != B_TYPE) {
936
        s->last_picture_ptr= s->next_picture_ptr;
937
        if(!s->dropable)
938
            s->next_picture_ptr= s->current_picture_ptr;
939
    }
940
/*    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,
941
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
942
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
943
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
944
        s->pict_type, s->dropable);*/
945

    
946
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
947
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
948

    
949
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
950
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
951
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
952
        goto alloc;
953
    }
954

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

    
957
    if(s->picture_structure!=PICT_FRAME){
958
        int i;
959
        for(i=0; i<4; i++){
960
            if(s->picture_structure == PICT_BOTTOM_FIELD){
961
                 s->current_picture.data[i] += s->current_picture.linesize[i];
962
            }
963
            s->current_picture.linesize[i] *= 2;
964
            s->last_picture.linesize[i] *=2;
965
            s->next_picture.linesize[i] *=2;
966
        }
967
    }
968

    
969
    s->hurry_up= s->avctx->hurry_up;
970
    s->error_resilience= avctx->error_resilience;
971

    
972
    /* set dequantizer, we can't do it during init as it might change for mpeg4
973
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
974
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
975
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
976
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
977
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
978
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
979
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
980
    }else{
981
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
982
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
983
    }
984

    
985
    if(s->dct_error_sum){
986
        assert(s->avctx->noise_reduction && s->encoding);
987

    
988
        update_noise_reduction(s);
989
    }
990

    
991
#ifdef HAVE_XVMC
992
    if(s->avctx->xvmc_acceleration)
993
        return XVMC_field_start(s, avctx);
994
#endif
995
    return 0;
996
}
997

    
998
/* generic function for encode/decode called after a frame has been coded/decoded */
999
void MPV_frame_end(MpegEncContext *s)
1000
{
1001
    int i;
1002
    /* draw edge for correct motion prediction if outside */
1003
#ifdef HAVE_XVMC
1004
//just to make sure that all data is rendered.
1005
    if(s->avctx->xvmc_acceleration){
1006
        XVMC_field_end(s);
1007
    }else
1008
#endif
1009
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1010
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1011
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1012
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1013
    }
1014
    emms_c();
1015

    
1016
    s->last_pict_type    = s->pict_type;
1017
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1018
    if(s->pict_type!=B_TYPE){
1019
        s->last_non_b_pict_type= s->pict_type;
1020
    }
1021
#if 0
1022
        /* copy back current_picture variables */
1023
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1024
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1025
            s->picture[i]= s->current_picture;
1026
            break;
1027
        }
1028
    }
1029
    assert(i<MAX_PICTURE_COUNT);
1030
#endif
1031

    
1032
    if(s->encoding){
1033
        /* release non-reference frames */
1034
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1035
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1036
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1037
            }
1038
        }
1039
    }
1040
    // clear copies, to avoid confusion
1041
#if 0
1042
    memset(&s->last_picture, 0, sizeof(Picture));
1043
    memset(&s->next_picture, 0, sizeof(Picture));
1044
    memset(&s->current_picture, 0, sizeof(Picture));
1045
#endif
1046
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1047
}
1048

    
1049
/**
1050
 * draws an line from (ex, ey) -> (sx, sy).
1051
 * @param w width of the image
1052
 * @param h height of the image
1053
 * @param stride stride/linesize of the image
1054
 * @param color color of the arrow
1055
 */
1056
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1057
    int x, y, fr, f;
1058

    
1059
    sx= av_clip(sx, 0, w-1);
1060
    sy= av_clip(sy, 0, h-1);
1061
    ex= av_clip(ex, 0, w-1);
1062
    ey= av_clip(ey, 0, h-1);
1063

    
1064
    buf[sy*stride + sx]+= color;
1065

    
1066
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1067
        if(sx > ex){
1068
            FFSWAP(int, sx, ex);
1069
            FFSWAP(int, sy, ey);
1070
        }
1071
        buf+= sx + sy*stride;
1072
        ex-= sx;
1073
        f= ((ey-sy)<<16)/ex;
1074
        for(x= 0; x <= ex; x++){
1075
            y = (x*f)>>16;
1076
            fr= (x*f)&0xFFFF;
1077
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1078
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1079
        }
1080
    }else{
1081
        if(sy > ey){
1082
            FFSWAP(int, sx, ex);
1083
            FFSWAP(int, sy, ey);
1084
        }
1085
        buf+= sx + sy*stride;
1086
        ey-= sy;
1087
        if(ey) f= ((ex-sx)<<16)/ey;
1088
        else   f= 0;
1089
        for(y= 0; y <= ey; y++){
1090
            x = (y*f)>>16;
1091
            fr= (y*f)&0xFFFF;
1092
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1093
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1094
        }
1095
    }
1096
}
1097

    
1098
/**
1099
 * draws an arrow from (ex, ey) -> (sx, sy).
1100
 * @param w width of the image
1101
 * @param h height of the image
1102
 * @param stride stride/linesize of the image
1103
 * @param color color of the arrow
1104
 */
1105
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1106
    int dx,dy;
1107

    
1108
    sx= av_clip(sx, -100, w+100);
1109
    sy= av_clip(sy, -100, h+100);
1110
    ex= av_clip(ex, -100, w+100);
1111
    ey= av_clip(ey, -100, h+100);
1112

    
1113
    dx= ex - sx;
1114
    dy= ey - sy;
1115

    
1116
    if(dx*dx + dy*dy > 3*3){
1117
        int rx=  dx + dy;
1118
        int ry= -dx + dy;
1119
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1120

    
1121
        //FIXME subpixel accuracy
1122
        rx= ROUNDED_DIV(rx*3<<4, length);
1123
        ry= ROUNDED_DIV(ry*3<<4, length);
1124

    
1125
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1126
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1127
    }
1128
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1129
}
1130

    
1131
/**
1132
 * prints debuging info for the given picture.
1133
 */
1134
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1135

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

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

    
1141
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1142
        switch (pict->pict_type) {
1143
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1144
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1145
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1146
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1147
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1148
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1149
        }
1150
        for(y=0; y<s->mb_height; y++){
1151
            for(x=0; x<s->mb_width; x++){
1152
                if(s->avctx->debug&FF_DEBUG_SKIP){
1153
                    int count= s->mbskip_table[x + y*s->mb_stride];
1154
                    if(count>9) count=9;
1155
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1156
                }
1157
                if(s->avctx->debug&FF_DEBUG_QP){
1158
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1159
                }
1160
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1161
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1162
                    //Type & MV direction
1163
                    if(IS_PCM(mb_type))
1164
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1165
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1166
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1167
                    else if(IS_INTRA4x4(mb_type))
1168
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1169
                    else if(IS_INTRA16x16(mb_type))
1170
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1171
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1172
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1173
                    else if(IS_DIRECT(mb_type))
1174
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1175
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1176
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1177
                    else if(IS_GMC(mb_type))
1178
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1179
                    else if(IS_SKIP(mb_type))
1180
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1181
                    else if(!USES_LIST(mb_type, 1))
1182
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1183
                    else if(!USES_LIST(mb_type, 0))
1184
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1185
                    else{
1186
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1187
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1188
                    }
1189

    
1190
                    //segmentation
1191
                    if(IS_8X8(mb_type))
1192
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1193
                    else if(IS_16X8(mb_type))
1194
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1195
                    else if(IS_8X16(mb_type))
1196
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1197
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1198
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1199
                    else
1200
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1201

    
1202

    
1203
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1204
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1205
                    else
1206
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1207
                }
1208
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1209
            }
1210
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1211
        }
1212
    }
1213

    
1214
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1215
        const int shift= 1 + s->quarter_sample;
1216
        int mb_y;
1217
        uint8_t *ptr;
1218
        int i;
1219
        int h_chroma_shift, v_chroma_shift;
1220
        const int width = s->avctx->width;
1221
        const int height= s->avctx->height;
1222
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1223
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1224
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1225

    
1226
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1227
        for(i=0; i<3; i++){
1228
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1229
            pict->data[i]= s->visualization_buffer[i];
1230
        }
1231
        pict->type= FF_BUFFER_TYPE_COPY;
1232
        ptr= pict->data[0];
1233

    
1234
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1235
            int mb_x;
1236
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1237
                const int mb_index= mb_x + mb_y*s->mb_stride;
1238
                if((s->avctx->debug_mv) && pict->motion_val){
1239
                  int type;
1240
                  for(type=0; type<3; type++){
1241
                    int direction = 0;
1242
                    switch (type) {
1243
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1244
                                continue;
1245
                              direction = 0;
1246
                              break;
1247
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1248
                                continue;
1249
                              direction = 0;
1250
                              break;
1251
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1252
                                continue;
1253
                              direction = 1;
1254
                              break;
1255
                    }
1256
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1257
                        continue;
1258

    
1259
                    if(IS_8X8(pict->mb_type[mb_index])){
1260
                      int i;
1261
                      for(i=0; i<4; i++){
1262
                        int sx= mb_x*16 + 4 + 8*(i&1);
1263
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1264
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1265
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1266
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1267
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1268
                      }
1269
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1270
                      int i;
1271
                      for(i=0; i<2; i++){
1272
                        int sx=mb_x*16 + 8;
1273
                        int sy=mb_y*16 + 4 + 8*i;
1274
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1275
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1276
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1277

    
1278
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1279
                            my*=2;
1280

    
1281
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1282
                      }
1283
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1284
                      int i;
1285
                      for(i=0; i<2; i++){
1286
                        int sx=mb_x*16 + 4 + 8*i;
1287
                        int sy=mb_y*16 + 8;
1288
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1289
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1290
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1291

    
1292
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1293
                            my*=2;
1294

    
1295
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1296
                      }
1297
                    }else{
1298
                      int sx= mb_x*16 + 8;
1299
                      int sy= mb_y*16 + 8;
1300
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1301
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1302
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1303
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1304
                    }
1305
                  }
1306
                }
1307
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1308
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1309
                    int y;
1310
                    for(y=0; y<8; y++){
1311
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1312
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1313
                    }
1314
                }
1315
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1316
                    int mb_type= pict->mb_type[mb_index];
1317
                    uint64_t u,v;
1318
                    int y;
1319
#define COLOR(theta, r)\
1320
u= (int)(128 + r*cos(theta*3.141592/180));\
1321
v= (int)(128 + r*sin(theta*3.141592/180));
1322

    
1323

    
1324
                    u=v=128;
1325
                    if(IS_PCM(mb_type)){
1326
                        COLOR(120,48)
1327
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1328
                        COLOR(30,48)
1329
                    }else if(IS_INTRA4x4(mb_type)){
1330
                        COLOR(90,48)
1331
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1332
//                        COLOR(120,48)
1333
                    }else if(IS_DIRECT(mb_type)){
1334
                        COLOR(150,48)
1335
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1336
                        COLOR(170,48)
1337
                    }else if(IS_GMC(mb_type)){
1338
                        COLOR(190,48)
1339
                    }else if(IS_SKIP(mb_type)){
1340
//                        COLOR(180,48)
1341
                    }else if(!USES_LIST(mb_type, 1)){
1342
                        COLOR(240,48)
1343
                    }else if(!USES_LIST(mb_type, 0)){
1344
                        COLOR(0,48)
1345
                    }else{
1346
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1347
                        COLOR(300,48)
1348
                    }
1349

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

    
1357
                    //segmentation
1358
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1359
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1360
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1361
                    }
1362
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1363
                        for(y=0; y<16; y++)
1364
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1365
                    }
1366
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1367
                        int dm= 1 << (mv_sample_log2-2);
1368
                        for(i=0; i<4; i++){
1369
                            int sx= mb_x*16 + 8*(i&1);
1370
                            int sy= mb_y*16 + 8*(i>>1);
1371
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1372
                            //FIXME bidir
1373
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1374
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1375
                                for(y=0; y<8; y++)
1376
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1377
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1378
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1379
                        }
1380
                    }
1381

    
1382
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1383
                        // hmm
1384
                    }
1385
                }
1386
                s->mbskip_table[mb_index]=0;
1387
            }
1388
        }
1389
    }
1390
}
1391

    
1392
/**
1393
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1394
 * @param buf destination buffer
1395
 * @param src source buffer
1396
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1397
 * @param block_w width of block
1398
 * @param block_h height of block
1399
 * @param src_x x coordinate of the top left sample of the block in the source buffer
1400
 * @param src_y y coordinate of the top left sample of the block in the source buffer
1401
 * @param w width of the source buffer
1402
 * @param h height of the source buffer
1403
 */
1404
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1405
                                    int src_x, int src_y, int w, int h){
1406
    int x, y;
1407
    int start_y, start_x, end_y, end_x;
1408

    
1409
    if(src_y>= h){
1410
        src+= (h-1-src_y)*linesize;
1411
        src_y=h-1;
1412
    }else if(src_y<=-block_h){
1413
        src+= (1-block_h-src_y)*linesize;
1414
        src_y=1-block_h;
1415
    }
1416
    if(src_x>= w){
1417
        src+= (w-1-src_x);
1418
        src_x=w-1;
1419
    }else if(src_x<=-block_w){
1420
        src+= (1-block_w-src_x);
1421
        src_x=1-block_w;
1422
    }
1423

    
1424
    start_y= FFMAX(0, -src_y);
1425
    start_x= FFMAX(0, -src_x);
1426
    end_y= FFMIN(block_h, h-src_y);
1427
    end_x= FFMIN(block_w, w-src_x);
1428

    
1429
    // copy existing part
1430
    for(y=start_y; y<end_y; y++){
1431
        for(x=start_x; x<end_x; x++){
1432
            buf[x + y*linesize]= src[x + y*linesize];
1433
        }
1434
    }
1435

    
1436
    //top
1437
    for(y=0; y<start_y; y++){
1438
        for(x=start_x; x<end_x; x++){
1439
            buf[x + y*linesize]= buf[x + start_y*linesize];
1440
        }
1441
    }
1442

    
1443
    //bottom
1444
    for(y=end_y; y<block_h; y++){
1445
        for(x=start_x; x<end_x; x++){
1446
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1447
        }
1448
    }
1449

    
1450
    for(y=0; y<block_h; y++){
1451
       //left
1452
        for(x=0; x<start_x; x++){
1453
            buf[x + y*linesize]= buf[start_x + y*linesize];
1454
        }
1455

    
1456
       //right
1457
        for(x=end_x; x<block_w; x++){
1458
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1459
        }
1460
    }
1461
}
1462

    
1463
static inline int hpel_motion_lowres(MpegEncContext *s,
1464
                                  uint8_t *dest, uint8_t *src,
1465
                                  int field_based, int field_select,
1466
                                  int src_x, int src_y,
1467
                                  int width, int height, int stride,
1468
                                  int h_edge_pos, int v_edge_pos,
1469
                                  int w, int h, h264_chroma_mc_func *pix_op,
1470
                                  int motion_x, int motion_y)
1471
{
1472
    const int lowres= s->avctx->lowres;
1473
    const int s_mask= (2<<lowres)-1;
1474
    int emu=0;
1475
    int sx, sy;
1476

    
1477
    if(s->quarter_sample){
1478
        motion_x/=2;
1479
        motion_y/=2;
1480
    }
1481

    
1482
    sx= motion_x & s_mask;
1483
    sy= motion_y & s_mask;
1484
    src_x += motion_x >> (lowres+1);
1485
    src_y += motion_y >> (lowres+1);
1486

    
1487
    src += src_y * stride + src_x;
1488

    
1489
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1490
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1491
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1492
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1493
        src= s->edge_emu_buffer;
1494
        emu=1;
1495
    }
1496

    
1497
    sx <<= 2 - lowres;
1498
    sy <<= 2 - lowres;
1499
    if(field_select)
1500
        src += s->linesize;
1501
    pix_op[lowres](dest, src, stride, h, sx, sy);
1502
    return emu;
1503
}
1504

    
1505
/* apply one mpeg motion vector to the three components */
1506
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1507
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1508
                               int field_based, int bottom_field, int field_select,
1509
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1510
                               int motion_x, int motion_y, int h)
1511
{
1512
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1513
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1514
    const int lowres= s->avctx->lowres;
1515
    const int block_s= 8>>lowres;
1516
    const int s_mask= (2<<lowres)-1;
1517
    const int h_edge_pos = s->h_edge_pos >> lowres;
1518
    const int v_edge_pos = s->v_edge_pos >> lowres;
1519
    linesize   = s->current_picture.linesize[0] << field_based;
1520
    uvlinesize = s->current_picture.linesize[1] << field_based;
1521

    
1522
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1523
        motion_x/=2;
1524
        motion_y/=2;
1525
    }
1526

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

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

    
1536
    if (s->out_format == FMT_H263) {
1537
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1538
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1539
        uvsrc_x = src_x>>1;
1540
        uvsrc_y = src_y>>1;
1541
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1542
        mx = motion_x / 4;
1543
        my = motion_y / 4;
1544
        uvsx = (2*mx) & s_mask;
1545
        uvsy = (2*my) & s_mask;
1546
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1547
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1548
    } else {
1549
        mx = motion_x / 2;
1550
        my = motion_y / 2;
1551
        uvsx = mx & s_mask;
1552
        uvsy = my & s_mask;
1553
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1554
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1555
    }
1556

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

    
1561
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1562
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1563
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1564
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1565
            ptr_y = s->edge_emu_buffer;
1566
            if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1567
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1568
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1569
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1570
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1571
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1572
                ptr_cb= uvbuf;
1573
                ptr_cr= uvbuf+16;
1574
            }
1575
    }
1576

    
1577
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1578
        dest_y += s->linesize;
1579
        dest_cb+= s->uvlinesize;
1580
        dest_cr+= s->uvlinesize;
1581
    }
1582

    
1583
    if(field_select){
1584
        ptr_y += s->linesize;
1585
        ptr_cb+= s->uvlinesize;
1586
        ptr_cr+= s->uvlinesize;
1587
    }
1588

    
1589
    sx <<= 2 - lowres;
1590
    sy <<= 2 - lowres;
1591
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1592

    
1593
    if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1594
        uvsx <<= 2 - lowres;
1595
        uvsy <<= 2 - lowres;
1596
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1597
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1598
    }
1599
    //FIXME h261 lowres loop filter
1600
}
1601

    
1602
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1603
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1604
                                     uint8_t **ref_picture,
1605
                                     h264_chroma_mc_func *pix_op,
1606
                                     int mx, int my){
1607
    const int lowres= s->avctx->lowres;
1608
    const int block_s= 8>>lowres;
1609
    const int s_mask= (2<<lowres)-1;
1610
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1611
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1612
    int emu=0, src_x, src_y, offset, sx, sy;
1613
    uint8_t *ptr;
1614

    
1615
    if(s->quarter_sample){
1616
        mx/=2;
1617
        my/=2;
1618
    }
1619

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

    
1625
    sx= mx & s_mask;
1626
    sy= my & s_mask;
1627
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1628
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1629

    
1630
    offset = src_y * s->uvlinesize + src_x;
1631
    ptr = ref_picture[1] + offset;
1632
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1633
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1634
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1635
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1636
            ptr= s->edge_emu_buffer;
1637
            emu=1;
1638
        }
1639
    }
1640
    sx <<= 2 - lowres;
1641
    sy <<= 2 - lowres;
1642
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1643

    
1644
    ptr = ref_picture[2] + offset;
1645
    if(emu){
1646
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1647
        ptr= s->edge_emu_buffer;
1648
    }
1649
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1650
}
1651

    
1652
/**
1653
 * motion compensation of a single macroblock
1654
 * @param s context
1655
 * @param dest_y luma destination pointer
1656
 * @param dest_cb chroma cb/u destination pointer
1657
 * @param dest_cr chroma cr/v destination pointer
1658
 * @param dir direction (0->forward, 1->backward)
1659
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1660
 * @param pic_op halfpel motion compensation function (average or put normally)
1661
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1662
 */
1663
static inline void MPV_motion_lowres(MpegEncContext *s,
1664
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1665
                              int dir, uint8_t **ref_picture,
1666
                              h264_chroma_mc_func *pix_op)
1667
{
1668
    int mx, my;
1669
    int mb_x, mb_y, i;
1670
    const int lowres= s->avctx->lowres;
1671
    const int block_s= 8>>lowres;
1672

    
1673
    mb_x = s->mb_x;
1674
    mb_y = s->mb_y;
1675

    
1676
    switch(s->mv_type) {
1677
    case MV_TYPE_16X16:
1678
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1679
                    0, 0, 0,
1680
                    ref_picture, pix_op,
1681
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1682
        break;
1683
    case MV_TYPE_8X8:
1684
        mx = 0;
1685
        my = 0;
1686
            for(i=0;i<4;i++) {
1687
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1688
                            ref_picture[0], 0, 0,
1689
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1690
                            s->width, s->height, s->linesize,
1691
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1692
                            block_s, block_s, pix_op,
1693
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1694

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

    
1699
        if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1700
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1701
        break;
1702
    case MV_TYPE_FIELD:
1703
        if (s->picture_structure == PICT_FRAME) {
1704
            /* top field */
1705
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1706
                        1, 0, s->field_select[dir][0],
1707
                        ref_picture, pix_op,
1708
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1709
            /* bottom field */
1710
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1711
                        1, 1, s->field_select[dir][1],
1712
                        ref_picture, pix_op,
1713
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1714
        } else {
1715
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
1716
                ref_picture= s->current_picture_ptr->data;
1717
            }
1718

    
1719
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1720
                        0, 0, s->field_select[dir][0],
1721
                        ref_picture, pix_op,
1722
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1723
        }
1724
        break;
1725
    case MV_TYPE_16X8:
1726
        for(i=0; i<2; i++){
1727
            uint8_t ** ref2picture;
1728

    
1729
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
1730
                ref2picture= ref_picture;
1731
            }else{
1732
                ref2picture= s->current_picture_ptr->data;
1733
            }
1734

    
1735
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1736
                        0, 0, s->field_select[dir][i],
1737
                        ref2picture, pix_op,
1738
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1739

    
1740
            dest_y += 2*block_s*s->linesize;
1741
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1742
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1743
        }
1744
        break;
1745
    case MV_TYPE_DMV:
1746
        if(s->picture_structure == PICT_FRAME){
1747
            for(i=0; i<2; i++){
1748
                int j;
1749
                for(j=0; j<2; j++){
1750
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1751
                                1, j, j^i,
1752
                                ref_picture, pix_op,
1753
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1754
                }
1755
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1756
            }
1757
        }else{
1758
            for(i=0; i<2; i++){
1759
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1760
                            0, 0, s->picture_structure != i+1,
1761
                            ref_picture, pix_op,
1762
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1763

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

    
1767
                //opposite parity is always in the same frame if this is second field
1768
                if(!s->first_field){
1769
                    ref_picture = s->current_picture_ptr->data;
1770
                }
1771
            }
1772
        }
1773
    break;
1774
    default: assert(0);
1775
    }
1776
}
1777

    
1778
/* put block[] to dest[] */
1779
static inline void put_dct(MpegEncContext *s,
1780
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1781
{
1782
    s->dct_unquantize_intra(s, block, i, qscale);
1783
    s->dsp.idct_put (dest, line_size, block);
1784
}
1785

    
1786
/* add block[] to dest[] */
1787
static inline void add_dct(MpegEncContext *s,
1788
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1789
{
1790
    if (s->block_last_index[i] >= 0) {
1791
        s->dsp.idct_add (dest, line_size, block);
1792
    }
1793
}
1794

    
1795
static inline void add_dequant_dct(MpegEncContext *s,
1796
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1797
{
1798
    if (s->block_last_index[i] >= 0) {
1799
        s->dct_unquantize_inter(s, block, i, qscale);
1800

    
1801
        s->dsp.idct_add (dest, line_size, block);
1802
    }
1803
}
1804

    
1805
/**
1806
 * cleans dc, ac, coded_block for the current non intra MB
1807
 */
1808
void ff_clean_intra_table_entries(MpegEncContext *s)
1809
{
1810
    int wrap = s->b8_stride;
1811
    int xy = s->block_index[0];
1812

    
1813
    s->dc_val[0][xy           ] =
1814
    s->dc_val[0][xy + 1       ] =
1815
    s->dc_val[0][xy     + wrap] =
1816
    s->dc_val[0][xy + 1 + wrap] = 1024;
1817
    /* ac pred */
1818
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1819
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1820
    if (s->msmpeg4_version>=3) {
1821
        s->coded_block[xy           ] =
1822
        s->coded_block[xy + 1       ] =
1823
        s->coded_block[xy     + wrap] =
1824
        s->coded_block[xy + 1 + wrap] = 0;
1825
    }
1826
    /* chroma */
1827
    wrap = s->mb_stride;
1828
    xy = s->mb_x + s->mb_y * wrap;
1829
    s->dc_val[1][xy] =
1830
    s->dc_val[2][xy] = 1024;
1831
    /* ac pred */
1832
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1833
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1834

    
1835
    s->mbintra_table[xy]= 0;
1836
}
1837

    
1838
/* generic function called after a macroblock has been parsed by the
1839
   decoder or after it has been encoded by the encoder.
1840

1841
   Important variables used:
1842
   s->mb_intra : true if intra macroblock
1843
   s->mv_dir   : motion vector direction
1844
   s->mv_type  : motion vector type
1845
   s->mv       : motion vector
1846
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1847
 */
1848
static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
1849
{
1850
    int mb_x, mb_y;
1851
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1852
#ifdef HAVE_XVMC
1853
    if(s->avctx->xvmc_acceleration){
1854
        XVMC_decode_mb(s);//xvmc uses pblocks
1855
        return;
1856
    }
1857
#endif
1858

    
1859
    mb_x = s->mb_x;
1860
    mb_y = s->mb_y;
1861

    
1862
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1863
       /* save DCT coefficients */
1864
       int i,j;
1865
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1866
       for(i=0; i<6; i++)
1867
           for(j=0; j<64; j++)
1868
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1869
    }
1870

    
1871
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1872

    
1873
    /* update DC predictors for P macroblocks */
1874
    if (!s->mb_intra) {
1875
        if (s->h263_pred || s->h263_aic) {
1876
            if(s->mbintra_table[mb_xy])
1877
                ff_clean_intra_table_entries(s);
1878
        } else {
1879
            s->last_dc[0] =
1880
            s->last_dc[1] =
1881
            s->last_dc[2] = 128 << s->intra_dc_precision;
1882
        }
1883
    }
1884
    else if (s->h263_pred || s->h263_aic)
1885
        s->mbintra_table[mb_xy]=1;
1886

    
1887
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1888
        uint8_t *dest_y, *dest_cb, *dest_cr;
1889
        int dct_linesize, dct_offset;
1890
        op_pixels_func (*op_pix)[4];
1891
        qpel_mc_func (*op_qpix)[16];
1892
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1893
        const int uvlinesize= s->current_picture.linesize[1];
1894
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1895
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1896

    
1897
        /* avoid copy if macroblock skipped in last frame too */
1898
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1899
        if(!s->encoding){
1900
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1901
            const int age= s->current_picture.age;
1902

    
1903
            assert(age);
1904

    
1905
            if (s->mb_skipped) {
1906
                s->mb_skipped= 0;
1907
                assert(s->pict_type!=I_TYPE);
1908

    
1909
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1910
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1911

    
1912
                /* if previous was skipped too, then nothing to do !  */
1913
                if (*mbskip_ptr >= age && s->current_picture.reference){
1914
                    return;
1915
                }
1916
            } else if(!s->current_picture.reference){
1917
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1918
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1919
            } else{
1920
                *mbskip_ptr = 0; /* not skipped */
1921
            }
1922
        }
1923

    
1924
        dct_linesize = linesize << s->interlaced_dct;
1925
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1926

    
1927
        if(readable){
1928
            dest_y=  s->dest[0];
1929
            dest_cb= s->dest[1];
1930
            dest_cr= s->dest[2];
1931
        }else{
1932
            dest_y = s->b_scratchpad;
1933
            dest_cb= s->b_scratchpad+16*linesize;
1934
            dest_cr= s->b_scratchpad+32*linesize;
1935
        }
1936

    
1937
        if (!s->mb_intra) {
1938
            /* motion handling */
1939
            /* decoding or more than one mb_type (MC was already done otherwise) */
1940
            if(!s->encoding){
1941
                if(lowres_flag){
1942
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1943

    
1944
                    if (s->mv_dir & MV_DIR_FORWARD) {
1945
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1946
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1947
                    }
1948
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1949
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1950
                    }
1951
                }else{
1952
                    op_qpix= s->me.qpel_put;
1953
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
1954
                        op_pix = s->dsp.put_pixels_tab;
1955
                    }else{
1956
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1957
                    }
1958
                    if (s->mv_dir & MV_DIR_FORWARD) {
1959
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1960
                        op_pix = s->dsp.avg_pixels_tab;
1961
                        op_qpix= s->me.qpel_avg;
1962
                    }
1963
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1964
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1965
                    }
1966
                }
1967
            }
1968

    
1969
            /* skip dequant / idct if we are really late ;) */
1970
            if(s->hurry_up>1) goto skip_idct;
1971
            if(s->avctx->skip_idct){
1972
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
1973
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
1974
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1975
                    goto skip_idct;
1976
            }
1977

    
1978
            /* add dct residue */
1979
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1980
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1981
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1982
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1983
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1984
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1985

    
1986
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1987
                    if (s->chroma_y_shift){
1988
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1989
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1990
                    }else{
1991
                        dct_linesize >>= 1;
1992
                        dct_offset >>=1;
1993
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1994
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1995
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1996
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1997
                    }
1998
                }
1999
            } else if(s->codec_id != CODEC_ID_WMV2){
2000
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2001
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2002
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2003
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2004

    
2005
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2006
                    if(s->chroma_y_shift){//Chroma420
2007
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
2008
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
2009
                    }else{
2010
                        //chroma422
2011
                        dct_linesize = uvlinesize << s->interlaced_dct;
2012
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2013

    
2014
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
2015
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
2016
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2017
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2018
                        if(!s->chroma_x_shift){//Chroma444
2019
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2020
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2021
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2022
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2023
                        }
2024
                    }
2025
                }//fi gray
2026
            }
2027
            else if (ENABLE_WMV2) {
2028
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2029
            }
2030
        } else {
2031
            /* dct only in intra block */
2032
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2033
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2034
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2035
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2036
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2037

    
2038
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2039
                    if(s->chroma_y_shift){
2040
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2041
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2042
                    }else{
2043
                        dct_offset >>=1;
2044
                        dct_linesize >>=1;
2045
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2046
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2047
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2048
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2049
                    }
2050
                }
2051
            }else{
2052
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2053
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2054
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2055
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2056

    
2057
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2058
                    if(s->chroma_y_shift){
2059
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2060
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2061
                    }else{
2062

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

    
2066
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2067
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2068
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2069
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2070
                        if(!s->chroma_x_shift){//Chroma444
2071
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2072
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2073
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2074
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2075
                        }
2076
                    }
2077
                }//gray
2078
            }
2079
        }
2080
skip_idct:
2081
        if(!readable){
2082
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2083
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2084
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2085
        }
2086
    }
2087
}
2088

    
2089
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2090
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
2091
    else                  MPV_decode_mb_internal(s, block, 0);
2092
}
2093

    
2094
/**
2095
 *
2096
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2097
 */
2098
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2099
    if (s->avctx->draw_horiz_band) {
2100
        AVFrame *src;
2101
        int offset[4];
2102

    
2103
        if(s->picture_structure != PICT_FRAME){
2104
            h <<= 1;
2105
            y <<= 1;
2106
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2107
        }
2108

    
2109
        h= FFMIN(h, s->avctx->height - y);
2110

    
2111
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2112
            src= (AVFrame*)s->current_picture_ptr;
2113
        else if(s->last_picture_ptr)
2114
            src= (AVFrame*)s->last_picture_ptr;
2115
        else
2116
            return;
2117

    
2118
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2119
            offset[0]=
2120
            offset[1]=
2121
            offset[2]=
2122
            offset[3]= 0;
2123
        }else{
2124
            offset[0]= y * s->linesize;;
2125
            offset[1]=
2126
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2127
            offset[3]= 0;
2128
        }
2129

    
2130
        emms_c();
2131

    
2132
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2133
                                  y, s->picture_structure, h);
2134
    }
2135
}
2136

    
2137
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2138
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2139
    const int uvlinesize= s->current_picture.linesize[1];
2140
    const int mb_size= 4 - s->avctx->lowres;
2141

    
2142
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2143
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2144
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2145
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2146
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2147
    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;
2148
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2149

    
2150
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2151
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2152
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2153

    
2154
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2155
    {
2156
        s->dest[0] += s->mb_y *   linesize << mb_size;
2157
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2158
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2159
    }
2160
}
2161

    
2162
void ff_mpeg_flush(AVCodecContext *avctx){
2163
    int i;
2164
    MpegEncContext *s = avctx->priv_data;
2165

    
2166
    if(s==NULL || s->picture==NULL)
2167
        return;
2168

    
2169
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2170
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2171
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2172
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2173
    }
2174
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2175

    
2176
    s->mb_x= s->mb_y= 0;
2177

    
2178
    s->parse_context.state= -1;
2179
    s->parse_context.frame_start_found= 0;
2180
    s->parse_context.overread= 0;
2181
    s->parse_context.overread_index= 0;
2182
    s->parse_context.index= 0;
2183
    s->parse_context.last_index= 0;
2184
    s->bitstream_buffer_size=0;
2185
    s->pp_time=0;
2186
}
2187

    
2188
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2189
                                   DCTELEM *block, int n, int qscale)
2190
{
2191
    int i, level, nCoeffs;
2192
    const uint16_t *quant_matrix;
2193

    
2194
    nCoeffs= s->block_last_index[n];
2195

    
2196
    if (n < 4)
2197
        block[0] = block[0] * s->y_dc_scale;
2198
    else
2199
        block[0] = block[0] * s->c_dc_scale;
2200
    /* XXX: only mpeg1 */
2201
    quant_matrix = s->intra_matrix;
2202
    for(i=1;i<=nCoeffs;i++) {
2203
        int j= s->intra_scantable.permutated[i];
2204
        level = block[j];
2205
        if (level) {
2206
            if (level < 0) {
2207
                level = -level;
2208
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2209
                level = (level - 1) | 1;
2210
                level = -level;
2211
            } else {
2212
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2213
                level = (level - 1) | 1;
2214
            }
2215
            block[j] = level;
2216
        }
2217
    }
2218
}
2219

    
2220
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2221
                                   DCTELEM *block, int n, int qscale)
2222
{
2223
    int i, level, nCoeffs;
2224
    const uint16_t *quant_matrix;
2225

    
2226
    nCoeffs= s->block_last_index[n];
2227

    
2228
    quant_matrix = s->inter_matrix;
2229
    for(i=0; i<=nCoeffs; i++) {
2230
        int j= s->intra_scantable.permutated[i];
2231
        level = block[j];
2232
        if (level) {
2233
            if (level < 0) {
2234
                level = -level;
2235
                level = (((level << 1) + 1) * qscale *
2236
                         ((int) (quant_matrix[j]))) >> 4;
2237
                level = (level - 1) | 1;
2238
                level = -level;
2239
            } else {
2240
                level = (((level << 1) + 1) * qscale *
2241
                         ((int) (quant_matrix[j]))) >> 4;
2242
                level = (level - 1) | 1;
2243
            }
2244
            block[j] = level;
2245
        }
2246
    }
2247
}
2248

    
2249
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2250
                                   DCTELEM *block, int n, int qscale)
2251
{
2252
    int i, level, nCoeffs;
2253
    const uint16_t *quant_matrix;
2254

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

    
2258
    if (n < 4)
2259
        block[0] = block[0] * s->y_dc_scale;
2260
    else
2261
        block[0] = block[0] * s->c_dc_scale;
2262
    quant_matrix = s->intra_matrix;
2263
    for(i=1;i<=nCoeffs;i++) {
2264
        int j= s->intra_scantable.permutated[i];
2265
        level = block[j];
2266
        if (level) {
2267
            if (level < 0) {
2268
                level = -level;
2269
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2270
                level = -level;
2271
            } else {
2272
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2273
            }
2274
            block[j] = level;
2275
        }
2276
    }
2277
}
2278

    
2279
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2280
                                   DCTELEM *block, int n, int qscale)
2281
{
2282
    int i, level, nCoeffs;
2283
    const uint16_t *quant_matrix;
2284
    int sum=-1;
2285

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

    
2289
    if (n < 4)
2290
        block[0] = block[0] * s->y_dc_scale;
2291
    else
2292
        block[0] = block[0] * s->c_dc_scale;
2293
    quant_matrix = s->intra_matrix;
2294
    for(i=1;i<=nCoeffs;i++) {
2295
        int j= s->intra_scantable.permutated[i];
2296
        level = block[j];
2297
        if (level) {
2298
            if (level < 0) {
2299
                level = -level;
2300
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2301
                level = -level;
2302
            } else {
2303
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2304
            }
2305
            block[j] = level;
2306
            sum+=level;
2307
        }
2308
    }
2309
    block[63]^=sum&1;
2310
}
2311

    
2312
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2313
                                   DCTELEM *block, int n, int qscale)
2314
{
2315
    int i, level, nCoeffs;
2316
    const uint16_t *quant_matrix;
2317
    int sum=-1;
2318

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

    
2322
    quant_matrix = s->inter_matrix;
2323
    for(i=0; i<=nCoeffs; i++) {
2324
        int j= s->intra_scantable.permutated[i];
2325
        level = block[j];
2326
        if (level) {
2327
            if (level < 0) {
2328
                level = -level;
2329
                level = (((level << 1) + 1) * qscale *
2330
                         ((int) (quant_matrix[j]))) >> 4;
2331
                level = -level;
2332
            } else {
2333
                level = (((level << 1) + 1) * qscale *
2334
                         ((int) (quant_matrix[j]))) >> 4;
2335
            }
2336
            block[j] = level;
2337
            sum+=level;
2338
        }
2339
    }
2340
    block[63]^=sum&1;
2341
}
2342

    
2343
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2344
                                  DCTELEM *block, int n, int qscale)
2345
{
2346
    int i, level, qmul, qadd;
2347
    int nCoeffs;
2348

    
2349
    assert(s->block_last_index[n]>=0);
2350

    
2351
    qmul = qscale << 1;
2352

    
2353
    if (!s->h263_aic) {
2354
        if (n < 4)
2355
            block[0] = block[0] * s->y_dc_scale;
2356
        else
2357
            block[0] = block[0] * s->c_dc_scale;
2358
        qadd = (qscale - 1) | 1;
2359
    }else{
2360
        qadd = 0;
2361
    }
2362
    if(s->ac_pred)
2363
        nCoeffs=63;
2364
    else
2365
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2366

    
2367
    for(i=1; i<=nCoeffs; i++) {
2368
        level = block[i];
2369
        if (level) {
2370
            if (level < 0) {
2371
                level = level * qmul - qadd;
2372
            } else {
2373
                level = level * qmul + qadd;
2374
            }
2375
            block[i] = level;
2376
        }
2377
    }
2378
}
2379

    
2380
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2381
                                  DCTELEM *block, int n, int qscale)
2382
{
2383
    int i, level, qmul, qadd;
2384
    int nCoeffs;
2385

    
2386
    assert(s->block_last_index[n]>=0);
2387

    
2388
    qadd = (qscale - 1) | 1;
2389
    qmul = qscale << 1;
2390

    
2391
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2392

    
2393
    for(i=0; i<=nCoeffs; i++) {
2394
        level = block[i];
2395
        if (level) {
2396
            if (level < 0) {
2397
                level = level * qmul - qadd;
2398
            } else {
2399
                level = level * qmul + qadd;
2400
            }
2401
            block[i] = level;
2402
        }
2403
    }
2404
}
2405

    
2406
/**
2407
 * set qscale and update qscale dependent variables.
2408
 */
2409
void ff_set_qscale(MpegEncContext * s, int qscale)
2410
{
2411
    if (qscale < 1)
2412
        qscale = 1;
2413
    else if (qscale > 31)
2414
        qscale = 31;
2415

    
2416
    s->qscale = qscale;
2417
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2418

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