Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ a2fc0f6a

History | View | Annotate | Download (87 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

    
57
int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58
void XVMC_field_end(MpegEncContext *s);
59
void XVMC_decode_mb(MpegEncContext *s);
60

    
61

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

    
65
//#define DEBUG
66

    
67

    
68
static const uint8_t ff_default_chroma_qscale_table[32]={
69
//  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
70
    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
71
};
72

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

    
81

    
82
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
83
    int i;
84

    
85
    assert(p<=end);
86
    if(p>=end)
87
        return end;
88

    
89
    for(i=0; i<3; i++){
90
        uint32_t tmp= *state << 8;
91
        *state= tmp + *(p++);
92
        if(tmp == 0x100 || p==end)
93
            return p;
94
    }
95

    
96
    while(p<end){
97
        if     (p[-1] > 1      ) p+= 3;
98
        else if(p[-2]          ) p+= 2;
99
        else if(p[-3]|(p[-1]-1)) p++;
100
        else{
101
            p++;
102
            break;
103
        }
104
    }
105

    
106
    p= FFMIN(p, end)-4;
107
    *state= AV_RB32(p);
108

    
109
    return p+4;
110
}
111

    
112
/* init common dct for both encoder and decoder */
113
int ff_dct_common_init(MpegEncContext *s)
114
{
115
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
116
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
117
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
118
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
119
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
120
    if(s->flags & CODEC_FLAG_BITEXACT)
121
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
122
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
123

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

    
140
    /* load & permutate scantables
141
       note: only wmv uses different ones
142
    */
143
    if(s->alternate_scan){
144
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
145
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
146
    }else{
147
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
148
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
149
    }
150
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
151
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
152

    
153
    return 0;
154
}
155

    
156
void ff_copy_picture(Picture *dst, Picture *src){
157
    *dst = *src;
158
    dst->type= FF_BUFFER_TYPE_COPY;
159
}
160

    
161
/**
162
 * allocates a Picture
163
 * The pixels are allocated/set by calling get_buffer() if shared=0
164
 */
165
int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
166
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
167
    const int mb_array_size= s->mb_stride*s->mb_height;
168
    const int b8_array_size= s->b8_stride*s->mb_height*2;
169
    const int b4_array_size= s->b4_stride*s->mb_height*4;
170
    int i;
171
    int r= -1;
172

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

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

    
182
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
183
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
184
            return -1;
185
        }
186

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

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

    
199
        s->linesize  = pic->linesize[0];
200
        s->uvlinesize= pic->linesize[1];
201
    }
202

    
203
    if(pic->qscale_table==NULL){
204
        if (s->encoding) {
205
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
206
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
207
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
208
        }
209

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

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

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

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

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

    
260
    av_freep(&pic->mb_var);
261
    av_freep(&pic->mc_mb_var);
262
    av_freep(&pic->mb_mean);
263
    av_freep(&pic->mbskip_table);
264
    av_freep(&pic->qscale_table);
265
    av_freep(&pic->mb_type_base);
266
    av_freep(&pic->dct_coeff);
267
    av_freep(&pic->pan_scan);
268
    pic->mb_type= NULL;
269
    for(i=0; i<2; i++){
270
        av_freep(&pic->motion_val_base[i]);
271
        av_freep(&pic->ref_index[i]);
272
    }
273

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

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

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

    
290
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
291
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
292
    s->me.temp=         s->me.scratchpad;
293
    s->rd_scratchpad=   s->me.scratchpad;
294
    s->b_scratchpad=    s->me.scratchpad;
295
    s->obmc_scratchpad= s->me.scratchpad + 16;
296
    if (s->encoding) {
297
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
298
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
299
        if(s->avctx->noise_reduction){
300
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
301
        }
302
    }
303
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
304
    s->block= s->blocks[0];
305

    
306
    for(i=0;i<12;i++){
307
        s->pblocks[i] = (short *)(&s->block[i]);
308
    }
309
    return 0;
310
fail:
311
    return -1; //free() through MPV_common_end()
312
}
313

    
314
static void free_duplicate_context(MpegEncContext *s){
315
    if(s==NULL) return;
316

    
317
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
318
    av_freep(&s->me.scratchpad);
319
    s->me.temp=
320
    s->rd_scratchpad=
321
    s->b_scratchpad=
322
    s->obmc_scratchpad= NULL;
323

    
324
    av_freep(&s->dct_error_sum);
325
    av_freep(&s->me.map);
326
    av_freep(&s->me.score_map);
327
    av_freep(&s->blocks);
328
    s->block= NULL;
329
}
330

    
331
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
332
#define COPY(a) bak->a= src->a
333
    COPY(allocated_edge_emu_buffer);
334
    COPY(edge_emu_buffer);
335
    COPY(me.scratchpad);
336
    COPY(me.temp);
337
    COPY(rd_scratchpad);
338
    COPY(b_scratchpad);
339
    COPY(obmc_scratchpad);
340
    COPY(me.map);
341
    COPY(me.score_map);
342
    COPY(blocks);
343
    COPY(block);
344
    COPY(start_mb_y);
345
    COPY(end_mb_y);
346
    COPY(me.map_generation);
347
    COPY(pb);
348
    COPY(dct_error_sum);
349
    COPY(dct_count[0]);
350
    COPY(dct_count[1]);
351
#undef COPY
352
}
353

    
354
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
355
    MpegEncContext bak;
356
    int i;
357
    //FIXME copy only needed parts
358
//START_TIMER
359
    backup_duplicate_context(&bak, dst);
360
    memcpy(dst, src, sizeof(MpegEncContext));
361
    backup_duplicate_context(dst, &bak);
362
    for(i=0;i<12;i++){
363
        dst->pblocks[i] = (short *)(&dst->block[i]);
364
    }
365
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
366
}
367

    
368
/**
369
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
370
 * the changed fields will not depend upon the prior state of the MpegEncContext.
371
 */
372
void MPV_common_defaults(MpegEncContext *s){
373
    s->y_dc_scale_table=
374
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
375
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
376
    s->progressive_frame= 1;
377
    s->progressive_sequence= 1;
378
    s->picture_structure= PICT_FRAME;
379

    
380
    s->coded_picture_number = 0;
381
    s->picture_number = 0;
382
    s->input_picture_number = 0;
383

    
384
    s->picture_in_gop_number = 0;
385

    
386
    s->f_code = 1;
387
    s->b_code = 1;
388
}
389

    
390
/**
391
 * sets the given MpegEncContext to defaults for decoding.
392
 * the changed fields will not depend upon the prior state of the MpegEncContext.
393
 */
