Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 00f0564f

History | View | Annotate | Download (88.6 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=  be2me_32(unaligned32(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(ARCH_POWERPC)
155
    MPV_common_init_ppc(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

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

    
199
        assert(!pic->data[0]);
200

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

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

    
208
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
209
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
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
            return -1;
216
        }
217

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

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

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

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

    
262
    return 0;
263
fail: //for the CHECKED_ALLOCZ macro
264
    return -1;
265
}
266

    
267
/**
268
 * deallocates a picture
269
 */
270
static void free_picture(MpegEncContext *s, Picture *pic){
271
    int i;
272

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

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

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

    
300
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
301
    int i;
302

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

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

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

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

    
333
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
334
    av_freep(&s->me.scratchpad);
335
    s->rd_scratchpad=
336
    s->b_scratchpad=
337
    s->obmc_scratchpad= NULL;
338

    
339
    av_freep(&s->dct_error_sum);
340
    av_freep(&s->me.map);
341
    av_freep(&s->me.score_map);
342
    av_freep(&s->blocks);
343
    s->block= NULL;
344
}
345

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

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

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

    
394
    s->coded_picture_number = 0;
395
    s->picture_number = 0;
396
    s->input_picture_number = 0;
397

    
398
    s->picture_in_gop_number = 0;
399

    
400
    s->f_code = 1;
401
    s->b_code = 1;
402
}
403

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

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

    
420
    s->mb_height = (s->height + 15) / 16;
421

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

    
427
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
428
        return -1;
429

    
430
    dsputil_init(&s->dsp, s->avctx);
431
    DCT_common_init(s);
432

    
433
    s->flags= s->avctx->flags;
434
    s->flags2= s->avctx->flags2;
435

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

    
443
    /* set chroma shifts */
444
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
445
                                                    &(s->chroma_y_shift) );
446

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

    
451
    s->mb_num = s->mb_width * s->mb_height;
452

    
453
    s->block_wrap[0]=
454
    s->block_wrap[1]=
455
    s->block_wrap[2]=
456
    s->block_wrap[3]= s->b8_stride;
457
    s->block_wrap[4]=
458
    s->block_wrap[5]= s->mb_stride;
459

    
460
    y_size = s->b8_stride * (2 * s->mb_height + 1);
461
    c_size = s->mb_stride * (s->mb_height + 1);
462
    yc_size = y_size + 2 * c_size;
463

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

    
470
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
471
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
472
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
473
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
474

    
475
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
476

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

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

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

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

    
508
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
509

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

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

    
523
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
524

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

    
548
        /* cbp values */
549
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
550
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
551

    
552
        /* cbp, ac_pred, pred_dir */
553
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
554
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
555
    }
556

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

    
568
    /* which mb is a intra block */
569
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
570
    memset(s->mbintra_table, 1, mb_array_size);
571

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

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

    
584
    s->context_initialized = 1;
585

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

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

    
599
    return 0;
600
 fail:
601
    MPV_common_end(s);
602
    return -1;
