Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 49fb20cb

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   HAVE_MMX
125
    MPV_common_init_mmx(s);
126
#elif ARCH_ALPHA
127
    MPV_common_init_axp(s);
128
#elif CONFIG_MLIB
129
    MPV_common_init_mlib(s);
130
#elif HAVE_MMI
131
    MPV_common_init_mmi(s);
132
#elif ARCH_ARM
133
    MPV_common_init_arm(s);
134
#elif HAVE_ALTIVEC
135
    MPV_common_init_altivec(s);
136
#elif 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
#if 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
#if 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->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
961
       && s->unrestricted_mv
962
       && s->current_picture.reference
963
       && !s->intra_only
964
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
965
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
966
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
967
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
968
    }
969
    emms_c();
970

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

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

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

    
1014
    sx= av_clip(sx, 0, w-1);
1015
    sy= av_clip(sy, 0, h-1);
1016
    ex= av_clip(ex, 0, w-1);
1017
    ey= av_clip(ey, 0, h-1);
1018

    
1019
    buf[sy*stride + sx]+= color;
1020

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

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

    
1063
    sx= av_clip(sx, -100, w+100);
1064
    sy= av_clip(sy, -100, h+100);
1065
    ex= av_clip(ex, -100, w+100);
1066
    ey= av_clip(ey, -100, h+100);
1067

    
1068
    dx= ex - sx;
1069
    dy= ey - sy;
1070

    
1071
    if(dx*dx + dy*dy > 3*3){
1072
        int rx=  dx + dy;
1073
        int ry= -dx + dy;
1074
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1075

    
1076
        //FIXME subpixel accuracy
1077
        rx= ROUNDED_DIV(rx*3<<4, length);
1078
        ry= ROUNDED_DIV(ry*3<<4, length);
1079

    
1080
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1081
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1082
    }
1083
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1084
}
1085

    
1086
/**
1087
 * prints debuging info for the given picture.
1088
 */
1089
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1090

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

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

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

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

    
1157

    
1158
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1159
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1160
                    else
1161
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1162
                }
1163
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1164
            }
1165
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1166
        }
1167
    }
1168

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

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

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

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

    
1234
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1235
                            my*=2;
1236

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

    
1248
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1249
                            my*=2;
1250

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

    
1279

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

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

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

    
1338
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1339
                        // hmm
1340
                    }
1341
                }
1342
                s->mbskip_table[mb_index]=0;
1343
            }
1344
        }
1345
    }
1346
}
1347

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

    
1362
    if(s->quarter_sample){
1363
        motion_x/=2;
1364
        motion_y/=2;
1365
    }
1366

    
1367
    sx= motion_x & s_mask;
1368
    sy= motion_y & s_mask;
1369
    src_x += motion_x >> (lowres+1);
1370
    src_y += motion_y >> (lowres+1);
1371

    
1372
    src += src_y * stride + src_x;
1373

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

    
1382
    sx <<= 2 - lowres;
1383
    sy <<= 2 - lowres;
1384
    if(field_select)
1385
        src += s->linesize;
1386
    pix_op[lowres](dest, src, stride, h, sx, sy);
1387
    return emu;
1388
}
1389

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

    
1407
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1408
        motion_x/=2;
1409
        motion_y/=2;
1410
    }
1411

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

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

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

    
1442
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1443
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1444
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1445

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

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

    
1468
    if(field_select){
1469
        ptr_y += s->linesize;
1470
        ptr_cb+= s->uvlinesize;
1471
        ptr_cr+= s->uvlinesize;
1472
    }
1473

    
1474
    sx <<= 2 - lowres;
1475
    sy <<= 2 - lowres;
1476
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1477

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

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

    
1500
    if(s->quarter_sample){
1501
        mx/=2;
1502
        my/=2;
1503
    }
1504

    
1505
    /* In case of 8X8, we construct a single chroma motion vector
1506
       with a special rounding */
1507
    mx= ff_h263_round_chroma(mx);
1508
    my= ff_h263_round_chroma(my);
1509

    
1510
    sx= mx & s_mask;
1511
    sy= my & s_mask;
1512
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1513
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1514

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

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

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

    
1558
    mb_x = s->mb_x;
1559
    mb_y = s->mb_y;
1560

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

    
1580
                mx += s->mv[dir][i][0];
1581
                my += s->mv[dir][i][1];
1582
            }
1583

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

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

    
1614
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1615
                ref2picture= ref_picture;
1616
            }else{
1617
                ref2picture= s->current_picture_ptr->data;
1618
            }
1619

    
1620
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1621
                        0, 0, s->field_select[dir][i],
1622
                        ref2picture, pix_op,
1623
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1624

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

    
1649
                // after put we make avg of the same block