394
void MPV_decode_defaults(MpegEncContext *s){
395
    MPV_common_defaults(s);
396
}
397

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

    
406
    s->mb_height = (s->height + 15) / 16;
407

    
408
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
409
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
410
        return -1;
411
    }
412

    
413
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
414
        return -1;
415

    
416
    dsputil_init(&s->dsp, s->avctx);
417
    ff_dct_common_init(s);
418

    
419
    s->flags= s->avctx->flags;
420
    s->flags2= s->avctx->flags2;
421

    
422
    s->mb_width  = (s->width  + 15) / 16;
423
    s->mb_stride = s->mb_width + 1;
424
    s->b8_stride = s->mb_width*2 + 1;
425
    s->b4_stride = s->mb_width*4 + 1;
426
    mb_array_size= s->mb_height * s->mb_stride;
427
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
428

    
429
    /* set chroma shifts */
430
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
431
                                                    &(s->chroma_y_shift) );
432

    
433
    /* set default edge pos, will be overriden in decode_header if needed */
434
    s->h_edge_pos= s->mb_width*16;
435
    s->v_edge_pos= s->mb_height*16;
436

    
437
    s->mb_num = s->mb_width * s->mb_height;
438

    
439
    s->block_wrap[0]=
440
    s->block_wrap[1]=
441
    s->block_wrap[2]=
442
    s->block_wrap[3]= s->b8_stride;
443
    s->block_wrap[4]=
444
    s->block_wrap[5]= s->mb_stride;
445

    
446
    y_size = s->b8_stride * (2 * s->mb_height + 1);
447
    c_size = s->mb_stride * (s->mb_height + 1);
448
    yc_size = y_size + 2 * c_size;
449

    
450
    /* convert fourcc to upper case */
451
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
452
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
453
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
454
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
455

    
456
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
457
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
458
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
459
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
460

    
461
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
462

    
463
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
464
    for(y=0; y<s->mb_height; y++){
465
        for(x=0; x<s->mb_width; x++){
466
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
467
        }
468
    }
469
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
470

    
471
    if (s->encoding) {
472
        /* Allocate MV tables */
473
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
474
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
475
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
476
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
477
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
478
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
479
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
480
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
481
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
482
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
483
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
484
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
485

    
486
        if(s->msmpeg4_version){
487
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
488
        }
489
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
490

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

    
494
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
495

    
496
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
497
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
498
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
499
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
500
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
501
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
502

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

    
509
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
510

    
511
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
512
        /* interlaced direct mode decoding tables */
513
            for(i=0; i<2; i++){
514
                int j, k;
515
                for(j=0; j<2; j++){
516
                    for(k=0; k<2; k++){
517
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
518
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
519
                    }
520
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
521
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
522
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
523
                }
524
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
525
            }
526
    }
527
    if (s->out_format == FMT_H263) {
528
        /* ac values */
529
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
530
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
531
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
532
        s->ac_val[2] = s->ac_val[1] + c_size;
533

    
534
        /* cbp values */
535
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
536
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
537

    
538
        /* cbp, ac_pred, pred_dir */
539
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
540
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
541
    }
542

    
543
    if (s->h263_pred || s->h263_plus || !s->encoding) {
544
        /* dc values */
545
        //MN: we need these for error resilience of intra-frames
546
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
547
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
548
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
549
        s->dc_val[2] = s->dc_val[1] + c_size;
550
        for(i=0;i<yc_size;i++)
551
            s->dc_val_base[i] = 1024;
552
    }
553

    
554
    /* which mb is a intra block */
555
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
556
    memset(s->mbintra_table, 1, mb_array_size);
557

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

    
563
    s->parse_context.state= -1;
564
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
565
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
566
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
567
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
568
    }
569

    
570
    s->context_initialized = 1;
571

    
572
    s->thread_context[0]= s;
573
    threads = s->avctx->thread_count;
574

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

    
580
    for(i=0; i<threads; i++){
581
        if(init_duplicate_context(s->thread_context[i], s) < 0)
582
           goto fail;
583
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
584
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
585
    }
586

    
587
    return 0;
588
 fail:
589
    MPV_common_end(s);
590
    return -1;