603
}
604

    
605
/* init common structure for both encoder and decoder */
606
void MPV_common_end(MpegEncContext *s)
607
{
608
    int i, j, k;
609

    
610
    for(i=0; i<s->avctx->thread_count; i++){
611
        free_duplicate_context(s->thread_context[i]);
612
    }
613
    for(i=1; i<s->avctx->thread_count; i++){
614
        av_freep(&s->thread_context[i]);
615
    }
616

    
617
    av_freep(&s->parse_context.buffer);
618
    s->parse_context.buffer_size=0;
619

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

    
646
    av_freep(&s->dc_val_base);
647
    av_freep(&s->ac_val_base);
648
    av_freep(&s->coded_block_base);
649
    av_freep(&s->mbintra_table);
650
    av_freep(&s->cbp_table);
651
    av_freep(&s->pred_dir_table);
652

    
653
    av_freep(&s->mbskip_table);
654
    av_freep(&s->prev_pict_types);
655
    av_freep(&s->bitstream_buffer);
656
    s->allocated_bitstream_buffer_size=0;
657

    
658
    av_freep(&s->avctx->stats_out);
659
    av_freep(&s->ac_stats);
660
    av_freep(&s->error_status_table);
661
    av_freep(&s->mb_index2xy);
662
    av_freep(&s->lambda_table);
663
    av_freep(&s->q_intra_matrix);
664
    av_freep(&s->q_inter_matrix);
665
    av_freep(&s->q_intra_matrix16);
666
    av_freep(&s->q_inter_matrix16);
667
    av_freep(&s->input_picture);
668
    av_freep(&s->reordered_input_picture);
669
    av_freep(&s->dct_offset);
670

    
671
    if(s->picture){
672
        for(i=0; i<MAX_PICTURE_COUNT; i++){
673
            free_picture(s, &s->picture[i]);
674
        }
675
    }
676
    av_freep(&s->picture);
677
    s->context_initialized = 0;
678
    s->last_picture_ptr=
679
    s->next_picture_ptr=
680
    s->current_picture_ptr= NULL;
681
    s->linesize= s->uvlinesize= 0;
682

    
683
    for(i=0; i<3; i++)
684
        av_freep(&s->visualization_buffer[i]);
685

    
686
    avcodec_default_free_buffers(s->avctx);
687
}
688

    
689
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
690
{
691
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
692
    uint8_t index_run[MAX_RUN+1];
693
    int last, run, level, start, end, i;
694

    
695
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
696
    if(static_store && rl->max_level[0])
697
        return;
698

    
699
    /* compute max_level[], max_run[] and index_run[] */
700
    for(last=0;last<2;last++) {
701
        if (last == 0) {
702
            start = 0;
703
            end = rl->last;
704
        } else {
705
            start = rl->last;
706
            end = rl->n;
707
        }
708

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

    
740
void init_vlc_rl(RLTable *rl, int use_static)
741
{
742
    int i, q;
743

    
744
    /* Return if static table is already initialized */
745
    if(use_static && rl->rl_vlc[0])
746
        return;
747

    
748
    init_vlc(&rl->vlc, 9, rl->n + 1,
749
             &rl->table_vlc[0][1], 4, 2,
750
             &rl->table_vlc[0][0], 4, 2, use_static);
751

    
752

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

    
757
        if(q==0){
758
            qmul=1;
759
            qadd=0;
760
        }
761
        if(use_static)
762
            rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
763
        else
764
            rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
765
        for(i=0; i<rl->vlc.table_size; i++){
766
            int code= rl->vlc.table[i][0];
767
            int len = rl->vlc.table[i][1];
768
            int level, run;
769

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

    
793
/* draw the edges of width 'w' of an image of size width, height */
794
//FIXME check that this is ok for mpeg4 interlaced
795
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
796
{
797
    uint8_t *ptr, *last_line;
798
    int i;
799

    
800
    last_line = buf + (height - 1) * wrap;
801
    for(i=0;i<w;i++) {
802
        /* top and bottom */
803
        memcpy(buf - (i + 1) * wrap, buf, width);
804
        memcpy(last_line + (i + 1) * wrap, last_line, width);
805
    }
806
    /* left and right */
807
    ptr = buf;
808
    for(i=0;i<height;i++) {
809
        memset(ptr - w, ptr[0], w);
810
        memset(ptr + width, ptr[width-1], w);
811
        ptr += wrap;
812
    }
813
    /* corners */
814
    for(i=0;i<w;i++) {
815
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
816
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
817
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
818
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
819
    }
820
}
821

    
822
int ff_find_unused_picture(MpegEncContext *s, int shared){
823
    int i;
824

    
825
    if(shared){
826
        for(i=0; i<MAX_PICTURE_COUNT; i++){
827
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
828
        }
829
    }else{
830
        for(i=0; i<MAX_PICTURE_COUNT; i++){
831
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
832
        }
833
        for(i=0; i<MAX_PICTURE_COUNT; i++){
834
            if(s->picture[i].data[0]==NULL) return i;
835
        }
836
    }
837

    
838
    assert(0);
839
    return -1;
840
}
841

    
842
static void update_noise_reduction(MpegEncContext *s){
843
    int intra, i;
844

    
845
    for(intra=0; intra<2; intra++){
846
        if(s->dct_count[intra] > (1<<16)){
847
            for(i=0; i<64; i++){
848
                s->dct_error_sum[intra][i] >>=1;
849
            }
850
            s->dct_count[intra] >>= 1;
851
        }
852

    
853
        for(i=0; i<64; i++){
854
            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);
855
        }
856
    }
857
}
858

    
859
/**
860
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
861
 */
862
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
863
{
864
    int i;
865
    AVFrame *pic;
866
    s->mb_skipped = 0;
867

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

    
870
    /* mark&release old frames */
871
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
872
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
873
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
874

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

    
896
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
897
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
898
        else{
899
            i= ff_find_unused_picture(s, 0);
900
            pic= (AVFrame*)&s->picture[i];
901
        }
902

    
903
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
904
                        && !s->dropable ? 3 : 0;
905

    
906
        pic->coded_picture_number= s->coded_picture_number++;
907

    
908
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
909
            return -1;
910

    
911
        s->current_picture_ptr= (Picture*)pic;
912
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
913
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
914
    }
915

    
916
    s->current_picture_ptr->pict_type= s->pict_type;
917
//    if(s->flags && CODEC_FLAG_QSCALE)
918
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
919
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
920

    
921
    copy_picture(&s->current_picture, s->current_picture_ptr);
922

    
923
    if (s->pict_type != B_TYPE) {
924
        s->last_picture_ptr= s->next_picture_ptr;
925
        if(!s->dropable)
926
            s->next_picture_ptr= s->current_picture_ptr;
927
    }
928
/*    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,
929
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
930
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
931
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
932
        s->pict_type, s->dropable);*/
933

    
934
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
935
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
936

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

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

    
945
    if(s->picture_structure!=PICT_FRAME){
946
        int i;
947
        for(i=0; i<4; i++){
948
            if(s->picture_structure == PICT_BOTTOM_FIELD){
949
                 s->current_picture.data[i] += s->current_picture.linesize[i];
950
            }
951
            s->current_picture.linesize[i] *= 2;
952
            s->last_picture.linesize[i] *=2;
953
            s->next_picture.linesize[i] *=2;
954
        }
955
    }
956

    
957
    s->hurry_up= s->avctx->hurry_up;
958
    s->error_resilience= avctx->error_resilience;
959

    
960
    /* set dequantizer, we can't do it during init as it might change for mpeg4
961
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
962
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
963
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
964
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
965
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
966
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
967
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
968
    }else{
969
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
970
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
971
    }
972

    
973
    if(s->dct_error_sum){
974
        assert(s->avctx->noise_reduction && s->encoding);
975

    
976
        update_noise_reduction(s);
977
    }
978

    
979
#ifdef HAVE_XVMC
980
    if(s->avctx->xvmc_acceleration)
981
        return XVMC_field_start(s, avctx);
982
#endif
983
    return 0;
984
}
985

    
986
/* generic function for encode/decode called after a frame has been coded/decoded */
987
void MPV_frame_end(MpegEncContext *s)
988
{
989
    int i;
990
    /* draw edge for correct motion prediction if outside */
991
#ifdef HAVE_XVMC
992
//just to make sure that all data is rendered.
993
    if(s->avctx->xvmc_acceleration){
994
        XVMC_field_end(s);
995
    }else
996
#endif
997
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
998
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
999
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1000
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1001
    }
1002
    emms_c();
1003

    
1004
    s->last_pict_type    = s->pict_type;
1005
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1006
    if(s->pict_type!=B_TYPE){
1007
        s->last_non_b_pict_type= s->pict_type;
1008
    }
1009
#if 0
1010
        /* copy back current_picture variables */
1011
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1012
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1013
            s->picture[i]= s->current_picture;
1014
            break;
1015
        }
1016
    }
1017
    assert(i<MAX_PICTURE_COUNT);
1018
#endif
1019

    
1020
    if(s->encoding){
1021
        /* release non-reference frames */
1022
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1023
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1024
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1025
            }
1026
        }
1027
    }
1028
    // clear copies, to avoid confusion
1029
#if 0
1030
    memset(&s->last_picture, 0, sizeof(Picture));
1031
    memset(&s->next_picture, 0, sizeof(Picture));
1032
    memset(&s->current_picture, 0, sizeof(Picture));
