Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 68e5d523

History | View | Annotate | Download (87.9 KB)

1
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24

    
25
/**
26
 * @file libavcodec/mpegvideo.c
27
 * The simplest mpeg encoder (well, it was the simplest!).
28
 */
29

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

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

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

    
58

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

    
62
//#define DEBUG
63

    
64

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

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

    
78
const enum PixelFormat ff_pixfmt_list_420[] = {
79
    PIX_FMT_YUV420P,
80
    PIX_FMT_NONE
81
};
82

    
83
const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
84
    PIX_FMT_YUV420P,
85
    PIX_FMT_NONE
86
};
87

    
88
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
89
    int i;
90

    
91
    assert(p<=end);
92
    if(p>=end)
93
        return end;
94

    
95
    for(i=0; i<3; i++){
96
        uint32_t tmp= *state << 8;
97
        *state= tmp + *(p++);
98
        if(tmp == 0x100 || p==end)
99
            return p;
100
    }
101

    
102
    while(p<end){
103
        if     (p[-1] > 1      ) p+= 3;
104
        else if(p[-2]          ) p+= 2;
105
        else if(p[-3]|(p[-1]-1)) p++;
106
        else{
107
            p++;
108
            break;
109
        }
110
    }
111

    
112
    p= FFMIN(p, end)-4;
113
    *state= AV_RB32(p);
114

    
115
    return p+4;
116
}
117

    
118
/* init common dct for both encoder and decoder */
119
av_cold int ff_dct_common_init(MpegEncContext *s)
120
{
121
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
122
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
123
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
124
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
125
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
126
    if(s->flags & CODEC_FLAG_BITEXACT)
127
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
128
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
129

    
130
#if   HAVE_MMX
131
    MPV_common_init_mmx(s);
132
#elif ARCH_ALPHA
133
    MPV_common_init_axp(s);
134
#elif CONFIG_MLIB
135
    MPV_common_init_mlib(s);
136
#elif HAVE_MMI
137
    MPV_common_init_mmi(s);
138
#elif ARCH_ARM
139
    MPV_common_init_arm(s);
140
#elif HAVE_ALTIVEC
141
    MPV_common_init_altivec(s);
142
#elif ARCH_BFIN
143
    MPV_common_init_bfin(s);
144
#endif
145

    
146
    /* load & permutate scantables
147
       note: only wmv uses different ones
148
    */
149
    if(s->alternate_scan){
150
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
151
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
152
    }else{
153
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
154
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
155
    }
156
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
157
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
158

    
159
    return 0;
160
}
161

    
162
void ff_copy_picture(Picture *dst, Picture *src){
163
    *dst = *src;
164
    dst->type= FF_BUFFER_TYPE_COPY;
165
}
166

    
167
/**
168
 * Releases a frame buffer
169
 */
170
static void free_frame_buffer(MpegEncContext *s, Picture *pic)
171
{
172
    s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
173
    av_freep(&pic->hwaccel_data_private);
174
}
175

    
176
/**
177
 * Allocates a frame buffer
178
 */
179
static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
180
{
181
    int r;
182

    
183
    if (s->avctx->hwaccel) {
184
        assert(!pic->hwaccel_data_private);
185
        if (s->avctx->hwaccel->priv_data_size) {
186
            pic->hwaccel_data_private = av_malloc(s->avctx->hwaccel->priv_data_size);
187
            if (!pic->hwaccel_data_private) {
188
                av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
189
                return -1;
190
            }
191
        }
192
    }
193

    
194
    r = s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
195

    
196
    if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
197
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
198
        av_freep(&pic->hwaccel_data_private);
199
        return -1;
200
    }
201

    
202
    if (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])) {
203
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
204
        free_frame_buffer(s, pic);
205
        return -1;
206
    }
207

    
208
    if (pic->linesize[1] != pic->linesize[2]) {
209
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
210
        free_frame_buffer(s, pic);
211
        return -1;
212
    }
213

    
214
    return 0;
215
}
216

    
217
/**
218
 * allocates a Picture
219
 * The pixels are allocated/set by calling get_buffer() if shared=0
220
 */
221
int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
222
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
223
    const int mb_array_size= s->mb_stride*s->mb_height;
224
    const int b8_array_size= s->b8_stride*s->mb_height*2;
225
    const int b4_array_size= s->b4_stride*s->mb_height*4;
226
    int i;
227
    int r= -1;
228

    
229
    if(shared){
230
        assert(pic->data[0]);
231
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
232
        pic->type= FF_BUFFER_TYPE_SHARED;
233
    }else{
234
        assert(!pic->data[0]);
235

    
236
        if (alloc_frame_buffer(s, pic) < 0)
237
            return -1;
238

    
239
        s->linesize  = pic->linesize[0];
240
        s->uvlinesize= pic->linesize[1];
241
    }
242

    
243
    if(pic->qscale_table==NULL){
244
        if (s->encoding) {
245
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
246
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
247
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
248
        }
249

    
250
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
251
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
252
        CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
253
        pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
254
        if(s->out_format == FMT_H264){
255
            for(i=0; i<2; i++){
256
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
257
                pic->motion_val[i]= pic->motion_val_base[i]+4;
258
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
259
            }
260
            pic->motion_subsample_log2= 2;
261
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
262
            for(i=0; i<2; i++){
263
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
264
                pic->motion_val[i]= pic->motion_val_base[i]+4;
265
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
266
            }
267
            pic->motion_subsample_log2= 3;
268
        }
269
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
270
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
271
        }
272
        pic->qstride= s->mb_stride;
273
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
274
    }
275

    
276
    /* It might be nicer if the application would keep track of these
277
     * but it would require an API change. */
278
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
279
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
280
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
281
        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.
282

    
283
    return 0;
284
fail: //for the CHECKED_ALLOCZ macro
285
    if(r>=0)
286
        free_frame_buffer(s, pic);
287
    return -1;
288
}
289

    
290
/**
291
 * deallocates a picture
292
 */
293
static void free_picture(MpegEncContext *s, Picture *pic){
294
    int i;
295

    
296
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
297
        free_frame_buffer(s, pic);
298
    }
299

    
300
    av_freep(&pic->mb_var);
301
    av_freep(&pic->mc_mb_var);
302
    av_freep(&pic->mb_mean);
303
    av_freep(&pic->mbskip_table);
304
    av_freep(&pic->qscale_table);
305
    av_freep(&pic->mb_type_base);
306
    av_freep(&pic->dct_coeff);
307
    av_freep(&pic->pan_scan);
308
    pic->mb_type= NULL;
309
    for(i=0; i<2; i++){
310
        av_freep(&pic->motion_val_base[i]);
311
        av_freep(&pic->ref_index[i]);
312
    }
313

    
314
    if(pic->type == FF_BUFFER_TYPE_SHARED){
315
        for(i=0; i<4; i++){
316
            pic->base[i]=
317
            pic->data[i]= NULL;
318
        }
319
        pic->type= 0;
320
    }
321
}
322

    
323
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
324
    int i;
325

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

    
330
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
331
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
332
    s->me.temp=         s->me.scratchpad;
333
    s->rd_scratchpad=   s->me.scratchpad;
334
    s->b_scratchpad=    s->me.scratchpad;
335
    s->obmc_scratchpad= s->me.scratchpad + 16;
336
    if (s->encoding) {
337
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
338
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
339
        if(s->avctx->noise_reduction){
340
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
341
        }
342
    }
343
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
344
    s->block= s->blocks[0];
345

    
346
    for(i=0;i<12;i++){
347
        s->pblocks[i] = &s->block[i];
348
    }
349
    return 0;
350
fail:
351
    return -1; //free() through MPV_common_end()
