Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ fe67a236

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 mpegvideo.c
27
 * The simplest mpeg encoder (well, it was the simplest!).
28
 */
29

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

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

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

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

    
61

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

    
65
//#define DEBUG
66

    
67

    
68
static const uint8_t ff_default_chroma_qscale_table[32]={
69
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
70
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
71
};
72

    
73
const uint8_t ff_mpeg1_dc_scale_table[128]={
74
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
75
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79
};
80

    
81

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

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

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

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

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

    
109
    return p+4;
110
}
111

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

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

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

    
153
    return 0;
154
}
155

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
329
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
330
#define COPY(a) bak->a= src->a
331
    COPY(allocated_edge_emu_buffer);
332
    COPY(edge_emu_buffer);
333
    COPY(me.scratchpad);
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
    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) copy_picture(&s->last_picture, s->last_picture_ptr);
895
    if(s->next_picture_ptr) 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
#ifdef HAVE_XVMC
940
    if(s->avctx->xvmc_acceleration)
941
        return 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
#ifdef HAVE_XVMC
952
//just to make sure that all data is rendered.
953
    if(s->avctx->xvmc_acceleration){
954
        XVMC_field_end(s);
955
    }else
956
#endif
957
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
958
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
959
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
960
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
961
    }
962
    emms_c();
963

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

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

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

    
1007
    sx= av_clip(sx, 0, w-1);
1008
    sy= av_clip(sy, 0, h-1);
1009
    ex= av_clip(ex, 0, w-1);
1010
    ey= av_clip(ey, 0, h-1);
1011

    
1012
    buf[sy*stride + sx]+= color;
1013

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

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

    
1056
    sx= av_clip(sx, -100, w+100);
1057
    sy= av_clip(sy, -100, h+100);
1058
    ex= av_clip(ex, -100, w+100);
1059
    ey= av_clip(ey, -100, h+100);
1060

    
1061
    dx= ex - sx;
1062
    dy= ey - sy;
1063

    
1064
    if(dx*dx + dy*dy > 3*3){
1065
        int rx=  dx + dy;
1066
        int ry= -dx + dy;
1067
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1068

    
1069
        //FIXME subpixel accuracy
1070
        rx= ROUNDED_DIV(rx*3<<4, length);
1071
        ry= ROUNDED_DIV(ry*3<<4, length);
1072

    
1073
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1074
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1075
    }
1076
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1077
}
1078

    
1079
/**
1080
 * prints debuging info for the given picture.
1081
 */
1082
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1083

    
1084
    if(!pict || !pict->mb_type) return;
1085

    
1086
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1087
        int x,y;
1088

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

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

    
1150

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

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

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

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

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

    
1227
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1228
                            my*=2;
1229

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

    
1241
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1242
                            my*=2;
1243

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

    
1272

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

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

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

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

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

    
1355
    if(s->quarter_sample){
1356
        motion_x/=2;
1357
        motion_y/=2;
1358
    }
1359

    
1360
    sx= motion_x & s_mask;
1361
    sy= motion_y & s_mask;
1362
    src_x += motion_x >> (lowres+1);
1363
    src_y += motion_y >> (lowres+1);
1364

    
1365
    src += src_y * stride + src_x;
1366

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

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

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

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

    
1405
    if(field_based){
1406
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1407
    }
1408

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

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

    
1435
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1436
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1437
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1438

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

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

    
1461
    if(field_select){
1462
        ptr_y += s->linesize;
1463
        ptr_cb+= s->uvlinesize;
1464
        ptr_cr+= s->uvlinesize;
1465
    }
1466

    
1467
    sx <<= 2 - lowres;
1468
    sy <<= 2 - lowres;
1469
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1470

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

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

    
1493
    if(s->quarter_sample){
1494
        mx/=2;
1495
        my/=2;
1496
    }
1497

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

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

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

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

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

    
1551
    mb_x = s->mb_x;
1552
    mb_y = s->mb_y;
1553

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

    
1573
                mx += s->mv[dir][i][0];
1574
                my += s->mv[dir][i][1];
1575
            }
1576

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

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

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

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

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

    
1642
                // after put we make avg of the same block
1643
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1644

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

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

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

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

    
1679
        s->dsp.idct_add (dest, line_size, block);
1680
    }
1681
}
1682

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

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

    
1713
    s->mbintra_table[xy]= 0;
1714
}
1715

    
1716
/* generic function called after a macroblock has been parsed by the
1717
   decoder or after it has been encoded by the encoder.
1718

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

    
1739
    mb_x = s->mb_x;
1740
    mb_y = s->mb_y;
1741

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

    
1751
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1752

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

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

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

    
1783
            assert(age);
1784

    
1785
            if (s->mb_skipped) {
1786
                s->mb_skipped= 0;
1787
                assert(s->pict_type!=FF_I_TYPE);
1788

    
1789
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1790
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1791

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

    
1804
        dct_linesize = linesize << s->interlaced_dct;
1805
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1806

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

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

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

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

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

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

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

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

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

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

    
1943
                        dct_linesize = uvlinesize << s->interlaced_dct;
1944
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1945

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

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

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

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

    
1995
        h= FFMIN(h, s->avctx->height - y);
1996

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

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

    
2016
        emms_c();
2017

    
2018
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2019
                                  y, s->picture_structure, h);
2020
    }
2021
}
2022

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

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

    
2036
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2037
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2038
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2039

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

    
2048
void ff_mpeg_flush(AVCodecContext *avctx){
2049
    int i;
2050
    MpegEncContext *s = avctx->priv_data;
2051

    
2052
    if(s==NULL || s->picture==NULL)
2053
        return;
2054

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

    
2062
    s->mb_x= s->mb_y= 0;
2063

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

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

    
2080
    nCoeffs= s->block_last_index[n];
2081

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

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

    
2112
    nCoeffs= s->block_last_index[n];
2113

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

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

    
2141
    if(s->alternate_scan) nCoeffs= 63;
2142
    else nCoeffs= s->block_last_index[n];
2143

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

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

    
2172
    if(s->alternate_scan) nCoeffs= 63;
2173
    else nCoeffs= s->block_last_index[n];
2174

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

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

    
2205
    if(s->alternate_scan) nCoeffs= 63;
2206
    else nCoeffs= s->block_last_index[n];
2207

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

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

    
2235
    assert(s->block_last_index[n]>=0);
2236

    
2237
    qmul = qscale << 1;
2238

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

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

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

    
2272
    assert(s->block_last_index[n]>=0);
2273

    
2274
    qadd = (qscale - 1) | 1;
2275
    qmul = qscale << 1;
2276

    
2277
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2278

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

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

    
2302
    s->qscale = qscale;
2303
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2304

    
2305
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2306
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2307
}