1033
#endif
1034
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1035
}
1036

    
1037
/**
1038
 * draws an line from (ex, ey) -> (sx, sy).
1039
 * @param w width of the image
1040
 * @param h height of the image
1041
 * @param stride stride/linesize of the image
1042
 * @param color color of the arrow
1043
 */
1044
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1045
    int x, y, fr, f;
1046

    
1047
    sx= av_clip(sx, 0, w-1);
1048
    sy= av_clip(sy, 0, h-1);
1049
    ex= av_clip(ex, 0, w-1);
1050
    ey= av_clip(ey, 0, h-1);
1051

    
1052
    buf[sy*stride + sx]+= color;
1053

    
1054
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1055
        if(sx > ex){
1056
            FFSWAP(int, sx, ex);
1057
            FFSWAP(int, sy, ey);
1058
        }
1059
        buf+= sx + sy*stride;
1060
        ex-= sx;
1061
        f= ((ey-sy)<<16)/ex;
1062
        for(x= 0; x <= ex; x++){
1063
            y = (x*f)>>16;
1064
            fr= (x*f)&0xFFFF;
1065
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1066
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1067
        }
1068
    }else{
1069
        if(sy > ey){
1070
            FFSWAP(int, sx, ex);
1071
            FFSWAP(int, sy, ey);
1072
        }
1073
        buf+= sx + sy*stride;
1074
        ey-= sy;
1075
        if(ey) f= ((ex-sx)<<16)/ey;
1076
        else   f= 0;
1077
        for(y= 0; y <= ey; y++){
1078
            x = (y*f)>>16;
1079
            fr= (y*f)&0xFFFF;
1080
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1081
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1082
        }
1083
    }
1084
}
1085

    
1086
/**
1087
 * draws an arrow from (ex, ey) -> (sx, sy).
1088
 * @param w width of the image
1089
 * @param h height of the image
1090
 * @param stride stride/linesize of the image
1091
 * @param color color of the arrow
1092
 */
1093
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1094
    int dx,dy;
1095

    
1096
    sx= av_clip(sx, -100, w+100);
1097
    sy= av_clip(sy, -100, h+100);
1098
    ex= av_clip(ex, -100, w+100);
1099
    ey= av_clip(ey, -100, h+100);
1100

    
1101
    dx= ex - sx;
1102
    dy= ey - sy;
1103

    
1104
    if(dx*dx + dy*dy > 3*3){
1105
        int rx=  dx + dy;
1106
        int ry= -dx + dy;
1107
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1108

    
1109
        //FIXME subpixel accuracy
1110
        rx= ROUNDED_DIV(rx*3<<4, length);
1111
        ry= ROUNDED_DIV(ry*3<<4, length);
1112

    
1113
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1114
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1115
    }
1116
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1117
}
1118

    
1119
/**
1120
 * prints debuging info for the given picture.
1121
 */
1122
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1123

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

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

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

    
1178
                    //segmentation
1179
                    if(IS_8X8(mb_type))
1180
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1181
                    else if(IS_16X8(mb_type))
1182
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1183
                    else if(IS_8X16(mb_type))
1184
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1185
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1186
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1187
                    else
1188
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1189

    
1190

    
1191
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1192
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1193
                    else
1194
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1195
                }
1196
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1197
            }
1198
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1199
        }
1200
    }
1201

    
1202
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1203
        const int shift= 1 + s->quarter_sample;
1204
        int mb_y;
1205
        uint8_t *ptr;
1206
        int i;
1207
        int h_chroma_shift, v_chroma_shift;
1208
        const int width = s->avctx->width;
1209
        const int height= s->avctx->height;
1210
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1211
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1212
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1213

    
1214
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1215
        for(i=0; i<3; i++){
1216
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1217
            pict->data[i]= s->visualization_buffer[i];
1218
        }
1219
        pict->type= FF_BUFFER_TYPE_COPY;
1220
        ptr= pict->data[0];
1221

    
1222
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1223
            int mb_x;
1224
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1225
                const int mb_index= mb_x + mb_y*s->mb_stride;
1226
                if((s->avctx->debug_mv) && pict->motion_val){
1227
                  int type;
1228
                  for(type=0; type<3; type++){
1229
                    int direction = 0;
1230
                    switch (type) {
1231
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1232
                                continue;
1233
                              direction = 0;
1234
                              break;
1235
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1236
                                continue;
1237
                              direction = 0;
1238
                              break;
1239
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1240
                                continue;
1241
                              direction = 1;
1242
                              break;
1243
                    }
1244
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1245
                        continue;
1246

    
1247
                    if(IS_8X8(pict->mb_type[mb_index])){
1248
                      int i;
1249
                      for(i=0; i<4; i++){
1250
                        int sx= mb_x*16 + 4 + 8*(i&1);
1251
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1252
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1253
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1254
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1255
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1256
                      }
1257
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1258
                      int i;
1259
                      for(i=0; i<2; i++){
1260
                        int sx=mb_x*16 + 8;
1261
                        int sy=mb_y*16 + 4 + 8*i;
1262
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1263
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1264
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1265

    
1266
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1267
                            my*=2;
1268

    
1269
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1270
                      }
1271
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1272
                      int i;
1273
                      for(i=0; i<2; i++){
1274
                        int sx=mb_x*16 + 4 + 8*i;
1275
                        int sy=mb_y*16 + 8;
1276
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1277
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1278
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1279

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

    
1283
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1284
                      }
1285
                    }else{
1286
                      int sx= mb_x*16 + 8;
1287
                      int sy= mb_y*16 + 8;
1288
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1289
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1290
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1291
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1292
                    }
1293
                  }
1294
                }
1295
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1296
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1297
                    int y;
1298
                    for(y=0; y<8; y++){
1299
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1300
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1301
                    }
1302
                }
1303
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1304
                    int mb_type= pict->mb_type[mb_index];
1305
                    uint64_t u,v;
1306
                    int y;
1307
#define COLOR(theta, r)\
1308
u= (int)(128 + r*cos(theta*3.141592/180));\
1309
v= (int)(128 + r*sin(theta*3.141592/180));
1310

    
1311

    
1312
                    u=v=128;