352
}
353

    
354
static void free_duplicate_context(MpegEncContext *s){
355
    if(s==NULL) return;
356

    
357
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
358
    av_freep(&s->me.scratchpad);
359
    s->me.temp=
360
    s->rd_scratchpad=
361
    s->b_scratchpad=
362
    s->obmc_scratchpad= NULL;
363

    
364
    av_freep(&s->dct_error_sum);
365
    av_freep(&s->me.map);
366
    av_freep(&s->me.score_map);
367
    av_freep(&s->blocks);
368
    s->block= NULL;
369
}
370

    
371
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
372
#define COPY(a) bak->a= src->a
373
    COPY(allocated_edge_emu_buffer);
374
    COPY(edge_emu_buffer);
375
    COPY(me.scratchpad);
376
    COPY(me.temp);
377
    COPY(rd_scratchpad);
378
    COPY(b_scratchpad);
379
    COPY(obmc_scratchpad);
380
    COPY(me.map);
381
    COPY(me.score_map);
382
    COPY(blocks);
383
    COPY(block);
384
    COPY(start_mb_y);
385
    COPY(end_mb_y);
386
    COPY(me.map_generation);
387
    COPY(pb);
388
    COPY(dct_error_sum);
389
    COPY(dct_count[0]);
390
    COPY(dct_count[1]);
391
#undef COPY
392
}
393

    
394
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
395
    MpegEncContext bak;
396
    int i;
397
    //FIXME copy only needed parts
398
//START_TIMER
399
    backup_duplicate_context(&bak, dst);
400
    memcpy(dst, src, sizeof(MpegEncContext));
401
    backup_duplicate_context(dst, &bak);
402
    for(i=0;i<12;i++){
403
        dst->pblocks[i] = &dst->block[i];
404
    }
405
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
406
}
407

    
408
/**
409
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
410
 * the changed fields will not depend upon the prior state of the MpegEncContext.
411
 */
412
void MPV_common_defaults(MpegEncContext *s){
413
    s->y_dc_scale_table=
414
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
415
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
416
    s->progressive_frame= 1;
417
    s->progressive_sequence= 1;
418
    s->picture_structure= PICT_FRAME;
419

    
420
    s->coded_picture_number = 0;
421
    s->picture_number = 0;
422
    s->input_picture_number = 0;
423

    
424
    s->picture_in_gop_number = 0;
425

    
426
    s->f_code = 1;
427
    s->b_code = 1;
428
}
429

    
430
/**
431
 * sets the given MpegEncContext to defaults for decoding.
432
 * the changed fields will not depend upon the prior state of the MpegEncContext.
433
 */
434
void MPV_decode_defaults(MpegEncContext *s){
435
    MPV_common_defaults(s);
436
}
437

    
438
/**
439
 * init common structure for both encoder and decoder.
440
 * this assumes that some variables like width/height are already set
441
 */
442
av_cold int MPV_common_init(MpegEncContext *s)
443
{
444
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
445

    
446
    s->mb_height = (s->height + 15) / 16;
447

    
448
    if(s->avctx->pix_fmt == PIX_FMT_NONE){
449
        av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
450
        return -1;
451
    }
452

    
453
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
454
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
455
        return -1;
456
    }
457

    
458
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
459
        return -1;
460

    
461
    dsputil_init(&s->dsp, s->avctx);
462
    ff_dct_common_init(s);
463

    
464
    s->flags= s->avctx->flags;
465
    s->flags2= s->avctx->flags2;
466

    
467
    s->mb_width  = (s->width  + 15) / 16;
468
    s->mb_stride = s->mb_width + 1;
469
    s->b8_stride = s->mb_width*2 + 1;
470
    s->b4_stride = s->mb_width*4 + 1;
471
    mb_array_size= s->mb_height * s->mb_stride;
472
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
473

    
474
    /* set chroma shifts */
475
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
476
                                                    &(s->chroma_y_shift) );
477

    
478
    /* set default edge pos, will be overriden in decode_header if needed */
479
    s->h_edge_pos= s->mb_width*16;
480
    s->v_edge_pos= s->mb_height*16;
481

    
482
    s->mb_num = s->mb_width * s->mb_height;
483

    
484
    s->block_wrap[0]=
485
    s->block_wrap[1]=
486
    s->block_wrap[2]=
487
    s->block_wrap[3]= s->b8_stride;
488
    s->block_wrap[4]=
489
    s->block_wrap[5]= s->mb_stride;
490

    
491
    y_size = s->b8_stride * (2 * s->mb_height + 1);
492
    c_size = s->mb_stride * (s->mb_height + 1);
493
    yc_size = y_size + 2 * c_size;
494

    
495
    /* convert fourcc to upper case */
496
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
497
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
498
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
499
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
500

    
501
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
502
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
503
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
504
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
505

    
506
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
507

    
508
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
509
    for(y=0; y<s->mb_height; y++){
510
        for(x=0; x<s->mb_width; x++){
511
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
512
        }
513
    }
514
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
515

    
516
    if (s->encoding) {
517
        /* Allocate MV tables */
518
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
519
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
520
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
521
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
522
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
523
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
524
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
525
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
526
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
527
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
528
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
529
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
530

    
531
        if(s->msmpeg4_version){
532
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
533
        }
534
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
535

    
536
        /* Allocate MB type table */
537
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
538

    
539
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
540

    
541
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
542
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
543
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
544
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
545
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
546
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
547

    
548
        if(s->avctx->noise_reduction){
549
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
550
        }
551
    }
552
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
553

    
554
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
555

    
556
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
557
        /* interlaced direct mode decoding tables */
558
            for(i=0; i<2; i++){
559
                int j, k;
560
                for(j=0; j<2; j++){
561
                    for(k=0; k<2; k++){
562
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
563
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
564
                    }
565
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
566
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
567
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
568
                }
569
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
570
            }
571
    }
572
    if (s->out_format == FMT_H263) {
573
        /* ac values */
574
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
575
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
576
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
577
        s->ac_val[2] = s->ac_val[1] + c_size;
578

    
579
        /* cbp values */
580
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
581
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
582

    
583
        /* cbp, ac_pred, pred_dir */
584
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
585
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
586
    }
587

    
588
    if (s->h263_pred || s->h263_plus || !s->encoding) {
589
        /* dc values */
590
        //MN: we need these for error resilience of intra-frames
591
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
592
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
593
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
594
        s->dc_val[2] = s->dc_val[1] + c_size;
595
        for(i=0;i<yc_size;i++)
596
            s->dc_val_base[i] = 1024;
597
    }
598

    
599
    /* which mb is a intra block */
600
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
601
    memset(s->mbintra_table, 1, mb_array_size);
602

    
603
    /* init macroblock skip table */
604
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
605
    //Note the +1 is for a quicker mpeg4 slice_end detection
606
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
607

    
608
    s->parse_context.state= -1;
609
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
610
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
611
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
612
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
613
    }
614

    
615
    s->context_initialized = 1;
616

    
617
    s->thread_context[0]= s;
618
    threads = s->avctx->thread_count;
619

    
620
    for(i=1; i<threads; i++){
621
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
622
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
623
    }
624

    
625
    for(i=0; i<threads; i++){
626
        if(init_duplicate_context(s->thread_context[i], s) < 0)
627
           goto fail;
628
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
629
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
630
    }
631

    
632
    return 0;
633
 fail:
634
    MPV_common_end(s);
635
    return -1;