591
}
592

    
593
/* init common structure for both encoder and decoder */
594
void MPV_common_end(MpegEncContext *s)
595
{
596
    int i, j, k;
597

    
598
    for(i=0; i<s->avctx->thread_count; i++){
599
        free_duplicate_context(s->thread_context[i]);
600
    }
601
    for(i=1; i<s->avctx->thread_count; i++){
602
        av_freep(&s->thread_context[i]);
603
    }
604

    
605
    av_freep(&s->parse_context.buffer);
606
    s->parse_context.buffer_size=0;
607

    
608
    av_freep(&s->mb_type);
609
    av_freep(&s->p_mv_table_base);
610
    av_freep(&s->b_forw_mv_table_base);
611
    av_freep(&s->b_back_mv_table_base);
612
    av_freep(&s->b_bidir_forw_mv_table_base);
613
    av_freep(&s->b_bidir_back_mv_table_base);
614
    av_freep(&s->b_direct_mv_table_base);
615
    s->p_mv_table= NULL;
616
    s->b_forw_mv_table= NULL;
617
    s->b_back_mv_table= NULL;
618
    s->b_bidir_forw_mv_table= NULL;
619
    s->b_bidir_back_mv_table= NULL;
620
    s->b_direct_mv_table= NULL;
621
    for(i=0; i<2; i++){
622
        for(j=0; j<2; j++){
623
            for(k=0; k<2; k++){
624
                av_freep(&s->b_field_mv_table_base[i][j][k]);
625
                s->b_field_mv_table[i][j][k]=NULL;
626
            }
627
            av_freep(&s->b_field_select_table[i][j]);
628
            av_freep(&s->p_field_mv_table_base[i][j]);
629
            s->p_field_mv_table[i][j]=NULL;
630
        }
631
        av_freep(&s->p_field_select_table[i]);
632
    }
633

    
634
    av_freep(&s->dc_val_base);
635
    av_freep(&s->ac_val_base);
636
    av_freep(&s->coded_block_base);
637
    av_freep(&s->mbintra_table);
638
    av_freep(&s->cbp_table);
639
    av_freep(&s->pred_dir_table);
640

    
641
    av_freep(&s->mbskip_table);
642
    av_freep(&s->prev_pict_types);
643
    av_freep(&s->bitstream_buffer);
644
    s->allocated_bitstream_buffer_size=0;
645

    
646
    av_freep(&s->avctx->stats_out);
647
    av_freep(&s->ac_stats);
648
    av_freep(&s->error_status_table);
649
    av_freep(&s->mb_index2xy);
650
    av_freep(&s->lambda_table);
651
    av_freep(&s->q_intra_matrix);
652
    av_freep(&s->q_inter_matrix);
653
    av_freep(&s->q_intra_matrix16);
654
    av_freep(&s->q_inter_matrix16);
655
    av_freep(&s->input_picture);
656
    av_freep(&s->reordered_input_picture);
657
    av_freep(&s->dct_offset);
658

    
659
    if(s->picture){
660
        for(i=0; i<MAX_PICTURE_COUNT; i++){
661
            free_picture(s, &s->picture[i]);
662
        }
663
    }
664
    av_freep(&s->picture);
665
    s->context_initialized = 0;
666
    s->last_picture_ptr=
667
    s->next_picture_ptr=
668
    s->current_picture_ptr= NULL;
669
    s->linesize= s->uvlinesize= 0;
670

    
671
    for(i=0; i<3; i++)
672
        av_freep(&s->visualization_buffer[i]);
673

    
674
    avcodec_default_free_buffers(s->avctx);
675
}
676

    
677
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
678
{
679
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
680
    uint8_t index_run[MAX_RUN+1];
681
    int last, run, level, start, end, i;
682

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

    
687
    /* compute max_level[], max_run[] and index_run[] */
688
    for(last=0;last<2;last++) {
689
        if (last == 0) {
690
            start = 0;
691
            end = rl->last;
692
        } else {
693
            start = rl->last;
694
            end = rl->n;
695
        }
696

    
697
        memset(max_level, 0, MAX_RUN + 1);
698
        memset(max_run, 0, MAX_LEVEL + 1);
699
        memset(index_run, rl->n, MAX_RUN + 1);
700
        for(i=start;i<end;i++) {
701
            run = rl->table_run[i];
702
            level = rl->table_level[i];
703
            if (index_run[run] == rl->n)
704
                index_run[run] = i;
705
            if (level > max_level[run])
706
                max_level[run] = level;
707
            if (run > max_run[level])
708
                max_run[level] = run;
709
        }
710
        if(static_store)
711
            rl->max_level[last] = static_store[last];
712
        else
713
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
714
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
715
        if(static_store)
716
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
717
        else
718
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
719
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
720
        if(static_store)
721
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
722
        else
723
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
724
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
725
    }
726
}
727

    
728
void init_vlc_rl(RLTable *rl)
729
{
730
    int i, q;
731

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

    
736
        if(q==0){
737
            qmul=1;
738
            qadd=0;
739
        }
740
        for(i=0; i<rl->vlc.table_size; i++){
741
            int code= rl->vlc.table[i][0];
742
            int len = rl->vlc.table[i][1];
743
            int level, run;
744

    
745
            if(len==0){ // illegal code
746
                run= 66;
747
                level= MAX_LEVEL;
748
            }else if(len<0){ //more bits needed
749
                run= 0;
750
                level= code;
751
            }else{
752
                if(code==rl->n){ //esc
753
                    run= 66;
754
                    level= 0;
755
                }else{
756
                    run=   rl->table_run  [code] + 1;
757
                    level= rl->table_level[code] * qmul + qadd;
758
                    if(code >= rl->last) run+=192;
759
                }
760
            }
761
            rl->rl_vlc[q][i].len= len;
762
            rl->rl_vlc[q][i].level= level;
763
            rl->rl_vlc[q][i].run= run;
764
        }
765
    }
766
}
767

    
768
int ff_find_unused_picture(MpegEncContext *s, int shared){
769
    int i;
770

    
771
    if(shared){
772
        for(i=0; i<MAX_PICTURE_COUNT; i++){
773
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
774
        }
775
    }else{
776
        for(i=0; i<MAX_PICTURE_COUNT; i++){
777
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
778
        }
779
        for(i=0; i<MAX_PICTURE_COUNT; i++){
780
            if(s->picture[i].data[0]==NULL) return i;
781
        }
782
    }
783

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

    
800
static void update_noise_reduction(MpegEncContext *s){
801
    int intra, i;
802

    
803
    for(intra=0; intra<2; intra++){
804
        if(s->dct_count[intra] > (1<<16)){
805
            for(i=0; i<64; i++){
806
                s->dct_error_sum[intra][i] >>=1;
807
            }
808
            s->dct_count[intra] >>= 1;
809
        }
810

    
811
        for(i=0; i<64; i++){
812
            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);
813
        }
814
    }
815
}
816

    
817
/**
818
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
819
 */
820
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
821
{
822
    int i;
823
    AVFrame *pic;
824
    s->mb_skipped = 0;
825

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

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

    
833
        /* release forgotten pictures */
834
        /* if(mpeg124/h263) */
835
        if(!s->encoding){
836
            for(i=0; i<MAX_PICTURE_COUNT; i++){
837
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
838
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
839
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
840
                }
841
            }
842
        }
843
      }
844
    }
845
alloc:
846
    if(!s->encoding){
847
        /* release non reference frames */
848
        for(i=0; i<MAX_PICTURE_COUNT; i++){
849
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
850
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
851
            }
852
        }
853

    
854
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
855
            pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
856
        else{
857
            i= ff_find_unused_picture(s, 0);
858
            pic= (AVFrame*)&s->picture[i];
859
        }
860

    
861
        pic->reference= 0;
862
        if (!s->dropable){
863
            if (s->codec_id == CODEC_ID_H264)
864
                pic->reference = s->picture_structure;
865
            else if (s->pict_type != FF_B_TYPE)
866
                pic->reference = 3;
867
        }
868

    
869
        pic->coded_picture_number= s->coded_picture_number++;
870

    
871
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
872
            return -1;
873

    
874
        s->current_picture_ptr= (Picture*)pic;
875
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
876
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
877
    }
878

    
879
    s->current_picture_ptr->pict_type= s->pict_type;
880
//    if(s->flags && CODEC_FLAG_QSCALE)
881
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
882
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
883

    
884
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
885

    
886
    if (s->pict_type != FF_B_TYPE) {
887
        s->last_picture_ptr= s->next_picture_ptr;
888
        if(!s->dropable)
889
            s->next_picture_ptr= s->current_picture_ptr;
890
    }
891
/*    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,
892
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
893
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
894
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
895
        s->pict_type, s->dropable);*/
896

    
897
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
898
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
899

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

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

    
908
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
909
        int i;
910
        for(i=0; i<4; i++){
911
            if(s->picture_structure == PICT_BOTTOM_FIELD){
912
                 s->current_picture.data[i] += s->current_picture.linesize[i];
913
            }
914
            s->current_picture.linesize[i] *= 2;
915
            s->last_picture.linesize[i] *=2;
916
            s->next_picture.linesize[i] *=2;
917
        }
918
    }