1313
                    if(IS_PCM(mb_type)){
1314
                        COLOR(120,48)
1315
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1316
                        COLOR(30,48)
1317
                    }else if(IS_INTRA4x4(mb_type)){
1318
                        COLOR(90,48)
1319
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1320
//                        COLOR(120,48)
1321
                    }else if(IS_DIRECT(mb_type)){
1322
                        COLOR(150,48)
1323
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1324
                        COLOR(170,48)
1325
                    }else if(IS_GMC(mb_type)){
1326
                        COLOR(190,48)
1327
                    }else if(IS_SKIP(mb_type)){
1328
//                        COLOR(180,48)
1329
                    }else if(!USES_LIST(mb_type, 1)){
1330
                        COLOR(240,48)
1331
                    }else if(!USES_LIST(mb_type, 0)){
1332
                        COLOR(0,48)
1333
                    }else{
1334
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1335
                        COLOR(300,48)
1336
                    }
1337

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

    
1345
                    //segmentation
1346
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1347
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1348
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1349
                    }
1350
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1351
                        for(y=0; y<16; y++)
1352
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1353
                    }
1354
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1355
                        int dm= 1 << (mv_sample_log2-2);
1356
                        for(i=0; i<4; i++){
1357
                            int sx= mb_x*16 + 8*(i&1);
1358
                            int sy= mb_y*16 + 8*(i>>1);
1359
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1360
                            //FIXME bidir
1361
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1362
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1363
                                for(y=0; y<8; y++)
1364
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1365
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1366
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1367
                        }
1368
                    }
1369

    
1370
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1371
                        // hmm
1372
                    }
1373
                }
1374
                s->mbskip_table[mb_index]=0;
1375
            }
1376
        }
1377
    }
1378
}
1379

    
1380
/**
1381
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1382
 * @param buf destination buffer
1383
 * @param src source buffer
1384
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1385
 * @param block_w width of block
1386
 * @param block_h height of block
1387
 * @param src_x x coordinate of the top left sample of the block in the source buffer
1388
 * @param src_y y coordinate of the top left sample of the block in the source buffer
1389
 * @param w width of the source buffer
1390
 * @param h height of the source buffer
1391
 */
1392
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1393
                                    int src_x, int src_y, int w, int h){
1394
    int x, y;
1395
    int start_y, start_x, end_y, end_x;
1396

    
1397
    if(src_y>= h){
1398
        src+= (h-1-src_y)*linesize;
1399
        src_y=h-1;
1400
    }else if(src_y<=-block_h){
1401
        src+= (1-block_h-src_y)*linesize;
1402
        src_y=1-block_h;
1403
    }
1404
    if(src_x>= w){
1405
        src+= (w-1-src_x);
1406
        src_x=w-1;
1407
    }else if(src_x<=-block_w){
1408
        src+= (1-block_w-src_x);
1409
        src_x=1-block_w;
1410
    }
1411

    
1412
    start_y= FFMAX(0, -src_y);
1413
    start_x= FFMAX(0, -src_x);
1414
    end_y= FFMIN(block_h, h-src_y);
1415
    end_x= FFMIN(block_w, w-src_x);
1416

    
1417
    // copy existing part
1418
    for(y=start_y; y<end_y; y++){
1419
        for(x=start_x; x<end_x; x++){
1420
            buf[x + y*linesize]= src[x + y*linesize];
1421
        }
1422
    }
1423

    
1424
    //top
1425
    for(y=0; y<start_y; y++){
1426
        for(x=start_x; x<end_x; x++){
1427
            buf[x + y*linesize]= buf[x + start_y*linesize];
1428
        }
1429
    }
1430

    
1431
    //bottom
1432
    for(y=end_y; y<block_h; y++){
1433
        for(x=start_x; x<end_x; x++){
1434
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1435
        }
1436
    }
1437

    
1438
    for(y=0; y<block_h; y++){
1439
       //left
1440
        for(x=0; x<start_x; x++){
1441
            buf[x + y*linesize]= buf[start_x + y*linesize];
1442
        }
1443

    
1444
       //right
1445
        for(x=end_x; x<block_w; x++){
1446
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1447
        }
1448
    }
1449
}
1450

    
1451
static inline int hpel_motion_lowres(MpegEncContext *s,
1452
                                  uint8_t *dest, uint8_t *src,
1453
                                  int field_based, int field_select,
1454
                                  int src_x, int src_y,
1455
                                  int width, int height, int stride,
1456
                                  int h_edge_pos, int v_edge_pos,
1457
                                  int w, int h, h264_chroma_mc_func *pix_op,
1458
                                  int motion_x, int motion_y)
1459
{
1460
    const int lowres= s->avctx->lowres;
1461
    const int s_mask= (2<<lowres)-1;
1462
    int emu=0;
1463
    int sx, sy;
1464

    
1465
    if(s->quarter_sample){
1466
        motion_x/=2;
1467
        motion_y/=2;
1468
    }
1469

    
1470
    sx= motion_x & s_mask;
1471
    sy= motion_y & s_mask;
1472
    src_x += motion_x >> (lowres+1);
1473
    src_y += motion_y >> (lowres+1);
1474

    
1475
    src += src_y * stride + src_x;
1476

    
1477
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1478
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1479
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1480
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1481
        src= s->edge_emu_buffer;
1482
        emu=1;
1483
    }
1484

    
1485
    sx <<= 2 - lowres;
1486
    sy <<= 2 - lowres;
1487
    if(field_select)
1488
        src += s->linesize;
1489
    pix_op[lowres](dest, src, stride, h, sx, sy);
1490
    return emu;
1491
}
1492

    
1493
/* apply one mpeg motion vector to the three components */
1494
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1495
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1496
                               int field_based, int bottom_field, int field_select,
1497
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1498
                               int motion_x, int motion_y, int h)
1499
{
1500
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1501
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1502
    const int lowres= s->avctx->lowres;
1503
    const int block_s= 8>>lowres;
1504
    const int s_mask= (2<<lowres)-1;
1505
    const int h_edge_pos = s->h_edge_pos >> lowres;
1506
    const int v_edge_pos = s->v_edge_pos >> lowres;
1507
    linesize   = s->current_picture.linesize[0] << field_based;
1508
    uvlinesize = s->current_picture.linesize[1] << field_based;
1509

    
1510
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1511
        motion_x/=2;
1512
        motion_y/=2;
1513
    }