636
}
637

    
638
/* init common structure for both encoder and decoder */
639
void MPV_common_end(MpegEncContext *s)
640
{
641
    int i, j, k;
642

    
643
    for(i=0; i<s->avctx->thread_count; i++){
644
        free_duplicate_context(s->thread_context[i]);
645
    }
646
    for(i=1; i<s->avctx->thread_count; i++){
647
        av_freep(&s->thread_context[i]);
648
    }
649

    
650
    av_freep(&s->parse_context.buffer);
651
    s->parse_context.buffer_size=0;
652

    
653
    av_freep(&s->mb_type);
654
    av_freep(&s->p_mv_table_base);
655
    av_freep(&s->b_forw_mv_table_base);
656
    av_freep(&s->b_back_mv_table_base);
657
    av_freep(&s->b_bidir_forw_mv_table_base);
658
    av_freep(&s->b_bidir_back_mv_table_base);
659
    av_freep(&s->b_direct_mv_table_base);
660
    s->p_mv_table= NULL;
661
    s->b_forw_mv_table= NULL;
662
    s->b_back_mv_table= NULL;
663
    s->b_bidir_forw_mv_table= NULL;
664
    s->b_bidir_back_mv_table= NULL;
665
    s->b_direct_mv_table= NULL;
666
    for(i=0; i<2; i++){
667
        for(j=0; j<2; j++){
668
            for(k=0; k<2; k++){
669
                av_freep(&s->b_field_mv_table_base[i][j][k]);
670
                s->b_field_mv_table[i][j][k]=NULL;
671
            }
672
            av_freep(&s->b_field_select_table[i][j]);
673
            av_freep(&s->p_field_mv_table_base[i][j]);
674
            s->p_field_mv_table[i][j]=NULL;
675
        }
676
        av_freep(&s->p_field_select_table[i]);
677
    }
678

    
679
    av_freep(&s->dc_val_base);
680
    av_freep(&s->ac_val_base);
681
    av_freep(&s->coded_block_base);
682
    av_freep(&s->mbintra_table);
683
    av_freep(&s->cbp_table);
684
    av_freep(&s->pred_dir_table);
685

    
686
    av_freep(&s->mbskip_table);
687
    av_freep(&s->prev_pict_types);
688
    av_freep(&s->bitstream_buffer);
689
    s->allocated_bitstream_buffer_size=0;
690

    
691
    av_freep(&s->avctx->stats_out);
692
    av_freep(&s->ac_stats);
693
    av_freep(&s->error_status_table);
694
    av_freep(&s->mb_index2xy);
695
    av_freep(&s->lambda_table);
696
    av_freep(&s->q_intra_matrix);
697
    av_freep(&s->q_inter_matrix);
698
    av_freep(&s->q_intra_matrix16);
699
    av_freep(&s->q_inter_matrix16);
700
    av_freep(&s->input_picture);
701
    av_freep(&s->reordered_input_picture);
702
    av_freep(&s->dct_offset);
703

    
704
    if(s->picture){
705
        for(i=0; i<MAX_PICTURE_COUNT; i++){
706
            free_picture(s, &s->picture[i]);
707
        }
708
    }
709
    av_freep(&s->picture);
710
    s->context_initialized = 0;
711
    s->last_picture_ptr=
712
    s->next_picture_ptr=
713
    s->current_picture_ptr= NULL;
714
    s->linesize= s->uvlinesize= 0;
715

    
716
    for(i=0; i<3; i++)
717
        av_freep(&s->visualization_buffer[i]);
718

    
719
    avcodec_default_free_buffers(s->avctx);
720
}
721

    
722
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
723
{
724
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
725
    uint8_t index_run[MAX_RUN+1];
726
    int last, run, level, start, end, i;
727

    
728
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
729
    if(static_store && rl->max_level[0])
730
        return;
731

    
732
    /* compute max_level[], max_run[] and index_run[] */
733
    for(last=0;last<2;last++) {
734
        if (last == 0) {
735
            start = 0;
736
            end = rl->last;
737
        } else {
738
            start = rl->last;
739
            end = rl->n;
740
        }
741

    
742
        memset(max_level, 0, MAX_RUN + 1);
743
        memset(max_run, 0, MAX_LEVEL + 1);
744
        memset(index_run, rl->n, MAX_RUN + 1);
745
        for(i=start;i<end;i++) {
746
            run = rl->table_run[i];
747
            level = rl->table_level[i];
748
            if (index_run[run] == rl->n)
749
                index_run[run] = i;
750
            if (level > max_level[run])
751
                max_level[run] = level;
752
            if (run > max_run[level])
753
                max_run[level] = run;
754
        }
755
        if(static_store)
756
            rl->max_level[last] = static_store[last];
757
        else
758
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
759
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
760
        if(static_store)
761
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
762
        else
763
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
764
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
765
        if(static_store)
766
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
767
        else
768
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
769
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
770
    }
771
}
772

    
773
void init_vlc_rl(RLTable *rl)
774
{
775
    int i, q;
776

    
777
    for(q=0; q<32; q++){
778
        int qmul= q*2;
779
        int qadd= (q-1)|1;
780

    
781
        if(q==0){
782
            qmul=1;
783
            qadd=0;
784
        }
785
        for(i=0; i<rl->vlc.table_size; i++){
786
            int code= rl->vlc.table[i][0];
787
            int len = rl->vlc.table[i][1];
788
            int level, run;
789

    
790
            if(len==0){ // illegal code
791
                run= 66;
792
                level= MAX_LEVEL;
793
            }else if(len<0){ //more bits needed
794
                run= 0;
795
                level= code;
796
            }else{
797
                if(code==rl->n){ //esc
798
                    run= 66;
799
                    level= 0;
800
                }else{
801
                    run=   rl->table_run  [code] + 1;
802
                    level= rl->table_level[code] * qmul + qadd;
803
                    if(code >= rl->last) run+=192;
804
                }
805
            }
806
            rl->rl_vlc[q][i].len= len;
807
            rl->rl_vlc[q][i].level= level;
808
            rl->rl_vlc[q][i].run= run;
809
        }
810
    }
811
}
812

    
813
int ff_find_unused_picture(MpegEncContext *s, int shared){
814
    int i;
815

    
816
    if(shared){
817
        for(i=0; i<MAX_PICTURE_COUNT; i++){
818
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
819
        }
820
    }else{
821
        for(i=0; i<MAX_PICTURE_COUNT; i++){
822
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
823
        }
824
        for(i=0; i<MAX_PICTURE_COUNT; i++){
825
            if(s->picture[i].data[0]==NULL) return i;
826
        }
827
    }
828

    
829
    av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
830
    /* We could return -1, but the codec would crash trying to draw into a
831
     * non-existing frame anyway. This is safer than waiting for a random crash.
832
     * Also the return of this is never useful, an encoder must only allocate
833
     * as much as allowed in the specification. This has no relationship to how
834
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
835
     * enough for such valid streams).
836
     * Plus, a decoder has to check stream validity and remove frames if too
837
     * many reference frames are around. Waiting for "OOM" is not correct at
838
     * all. Similarly, missing reference frames have to be replaced by
839
     * interpolated/MC frames, anything else is a bug in the codec ...
840
     */
841
    abort();
842
    return -1;
843
}
844

    
845
static void update_noise_reduction(MpegEncContext *s){
846
    int intra, i;
847

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

    
856
        for(i=0; i<64; i++){
857
            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);
858
        }
859
    }
860
}
861

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

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

    
873
    /* mark&release old frames */
874
    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]) {
875
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
876
          free_frame_buffer(s, s->last_picture_ptr);
877

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

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

    
906
        pic->reference= 0;
907
        if (!s->dropable){
908
            if (s->codec_id == CODEC_ID_H264)
909
                pic->reference = s->picture_structure;
910
            else if (s->pict_type != FF_B_TYPE)
911
                pic->reference = 3;
912
        }
913

    
914
        pic->coded_picture_number= s->coded_picture_number++;
915

    
916
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
917
            return -1;
918

    
919
        s->current_picture_ptr= (Picture*)pic;
920
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
921
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
922
    }