919

    
920
    s->hurry_up= s->avctx->hurry_up;
921
    s->error_recognition= avctx->error_recognition;
922

    
923
    /* set dequantizer, we can't do it during init as it might change for mpeg4
924
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
925
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
926
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
927
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
928
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
929
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
930
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
931
    }else{
932
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
933
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
934
    }
935

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

    
939
        update_noise_reduction(s);
940
    }
941

    
942
#ifdef CONFIG_XVMC
943
    if(s->avctx->xvmc_acceleration)
944
        return XVMC_field_start(s, avctx);
945
#endif
946
    return 0;
947
}
948

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

    
967
    s->last_pict_type    = s->pict_type;
968
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
969
    if(s->pict_type!=FF_B_TYPE){
970
        s->last_non_b_pict_type= s->pict_type;
971
    }
972
#if 0
973
        /* copy back current_picture variables */
974
    for(i=0; i<MAX_PICTURE_COUNT; i++){
975
        if(s->picture[i].data[0] == s->current_picture.data[0]){
976
            s->picture[i]= s->current_picture;
977
            break;
978
        }
979
    }
980
    assert(i<MAX_PICTURE_COUNT);
981
#endif
982

    
983
    if(s->encoding){
984
        /* release non-reference frames */
985
        for(i=0; i<MAX_PICTURE_COUNT; i++){
986
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
987
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
988
            }
989
        }
990
    }
991
    // clear copies, to avoid confusion
992
#if 0
993
    memset(&s->last_picture, 0, sizeof(Picture));
994
    memset(&s->next_picture, 0, sizeof(Picture));
995
    memset(&s->current_picture, 0, sizeof(Picture));
996
#endif
997
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
998
}
999

    
1000
/**
1001
 * draws an line from (ex, ey) -> (sx, sy).
1002
 * @param w width of the image
1003
 * @param h height of the image
1004
 * @param stride stride/linesize of the image
1005
 * @param color color of the arrow
1006
 */
1007
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1008
    int x, y, fr, f;
1009

    
1010
    sx= av_clip(sx, 0, w-1);
1011
    sy= av_clip(sy, 0, h-1);
1012
    ex= av_clip(ex, 0, w-1);
1013
    ey= av_clip(ey, 0, h-1);
1014

    
1015
    buf[sy*stride + sx]+= color;
1016

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

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

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

    
1064
    dx= ex - sx;
1065
    dy= ey - sy;
1066

    
1067
    if(dx*dx + dy*dy > 3*3){
1068
        int rx=  dx + dy;
1069
        int ry= -dx + dy;
1070
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1071

    
1072
        //FIXME subpixel accuracy
1073
        rx= ROUNDED_DIV(rx*3<<4, length);
1074
        ry= ROUNDED_DIV(ry*3<<4, length);
1075

    
1076
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1077
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1078
    }
1079
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1080
}
1081

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

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

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

    
1092
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1093
        switch (pict->pict_type) {
1094
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1095
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1096
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1097
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1098
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1099
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1100
        }
1101
        for(y=0; y<s->mb_height; y++){
1102
            for(x=0; x<s->mb_width; x++){
1103
                if(s->avctx->debug&FF_DEBUG_SKIP){
1104
                    int count= s->mbskip_table[x + y*s->mb_stride];
1105
                    if(count>9) count=9;
1106
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1107
                }
1108
                if(s->avctx->debug&FF_DEBUG_QP){
1109
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1110
                }
1111
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1112
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1113
                    //Type & MV direction
1114
                    if(IS_PCM(mb_type))
1115
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1116
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1117
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1118
                    else if(IS_INTRA4x4(mb_type))
1119
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1120
                    else if(IS_INTRA16x16(mb_type))
1121
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1122
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1123
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1124
                    else if(IS_DIRECT(mb_type))
1125
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1126
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1127
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1128
                    else if(IS_GMC(mb_type))
1129
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1130
                    else if(IS_SKIP(mb_type))
1131
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1132
                    else if(!USES_LIST(mb_type, 1))
1133
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1134
                    else if(!USES_LIST(mb_type, 0))
1135
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1136
                    else{
1137
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1138
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1139
                    }
1140

    
1141
                    //segmentation
1142
                    if(IS_8X8(mb_type))
1143
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1144
                    else if(IS_16X8(mb_type))
1145
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1146
                    else if(IS_8X16(mb_type))
1147
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1148
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1149
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1150
                    else
1151
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1152

    
1153

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

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

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

    
1186
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1187
            int mb_x;
1188
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1189
                const int mb_index= mb_x + mb_y*s->mb_stride;
1190
                if((s->avctx->debug_mv) && pict->motion_val){
1191
                  int type;
1192
                  for(type=0; type<3; type++){
1193
                    int direction = 0;
1194
                    switch (type) {
1195
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1196
                                continue;
1197
                              direction = 0;
1198
                              break;
1199
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1200
                                continue;
1201
                              direction = 0;
1202
                              break;
1203
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1204
                                continue;
1205
                              direction = 1;
1206
                              break;
1207
                    }
1208
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1209
                        continue;
1210

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

    
1230
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1231
                            my*=2;
1232

    
1233
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1234
                      }
1235
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1236
                      int i;
1237
                      for(i=0; i<2; i++){
1238
                        int sx=mb_x*16 + 4 + 8*i;
1239
                        int sy=mb_y*16 + 8;
1240
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1241
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1242
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1243

    
1244
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1245
                            my*=2;
1246

    
1247
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1248
                      }
1249
                    }else{
1250
                      int sx= mb_x*16 + 8;
1251
                      int sy= mb_y*16 + 8;
1252
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
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
                  }
1258
                }
1259
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1260
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1261
                    int y;
1262
                    for(y=0; y<block_height; y++){
1263
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1264
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1265
                    }
1266
                }
1267
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1268
                    int mb_type= pict->mb_type[mb_index];
1269
                    uint64_t u,v;
1270
                    int y;
1271
#define COLOR(theta, r)\
1272
u= (int)(128 + r*cos(theta*3.141592/180));\
1273
v= (int)(128 + r*sin(theta*3.141592/180));
1274

    
1275

    
1276
                    u=v=128;
1277
                    if(IS_PCM(mb_type)){
1278
                        COLOR(120,48)
1279
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1280
                        COLOR(30,48)
1281
                    }else if(IS_INTRA4x4(mb_type)){
1282
                        COLOR(90,48)
1283
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1284
//                        COLOR(120,48)
1285
                    }else if(IS_DIRECT(mb_type)){
1286
                        COLOR(150,48)
1287
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1288
                        COLOR(170,48)
1289
                    }else if(IS_GMC(mb_type)){
1290
                        COLOR(190,48)
1291
                    }else if(IS_SKIP(mb_type)){
1292
//                        COLOR(180,48)
1293
                    }else if(!USES_LIST(mb_type, 1)){
1294
                        COLOR(240,48)
1295
                    }else if(!USES_LIST(mb_type, 0)){
1296
                        COLOR(0,48)
1297
                    }else{
1298
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1299
                        COLOR(300,48)
1300
                    }