1514

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

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

    
1524
    if (s->out_format == FMT_H263) {
1525
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1526
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1527
        uvsrc_x = src_x>>1;
1528
        uvsrc_y = src_y>>1;
1529
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1530
        mx = motion_x / 4;
1531
        my = motion_y / 4;
1532
        uvsx = (2*mx) & s_mask;
1533
        uvsy = (2*my) & s_mask;
1534
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1535
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1536
    } else {
1537
        mx = motion_x / 2;
1538
        my = motion_y / 2;
1539
        uvsx = mx & s_mask;
1540
        uvsy = my & s_mask;
1541
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1542
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1543
    }
1544

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

    
1549
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1550
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1551
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1552
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1553
            ptr_y = s->edge_emu_buffer;
1554
            if(!(s->flags&CODEC_FLAG_GRAY)){
1555
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1556
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1557
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1558
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1559
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1560
                ptr_cb= uvbuf;
1561
                ptr_cr= uvbuf+16;
1562
            }
1563
    }
1564

    
1565
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1566
        dest_y += s->linesize;
1567
        dest_cb+= s->uvlinesize;
1568
        dest_cr+= s->uvlinesize;
1569
    }
1570

    
1571
    if(field_select){
1572
        ptr_y += s->linesize;
1573
        ptr_cb+= s->uvlinesize;
1574
        ptr_cr+= s->uvlinesize;
1575
    }
1576

    
1577
    sx <<= 2 - lowres;
1578
    sy <<= 2 - lowres;
1579
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1580

    
1581
    if(!(s->flags&CODEC_FLAG_GRAY)){
1582
        uvsx <<= 2 - lowres;
1583
        uvsy <<= 2 - lowres;
1584
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1585
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1586
    }
1587
    //FIXME h261 lowres loop filter
1588
}
1589

    
1590
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1591
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1592
                                     uint8_t **ref_picture,
1593
                                     h264_chroma_mc_func *pix_op,
1594
                                     int mx, int my){
1595
    const int lowres= s->avctx->lowres;
1596
    const int block_s= 8>>lowres;
1597
    const int s_mask= (2<<lowres)-1;
1598
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1599
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1600
    int emu=0, src_x, src_y, offset, sx, sy;
1601
    uint8_t *ptr;
1602

    
1603
    if(s->quarter_sample){
1604
        mx/=2;
1605
        my/=2;
1606
    }
1607

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

    
1613
    sx= mx & s_mask;
1614
    sy= my & s_mask;
1615
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1616
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1617

    
1618
    offset = src_y * s->uvlinesize + src_x;
1619
    ptr = ref_picture[1] + offset;
1620
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1621
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1622
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1623
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1624
            ptr= s->edge_emu_buffer;
1625
            emu=1;
1626
        }
1627
    }
1628
    sx <<= 2 - lowres;
1629
    sy <<= 2 - lowres;
1630
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1631

    
1632
    ptr = ref_picture[2] + offset;
1633
    if(emu){
1634
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1635
        ptr= s->edge_emu_buffer;
1636
    }
1637
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1638
}
1639

    
1640
/**
1641
 * motion compensation of a single macroblock
1642
 * @param s context
1643
 * @param dest_y luma destination pointer
1644
 * @param dest_cb chroma cb/u destination pointer
1645
 * @param dest_cr chroma cr/v destination pointer
1646
 * @param dir direction (0->forward, 1->backward)
1647
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1648
 * @param pic_op halfpel motion compensation function (average or put normally)
1649
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1650
 */
1651
static inline void MPV_motion_lowres(MpegEncContext *s,
1652
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1653
                              int dir, uint8_t **ref_picture,
1654
                              h264_chroma_mc_func *pix_op)
1655
{
1656
    int mx, my;
1657
    int mb_x, mb_y, i;
1658
    const int lowres= s->avctx->lowres;
1659
    const int block_s= 8>>lowres;
1660

    
1661
    mb_x = s->mb_x;
1662
    mb_y = s->mb_y;
1663

    
1664
    switch(s->mv_type) {
1665
    case MV_TYPE_16X16:
1666
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1667
                    0, 0, 0,
1668
                    ref_picture, pix_op,
1669
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1670
        break;
1671
    case MV_TYPE_8X8:
1672
        mx = 0;
1673
        my = 0;
1674
            for(i=0;i<4;i++) {
1675
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1676
                            ref_picture[0], 0, 0,
1677
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1678
                            s->width, s->height, s->linesize,
1679
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1680
                            block_s, block_s, pix_op,
1681
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1682

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

    
1687
        if(!(s->flags&CODEC_FLAG_GRAY))
1688
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1689
        break;
1690
    case MV_TYPE_FIELD:
1691
        if (s->picture_structure == PICT_FRAME) {
1692
            /* top field */
1693
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1694
                        1, 0, s->field_select[dir][0],
1695
                        ref_picture, pix_op,
1696
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1697
            /* bottom field */
1698
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1699
                        1, 1, s->field_select[dir][1],
1700
                        ref_picture, pix_op,
1701
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1702
        } else {
1703
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
1704
                ref_picture= s->current_picture_ptr->data;
1705
            }
1706

    
1707
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1708
                        0, 0, s->field_select[dir][0],
1709
                        ref_picture, pix_op,
1710
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1711
        }
1712
        break;
1713
    case MV_TYPE_16X8:
1714
        for(i=0; i<2; i++){
1715
            uint8_t ** ref2picture;
1716

    
1717
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
1718
                ref2picture= ref_picture;
1719
            }else{
1720
                ref2picture= s->current_picture_ptr->data;
1721
            }
1722

    
1723
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1724
                        0, 0, s->field_select[dir][i],
1725
                        ref2picture, pix_op,
1726
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1727

    
1728
            dest_y += 2*block_s*s->linesize;
1729
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1730
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1731
        }
1732
        break;
1733
    case MV_TYPE_DMV:
1734
        if(s->picture_structure == PICT_FRAME){
1735
            for(i=0; i<2; i++){
1736
                int j;
1737
                for(j=0; j<2; j++){
1738
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1739
                                1, j, j^i,
1740
                                ref_picture, pix_op,
1741
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1742
                }
1743
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1744
            }
1745
        }else{
1746
            for(i=0; i<2; i++){
1747
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1748
                            0, 0, s->picture_structure != i+1,
1749
                            ref_picture, pix_op,
1750
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1751

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

    
1755
                //opposite parity is always in the same frame if this is second field
1756
                if(!s->first_field){
1757
                    ref_picture = s->current_picture_ptr->data;
1758
                }
1759
            }
1760
        }
1761
    break;
1762
    default: assert(0);
1763
    }