923

    
924
    s->current_picture_ptr->pict_type= s->pict_type;
925
//    if(s->flags && CODEC_FLAG_QSCALE)
926
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
927
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
928

    
929
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
930

    
931
    if (s->pict_type != FF_B_TYPE) {
932
        s->last_picture_ptr= s->next_picture_ptr;
933
        if(!s->dropable)
934
            s->next_picture_ptr= s->current_picture_ptr;
935
    }
936
/*    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,
937
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
938
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
939
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
940
        s->pict_type, s->dropable);*/
941

    
942
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
943
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
944

    
945
    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){
946
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
947
        assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
948
        goto alloc;
949
    }
950

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

    
953
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
954
        int i;
955
        for(i=0; i<4; i++){
956
            if(s->picture_structure == PICT_BOTTOM_FIELD){
957
                 s->current_picture.data[i] += s->current_picture.linesize[i];
958
            }
959
            s->current_picture.linesize[i] *= 2;
960
            s->last_picture.linesize[i] *=2;
961
            s->next_picture.linesize[i] *=2;
962
        }
963
    }
964

    
965
    s->hurry_up= s->avctx->hurry_up;
966
    s->error_recognition= avctx->error_recognition;
967

    
968
    /* set dequantizer, we can't do it during init as it might change for mpeg4
969
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
970
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
971
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
972
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
973
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
974
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
975
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
976
    }else{
977
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
978
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
979
    }
980

    
981
    if(s->dct_error_sum){
982
        assert(s->avctx->noise_reduction && s->encoding);
983

    
984
        update_noise_reduction(s);
985
    }
986

    
987
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
988
        return ff_xvmc_field_start(s, avctx);
989

    
990
    return 0;
991
}
992

    
993
/* generic function for encode/decode called after a frame has been coded/decoded */
994
void MPV_frame_end(MpegEncContext *s)
995
{
996
    int i;
997
    /* draw edge for correct motion prediction if outside */
998
    //just to make sure that all data is rendered.
999
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1000
        ff_xvmc_field_end(s);
1001
    }else if(!s->avctx->hwaccel
1002
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1003
       && s->unrestricted_mv
1004
       && s->current_picture.reference
1005
       && !s->intra_only
1006
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1007
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1008
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1009
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1010
    }
1011
    emms_c();
1012

    
1013
    s->last_pict_type    = s->pict_type;
1014
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1015
    if(s->pict_type!=FF_B_TYPE){
1016
        s->last_non_b_pict_type= s->pict_type;
1017
    }
1018
#if 0
1019
        /* copy back current_picture variables */
1020
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1021
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1022
            s->picture[i]= s->current_picture;
1023
            break;
1024
        }
1025
    }
1026
    assert(i<MAX_PICTURE_COUNT);
1027
#endif
1028

    
1029
    if(s->encoding){
1030
        /* release non-reference frames */
1031
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1032
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1033
                free_frame_buffer(s, &s->picture[i]);
1034
            }
1035
        }
1036
    }
1037
    // clear copies, to avoid confusion
1038
#if 0
1039
    memset(&s->last_picture, 0, sizeof(Picture));
1040
    memset(&s->next_picture, 0, sizeof(Picture));
1041
    memset(&s->current_picture, 0, sizeof(Picture));
1042
#endif
1043
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1044
}
1045

    
1046
/**
1047
 * draws an line 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_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1054
    int x, y, fr, f;
1055

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

    
1061
    buf[sy*stride + sx]+= color;
1062

    
1063
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1064
        if(sx > ex){
1065
            FFSWAP(int, sx, ex);
1066
            FFSWAP(int, sy, ey);
1067
        }
1068
        buf+= sx + sy*stride;
1069
        ex-= sx;
1070
        f= ((ey-sy)<<16)/ex;
1071
        for(x= 0; x <= ex; x++){
1072
            y = (x*f)>>16;
1073
            fr= (x*f)&0xFFFF;
1074
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1075
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1076
        }
1077
    }else{
1078
        if(sy > ey){
1079
            FFSWAP(int, sx, ex);
1080
            FFSWAP(int, sy, ey);
1081
        }
1082
        buf+= sx + sy*stride;
1083
        ey-= sy;
1084
        if(ey) f= ((ex-sx)<<16)/ey;
1085
        else   f= 0;
1086
        for(y= 0; y <= ey; y++){
1087
            x = (y*f)>>16;
1088
            fr= (y*f)&0xFFFF;
1089
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1090
            buf[y*stride + x+1]+= (color*         fr )>>16;
1091
        }
1092
    }
1093
}
1094

    
1095
/**
1096
 * draws an arrow from (ex, ey) -> (sx, sy).
1097
 * @param w width of the image
1098
 * @param h height of the image
1099
 * @param stride stride/linesize of the image
1100
 * @param color color of the arrow
1101
 */
1102
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1103
    int dx,dy;
1104

    
1105
    sx= av_clip(sx, -100, w+100);
1106
    sy= av_clip(sy, -100, h+100);
1107
    ex= av_clip(ex, -100, w+100);
1108
    ey= av_clip(ey, -100, h+100);
1109

    
1110
    dx= ex - sx;
1111
    dy= ey - sy;
1112

    
1113
    if(dx*dx + dy*dy > 3*3){
1114
        int rx=  dx + dy;
1115
        int ry= -dx + dy;
1116
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1117

    
1118
        //FIXME subpixel accuracy
1119
        rx= ROUNDED_DIV(rx*3<<4, length);
1120
        ry= ROUNDED_DIV(ry*3<<4, length);
1121

    
1122
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1123
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1124
    }
1125
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1126
}
1127

    
1128
/**
1129
 * prints debuging info for the given picture.
1130
 */
1131
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1132

    
1133
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1134

    
1135
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1136
        int x,y;
1137

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

    
1187
                    //segmentation
1188
                    if(IS_8X8(mb_type))
1189
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1190
                    else if(IS_16X8(mb_type))
1191
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1192
                    else if(IS_8X16(mb_type))
1193
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1194
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1195
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1196
                    else
1197
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1198

    
1199

    
1200
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1201
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1202
                    else
1203
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1204
                }
1205
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1206
            }
1207
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1208
        }
1209
    }
1210

    
1211
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1212
        const int shift= 1 + s->quarter_sample;
1213
        int mb_y;
1214
        uint8_t *ptr;
1215
        int i;
1216
        int h_chroma_shift, v_chroma_shift, block_height;
1217
        const int width = s->avctx->width;
1218
        const int height= s->avctx->height;
1219
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1220
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1221
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1222

    
1223
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1224
        for(i=0; i<3; i++){
1225
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1226
            pict->data[i]= s->visualization_buffer[i];
1227
        }
1228
        pict->type= FF_BUFFER_TYPE_COPY;
1229
        ptr= pict->data[0];
1230
        block_height = 16>>v_chroma_shift;
1231

    
1232
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1233
            int mb_x;
1234
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1235
                const int mb_index= mb_x + mb_y*s->mb_stride;