1301

    
1302
                    u*= 0x0101010101010101ULL;
1303
                    v*= 0x0101010101010101ULL;
1304
                    for(y=0; y<block_height; y++){
1305
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1306
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1307
                    }
1308

    
1309
                    //segmentation
1310
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1311
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1312
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1313
                    }
1314
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1315
                        for(y=0; y<16; y++)
1316
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1317
                    }
1318
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1319
                        int dm= 1 << (mv_sample_log2-2);
1320
                        for(i=0; i<4; i++){
1321
                            int sx= mb_x*16 + 8*(i&1);
1322
                            int sy= mb_y*16 + 8*(i>>1);
1323
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1324
                            //FIXME bidir
1325
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1326
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1327
                                for(y=0; y<8; y++)
1328
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1329
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1330
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1331
                        }
1332
                    }
1333

    
1334
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1335
                        // hmm
1336
                    }
1337
                }
1338
                s->mbskip_table[mb_index]=0;
1339
            }
1340
        }
1341
    }
1342
}
1343

    
1344
static inline int hpel_motion_lowres(MpegEncContext *s,
1345
                                  uint8_t *dest, uint8_t *src,
1346
                                  int field_based, int field_select,
1347
                                  int src_x, int src_y,
1348
                                  int width, int height, int stride,
1349
                                  int h_edge_pos, int v_edge_pos,
1350
                                  int w, int h, h264_chroma_mc_func *pix_op,
1351
                                  int motion_x, int motion_y)
1352
{
1353
    const int lowres= s->avctx->lowres;
1354
    const int s_mask= (2<<lowres)-1;
1355
    int emu=0;
1356
    int sx, sy;
1357

    
1358
    if(s->quarter_sample){
1359
        motion_x/=2;
1360
        motion_y/=2;
1361
    }
1362

    
1363
    sx= motion_x & s_mask;
1364
    sy= motion_y & s_mask;
1365
    src_x += motion_x >> (lowres+1);
1366
    src_y += motion_y >> (lowres+1);
1367

    
1368
    src += src_y * stride + src_x;
1369

    
1370
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1371
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1372
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1373
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1374
        src= s->edge_emu_buffer;
1375
        emu=1;
1376
    }
1377

    
1378
    sx <<= 2 - lowres;
1379
    sy <<= 2 - lowres;
1380
    if(field_select)
1381
        src += s->linesize;
1382
    pix_op[lowres](dest, src, stride, h, sx, sy);
1383
    return emu;
1384
}
1385

    
1386
/* apply one mpeg motion vector to the three components */
1387
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1388
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1389
                               int field_based, int bottom_field, int field_select,
1390
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1391
                               int motion_x, int motion_y, int h)
1392
{
1393
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1394
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1395
    const int lowres= s->avctx->lowres;
1396
    const int block_s= 8>>lowres;
1397
    const int s_mask= (2<<lowres)-1;
1398
    const int h_edge_pos = s->h_edge_pos >> lowres;
1399
    const int v_edge_pos = s->v_edge_pos >> lowres;
1400
    linesize   = s->current_picture.linesize[0] << field_based;
1401
    uvlinesize = s->current_picture.linesize[1] << field_based;
1402

    
1403
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1404
        motion_x/=2;
1405
        motion_y/=2;
1406
    }
1407

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

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

    
1417
    if (s->out_format == FMT_H263) {
1418
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1419
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1420
        uvsrc_x = src_x>>1;
1421
        uvsrc_y = src_y>>1;
1422
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1423
        mx = motion_x / 4;
1424
        my = motion_y / 4;
1425
        uvsx = (2*mx) & s_mask;
1426
        uvsy = (2*my) & s_mask;
1427
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1428
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1429
    } else {
1430
        mx = motion_x / 2;
1431
        my = motion_y / 2;
1432
        uvsx = mx & s_mask;
1433
        uvsy = my & s_mask;
1434
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1435
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1436
    }
1437

    
1438
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1439
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1440
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1441

    
1442
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1443
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1444
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1445
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1446
            ptr_y = s->edge_emu_buffer;
1447
            if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1448
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1449
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1450
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1451
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1452
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1453
                ptr_cb= uvbuf;
1454
                ptr_cr= uvbuf+16;
1455
            }
1456
    }
1457

    
1458
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1459
        dest_y += s->linesize;
1460
        dest_cb+= s->uvlinesize;
1461
        dest_cr+= s->uvlinesize;
1462
    }
1463

    
1464
    if(field_select){
1465
        ptr_y += s->linesize;
1466
        ptr_cb+= s->uvlinesize;
1467
        ptr_cr+= s->uvlinesize;
1468
    }
1469

    
1470
    sx <<= 2 - lowres;
1471
    sy <<= 2 - lowres;
1472
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1473

    
1474
    if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1475
        uvsx <<= 2 - lowres;
1476
        uvsy <<= 2 - lowres;
1477
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1478
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1479
    }
1480
    //FIXME h261 lowres loop filter
1481
}
1482

    
1483
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1484
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1485
                                     uint8_t **ref_picture,
1486
                                     h264_chroma_mc_func *pix_op,
1487
                                     int mx, int my){
1488
    const int lowres= s->avctx->lowres;
1489
    const int block_s= 8>>lowres;
1490
    const int s_mask= (2<<lowres)-1;
1491
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1492
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1493
    int emu=0, src_x, src_y, offset, sx, sy;
1494
    uint8_t *ptr;
1495

    
1496
    if(s->quarter_sample){
1497
        mx/=2;
1498
        my/=2;
1499
    }
1500

    
1501
    /* In case of 8X8, we construct a single chroma motion vector
1502
       with a special rounding */
1503
    mx= ff_h263_round_chroma(mx);
1504
    my= ff_h263_round_chroma(my);
1505

    
1506
    sx= mx & s_mask;
1507
    sy= my & s_mask;
1508
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1509
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1510

    
1511
    offset = src_y * s->uvlinesize + src_x;
1512
    ptr = ref_picture[1] + offset;
1513
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1514
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1515
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1516
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1517
            ptr= s->edge_emu_buffer;
1518
            emu=1;
1519
        }
1520
    }
1521
    sx <<= 2 - lowres;
1522
    sy <<= 2 - lowres;
1523
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1524

    
1525
    ptr = ref_picture[2] + offset;