1650
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1651

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

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

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

    
1680
static inline void add_dequant_dct(MpegEncContext *s,
1681
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1682
{
1683
    if (s->block_last_index[i] >= 0) {
1684
        s->dct_unquantize_inter(s, block, i, qscale);
1685

    
1686
        s->dsp.idct_add (dest, line_size, block);
1687
    }
1688
}
1689

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

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

    
1720
    s->mbintra_table[xy]= 0;
1721
}
1722

    
1723
/* generic function called after a macroblock has been parsed by the
1724
   decoder or after it has been encoded by the encoder.
1725

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

    
1746
    mb_x = s->mb_x;
1747
    mb_y = s->mb_y;
1748

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

    
1758
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1759

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

    
1774
    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
1775
        uint8_t *dest_y, *dest_cb, *dest_cr;
1776
        int dct_linesize, dct_offset;
1777
        op_pixels_func (*op_pix)[4];
1778
        qpel_mc_func (*op_qpix)[16];
1779
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1780
        const int uvlinesize= s->current_picture.linesize[1];
1781
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1782
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1783

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

    
1790
            assert(age);
1791

    
1792
            if (s->mb_skipped) {
1793
                s->mb_skipped= 0;
1794
                assert(s->pict_type!=FF_I_TYPE);
1795

    
1796
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1797
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1798

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

    
1811
        dct_linesize = linesize << s->interlaced_dct;
1812
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1813

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

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

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

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

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

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

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

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

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

    
1944
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1945
                    if(s->chroma_y_shift){
1946
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1947
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1948
                    }else{
1949

    
1950
                        dct_linesize = uvlinesize << s->interlaced_dct;
1951
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1952

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

    
1976
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1977
#if !CONFIG_SMALL
1978
    if(s->out_format == FMT_MPEG1) {
1979
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1980
        else                 MPV_decode_mb_internal(s, block, 0, 1);
1981
    } else
1982
#endif
1983
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1984
    else                  MPV_decode_mb_internal(s, block, 0, 0);
1985
}
1986

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

    
1996
        if(s->picture_structure != PICT_FRAME){
1997
            h <<= 1;
1998
            y <<= 1;
1999
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2000
        }
2001

    
2002
        h= FFMIN(h, s->avctx->height - y);
2003

    
2004
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2005
            src= (AVFrame*)s->current_picture_ptr;
2006
        else if(s->last_picture_ptr)
2007
            src= (AVFrame*)s->last_picture_ptr;
2008
        else
2009
            return;
2010

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

    
2023
        emms_c();
2024

    
2025
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2026
                                  y, s->picture_structure, h);
2027
    }
2028
}
2029

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

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

    
2043
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2044
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2045
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2046

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

    
2055
void ff_mpeg_flush(AVCodecContext *avctx){
2056
    int i;
2057
    MpegEncContext *s = avctx->priv_data;
2058

    
2059
    if(s==NULL || s->picture==NULL)
2060
        return;
2061

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

    
2069
    s->mb_x= s->mb_y= 0;
2070

    
2071
    s->parse_context.state= -1;
2072
    s->parse_context.frame_start_found= 0;
2073
    s->parse_context.overread= 0;
2074
    s->parse_context.overread_index= 0;
2075
    s->parse_context.index= 0;
2076
    s->parse_context.last_index= 0;
2077
    s->bitstream_buffer_size=0;
2078
    s->pp_time=0;
2079
}
2080

    
2081
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2082
                                   DCTELEM *block, int n, int qscale)
2083
{
2084
    int i, level, nCoeffs;
2085
    const uint16_t *quant_matrix;
2086

    
2087
    nCoeffs= s->block_last_index[n];
2088

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

    
2113
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2114
                                   DCTELEM *block, int n, int qscale)
2115
{
2116
    int i, level, nCoeffs;
2117
    const uint16_t *quant_matrix;
2118

    
2119
    nCoeffs= s->block_last_index[n];
2120

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

    
2142
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2143
                                   DCTELEM *block, int n, int qscale)
2144
{
2145
    int i, level, nCoeffs;
2146
    const uint16_t *quant_matrix;
2147

    
2148
    if(s->alternate_scan) nCoeffs= 63;
2149
    else nCoeffs= s->block_last_index[n];
2150

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

    
2172
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2173
                                   DCTELEM *block, int n, int qscale)
2174
{
2175
    int i, level, nCoeffs;
2176
    const uint16_t *quant_matrix;
2177
    int sum=-1;
2178

    
2179
    if(s->alternate_scan) nCoeffs= 63;
2180
    else nCoeffs= s->block_last_index[n];
2181

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

    
2205
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2206
                                   DCTELEM *block, int n, int qscale)
2207
{
2208
    int i, level, nCoeffs;
2209
    const uint16_t *quant_matrix;
2210
    int sum=-1;
2211

    
2212
    if(s->alternate_scan) nCoeffs= 63;
2213
    else nCoeffs= s->block_last_index[n];
2214

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

    
2236
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2237
                                  DCTELEM *block, int n, int qscale)
2238
{
2239
    int i, level, qmul, qadd;
2240
    int nCoeffs;
2241

    
2242
    assert(s->block_last_index[n]>=0);
2243

    
2244
    qmul = qscale << 1;
2245

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

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

    
2273
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2274
                                  DCTELEM *block, int n, int qscale)
2275
{
2276
    int i, level, qmul, qadd;
2277
    int nCoeffs;
2278

    
2279
    assert(s->block_last_index[n]>=0);
2280

    
2281
    qadd = (qscale - 1) | 1;
2282
    qmul = qscale << 1;
2283

    
2284
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2285

    
2286
    for(i=0; i<=nCoeffs; i++) {
2287
        level = block[i];
2288
        if (level) {
2289
            if (level < 0) {
2290
                level = level * qmul - qadd;
2291
            } else {
2292
                level = level * qmul + qadd;
2293
            }
2294
            block[i] = level;
2295
        }
2296
    }
2297
}
2298

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

    
2309
    s->qscale = qscale;
2310
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2311

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