1236
                if((s->avctx->debug_mv) && pict->motion_val){
1237
                  int type;
1238
                  for(type=0; type<3; type++){
1239
                    int direction = 0;
1240
                    switch (type) {
1241
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1242
                                continue;
1243
                              direction = 0;
1244
                              break;
1245
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1246
                                continue;
1247
                              direction = 0;
1248
                              break;
1249
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1250
                                continue;
1251
                              direction = 1;
1252
                              break;
1253
                    }
1254
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1255
                        continue;
1256

    
1257
                    if(IS_8X8(pict->mb_type[mb_index])){
1258
                      int i;
1259
                      for(i=0; i<4; i++){
1260
                        int sx= mb_x*16 + 4 + 8*(i&1);
1261
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1262
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1263
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1264
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1265
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1266
                      }
1267
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1268
                      int i;
1269
                      for(i=0; i<2; i++){
1270
                        int sx=mb_x*16 + 8;
1271
                        int sy=mb_y*16 + 4 + 8*i;
1272
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1273
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1274
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1275

    
1276
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1277
                            my*=2;
1278

    
1279
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1280
                      }
1281
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1282
                      int i;
1283
                      for(i=0; i<2; i++){
1284
                        int sx=mb_x*16 + 4 + 8*i;
1285
                        int sy=mb_y*16 + 8;
1286
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1287
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1288
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1289

    
1290
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1291
                            my*=2;
1292

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

    
1321

    
1322
                    u=v=128;
1323
                    if(IS_PCM(mb_type)){
1324
                        COLOR(120,48)
1325
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1326
                        COLOR(30,48)
1327
                    }else if(IS_INTRA4x4(mb_type)){
1328
                        COLOR(90,48)
1329
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1330
//                        COLOR(120,48)
1331
                    }else if(IS_DIRECT(mb_type)){
1332
                        COLOR(150,48)
1333
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1334
                        COLOR(170,48)
1335
                    }else if(IS_GMC(mb_type)){
1336
                        COLOR(190,48)
1337
                    }else if(IS_SKIP(mb_type)){
1338
//                        COLOR(180,48)
1339
                    }else if(!USES_LIST(mb_type, 1)){
1340
                        COLOR(240,48)
1341
                    }else if(!USES_LIST(mb_type, 0)){
1342
                        COLOR(0,48)
1343
                    }else{
1344
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1345
                        COLOR(300,48)
1346
                    }
1347

    
1348
                    u*= 0x0101010101010101ULL;
1349
                    v*= 0x0101010101010101ULL;
1350
                    for(y=0; y<block_height; y++){
1351
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1352
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1353
                    }
1354

    
1355
                    //segmentation
1356
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1357
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1358
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1359
                    }
1360
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1361
                        for(y=0; y<16; y++)
1362
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1363
                    }
1364
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1365
                        int dm= 1 << (mv_sample_log2-2);
1366
                        for(i=0; i<4; i++){
1367
                            int sx= mb_x*16 + 8*(i&1);
1368
                            int sy= mb_y*16 + 8*(i>>1);
1369
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1370
                            //FIXME bidir
1371
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1372
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1373
                                for(y=0; y<8; y++)
1374
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1375
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1376
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1377
                        }
1378
                    }
1379

    
1380
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1381
                        // hmm
1382
                    }
1383
                }
1384
                s->mbskip_table[mb_index]=0;
1385
            }
1386
        }
1387
    }
1388
}
1389

    
1390
static inline int hpel_motion_lowres(MpegEncContext *s,
1391
                                  uint8_t *dest, uint8_t *src,
1392
                                  int field_based, int field_select,
1393
                                  int src_x, int src_y,
1394
                                  int width, int height, int stride,
1395
                                  int h_edge_pos, int v_edge_pos,
1396
                                  int w, int h, h264_chroma_mc_func *pix_op,
1397
                                  int motion_x, int motion_y)
1398
{
1399
    const int lowres= s->avctx->lowres;
1400
    const int s_mask= (2<<lowres)-1;
1401
    int emu=0;
1402
    int sx, sy;
1403

    
1404
    if(s->quarter_sample){
1405
        motion_x/=2;
1406
        motion_y/=2;
1407
    }
1408

    
1409
    sx= motion_x & s_mask;
1410
    sy= motion_y & s_mask;
1411
    src_x += motion_x >> (lowres+1);
1412
    src_y += motion_y >> (lowres+1);
1413

    
1414
    src += src_y * stride + src_x;
1415

    
1416
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1417
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1418
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1419
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1420
        src= s->edge_emu_buffer;
1421
        emu=1;
1422
    }
1423

    
1424
    sx <<= 2 - lowres;
1425
    sy <<= 2 - lowres;
1426
    if(field_select)
1427
        src += s->linesize;
1428
    pix_op[lowres](dest, src, stride, h, sx, sy);
1429
    return emu;
1430
}
1431

    
1432
/* apply one mpeg motion vector to the three components */
1433
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1434
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1435
                               int field_based, int bottom_field, int field_select,
1436
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1437
                               int motion_x, int motion_y, int h)
1438
{
1439
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1440
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1441
    const int lowres= s->avctx->lowres;
1442
    const int block_s= 8>>lowres;
1443
    const int s_mask= (2<<lowres)-1;
1444
    const int h_edge_pos = s->h_edge_pos >> lowres;
1445
    const int v_edge_pos = s->v_edge_pos >> lowres;
1446
    linesize   = s->current_picture.linesize[0] << field_based;
1447
    uvlinesize = s->current_picture.linesize[1] << field_based;
1448

    
1449
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1450
        motion_x/=2;
1451
        motion_y/=2;
1452
    }
1453

    
1454
    if(field_based){
1455
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1456
    }
1457

    
1458
    sx= motion_x & s_mask;
1459
    sy= motion_y & s_mask;
1460
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1461
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1462

    
1463
    if (s->out_format == FMT_H263) {
1464
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1465
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1466
        uvsrc_x = src_x>>1;
1467
        uvsrc_y = src_y>>1;
1468
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1469
        mx = motion_x / 4;
1470
        my = motion_y / 4;
1471
        uvsx = (2*mx) & s_mask;
1472
        uvsy = (2*my) & s_mask;
1473
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1474
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1475
    } else {
1476
        mx = motion_x / 2;
1477
        my = motion_y / 2;
1478
        uvsx = mx & s_mask;
1479
        uvsy = my & s_mask;
1480
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1481
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1482
    }
1483

    
1484
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1485
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1486
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1487

    
1488
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1489
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1490
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1491
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1492
            ptr_y = s->edge_emu_buffer;
1493
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1494
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1495
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1496
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1497
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1498
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1499
                ptr_cb= uvbuf;
1500
                ptr_cr= uvbuf+16;
1501
            }
1502
    }
1503

    
1504
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1505
        dest_y += s->linesize;
1506
        dest_cb+= s->uvlinesize;
1507
        dest_cr+= s->uvlinesize;
1508
    }
1509

    
1510
    if(field_select){
1511
        ptr_y += s->linesize;
1512
        ptr_cb+= s->uvlinesize;
1513
        ptr_cr+= s->uvlinesize;
1514
    }
1515

    
1516
    sx <<= 2 - lowres;
1517
    sy <<= 2 - lowres;
1518
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1519

    
1520
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1521
        uvsx <<= 2 - lowres;
1522
        uvsy <<= 2 - lowres;
1523
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1524
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1525
    }
1526
    //FIXME h261 lowres loop filter
1527
}
1528

    
1529
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1530
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1531
                                     uint8_t **ref_picture,
1532
                                     h264_chroma_mc_func *pix_op,