1526
    if(emu){
1527
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1528
        ptr= s->edge_emu_buffer;
1529
    }
1530
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1531
}
1532

    
1533
/**
1534
 * motion compensation of a single macroblock
1535
 * @param s context
1536
 * @param dest_y luma destination pointer
1537
 * @param dest_cb chroma cb/u destination pointer
1538
 * @param dest_cr chroma cr/v destination pointer
1539
 * @param dir direction (0->forward, 1->backward)
1540
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1541
 * @param pic_op halfpel motion compensation function (average or put normally)
1542
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1543
 */
1544
static inline void MPV_motion_lowres(MpegEncContext *s,
1545
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1546
                              int dir, uint8_t **ref_picture,
1547
                              h264_chroma_mc_func *pix_op)
1548
{
1549
    int mx, my;
1550
    int mb_x, mb_y, i;
1551
    const int lowres= s->avctx->lowres;
1552
    const int block_s= 8>>lowres;
1553

    
1554
    mb_x = s->mb_x;
1555
    mb_y = s->mb_y;
1556

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

    
1576
                mx += s->mv[dir][i][0];
1577
                my += s->mv[dir][i][1];
1578
            }
1579

    
1580
        if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1581
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1582
        break;
1583
    case MV_TYPE_FIELD:
1584
        if (s->picture_structure == PICT_FRAME) {
1585
            /* top field */
1586
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1587
                        1, 0, s->field_select[dir][0],
1588
                        ref_picture, pix_op,
1589
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1590
            /* bottom field */
1591
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1592
                        1, 1, s->field_select[dir][1],
1593
                        ref_picture, pix_op,
1594
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1595
        } else {
1596
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1597
                ref_picture= s->current_picture_ptr->data;
1598
            }
1599

    
1600
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1601
                        0, 0, s->field_select[dir][0],
1602
                        ref_picture, pix_op,
1603
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1604
        }
1605
        break;
1606
    case MV_TYPE_16X8:
1607
        for(i=0; i<2; i++){
1608
            uint8_t ** ref2picture;
1609

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

    
1616
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1617
                        0, 0, s->field_select[dir][i],
1618
                        ref2picture, pix_op,
1619
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1620

    
1621
            dest_y += 2*block_s*s->linesize;
1622
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1623
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1624
        }
1625
        break;
1626
    case MV_TYPE_DMV:
1627
        if(s->picture_structure == PICT_FRAME){
1628
            for(i=0; i<2; i++){
1629
                int j;
1630
                for(j=0; j<2; j++){
1631
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1632
                                1, j, j^i,
1633
                                ref_picture, pix_op,
1634
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1635
                }
1636
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1637
            }
1638
        }else{
1639
            for(i=0; i<2; i++){
1640
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1641
                            0, 0, s->picture_structure != i+1,
1642
                            ref_picture, pix_op,
1643
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1644

    
1645
                // after put we make avg of the same block
1646
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1647

    
1648
                //opposite parity is always in the same frame if this is second field
1649
                if(!s->first_field){
1650
                    ref_picture = s->current_picture_ptr->data;
1651
                }
1652
            }
1653
        }
1654
    break;
1655
    default: assert(0);
1656
    }
1657
}
1658

    
1659
/* put block[] to dest[] */
1660
static inline void put_dct(MpegEncContext *s,
1661
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1662
{
1663
    s->dct_unquantize_intra(s, block, i, qscale);
1664
    s->dsp.idct_put (dest, line_size, block);
1665
}
1666

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

    
1676
static inline void add_dequant_dct(MpegEncContext *s,
1677
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1678
{
1679
    if (s->block_last_index[i] >= 0) {
1680
        s->dct_unquantize_inter(s, block, i, qscale);
1681

    
1682
        s->dsp.idct_add (dest, line_size, block);
1683
    }
1684
}
1685

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

    
1694
    s->dc_val[0][xy           ] =
1695
    s->dc_val[0][xy + 1       ] =
1696
    s->dc_val[0][xy     + wrap] =
1697
    s->dc_val[0][xy + 1 + wrap] = 1024;
1698
    /* ac pred */
1699
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1700
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1701
    if (s->msmpeg4_version>=3) {
1702
        s->coded_block[xy           ] =
1703
        s->coded_block[xy + 1       ] =
1704
        s->coded_block[xy     + wrap] =
1705
        s->coded_block[xy + 1 + wrap] = 0;
1706
    }
1707
    /* chroma */
1708
    wrap = s->mb_stride;
1709
    xy = s->mb_x + s->mb_y * wrap;
1710
    s->dc_val[1][xy] =
1711
    s->dc_val[2][xy] = 1024;
1712
    /* ac pred */
1713
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1714
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1715

    
1716
    s->mbintra_table[xy]= 0;
1717
}
1718

    
1719
/* generic function called after a macroblock has been parsed by the
1720
   decoder or after it has been encoded by the encoder.
1721

1722
   Important variables used:
1723
   s->mb_intra : true if intra macroblock
1724
   s->mv_dir   : motion vector direction
1725
   s->mv_type  : motion vector type
1726
   s->mv       : motion vector
1727
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1728
 */
1729
static av_always_inline
1730
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1731
                            int lowres_flag, int is_mpeg12)
1732
{
1733
    int mb_x, mb_y;
1734
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1735
#ifdef CONFIG_XVMC
1736
    if(s->avctx->xvmc_acceleration){
1737
        XVMC_decode_mb(s);//xvmc uses pblocks
1738
        return;
1739
    }
1740
#endif
1741

    
1742
    mb_x = s->mb_x;
1743
    mb_y = s->mb_y;
1744

    
1745
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1746
       /* save DCT coefficients */
1747
       int i,j;
1748
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1749
       for(i=0; i<6; i++)
1750
           for(j=0; j<64; j++)
1751
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1752
    }
1753

    
1754
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1755

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

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

    
1780
        /* avoid copy if macroblock skipped in last frame too */
1781
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1782
        if(!s->encoding){
1783
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1784
            const int age= s->current_picture.age;
1785

    
1786
            assert(age);
1787

    
1788
            if (s->mb_skipped) {
1789
                s->mb_skipped= 0;
1790
                assert(s->pict_type!=FF_I_TYPE);
1791

    
1792
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1793
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1794

    
1795
                /* if previous was skipped too, then nothing to do !  */
1796
                if (*mbskip_ptr >= age && s->current_picture.reference){
1797
                    return;
1798
                }
1799
            } else if(!s->current_picture.reference){
1800
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1801
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1802
            } else{
1803
                *mbskip_ptr = 0; /* not skipped */
1804
            }
1805
        }