1764
}
1765

    
1766
/* put block[] to dest[] */
1767
static inline void put_dct(MpegEncContext *s,
1768
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1769
{
1770
    s->dct_unquantize_intra(s, block, i, qscale);
1771
    s->dsp.idct_put (dest, line_size, block);
1772
}
1773

    
1774
/* add block[] to dest[] */
1775
static inline void add_dct(MpegEncContext *s,
1776
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1777
{
1778
    if (s->block_last_index[i] >= 0) {
1779
        s->dsp.idct_add (dest, line_size, block);
1780
    }
1781
}
1782

    
1783
static inline void add_dequant_dct(MpegEncContext *s,
1784
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1785
{
1786
    if (s->block_last_index[i] >= 0) {
1787
        s->dct_unquantize_inter(s, block, i, qscale);
1788

    
1789
        s->dsp.idct_add (dest, line_size, block);
1790
    }
1791
}
1792

    
1793
/**
1794
 * cleans dc, ac, coded_block for the current non intra MB
1795
 */
1796
void ff_clean_intra_table_entries(MpegEncContext *s)
1797
{
1798
    int wrap = s->b8_stride;
1799
    int xy = s->block_index[0];
1800

    
1801
    s->dc_val[0][xy           ] =
1802
    s->dc_val[0][xy + 1       ] =
1803
    s->dc_val[0][xy     + wrap] =
1804
    s->dc_val[0][xy + 1 + wrap] = 1024;
1805
    /* ac pred */
1806
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1807
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1808
    if (s->msmpeg4_version>=3) {
1809
        s->coded_block[xy           ] =
1810
        s->coded_block[xy + 1       ] =
1811
        s->coded_block[xy     + wrap] =
1812
        s->coded_block[xy + 1 + wrap] = 0;
1813
    }
1814
    /* chroma */
1815
    wrap = s->mb_stride;
1816
    xy = s->mb_x + s->mb_y * wrap;
1817
    s->dc_val[1][xy] =
1818
    s->dc_val[2][xy] = 1024;
1819
    /* ac pred */
1820
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1821
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1822

    
1823
    s->mbintra_table[xy]= 0;
1824
}
1825

    
1826
/* generic function called after a macroblock has been parsed by the
1827
   decoder or after it has been encoded by the encoder.
1828

1829
   Important variables used:
1830
   s->mb_intra : true if intra macroblock
1831
   s->mv_dir   : motion vector direction
1832
   s->mv_type  : motion vector type
1833
   s->mv       : motion vector
1834
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1835
 */
1836
static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
1837
{
1838
    int mb_x, mb_y;
1839
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1840
#ifdef HAVE_XVMC
1841
    if(s->avctx->xvmc_acceleration){
1842
        XVMC_decode_mb(s);//xvmc uses pblocks
1843
        return;
1844
    }
1845
#endif
1846

    
1847
    mb_x = s->mb_x;
1848
    mb_y = s->mb_y;
1849

    
1850
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1851
       /* save DCT coefficients */
1852
       int i,j;
1853
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1854
       for(i=0; i<6; i++)
1855
           for(j=0; j<64; j++)
1856
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1857
    }
1858

    
1859
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1860

    
1861
    /* update DC predictors for P macroblocks */
1862
    if (!s->mb_intra) {
1863
        if (s->h263_pred || s->h263_aic) {
1864
            if(s->mbintra_table[mb_xy])
1865
                ff_clean_intra_table_entries(s);
1866
        } else {
1867
            s->last_dc[0] =
1868
            s->last_dc[1] =
1869
            s->last_dc[2] = 128 << s->intra_dc_precision;
1870
        }
1871
    }
1872
    else if (s->h263_pred || s->h263_aic)
1873
        s->mbintra_table[mb_xy]=1;
1874

    
1875
    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
1876
        uint8_t *dest_y, *dest_cb, *dest_cr;
1877
        int dct_linesize, dct_offset;
1878
        op_pixels_func (*op_pix)[4];
1879
        qpel_mc_func (*op_qpix)[16];
1880
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1881
        const int uvlinesize= s->current_picture.linesize[1];
1882
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1883
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1884

    
1885
        /* avoid copy if macroblock skipped in last frame too */
1886
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1887
        if(!s->encoding){
1888
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1889
            const int age= s->current_picture.age;
1890

    
1891
            assert(age);
1892

    
1893
            if (s->mb_skipped) {
1894
                s->mb_skipped= 0;
1895
                assert(s->pict_type!=I_TYPE);
1896

    
1897
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1898
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1899

    
1900
                /* if previous was skipped too, then nothing to do !  */
1901
                if (*mbskip_ptr >= age && s->current_picture.reference){
1902
                    return;
1903
                }
1904
            } else if(!s->current_picture.reference){
1905
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1906
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1907
            } else{
1908
                *mbskip_ptr = 0; /* not skipped */
1909
            }
1910
        }
1911

    
1912
        dct_linesize = linesize << s->interlaced_dct;
1913
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1914

    
1915
        if(readable){
1916
            dest_y=  s->dest[0];
1917
            dest_cb= s->dest[1];
1918
            dest_cr= s->dest[2];
1919
        }else{
1920
            dest_y = s->b_scratchpad;
1921
            dest_cb= s->b_scratchpad+16*linesize;
1922
            dest_cr= s->b_scratchpad+32*linesize;
1923
        }
1924

    
1925
        if (!s->mb_intra) {
1926
            /* motion handling */
1927
            /* decoding or more than one mb_type (MC was already done otherwise) */
1928
            if(!s->encoding){
1929
                if(lowres_flag){
1930
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1931

    
1932
                    if (s->mv_dir & MV_DIR_FORWARD) {
1933
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1934
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1935
                    }
1936
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1937
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1938
                    }
1939
                }else{
1940
                    op_qpix= s->me.qpel_put;
1941
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
1942
                        op_pix = s->dsp.put_pixels_tab;
1943
                    }else{
1944
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1945
                    }
1946
                    if (s->mv_dir & MV_DIR_FORWARD) {
1947
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1948
                        op_pix = s->dsp.avg_pixels_tab;
1949
                        op_qpix= s->me.qpel_avg;
1950
                    }
1951
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1952
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1953
                    }
1954
                }
1955
            }
1956

    
1957
            /* skip dequant / idct if we are really late ;) */
1958
            if(s->hurry_up>1) goto skip_idct;
1959
            if(s->avctx->skip_idct){
1960
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
1961
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
1962
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1963
                    goto skip_idct;
1964
            }
1965

    
1966
            /* add dct residue */
1967
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1968
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1969
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1970
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1971
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1972
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1973

    
1974
                if(!(s->flags&CODEC_FLAG_GRAY)){
1975
                    if (s->chroma_y_shift){
1976
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1977
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1978
                    }else{
1979
                        dct_linesize >>= 1;
1980
                        dct_offset >>=1;
1981
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1982
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1983
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1984
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1985
                    }
1986
                }
1987
            } else if(s->codec_id != CODEC_ID_WMV2){
1988
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1989
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1990
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1991
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1992

    
1993
                if(!(s->flags&CODEC_FLAG_GRAY)){
1994
                    if(s->chroma_y_shift){//Chroma420
1995
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
1996
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
1997
                    }else{
1998
                        //chroma422
1999
                        dct_linesize = uvlinesize << s->interlaced_dct;
2000
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2001

    
2002
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
2003
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
2004
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2005
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2006
                        if(!s->chroma_x_shift){//Chroma444
2007
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2008
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2009
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2010
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2011
                        }
2012
                    }
2013
                }//fi gray
2014
            }