1533
                                     int mx, int my){
1534
    const int lowres= s->avctx->lowres;
1535
    const int block_s= 8>>lowres;
1536
    const int s_mask= (2<<lowres)-1;
1537
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1538
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1539
    int emu=0, src_x, src_y, offset, sx, sy;
1540
    uint8_t *ptr;
1541

    
1542
    if(s->quarter_sample){
1543
        mx/=2;
1544
        my/=2;
1545
    }
1546

    
1547
    /* In case of 8X8, we construct a single chroma motion vector
1548
       with a special rounding */
1549
    mx= ff_h263_round_chroma(mx);
1550
    my= ff_h263_round_chroma(my);
1551

    
1552
    sx= mx & s_mask;
1553
    sy= my & s_mask;
1554
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1555
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1556

    
1557
    offset = src_y * s->uvlinesize + src_x;
1558
    ptr = ref_picture[1] + offset;
1559
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1560
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1561
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1562
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1563
            ptr= s->edge_emu_buffer;
1564
            emu=1;
1565
        }
1566
    }
1567
    sx <<= 2 - lowres;
1568
    sy <<= 2 - lowres;
1569
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1570

    
1571
    ptr = ref_picture[2] + offset;
1572
    if(emu){
1573
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1574
        ptr= s->edge_emu_buffer;
1575
    }
1576
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1577
}
1578

    
1579
/**
1580
 * motion compensation of a single macroblock
1581
 * @param s context
1582
 * @param dest_y luma destination pointer
1583
 * @param dest_cb chroma cb/u destination pointer
1584
 * @param dest_cr chroma cr/v destination pointer
1585
 * @param dir direction (0->forward, 1->backward)
1586
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1587
 * @param pic_op halfpel motion compensation function (average or put normally)
1588
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1589
 */
1590
static inline void MPV_motion_lowres(MpegEncContext *s,
1591
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1592
                              int dir, uint8_t **ref_picture,
1593
                              h264_chroma_mc_func *pix_op)
1594
{
1595
    int mx, my;
1596
    int mb_x, mb_y, i;
1597
    const int lowres= s->avctx->lowres;
1598
    const int block_s= 8>>lowres;
1599

    
1600
    mb_x = s->mb_x;
1601
    mb_y = s->mb_y;
1602

    
1603
    switch(s->mv_type) {
1604
    case MV_TYPE_16X16:
1605
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1606
                    0, 0, 0,
1607
                    ref_picture, pix_op,
1608
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1609
        break;
1610
    case MV_TYPE_8X8:
1611
        mx = 0;
1612
        my = 0;
1613
            for(i=0;i<4;i++) {
1614
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1615
                            ref_picture[0], 0, 0,
1616
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1617
                            s->width, s->height, s->linesize,
1618
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1619
                            block_s, block_s, pix_op,
1620
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1621

    
1622
                mx += s->mv[dir][i][0];
1623
                my += s->mv[dir][i][1];
1624
            }
1625

    
1626
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1627
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1628
        break;
1629
    case MV_TYPE_FIELD:
1630
        if (s->picture_structure == PICT_FRAME) {
1631
            /* top field */
1632
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1633
                        1, 0, s->field_select[dir][0],
1634
                        ref_picture, pix_op,
1635
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1636
            /* bottom field */
1637
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1638
                        1, 1, s->field_select[dir][1],
1639
                        ref_picture, pix_op,
1640
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1641
        } else {
1642
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1643
                ref_picture= s->current_picture_ptr->data;
1644
            }
1645

    
1646
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1647
                        0, 0, s->field_select[dir][0],
1648
                        ref_picture, pix_op,
1649
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1650
        }
1651
        break;
1652
    case MV_TYPE_16X8:
1653
        for(i=0; i<2; i++){
1654
            uint8_t ** ref2picture;
1655

    
1656
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1657
                ref2picture= ref_picture;
1658
            }else{
1659
                ref2picture= s->current_picture_ptr->data;
1660
            }
1661

    
1662
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1663
                        0, 0, s->field_select[dir][i],
1664
                        ref2picture, pix_op,
1665
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1666

    
1667
            dest_y += 2*block_s*s->linesize;
1668
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1669
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1670
        }
1671
        break;
1672
    case MV_TYPE_DMV:
1673
        if(s->picture_structure == PICT_FRAME){
1674
            for(i=0; i<2; i++){
1675
                int j;
1676
                for(j=0; j<2; j++){
1677
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1678
                                1, j, j^i,
1679
                                ref_picture, pix_op,
1680
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1681
                }
1682
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1683
            }
1684
        }else{
1685
            for(i=0; i<2; i++){
1686
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1687
                            0, 0, s->picture_structure != i+1,
1688
                            ref_picture, pix_op,
1689
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1690

    
1691
                // after put we make avg of the same block
1692
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1693

    
1694
                //opposite parity is always in the same frame if this is second field
1695
                if(!s->first_field){
1696
                    ref_picture = s->current_picture_ptr->data;
1697
                }
1698
            }
1699
        }
1700
    break;
1701
    default: assert(0);
1702
    }
1703
}
1704

    
1705
/* put block[] to dest[] */
1706
static inline void put_dct(MpegEncContext *s,
1707
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1708
{
1709
    s->dct_unquantize_intra(s, block, i, qscale);
1710
    s->dsp.idct_put (dest, line_size, block);
1711
}
1712

    
1713
/* add block[] to dest[] */
1714
static inline void add_dct(MpegEncContext *s,
1715
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1716
{
1717
    if (s->block_last_index[i] >= 0) {
1718
        s->dsp.idct_add (dest, line_size, block);
1719
    }
1720
}
1721

    
1722
static inline void add_dequant_dct(MpegEncContext *s,
1723
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1724
{
1725
    if (s->block_last_index[i] >= 0) {
1726
        s->dct_unquantize_inter(s, block, i, qscale);
1727

    
1728
        s->dsp.idct_add (dest, line_size, block);
1729
    }
1730
}
1731

    
1732
/**
1733
 * cleans dc, ac, coded_block for the current non intra MB
1734
 */
1735
void ff_clean_intra_table_entries(MpegEncContext *s)
1736
{
1737
    int wrap = s->b8_stride;
1738
    int xy = s->block_index[0];
1739

    
1740
    s->dc_val[0][xy           ] =
1741
    s->dc_val[0][xy + 1       ] =
1742
    s->dc_val[0][xy     + wrap] =
1743
    s->dc_val[0][xy + 1 + wrap] = 1024;
1744
    /* ac pred */
1745
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1746
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1747
    if (s->msmpeg4_version>=3) {
1748
        s->coded_block[xy           ] =
1749
        s->coded_block[xy + 1       ] =
1750
        s->coded_block[xy     + wrap] =
1751
        s->coded_block[xy + 1 + wrap] = 0;
1752
    }
1753
    /* chroma */
1754
    wrap = s->mb_stride;
1755
    xy = s->mb_x + s->mb_y * wrap;
1756
    s->dc_val[1][xy] =
1757
    s->dc_val[2][xy] = 1024;
1758
    /* ac pred */
1759
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1760
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1761

    
1762
    s->mbintra_table[xy]= 0;
1763
}
1764

    
1765
/* generic function called after a macroblock has been parsed by the
1766
   decoder or after it has been encoded by the encoder.
1767

1768
   Important variables used:
1769
   s->mb_intra : true if intra macroblock
1770
   s->mv_dir   : motion vector direction
1771
   s->mv_type  : motion vector type
1772
   s->mv       : motion vector
1773
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1774
 */
1775
static av_always_inline
1776
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1777
                            int lowres_flag, int is_mpeg12)
1778
{
1779
    int mb_x, mb_y;
1780
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1781
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1782
        ff_xvmc_decode_mb(s);//xvmc uses pblocks
1783
        return;
1784
    }
1785

    
1786
    mb_x = s->mb_x;
1787
    mb_y = s->mb_y;
1788

    
1789
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1790
       /* save DCT coefficients */
1791
       int i,j;
1792
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1793
       for(i=0; i<6; i++)
1794
           for(j=0; j<64; j++)
1795
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1796
    }
1797

    
1798
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1799

    
1800
    /* update DC predictors for P macroblocks */
1801
    if (!s->mb_intra) {
1802
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1803
            if(s->mbintra_table[mb_xy])
1804
                ff_clean_intra_table_entries(s);
1805
        } else {
1806
            s->last_dc[0] =
1807
            s->last_dc[1] =
1808
            s->last_dc[2] = 128 << s->intra_dc_precision;
1809
        }
1810
    }
