Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 4440bd0d

History | View | Annotate | Download (86.9 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 libavcodec/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 "xvmc_internal.h"
38
#include <limits.h>
39

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

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

    
58

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

    
62
//#define DEBUG
63

    
64

    
65
static const uint8_t ff_default_chroma_qscale_table[32]={
66
//  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
67
    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
68
};
69

    
70
const uint8_t ff_mpeg1_dc_scale_table[128]={
71
//  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
72
    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,
73
    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,
74
    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,
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
};
77

    
78

    
79
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
80
    int i;
81

    
82
    assert(p<=end);
83
    if(p>=end)
84
        return end;
85

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

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

    
103
    p= FFMIN(p, end)-4;
104
    *state= AV_RB32(p);
105

    
106
    return p+4;
107
}
108

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

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

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

    
150
    return 0;
151
}
152

    
153
void ff_copy_picture(Picture *dst, Picture *src){
154
    *dst = *src;
155
    dst->type= FF_BUFFER_TYPE_COPY;
156
}
157

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

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

    
177
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
178

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

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

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

    
196
        s->linesize  = pic->linesize[0];
197
        s->uvlinesize= pic->linesize[1];
198
    }
199

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

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

    
233
    /* It might be nicer if the application would keep track of these
234
     * but it would require an API change. */
235
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
236
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
237
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
238
        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.
239

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

    
247
/**
248
 * deallocates a picture
249
 */
250
static void free_picture(MpegEncContext *s, Picture *pic){
251
    int i;
252

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

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

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

    
280
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
281
    int i;
282

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

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

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

    
311
static void free_duplicate_context(MpegEncContext *s){
312
    if(s==NULL) return;
313

    
314
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
315
    av_freep(&s->me.scratchpad);
316
    s->me.temp=
317
    s->rd_scratchpad=
318
    s->b_scratchpad=
319
    s->obmc_scratchpad= NULL;
320

    
321
    av_freep(&s->dct_error_sum);
322
    av_freep(&s->me.map);
323
    av_freep(&s->me.score_map);
324
    av_freep(&s->blocks);
325
    s->block= NULL;
326
}
327

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

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

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

    
377
    s->coded_picture_number = 0;
378
    s->picture_number = 0;
379
    s->input_picture_number = 0;
380

    
381
    s->picture_in_gop_number = 0;
382

    
383
    s->f_code = 1;
384
    s->b_code = 1;
385
}
386

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

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

    
403
    s->mb_height = (s->height + 15) / 16;
404

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

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

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

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

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

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

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

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

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

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

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

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

    
458
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
459

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
567
    s->context_initialized = 1;
568

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

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

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

    
584
    return 0;
585
 fail:
586
    MPV_common_end(s);
587
    return -1;
588
}
589

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

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

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

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

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

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

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

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

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

    
671
    avcodec_default_free_buffers(s->avctx);
672
}
673

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

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

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

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

    
725
void init_vlc_rl(RLTable *rl)
726
{
727
    int i, q;
728

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

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

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

    
765
int ff_find_unused_picture(MpegEncContext *s, int shared){
766
    int i;
767

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

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

    
797
static void update_noise_reduction(MpegEncContext *s){
798
    int intra, i;
799

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

    
808
        for(i=0; i<64; i++){
809
            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);
810
        }
811
    }
812
}
813

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

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

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

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

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

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

    
866
        pic->coded_picture_number= s->coded_picture_number++;
867

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

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

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

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

    
883
    if (s->pict_type != FF_B_TYPE) {
884
        s->last_picture_ptr= s->next_picture_ptr;
885
        if(!s->dropable)
886
            s->next_picture_ptr= s->current_picture_ptr;
887
    }
888
/*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
889
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
890
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
891
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
892
        s->pict_type, s->dropable);*/
893

    
894
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
895
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
896

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

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

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

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

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

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

    
936
        update_noise_reduction(s);
937
    }
938

    
939
#if CONFIG_MPEG_XVMC_DECODER
940
    if(s->avctx->xvmc_acceleration)
941
        return ff_xvmc_field_start(s, avctx);
942
#endif
943
    return 0;
944
}
945

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1154

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

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

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

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

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

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

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

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

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

    
1276

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

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

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

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

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

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

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

    
1369
    src += src_y * stride + src_x;
1370

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1787
            assert(age);
1788

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2020
        emms_c();
2021

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2241
    qmul = qscale << 1;
2242

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

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

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

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

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

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

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

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

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

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