2015
            else if (ENABLE_WMV2) {
2016
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2017
            }
2018
        } else {
2019
            /* dct only in intra block */
2020
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2021
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2022
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2023
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2024
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2025

    
2026
                if(!(s->flags&CODEC_FLAG_GRAY)){
2027
                    if(s->chroma_y_shift){
2028
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2029
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2030
                    }else{
2031
                        dct_offset >>=1;
2032
                        dct_linesize >>=1;
2033
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2034
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2035
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2036
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2037
                    }
2038
                }
2039
            }else{
2040
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2041
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2042
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2043
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2044

    
2045
                if(!(s->flags&CODEC_FLAG_GRAY)){
2046
                    if(s->chroma_y_shift){
2047
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2048
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2049
                    }else{
2050

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

    
2054
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2055
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2056
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2057
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2058
                        if(!s->chroma_x_shift){//Chroma444
2059
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2060
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2061
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2062
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2063
                        }
2064
                    }
2065
                }//gray
2066
            }
2067
        }
2068
skip_idct:
2069
        if(!readable){
2070
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2071
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2072
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2073
        }
2074
    }
2075
}
2076

    
2077
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2078
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
2079
    else                  MPV_decode_mb_internal(s, block, 0);
2080
}
2081

    
2082
/**
2083
 *
2084
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2085
 */
2086
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2087
    if (s->avctx->draw_horiz_band) {
2088
        AVFrame *src;
2089
        int offset[4];
2090

    
2091
        if(s->picture_structure != PICT_FRAME){
2092
            h <<= 1;
2093
            y <<= 1;
2094
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2095
        }
2096

    
2097
        h= FFMIN(h, s->avctx->height - y);
2098

    
2099
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2100
            src= (AVFrame*)s->current_picture_ptr;
2101
        else if(s->last_picture_ptr)
2102
            src= (AVFrame*)s->last_picture_ptr;
2103
        else
2104
            return;
2105

    
2106
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2107
            offset[0]=
2108
            offset[1]=
2109
            offset[2]=
2110
            offset[3]= 0;
2111
        }else{
2112
            offset[0]= y * s->linesize;;
2113
            offset[1]=
2114
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2115
            offset[3]= 0;
2116
        }
2117

    
2118
        emms_c();
2119

    
2120
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2121
                                  y, s->picture_structure, h);
2122
    }
2123
}
2124

    
2125
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2126
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2127
    const int uvlinesize= s->current_picture.linesize[1];
2128
    const int mb_size= 4 - s->avctx->lowres;
2129

    
2130
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2131
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2132
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2133
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2134
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2135
    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;
2136
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2137

    
2138
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2139
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2140
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2141

    
2142
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2143
    {
2144
        s->dest[0] += s->mb_y *   linesize << mb_size;
2145
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2146
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2147
    }
2148
}
2149

    
2150
void ff_mpeg_flush(AVCodecContext *avctx){
2151
    int i;
2152
    MpegEncContext *s = avctx->priv_data;
2153

    
2154
    if(s==NULL || s->picture==NULL)
2155
        return;
2156

    
2157
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2158
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2159
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2160
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2161
    }
2162
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2163

    
2164
    s->mb_x= s->mb_y= 0;
2165

    
2166
    s->parse_context.state= -1;
2167
    s->parse_context.frame_start_found= 0;
2168
    s->parse_context.overread= 0;
2169
    s->parse_context.overread_index= 0;
2170
    s->parse_context.index= 0;
2171
    s->parse_context.last_index= 0;
2172
    s->bitstream_buffer_size=0;
2173
    s->pp_time=0;
2174
}
2175

    
2176
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2177
                                   DCTELEM *block, int n, int qscale)
2178
{
2179
    int i, level, nCoeffs;
2180
    const uint16_t *quant_matrix;
2181

    
2182
    nCoeffs= s->block_last_index[n];
2183

    
2184
    if (n < 4)
2185
        block[0] = block[0] * s->y_dc_scale;
2186
    else
2187
        block[0] = block[0] * s->c_dc_scale;
2188
    /* XXX: only mpeg1 */
2189
    quant_matrix = s->intra_matrix;
2190
    for(i=1;i<=nCoeffs;i++) {
2191
        int j= s->intra_scantable.permutated[i];
2192
        level = block[j];
2193
        if (level) {
2194
            if (level < 0) {
2195
                level = -level;
2196
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2197
                level = (level - 1) | 1;
2198
                level = -level;
2199
            } else {
2200
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2201
                level = (level - 1) | 1;
2202
            }
2203
            block[j] = level;
2204
        }
2205
    }
2206
}
2207

    
2208
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2209
                                   DCTELEM *block, int n, int qscale)