1811
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1812
        s->mbintra_table[mb_xy]=1;
1813

    
1814
    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
1815
        uint8_t *dest_y, *dest_cb, *dest_cr;
1816
        int dct_linesize, dct_offset;
1817
        op_pixels_func (*op_pix)[4];
1818
        qpel_mc_func (*op_qpix)[16];
1819
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1820
        const int uvlinesize= s->current_picture.linesize[1];
1821
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1822
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1823

    
1824
        /* avoid copy if macroblock skipped in last frame too */
1825
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1826
        if(!s->encoding){
1827
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1828
            const int age= s->current_picture.age;
1829

    
1830
            assert(age);
1831

    
1832
            if (s->mb_skipped) {
1833
                s->mb_skipped= 0;
1834
                assert(s->pict_type!=FF_I_TYPE);
1835

    
1836
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1837
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1838

    
1839
                /* if previous was skipped too, then nothing to do !  */
1840
                if (*mbskip_ptr >= age && s->current_picture.reference){
1841
                    return;
1842
                }
1843
            } else if(!s->current_picture.reference){
1844
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1845
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1846
            } else{
1847
                *mbskip_ptr = 0; /* not skipped */
1848
            }
1849
        }
1850

    
1851
        dct_linesize = linesize << s->interlaced_dct;
1852
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1853

    
1854
        if(readable){
1855
            dest_y=  s->dest[0];
1856
            dest_cb= s->dest[1];
1857
            dest_cr= s->dest[2];
1858
        }else{
1859
            dest_y = s->b_scratchpad;
1860
            dest_cb= s->b_scratchpad+16*linesize;
1861
            dest_cr= s->b_scratchpad+32*linesize;
1862
        }
1863

    
1864
        if (!s->mb_intra) {
1865
            /* motion handling */
1866
            /* decoding or more than one mb_type (MC was already done otherwise) */
1867
            if(!s->encoding){
1868
                if(lowres_flag){
1869
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1870

    
1871
                    if (s->mv_dir & MV_DIR_FORWARD) {
1872
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1873
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1874
                    }
1875
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1876
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1877
                    }
1878
                }else{
1879
                    op_qpix= s->me.qpel_put;
1880
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1881
                        op_pix = s->dsp.put_pixels_tab;
1882
                    }else{
1883
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1884
                    }
1885
                    if (s->mv_dir & MV_DIR_FORWARD) {
1886
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1887
                        op_pix = s->dsp.avg_pixels_tab;
1888
                        op_qpix= s->me.qpel_avg;
1889
                    }
1890
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1891
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1892
                    }
1893
                }
1894
            }
1895

    
1896
            /* skip dequant / idct if we are really late ;) */
1897
            if(s->hurry_up>1) goto skip_idct;
1898
            if(s->avctx->skip_idct){
1899
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1900
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1901
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1902
                    goto skip_idct;
1903
            }
1904

    
1905
            /* add dct residue */
1906
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1907
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1908
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1909
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1910
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1911
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1912

    
1913
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1914
                    if (s->chroma_y_shift){
1915
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1916
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1917
                    }else{
1918
                        dct_linesize >>= 1;
1919
                        dct_offset >>=1;
1920
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1921
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1922
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1923
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1924
                    }
1925
                }
1926
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1927
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1928
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1929
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1930
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1931

    
1932
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1933
                    if(s->chroma_y_shift){//Chroma420
1934
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
1935
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
1936
                    }else{
1937
                        //chroma422
1938
                        dct_linesize = uvlinesize << s->interlaced_dct;
1939
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1940

    
1941
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
1942
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
1943
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1944
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1945
                        if(!s->chroma_x_shift){//Chroma444
1946
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1947
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1948
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1949
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1950
                        }
1951
                    }
1952
                }//fi gray
1953
            }
1954
            else if (CONFIG_WMV2) {
1955
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1956
            }
1957
        } else {
1958
            /* dct only in intra block */
1959
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1960
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1961
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1962
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1963
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1964

    
1965
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1966
                    if(s->chroma_y_shift){
1967
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1968
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1969
                    }else{
1970
                        dct_offset >>=1;
1971
                        dct_linesize >>=1;
1972
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1973
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1974
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1975
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1976
                    }
1977
                }
1978
            }else{
1979
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1980
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1981
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1982
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1983

    
1984
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1985
                    if(s->chroma_y_shift){
1986
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1987
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1988
                    }else{
1989

    
1990
                        dct_linesize = uvlinesize << s->interlaced_dct;
1991
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1992

    
1993
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1994
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1995
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1996
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1997
                        if(!s->chroma_x_shift){//Chroma444
1998
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1999
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2000
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2001
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2002
                        }
2003
                    }
2004
                }//gray
2005
            }
2006
        }
2007
skip_idct:
2008
        if(!readable){
2009
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2010
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2011
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2012
        }
2013
    }
2014
}
2015

    
2016
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2017
#if !CONFIG_SMALL
2018
    if(s->out_format == FMT_MPEG1) {
2019
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2020
        else                 MPV_decode_mb_internal(s, block, 0, 1);
2021
    } else
2022
#endif
2023
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2024
    else                  MPV_decode_mb_internal(s, block, 0, 0);
2025
}
2026

    
2027
/**
2028
 *
2029
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2030
 */
2031
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2032
    if (s->avctx->draw_horiz_band) {
2033
        AVFrame *src;
2034
        int offset[4];
2035

    
2036
        if(s->picture_structure != PICT_FRAME){
2037
            h <<= 1;
2038
            y <<= 1;
2039
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2040
        }
2041

    
2042
        h= FFMIN(h, s->avctx->height - y);
2043

    
2044
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2045
            src= (AVFrame*)s->current_picture_ptr;
2046
        else if(s->last_picture_ptr)
2047
            src= (AVFrame*)s->last_picture_ptr;
2048
        else
2049
            return;
2050

    
2051
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2052
            offset[0]=
2053
            offset[1]=
2054
            offset[2]=
2055
            offset[3]= 0;
2056
        }else{
2057
            offset[0]= y * s->linesize;
2058
            offset[1]=
2059
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2060
            offset[3]= 0;
2061
        }
2062

    
2063
        emms_c();
2064

    
2065
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2066
                                  y, s->picture_structure, h);
2067
    }
2068
}
2069

    
2070
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2071
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2072
    const int uvlinesize= s->current_picture.linesize[1];
2073
    const int mb_size= 4 - s->avctx->lowres;
2074

    
2075
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2076
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2077
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2078
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2079
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2080
    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;
2081
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2082

    
2083
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2084
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2085
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2086

    
2087
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2088
    {
2089
        s->dest[0] += s->mb_y *   linesize << mb_size;
2090
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2091
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2092
    }
2093
}
2094

    
2095
void ff_mpeg_flush(AVCodecContext *avctx){
2096
    int i;
2097
    MpegEncContext *s = avctx->priv_data;
2098

    
2099
    if(s==NULL || s->picture==NULL)
2100
        return;
2101

    
2102
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2103
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2104
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2105
        free_frame_buffer(s, &s->picture[i]);
2106
    }
2107
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2108

    
2109
    s->mb_x= s->mb_y= 0;