1806

    
1807
        dct_linesize = linesize << s->interlaced_dct;
1808
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1809

    
1810
        if(readable){
1811
            dest_y=  s->dest[0];
1812
            dest_cb= s->dest[1];
1813
            dest_cr= s->dest[2];
1814
        }else{
1815
            dest_y = s->b_scratchpad;
1816
            dest_cb= s->b_scratchpad+16*linesize;
1817
            dest_cr= s->b_scratchpad+32*linesize;
1818
        }
1819

    
1820
        if (!s->mb_intra) {
1821
            /* motion handling */
1822
            /* decoding or more than one mb_type (MC was already done otherwise) */
1823
            if(!s->encoding){
1824
                if(lowres_flag){
1825
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1826

    
1827
                    if (s->mv_dir & MV_DIR_FORWARD) {
1828
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1829
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1830
                    }
1831
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1832
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1833
                    }
1834
                }else{
1835
                    op_qpix= s->me.qpel_put;
1836
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1837
                        op_pix = s->dsp.put_pixels_tab;
1838
                    }else{
1839
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1840
                    }
1841
                    if (s->mv_dir & MV_DIR_FORWARD) {
1842
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1843
                        op_pix = s->dsp.avg_pixels_tab;
1844
                        op_qpix= s->me.qpel_avg;
1845
                    }
1846
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1847
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1848
                    }
1849
                }
1850
            }
1851

    
1852
            /* skip dequant / idct if we are really late ;) */
1853
            if(s->hurry_up>1) goto skip_idct;
1854
            if(s->avctx->skip_idct){
1855
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1856
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1857
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1858
                    goto skip_idct;
1859
            }
1860

    
1861
            /* add dct residue */
1862
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1863
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1864
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1865
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1866
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1867
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1868

    
1869
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1870
                    if (s->chroma_y_shift){
1871
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1872
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1873
                    }else{
1874
                        dct_linesize >>= 1;
1875
                        dct_offset >>=1;
1876
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1877
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1878
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1879
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1880
                    }
1881
                }
1882
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1883
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1884
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1885
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1886
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1887

    
1888
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1889
                    if(s->chroma_y_shift){//Chroma420
1890
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
1891
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
1892
                    }else{
1893
                        //chroma422
1894
                        dct_linesize = uvlinesize << s->interlaced_dct;
1895
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1896

    
1897
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
1898
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
1899
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1900
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1901
                        if(!s->chroma_x_shift){//Chroma444
1902
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1903
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1904
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1905
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1906
                        }
1907
                    }
1908
                }//fi gray
1909
            }
1910
            else if (ENABLE_WMV2) {
1911
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1912
            }
1913
        } else {
1914
            /* dct only in intra block */
1915
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1916
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1917
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1918
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1919
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1920

    
1921
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1922
                    if(s->chroma_y_shift){
1923
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1924
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1925
                    }else{
1926
                        dct_offset >>=1;
1927
                        dct_linesize >>=1;
1928
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1929
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1930
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1931
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1932
                    }
1933
                }
1934
            }else{
1935
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1936
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1937
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1938
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1939

    
1940
                if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1941
                    if(s->chroma_y_shift){
1942
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1943
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1944
                    }else{
1945

    
1946
                        dct_linesize = uvlinesize << s->interlaced_dct;
1947
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1948

    
1949
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1950
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1951
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1952
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1953
                        if(!s->chroma_x_shift){//Chroma444
1954
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1955
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
1956
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1957
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1958
                        }
1959
                    }
1960
                }//gray
1961
            }
1962
        }
1963
skip_idct:
1964
        if(!readable){
1965
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
1966
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1967
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1968
        }
1969
    }
1970
}
1971

    
1972
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1973
#ifndef CONFIG_SMALL
1974
    if(s->out_format == FMT_MPEG1) {
1975
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1976
        else                 MPV_decode_mb_internal(s, block, 0, 1);
1977
    } else
1978
#endif
1979
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1980
    else                  MPV_decode_mb_internal(s, block, 0, 0);
1981
}
1982

    
1983
/**
1984
 *
1985
 * @param h is the normal height, this will be reduced automatically if needed for the last row
1986
 */
1987
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1988
    if (s->avctx->draw_horiz_band) {
1989
        AVFrame *src;
1990
        int offset[4];
1991

    
1992
        if(s->picture_structure != PICT_FRAME){
1993
            h <<= 1;
1994
            y <<= 1;
1995
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1996
        }
1997

    
1998
        h= FFMIN(h, s->avctx->height - y);
1999

    
2000
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2001
            src= (AVFrame*)s->current_picture_ptr;
2002
        else if(s->last_picture_ptr)
2003
            src= (AVFrame*)s->last_picture_ptr;
2004
        else
2005
            return;
2006

    
2007
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2008
            offset[0]=
2009
            offset[1]=
2010
            offset[2]=
2011
            offset[3]= 0;
2012
        }else{
2013
            offset[0]= y * s->linesize;
2014
            offset[1]=
2015
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2016
            offset[3]= 0;
2017
        }
2018

    
2019
        emms_c();
2020

    
2021
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2022
                                  y, s->picture_structure, h);
2023
    }
2024
}
2025

    
2026
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2027
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2028
    const int uvlinesize= s->current_picture.linesize[1];
2029
    const int mb_size= 4 - s->avctx->lowres;
2030

    
2031
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2032
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2033
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2034
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2035
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2036
    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;
2037
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2038

    
2039
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2040
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2041
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2042

    
2043
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2044
    {
2045
        s->dest[0] += s->mb_y *   linesize << mb_size;
2046
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2047
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2048
    }
2049
}
2050

    
2051
void ff_mpeg_flush(AVCodecContext *avctx){
2052
    int i;
2053
    MpegEncContext *s = avctx->priv_data;
2054

    
2055
    if(s==NULL || s->picture==NULL)
2056
        return;
2057

    
2058
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2059
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2060
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2061
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2062
    }
2063
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2064

    
2065
    s->mb_x= s->mb_y= 0;
2066

    
2067
    s->parse_context.state= -1;
2068
    s->parse_context.frame_start_found= 0;
2069
    s->parse_context.overread= 0;
2070
    s->parse_context.overread_index= 0;
2071
    s->parse_context.index= 0;
2072
    s->parse_context.last_index= 0;
2073
    s->bitstream_buffer_size=0;
2074
    s->pp_time=0;
2075
}
2076

    
2077
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2078
                                   DCTELEM *block, int n, int qscale)