2210
{
2211
    int i, level, nCoeffs;
2212
    const uint16_t *quant_matrix;
2213

    
2214
    nCoeffs= s->block_last_index[n];
2215

    
2216
    quant_matrix = s->inter_matrix;
2217
    for(i=0; i<=nCoeffs; i++) {
2218
        int j= s->intra_scantable.permutated[i];
2219
        level = block[j];
2220
        if (level) {
2221
            if (level < 0) {
2222
                level = -level;
2223
                level = (((level << 1) + 1) * qscale *
2224
                         ((int) (quant_matrix[j]))) >> 4;
2225
                level = (level - 1) | 1;
2226
                level = -level;
2227
            } else {
2228
                level = (((level << 1) + 1) * qscale *
2229
                         ((int) (quant_matrix[j]))) >> 4;
2230
                level = (level - 1) | 1;
2231
            }
2232
            block[j] = level;
2233
        }
2234
    }
2235
}
2236

    
2237
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2238
                                   DCTELEM *block, int n, int qscale)
2239
{
2240
    int i, level, nCoeffs;
2241
    const uint16_t *quant_matrix;
2242

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

    
2246
    if (n < 4)
2247
        block[0] = block[0] * s->y_dc_scale;
2248
    else
2249
        block[0] = block[0] * s->c_dc_scale;
2250
    quant_matrix = s->intra_matrix;
2251
    for(i=1;i<=nCoeffs;i++) {
2252
        int j= s->intra_scantable.permutated[i];
2253
        level = block[j];
2254
        if (level) {
2255
            if (level < 0) {
2256
                level = -level;
2257
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2258
                level = -level;
2259
            } else {
2260
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2261
            }
2262
            block[j] = level;
2263
        }
2264
    }
2265
}
2266

    
2267
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2268
                                   DCTELEM *block, int n, int qscale)
2269
{
2270
    int i, level, nCoeffs;
2271
    const uint16_t *quant_matrix;
2272
    int sum=-1;
2273

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

    
2277
    if (n < 4)
2278
        block[0] = block[0] * s->y_dc_scale;
2279
    else
2280
        block[0] = block[0] * s->c_dc_scale;
2281
    quant_matrix = s->intra_matrix;
2282
    for(i=1;i<=nCoeffs;i++) {
2283
        int j= s->intra_scantable.permutated[i];
2284
        level = block[j];
2285
        if (level) {
2286
            if (level < 0) {
2287
                level = -level;
2288
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2289
                level = -level;
2290
            } else {
2291
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2292
            }
2293
            block[j] = level;
2294
            sum+=level;
2295
        }
2296
    }
2297
    block[63]^=sum&1;
2298
}
2299

    
2300
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2301
                                   DCTELEM *block, int n, int qscale)
2302
{
2303
    int i, level, nCoeffs;
2304
    const uint16_t *quant_matrix;
2305
    int sum=-1;
2306

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

    
2310
    quant_matrix = s->inter_matrix;
2311
    for(i=0; i<=nCoeffs; i++) {
2312
        int j= s->intra_scantable.permutated[i];
2313
        level = block[j];
2314
        if (level) {
2315
            if (level < 0) {
2316
                level = -level;
2317
                level = (((level << 1) + 1) * qscale *
2318
                         ((int) (quant_matrix[j]))) >> 4;
2319
                level = -level;
2320
            } else {
2321
                level = (((level << 1) + 1) * qscale *
2322
                         ((int) (quant_matrix[j]))) >> 4;
2323
            }
2324
            block[j] = level;
2325
            sum+=level;
2326
        }
2327
    }
2328
    block[63]^=sum&1;
2329
}
2330

    
2331
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2332
                                  DCTELEM *block, int n, int qscale)
2333
{
2334
    int i, level, qmul, qadd;
2335
    int nCoeffs;
2336

    
2337
    assert(s->block_last_index[n]>=0);
2338

    
2339
    qmul = qscale << 1;
2340

    
2341
    if (!s->h263_aic) {
2342
        if (n < 4)
2343
            block[0] = block[0] * s->y_dc_scale;
2344
        else
2345
            block[0] = block[0] * s->c_dc_scale;
2346
        qadd = (qscale - 1) | 1;
2347
    }else{
2348
        qadd = 0;
2349
    }
2350
    if(s->ac_pred)
2351
        nCoeffs=63;
2352
    else
2353
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2354

    
2355
    for(i=1; i<=nCoeffs; i++) {
2356
        level = block[i];
2357
        if (level) {
2358
            if (level < 0) {
2359
                level = level * qmul - qadd;
2360
            } else {
2361
                level = level * qmul + qadd;
2362
            }
2363
            block[i] = level;
2364
        }
2365
    }
2366
}
2367

    
2368
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2369
                                  DCTELEM *block, int n, int qscale)
2370
{
2371
    int i, level, qmul, qadd;
2372
    int nCoeffs;
2373

    
2374
    assert(s->block_last_index[n]>=0);
2375

    
2376
    qadd = (qscale - 1) | 1;
2377
    qmul = qscale << 1;
2378

    
2379
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2380

    
2381
    for(i=0; i<=nCoeffs; i++) {
2382
        level = block[i];
2383
        if (level) {
2384
            if (level < 0) {
2385
                level = level * qmul - qadd;
2386
            } else {
2387
                level = level * qmul + qadd;
2388
            }
2389
            block[i] = level;
2390
        }
2391
    }
2392
}
2393

    
2394
/**
2395
 * set qscale and update qscale dependent variables.
2396
 */
2397
void ff_set_qscale(MpegEncContext * s, int qscale)
2398
{
2399
    if (qscale < 1)
2400
        qscale = 1;
2401
    else if (qscale > 31)
2402
        qscale = 31;
2403

    
2404
    s->qscale = qscale;
2405
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2406

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