2110

    
2111
    s->parse_context.state= -1;
2112
    s->parse_context.frame_start_found= 0;
2113
    s->parse_context.overread= 0;
2114
    s->parse_context.overread_index= 0;
2115
    s->parse_context.index= 0;
2116
    s->parse_context.last_index= 0;
2117
    s->bitstream_buffer_size=0;
2118
    s->pp_time=0;
2119
}
2120

    
2121
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2122
                                   DCTELEM *block, int n, int qscale)
2123
{
2124
    int i, level, nCoeffs;
2125
    const uint16_t *quant_matrix;
2126

    
2127
    nCoeffs= s->block_last_index[n];
2128

    
2129
    if (n < 4)
2130
        block[0] = block[0] * s->y_dc_scale;
2131
    else
2132
        block[0] = block[0] * s->c_dc_scale;
2133
    /* XXX: only mpeg1 */
2134
    quant_matrix = s->intra_matrix;
2135
    for(i=1;i<=nCoeffs;i++) {
2136
        int j= s->intra_scantable.permutated[i];
2137
        level = block[j];
2138
        if (level) {
2139
            if (level < 0) {
2140
                level = -level;
2141
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2142
                level = (level - 1) | 1;
2143
                level = -level;
2144
            } else {
2145
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2146
                level = (level - 1) | 1;
2147
            }
2148
            block[j] = level;
2149
        }
2150
    }
2151
}
2152

    
2153
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2154
                                   DCTELEM *block, int n, int qscale)
2155
{
2156
    int i, level, nCoeffs;
2157
    const uint16_t *quant_matrix;
2158

    
2159
    nCoeffs= s->block_last_index[n];
2160

    
2161
    quant_matrix = s->inter_matrix;
2162
    for(i=0; i<=nCoeffs; i++) {
2163
        int j= s->intra_scantable.permutated[i];
2164
        level = block[j];
2165
        if (level) {
2166
            if (level < 0) {
2167
                level = -level;
2168
                level = (((level << 1) + 1) * qscale *
2169
                         ((int) (quant_matrix[j]))) >> 4;
2170
                level = (level - 1) | 1;
2171
                level = -level;
2172
            } else {
2173
                level = (((level << 1) + 1) * qscale *
2174
                         ((int) (quant_matrix[j]))) >> 4;
2175
                level = (level - 1) | 1;
2176
            }
2177
            block[j] = level;
2178
        }
2179
    }
2180
}
2181

    
2182
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2183
                                   DCTELEM *block, int n, int qscale)
2184
{
2185
    int i, level, nCoeffs;
2186
    const uint16_t *quant_matrix;
2187

    
2188
    if(s->alternate_scan) nCoeffs= 63;
2189
    else nCoeffs= s->block_last_index[n];
2190

    
2191
    if (n < 4)
2192
        block[0] = block[0] * s->y_dc_scale;
2193
    else
2194
        block[0] = block[0] * s->c_dc_scale;
2195
    quant_matrix = s->intra_matrix;
2196
    for(i=1;i<=nCoeffs;i++) {
2197
        int j= s->intra_scantable.permutated[i];
2198
        level = block[j];
2199
        if (level) {
2200
            if (level < 0) {
2201
                level = -level;
2202
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2203
                level = -level;
2204
            } else {
2205
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2206
            }
2207
            block[j] = level;
2208
        }
2209
    }
2210
}
2211

    
2212
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2213
                                   DCTELEM *block, int n, int qscale)
2214
{
2215
    int i, level, nCoeffs;
2216
    const uint16_t *quant_matrix;
2217
    int sum=-1;
2218

    
2219
    if(s->alternate_scan) nCoeffs= 63;
2220
    else nCoeffs= s->block_last_index[n];
2221

    
2222
    if (n < 4)
2223
        block[0] = block[0] * s->y_dc_scale;
2224
    else
2225
        block[0] = block[0] * s->c_dc_scale;
2226
    quant_matrix = s->intra_matrix;
2227
    for(i=1;i<=nCoeffs;i++) {
2228
        int j= s->intra_scantable.permutated[i];
2229
        level = block[j];
2230
        if (level) {
2231
            if (level < 0) {
2232
                level = -level;
2233
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2234
                level = -level;
2235
            } else {
2236
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2237
            }
2238
            block[j] = level;
2239
            sum+=level;
2240
        }
2241
    }
2242
    block[63]^=sum&1;
2243
}
2244

    
2245
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2246
                                   DCTELEM *block, int n, int qscale)
2247
{
2248
    int i, level, nCoeffs;
2249
    const uint16_t *quant_matrix;
2250
    int sum=-1;
2251

    
2252
    if(s->alternate_scan) nCoeffs= 63;
2253
    else nCoeffs= s->block_last_index[n];
2254

    
2255
    quant_matrix = s->inter_matrix;
2256
    for(i=0; i<=nCoeffs; i++) {
2257
        int j= s->intra_scantable.permutated[i];
2258
        level = block[j];
2259
        if (level) {
2260
            if (level < 0) {
2261
                level = -level;
2262
                level = (((level << 1) + 1) * qscale *
2263
                         ((int) (quant_matrix[j]))) >> 4;
2264
                level = -level;
2265
            } else {
2266
                level = (((level << 1) + 1) * qscale *
2267
                         ((int) (quant_matrix[j]))) >> 4;
2268
            }
2269
            block[j] = level;
2270
            sum+=level;
2271
        }
2272
    }
2273
    block[63]^=sum&1;
2274
}
2275

    
2276
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2277
                                  DCTELEM *block, int n, int qscale)
2278
{
2279
    int i, level, qmul, qadd;
2280
    int nCoeffs;
2281

    
2282
    assert(s->block_last_index[n]>=0);
2283

    
2284
    qmul = qscale << 1;
2285

    
2286
    if (!s->h263_aic) {
2287
        if (n < 4)
2288
            block[0] = block[0] * s->y_dc_scale;
2289
        else
2290
            block[0] = block[0] * s->c_dc_scale;
2291
        qadd = (qscale - 1) | 1;
2292
    }else{
2293
        qadd = 0;
2294
    }
2295
    if(s->ac_pred)
2296
        nCoeffs=63;
2297
    else
2298
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2299

    
2300
    for(i=1; i<=nCoeffs; i++) {
2301
        level = block[i];
2302
        if (level) {
2303
            if (level < 0) {
2304
                level = level * qmul - qadd;
2305
            } else {
2306
                level = level * qmul + qadd;
2307
            }
2308
            block[i] = level;
2309
        }
2310
    }
2311
}
2312

    
2313
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2314
                                  DCTELEM *block, int n, int qscale)
2315
{
2316
    int i, level, qmul, qadd;
2317
    int nCoeffs;
2318

    
2319
    assert(s->block_last_index[n]>=0);
2320

    
2321
    qadd = (qscale - 1) | 1;
2322
    qmul = qscale << 1;
2323

    
2324
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2325

    
2326
    for(i=0; i<=nCoeffs; i++) {
2327
        level = block[i];
2328
        if (level) {
2329
            if (level < 0) {
2330
                level = level * qmul - qadd;
2331
            } else {
2332
                level = level * qmul + qadd;
2333
            }
2334
            block[i] = level;
2335
        }
2336
    }
2337
}
2338

    
2339
/**
2340
 * set qscale and update qscale dependent variables.
2341
 */
2342
void ff_set_qscale(MpegEncContext * s, int qscale)
2343
{
2344
    if (qscale < 1)
2345
        qscale = 1;
2346
    else if (qscale > 31)
2347
        qscale = 31;
2348

    
2349
    s->qscale = qscale;
2350
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2351

    
2352
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2353
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2354
}