2079
{
2080
    int i, level, nCoeffs;
2081
    const uint16_t *quant_matrix;
2082

    
2083
    nCoeffs= s->block_last_index[n];
2084

    
2085
    if (n < 4)
2086
        block[0] = block[0] * s->y_dc_scale;
2087
    else
2088
        block[0] = block[0] * s->c_dc_scale;
2089
    /* XXX: only mpeg1 */
2090
    quant_matrix = s->intra_matrix;
2091
    for(i=1;i<=nCoeffs;i++) {
2092
        int j= s->intra_scantable.permutated[i];
2093
        level = block[j];
2094
        if (level) {
2095
            if (level < 0) {
2096
                level = -level;
2097
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2098
                level = (level - 1) | 1;
2099
                level = -level;
2100
            } else {
2101
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2102
                level = (level - 1) | 1;
2103
            }
2104
            block[j] = level;
2105
        }
2106
    }
2107
}
2108

    
2109
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2110
                                   DCTELEM *block, int n, int qscale)
2111
{
2112
    int i, level, nCoeffs;
2113
    const uint16_t *quant_matrix;
2114

    
2115
    nCoeffs= s->block_last_index[n];
2116

    
2117
    quant_matrix = s->inter_matrix;
2118
    for(i=0; i<=nCoeffs; i++) {
2119
        int j= s->intra_scantable.permutated[i];
2120
        level = block[j];
2121
        if (level) {
2122
            if (level < 0) {
2123
                level = -level;
2124
                level = (((level << 1) + 1) * qscale *
2125
                         ((int) (quant_matrix[j]))) >> 4;
2126
                level = (level - 1) | 1;
2127
                level = -level;
2128
            } else {
2129
                level = (((level << 1) + 1) * qscale *
2130
                         ((int) (quant_matrix[j]))) >> 4;
2131
                level = (level - 1) | 1;
2132
            }
2133
            block[j] = level;
2134
        }
2135
    }
2136
}
2137

    
2138
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2139
                                   DCTELEM *block, int n, int qscale)
2140
{
2141
    int i, level, nCoeffs;
2142
    const uint16_t *quant_matrix;
2143

    
2144
    if(s->alternate_scan) nCoeffs= 63;
2145
    else nCoeffs= s->block_last_index[n];
2146

    
2147
    if (n < 4)
2148
        block[0] = block[0] * s->y_dc_scale;
2149
    else
2150
        block[0] = block[0] * s->c_dc_scale;
2151
    quant_matrix = s->intra_matrix;
2152
    for(i=1;i<=nCoeffs;i++) {
2153
        int j= s->intra_scantable.permutated[i];
2154
        level = block[j];
2155
        if (level) {
2156
            if (level < 0) {
2157
                level = -level;
2158
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2159
                level = -level;
2160
            } else {
2161
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2162
            }
2163
            block[j] = level;
2164
        }
2165
    }
2166
}
2167

    
2168
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2169
                                   DCTELEM *block, int n, int qscale)
2170
{
2171
    int i, level, nCoeffs;
2172
    const uint16_t *quant_matrix;
2173
    int sum=-1;
2174

    
2175
    if(s->alternate_scan) nCoeffs= 63;
2176
    else nCoeffs= s->block_last_index[n];
2177

    
2178
    if (n < 4)
2179
        block[0] = block[0] * s->y_dc_scale;
2180
    else
2181
        block[0] = block[0] * s->c_dc_scale;
2182
    quant_matrix = s->intra_matrix;
2183
    for(i=1;i<=nCoeffs;i++) {
2184
        int j= s->intra_scantable.permutated[i];
2185
        level = block[j];
2186
        if (level) {
2187
            if (level < 0) {
2188
                level = -level;
2189
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2190
                level = -level;
2191
            } else {
2192
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2193
            }
2194
            block[j] = level;
2195
            sum+=level;
2196
        }
2197
    }
2198
    block[63]^=sum&1;
2199
}
2200

    
2201
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2202
                                   DCTELEM *block, int n, int qscale)
2203
{
2204
    int i, level, nCoeffs;
2205
    const uint16_t *quant_matrix;
2206
    int sum=-1;
2207

    
2208
    if(s->alternate_scan) nCoeffs= 63;
2209
    else nCoeffs= s->block_last_index[n];
2210

    
2211
    quant_matrix = s->inter_matrix;
2212
    for(i=0; i<=nCoeffs; i++) {
2213
        int j= s->intra_scantable.permutated[i];
2214
        level = block[j];
2215
        if (level) {
2216
            if (level < 0) {
2217
                level = -level;
2218
                level = (((level << 1) + 1) * qscale *
2219
                         ((int) (quant_matrix[j]))) >> 4;
2220
                level = -level;
2221
            } else {
2222
                level = (((level << 1) + 1) * qscale *
2223
                         ((int) (quant_matrix[j]))) >> 4;
2224
            }
2225
            block[j] = level;
2226
            sum+=level;
2227
        }
2228
    }
2229
    block[63]^=sum&1;
2230
}
2231

    
2232
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2233
                                  DCTELEM *block, int n, int qscale)
2234
{
2235
    int i, level, qmul, qadd;
2236
    int nCoeffs;
2237

    
2238
    assert(s->block_last_index[n]>=0);
2239

    
2240
    qmul = qscale << 1;
2241

    
2242
    if (!s->h263_aic) {
2243
        if (n < 4)
2244
            block[0] = block[0] * s->y_dc_scale;
2245
        else
2246
            block[0] = block[0] * s->c_dc_scale;
2247
        qadd = (qscale - 1) | 1;
2248
    }else{
2249
        qadd = 0;
2250
    }
2251
    if(s->ac_pred)
2252
        nCoeffs=63;
2253
    else
2254
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2255

    
2256
    for(i=1; i<=nCoeffs; i++) {
2257
        level = block[i];
2258
        if (level) {
2259
            if (level < 0) {
2260
                level = level * qmul - qadd;
2261
            } else {
2262
                level = level * qmul + qadd;
2263
            }
2264
            block[i] = level;
2265
        }
2266
    }
2267
}
2268

    
2269
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2270
                                  DCTELEM *block, int n, int qscale)
2271
{
2272
    int i, level, qmul, qadd;
2273
    int nCoeffs;
2274

    
2275
    assert(s->block_last_index[n]>=0);
2276

    
2277
    qadd = (qscale - 1) | 1;
2278
    qmul = qscale << 1;
2279

    
2280
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2281

    
2282
    for(i=0; i<=nCoeffs; i++) {
2283
        level = block[i];
2284
        if (level) {
2285
            if (level < 0) {
2286
                level = level * qmul - qadd;
2287
            } else {
2288
                level = level * qmul + qadd;
2289
            }
2290
            block[i] = level;
2291
        }
2292
    }
2293
}
2294

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

    
2305
    s->qscale = qscale;
2306
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2307

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