Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ d52b4abe

History | View | Annotate | Download (89.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_VAAPI_VLD,
85
    PIX_FMT_YUV420P,
86
    PIX_FMT_NONE
87
};
88

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

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

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

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

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

    
116
    return p+4;
117
}
118

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

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

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

    
160
    return 0;
161
}
162

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

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

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

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

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

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

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

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

    
215
    return 0;
216
}
217

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
425
    s->picture_in_gop_number = 0;
426

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

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

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

    
447
    if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
448
        s->mb_height = (s->height + 31) / 32 * 2;
449
    else
450
        s->mb_height = (s->height + 15) / 16;
451

    
452
    if(s->avctx->pix_fmt == PIX_FMT_NONE){
453
        av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
454
        return -1;
455
    }
456

    
457
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
458
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
459
        return -1;
460
    }
461

    
462
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
463
        return -1;
464

    
465
    dsputil_init(&s->dsp, s->avctx);
466
    ff_dct_common_init(s);
467

    
468
    s->flags= s->avctx->flags;
469
    s->flags2= s->avctx->flags2;
470

    
471
    s->mb_width  = (s->width  + 15) / 16;
472
    s->mb_stride = s->mb_width + 1;
473
    s->b8_stride = s->mb_width*2 + 1;
474
    s->b4_stride = s->mb_width*4 + 1;
475
    mb_array_size= s->mb_height * s->mb_stride;
476
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
477

    
478
    /* set chroma shifts */
479
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
480
                                                    &(s->chroma_y_shift) );
481

    
482
    /* set default edge pos, will be overriden in decode_header if needed */
483
    s->h_edge_pos= s->mb_width*16;
484
    s->v_edge_pos= s->mb_height*16;
485

    
486
    s->mb_num = s->mb_width * s->mb_height;
487

    
488
    s->block_wrap[0]=
489
    s->block_wrap[1]=
490
    s->block_wrap[2]=
491
    s->block_wrap[3]= s->b8_stride;
492
    s->block_wrap[4]=
493
    s->block_wrap[5]= s->mb_stride;
494

    
495
    y_size = s->b8_stride * (2 * s->mb_height + 1);
496
    c_size = s->mb_stride * (s->mb_height + 1);
497
    yc_size = y_size + 2 * c_size;
498

    
499
    /* convert fourcc to upper case */
500
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
501
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
502
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
503
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
504

    
505
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
506
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
507
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
508
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
509

    
510
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
511

    
512
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
513
    for(y=0; y<s->mb_height; y++){
514
        for(x=0; x<s->mb_width; x++){
515
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
516
        }
517
    }
518
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
519

    
520
    if (s->encoding) {
521
        /* Allocate MV tables */
522
        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t), fail)
523
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
524
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
525
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
526
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
527
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t), fail)
528
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
529
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
530
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
531
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
532
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
533
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
534

    
535
        if(s->msmpeg4_version){
536
            FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
537
        }
538
        FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
539

    
540
        /* Allocate MB type table */
541
        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type  , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
542

    
543
        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
544

    
545
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix  , 64*32   * sizeof(int), fail)
546
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix  , 64*32   * sizeof(int), fail)
547
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
548
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
549
        FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
550
        FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
551

    
552
        if(s->avctx->noise_reduction){
553
            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
554
        }
555
    }
556
    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, MAX_PICTURE_COUNT * sizeof(Picture), fail)
557
    for(i = 0; i < MAX_PICTURE_COUNT; i++) {
558
        avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
559
    }
560

    
561
    FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
562

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

    
586
        /* cbp values */
587
        FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
588
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
589

    
590
        /* cbp, ac_pred, pred_dir */
591
        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail)
592
        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
593
    }
594

    
595
    if (s->h263_pred || s->h263_plus || !s->encoding) {
596
        /* dc values */
597
        //MN: we need these for error resilience of intra-frames
598
        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
599
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
600
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
601
        s->dc_val[2] = s->dc_val[1] + c_size;
602
        for(i=0;i<yc_size;i++)
603
            s->dc_val_base[i] = 1024;
604
    }
605

    
606
    /* which mb is a intra block */
607
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
608
    memset(s->mbintra_table, 1, mb_array_size);
609

    
610
    /* init macroblock skip table */
611
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
612
    //Note the +1 is for a quicker mpeg4 slice_end detection
613
    FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
614

    
615
    s->parse_context.state= -1;
616
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
617
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
618
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
619
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
620
    }
621

    
622
    s->context_initialized = 1;
623

    
624
    s->thread_context[0]= s;
625
    threads = s->avctx->thread_count;
626

    
627
    for(i=1; i<threads; i++){
628
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
629
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
630
    }
631

    
632
    for(i=0; i<threads; i++){
633
        if(init_duplicate_context(s->thread_context[i], s) < 0)
634
           goto fail;
635
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
636
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
637
    }
638

    
639
    return 0;
640
 fail:
641
    MPV_common_end(s);
642
    return -1;
643
}
644

    
645
/* init common structure for both encoder and decoder */
646
void MPV_common_end(MpegEncContext *s)
647
{
648
    int i, j, k;
649

    
650
    for(i=0; i<s->avctx->thread_count; i++){
651
        free_duplicate_context(s->thread_context[i]);
652
    }
653
    for(i=1; i<s->avctx->thread_count; i++){
654
        av_freep(&s->thread_context[i]);
655
    }
656

    
657
    av_freep(&s->parse_context.buffer);
658
    s->parse_context.buffer_size=0;
659

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

    
686
    av_freep(&s->dc_val_base);
687
    av_freep(&s->ac_val_base);
688
    av_freep(&s->coded_block_base);
689
    av_freep(&s->mbintra_table);
690
    av_freep(&s->cbp_table);
691
    av_freep(&s->pred_dir_table);
692

    
693
    av_freep(&s->mbskip_table);
694
    av_freep(&s->prev_pict_types);
695
    av_freep(&s->bitstream_buffer);
696
    s->allocated_bitstream_buffer_size=0;
697

    
698
    av_freep(&s->avctx->stats_out);
699
    av_freep(&s->ac_stats);
700
    av_freep(&s->error_status_table);
701
    av_freep(&s->mb_index2xy);
702
    av_freep(&s->lambda_table);
703
    av_freep(&s->q_intra_matrix);
704
    av_freep(&s->q_inter_matrix);
705
    av_freep(&s->q_intra_matrix16);
706
    av_freep(&s->q_inter_matrix16);
707
    av_freep(&s->input_picture);
708
    av_freep(&s->reordered_input_picture);
709
    av_freep(&s->dct_offset);
710

    
711
    if(s->picture){
712
        for(i=0; i<MAX_PICTURE_COUNT; i++){
713
            free_picture(s, &s->picture[i]);
714
        }
715
    }
716
    av_freep(&s->picture);
717
    s->context_initialized = 0;
718
    s->last_picture_ptr=
719
    s->next_picture_ptr=
720
    s->current_picture_ptr= NULL;
721
    s->linesize= s->uvlinesize= 0;
722

    
723
    for(i=0; i<3; i++)
724
        av_freep(&s->visualization_buffer[i]);
725

    
726
    avcodec_default_free_buffers(s->avctx);
727
}
728

    
729
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
730
{
731
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
732
    uint8_t index_run[MAX_RUN+1];
733
    int last, run, level, start, end, i;
734

    
735
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
736
    if(static_store && rl->max_level[0])
737
        return;
738

    
739
    /* compute max_level[], max_run[] and index_run[] */
740
    for(last=0;last<2;last++) {
741
        if (last == 0) {
742
            start = 0;
743
            end = rl->last;
744
        } else {
745
            start = rl->last;
746
            end = rl->n;
747
        }
748

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

    
780
void init_vlc_rl(RLTable *rl)
781
{
782
    int i, q;
783

    
784
    for(q=0; q<32; q++){
785
        int qmul= q*2;
786
        int qadd= (q-1)|1;
787

    
788
        if(q==0){
789
            qmul=1;
790
            qadd=0;
791
        }
792
        for(i=0; i<rl->vlc.table_size; i++){
793
            int code= rl->vlc.table[i][0];
794
            int len = rl->vlc.table[i][1];
795
            int level, run;
796

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

    
820
int ff_find_unused_picture(MpegEncContext *s, int shared){
821
    int i;
822

    
823
    if(shared){
824
        for(i=0; i<MAX_PICTURE_COUNT; i++){
825
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
826
        }
827
    }else{
828
        for(i=0; i<MAX_PICTURE_COUNT; i++){
829
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
830
        }
831
        for(i=0; i<MAX_PICTURE_COUNT; i++){
832
            if(s->picture[i].data[0]==NULL) return i;
833
        }
834
    }
835

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

    
852
static void update_noise_reduction(MpegEncContext *s){
853
    int intra, i;
854

    
855
    for(intra=0; intra<2; intra++){
856
        if(s->dct_count[intra] > (1<<16)){
857
            for(i=0; i<64; i++){
858
                s->dct_error_sum[intra][i] >>=1;
859
            }
860
            s->dct_count[intra] >>= 1;
861
        }
862

    
863
        for(i=0; i<64; i++){
864
            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);
865
        }
866
    }
867
}
868

    
869
/**
870
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
871
 */
872
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
873
{
874
    int i;
875
    Picture *pic;
876
    s->mb_skipped = 0;
877

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

    
880
    /* mark&release old frames */
881
    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]) {
882
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
883
          free_frame_buffer(s, s->last_picture_ptr);
884

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

    
898
    if(!s->encoding){
899
        /* release non reference frames */
900
        for(i=0; i<MAX_PICTURE_COUNT; i++){
901
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
902
                free_frame_buffer(s, &s->picture[i]);
903
            }
904
        }
905

    
906
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
907
            pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
908
        else{
909
            i= ff_find_unused_picture(s, 0);
910
            pic= &s->picture[i];
911
        }
912

    
913
        pic->reference= 0;
914
        if (!s->dropable){
915
            if (s->codec_id == CODEC_ID_H264)
916
                pic->reference = s->picture_structure;
917
            else if (s->pict_type != FF_B_TYPE)
918
                pic->reference = 3;
919
        }
920

    
921
        pic->coded_picture_number= s->coded_picture_number++;
922

    
923
        if(ff_alloc_picture(s, pic, 0) < 0)
924
            return -1;
925

    
926
        s->current_picture_ptr= pic;
927
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
928
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
929
    }
930

    
931
    s->current_picture_ptr->pict_type= s->pict_type;
932
//    if(s->flags && CODEC_FLAG_QSCALE)
933
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
934
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
935

    
936
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
937

    
938
    if (s->pict_type != FF_B_TYPE) {
939
        s->last_picture_ptr= s->next_picture_ptr;
940
        if(!s->dropable)
941
            s->next_picture_ptr= s->current_picture_ptr;
942
    }
943
/*    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,
944
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
945
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
946
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
947
        s->pict_type, s->dropable);*/
948

    
949
    if(s->codec_id != CODEC_ID_H264){
950
        if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && s->pict_type!=FF_I_TYPE){
951
            av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
952
            /* Allocate a dummy frame */
953
            i= ff_find_unused_picture(s, 0);
954
            s->last_picture_ptr= &s->picture[i];
955
            if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
956
                return -1;
957
        }
958
        if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
959
            /* Allocate a dummy frame */
960
            i= ff_find_unused_picture(s, 0);
961
            s->next_picture_ptr= &s->picture[i];
962
            if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
963
                return -1;
964
        }
965
    }
966

    
967
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
968
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
969

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

    
972
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
973
        int i;
974
        for(i=0; i<4; i++){
975
            if(s->picture_structure == PICT_BOTTOM_FIELD){
976
                 s->current_picture.data[i] += s->current_picture.linesize[i];
977
            }
978
            s->current_picture.linesize[i] *= 2;
979
            s->last_picture.linesize[i] *=2;
980
            s->next_picture.linesize[i] *=2;
981
        }
982
    }
983

    
984
    s->hurry_up= s->avctx->hurry_up;
985
    s->error_recognition= avctx->error_recognition;
986

    
987
    /* set dequantizer, we can't do it during init as it might change for mpeg4
988
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
989
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
990
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
991
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
992
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
993
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
994
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
995
    }else{
996
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
997
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
998
    }
999

    
1000
    if(s->dct_error_sum){
1001
        assert(s->avctx->noise_reduction && s->encoding);
1002

    
1003
        update_noise_reduction(s);
1004
    }
1005

    
1006
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1007
        return ff_xvmc_field_start(s, avctx);
1008

    
1009
    return 0;
1010
}
1011

    
1012
/* generic function for encode/decode called after a frame has been coded/decoded */
1013
void MPV_frame_end(MpegEncContext *s)
1014
{
1015
    int i;
1016
    /* draw edge for correct motion prediction if outside */
1017
    //just to make sure that all data is rendered.
1018
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1019
        ff_xvmc_field_end(s);
1020
    }else if(!s->avctx->hwaccel
1021
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1022
       && s->unrestricted_mv
1023
       && s->current_picture.reference
1024
       && !s->intra_only
1025
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1026
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1027
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1028
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1029
    }
1030
    emms_c();
1031

    
1032
    s->last_pict_type    = s->pict_type;
1033
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1034
    if(s->pict_type!=FF_B_TYPE){
1035
        s->last_non_b_pict_type= s->pict_type;
1036
    }
1037
#if 0
1038
        /* copy back current_picture variables */
1039
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1040
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1041
            s->picture[i]= s->current_picture;
1042
            break;
1043
        }
1044
    }
1045
    assert(i<MAX_PICTURE_COUNT);
1046
#endif
1047

    
1048
    if(s->encoding){
1049
        /* release non-reference frames */
1050
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1051
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1052
                free_frame_buffer(s, &s->picture[i]);
1053
            }
1054
        }
1055
    }
1056
    // clear copies, to avoid confusion
1057
#if 0
1058
    memset(&s->last_picture, 0, sizeof(Picture));
1059
    memset(&s->next_picture, 0, sizeof(Picture));
1060
    memset(&s->current_picture, 0, sizeof(Picture));
1061
#endif
1062
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1063
}
1064

    
1065
/**
1066
 * draws an line from (ex, ey) -> (sx, sy).
1067
 * @param w width of the image
1068
 * @param h height of the image
1069
 * @param stride stride/linesize of the image
1070
 * @param color color of the arrow
1071
 */
1072
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1073
    int x, y, fr, f;
1074

    
1075
    sx= av_clip(sx, 0, w-1);
1076
    sy= av_clip(sy, 0, h-1);
1077
    ex= av_clip(ex, 0, w-1);
1078
    ey= av_clip(ey, 0, h-1);
1079

    
1080
    buf[sy*stride + sx]+= color;
1081

    
1082
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1083
        if(sx > ex){
1084
            FFSWAP(int, sx, ex);
1085
            FFSWAP(int, sy, ey);
1086
        }
1087
        buf+= sx + sy*stride;
1088
        ex-= sx;
1089
        f= ((ey-sy)<<16)/ex;
1090
        for(x= 0; x <= ex; x++){
1091
            y = (x*f)>>16;
1092
            fr= (x*f)&0xFFFF;
1093
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1094
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1095
        }
1096
    }else{
1097
        if(sy > ey){
1098
            FFSWAP(int, sx, ex);
1099
            FFSWAP(int, sy, ey);
1100
        }
1101
        buf+= sx + sy*stride;
1102
        ey-= sy;
1103
        if(ey) f= ((ex-sx)<<16)/ey;
1104
        else   f= 0;
1105
        for(y= 0; y <= ey; y++){
1106
            x = (y*f)>>16;
1107
            fr= (y*f)&0xFFFF;
1108
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1109
            buf[y*stride + x+1]+= (color*         fr )>>16;
1110
        }
1111
    }
1112
}
1113

    
1114
/**
1115
 * draws an arrow from (ex, ey) -> (sx, sy).
1116
 * @param w width of the image
1117
 * @param h height of the image
1118
 * @param stride stride/linesize of the image
1119
 * @param color color of the arrow
1120
 */
1121
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1122
    int dx,dy;
1123

    
1124
    sx= av_clip(sx, -100, w+100);
1125
    sy= av_clip(sy, -100, h+100);
1126
    ex= av_clip(ex, -100, w+100);
1127
    ey= av_clip(ey, -100, h+100);
1128

    
1129
    dx= ex - sx;
1130
    dy= ey - sy;
1131

    
1132
    if(dx*dx + dy*dy > 3*3){
1133
        int rx=  dx + dy;
1134
        int ry= -dx + dy;
1135
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1136

    
1137
        //FIXME subpixel accuracy
1138
        rx= ROUNDED_DIV(rx*3<<4, length);
1139
        ry= ROUNDED_DIV(ry*3<<4, length);
1140

    
1141
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1142
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1143
    }
1144
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1145
}
1146

    
1147
/**
1148
 * prints debuging info for the given picture.
1149
 */
1150
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1151

    
1152
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1153

    
1154
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1155
        int x,y;
1156

    
1157
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1158
        switch (pict->pict_type) {
1159
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1160
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1161
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1162
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1163
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1164
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1165
        }
1166
        for(y=0; y<s->mb_height; y++){
1167
            for(x=0; x<s->mb_width; x++){
1168
                if(s->avctx->debug&FF_DEBUG_SKIP){
1169
                    int count= s->mbskip_table[x + y*s->mb_stride];
1170
                    if(count>9) count=9;
1171
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1172
                }
1173
                if(s->avctx->debug&FF_DEBUG_QP){
1174
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1175
                }
1176
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1177
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1178
                    //Type & MV direction
1179
                    if(IS_PCM(mb_type))
1180
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1181
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1182
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1183
                    else if(IS_INTRA4x4(mb_type))
1184
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1185
                    else if(IS_INTRA16x16(mb_type))
1186
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1187
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1188
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1189
                    else if(IS_DIRECT(mb_type))
1190
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1191
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1192
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1193
                    else if(IS_GMC(mb_type))
1194
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1195
                    else if(IS_SKIP(mb_type))
1196
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1197
                    else if(!USES_LIST(mb_type, 1))
1198
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1199
                    else if(!USES_LIST(mb_type, 0))
1200
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1201
                    else{
1202
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1203
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1204
                    }
1205

    
1206
                    //segmentation
1207
                    if(IS_8X8(mb_type))
1208
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1209
                    else if(IS_16X8(mb_type))
1210
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1211
                    else if(IS_8X16(mb_type))
1212
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1213
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1214
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1215
                    else
1216
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1217

    
1218

    
1219
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1220
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1221
                    else
1222
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1223
                }
1224
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1225
            }
1226
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1227
        }
1228
    }
1229

    
1230
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1231
        const int shift= 1 + s->quarter_sample;
1232
        int mb_y;
1233
        uint8_t *ptr;
1234
        int i;
1235
        int h_chroma_shift, v_chroma_shift, block_height;
1236
        const int width = s->avctx->width;
1237
        const int height= s->avctx->height;
1238
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1239
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1240
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1241

    
1242
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1243
        for(i=0; i<3; i++){
1244
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1245
            pict->data[i]= s->visualization_buffer[i];
1246
        }
1247
        pict->type= FF_BUFFER_TYPE_COPY;
1248
        ptr= pict->data[0];
1249
        block_height = 16>>v_chroma_shift;
1250

    
1251
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1252
            int mb_x;
1253
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1254
                const int mb_index= mb_x + mb_y*s->mb_stride;
1255
                if((s->avctx->debug_mv) && pict->motion_val){
1256
                  int type;
1257
                  for(type=0; type<3; type++){
1258
                    int direction = 0;
1259
                    switch (type) {
1260
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1261
                                continue;
1262
                              direction = 0;
1263
                              break;
1264
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1265
                                continue;
1266
                              direction = 0;
1267
                              break;
1268
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1269
                                continue;
1270
                              direction = 1;
1271
                              break;
1272
                    }
1273
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1274
                        continue;
1275

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

    
1295
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1296
                            my*=2;
1297

    
1298
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1299
                      }
1300
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1301
                      int i;
1302
                      for(i=0; i<2; i++){
1303
                        int sx=mb_x*16 + 4 + 8*i;
1304
                        int sy=mb_y*16 + 8;
1305
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1306
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1307
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1308

    
1309
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1310
                            my*=2;
1311

    
1312
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1313
                      }
1314
                    }else{
1315
                      int sx= mb_x*16 + 8;
1316
                      int sy= mb_y*16 + 8;
1317
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1318
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1319
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1320
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1321
                    }
1322
                  }
1323
                }
1324
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1325
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1326
                    int y;
1327
                    for(y=0; y<block_height; y++){
1328
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1329
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1330
                    }
1331
                }
1332
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1333
                    int mb_type= pict->mb_type[mb_index];
1334
                    uint64_t u,v;
1335
                    int y;
1336
#define COLOR(theta, r)\
1337
u= (int)(128 + r*cos(theta*3.141592/180));\
1338
v= (int)(128 + r*sin(theta*3.141592/180));
1339

    
1340

    
1341
                    u=v=128;
1342
                    if(IS_PCM(mb_type)){
1343
                        COLOR(120,48)
1344
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1345
                        COLOR(30,48)
1346
                    }else if(IS_INTRA4x4(mb_type)){
1347
                        COLOR(90,48)
1348
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1349
//                        COLOR(120,48)
1350
                    }else if(IS_DIRECT(mb_type)){
1351
                        COLOR(150,48)
1352
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1353
                        COLOR(170,48)
1354
                    }else if(IS_GMC(mb_type)){
1355
                        COLOR(190,48)
1356
                    }else if(IS_SKIP(mb_type)){
1357
//                        COLOR(180,48)
1358
                    }else if(!USES_LIST(mb_type, 1)){
1359
                        COLOR(240,48)
1360
                    }else if(!USES_LIST(mb_type, 0)){
1361
                        COLOR(0,48)
1362
                    }else{
1363
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1364
                        COLOR(300,48)
1365
                    }
1366

    
1367
                    u*= 0x0101010101010101ULL;
1368
                    v*= 0x0101010101010101ULL;
1369
                    for(y=0; y<block_height; y++){
1370
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1371
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1372
                    }
1373

    
1374
                    //segmentation
1375
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1376
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1377
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1378
                    }
1379
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1380
                        for(y=0; y<16; y++)
1381
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1382
                    }
1383
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1384
                        int dm= 1 << (mv_sample_log2-2);
1385
                        for(i=0; i<4; i++){
1386
                            int sx= mb_x*16 + 8*(i&1);
1387
                            int sy= mb_y*16 + 8*(i>>1);
1388
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1389
                            //FIXME bidir
1390
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1391
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1392
                                for(y=0; y<8; y++)
1393
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1394
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1395
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1396
                        }
1397
                    }
1398

    
1399
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1400
                        // hmm
1401
                    }
1402
                }
1403
                s->mbskip_table[mb_index]=0;
1404
            }
1405
        }
1406
    }
1407
}
1408

    
1409
static inline int hpel_motion_lowres(MpegEncContext *s,
1410
                                  uint8_t *dest, uint8_t *src,
1411
                                  int field_based, int field_select,
1412
                                  int src_x, int src_y,
1413
                                  int width, int height, int stride,
1414
                                  int h_edge_pos, int v_edge_pos,
1415
                                  int w, int h, h264_chroma_mc_func *pix_op,
1416
                                  int motion_x, int motion_y)
1417
{
1418
    const int lowres= s->avctx->lowres;
1419
    const int s_mask= (2<<lowres)-1;
1420
    int emu=0;
1421
    int sx, sy;
1422

    
1423
    if(s->quarter_sample){
1424
        motion_x/=2;
1425
        motion_y/=2;
1426
    }
1427

    
1428
    sx= motion_x & s_mask;
1429
    sy= motion_y & s_mask;
1430
    src_x += motion_x >> (lowres+1);
1431
    src_y += motion_y >> (lowres+1);
1432

    
1433
    src += src_y * stride + src_x;
1434

    
1435
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1436
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1437
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1438
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1439
        src= s->edge_emu_buffer;
1440
        emu=1;
1441
    }
1442

    
1443
    sx <<= 2 - lowres;
1444
    sy <<= 2 - lowres;
1445
    if(field_select)
1446
        src += s->linesize;
1447
    pix_op[lowres](dest, src, stride, h, sx, sy);
1448
    return emu;
1449
}
1450

    
1451
/* apply one mpeg motion vector to the three components */
1452
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1453
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1454
                               int field_based, int bottom_field, int field_select,
1455
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1456
                               int motion_x, int motion_y, int h, int mb_y)
1457
{
1458
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1459
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1460
    const int lowres= s->avctx->lowres;
1461
    const int block_s= 8>>lowres;
1462
    const int s_mask= (2<<lowres)-1;
1463
    const int h_edge_pos = s->h_edge_pos >> lowres;
1464
    const int v_edge_pos = s->v_edge_pos >> lowres;
1465
    linesize   = s->current_picture.linesize[0] << field_based;
1466
    uvlinesize = s->current_picture.linesize[1] << field_based;
1467

    
1468
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1469
        motion_x/=2;
1470
        motion_y/=2;
1471
    }
1472

    
1473
    if(field_based){
1474
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1475
    }
1476

    
1477
    sx= motion_x & s_mask;
1478
    sy= motion_y & s_mask;
1479
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1480
    src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1481

    
1482
    if (s->out_format == FMT_H263) {
1483
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1484
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1485
        uvsrc_x = src_x>>1;
1486
        uvsrc_y = src_y>>1;
1487
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1488
        mx = motion_x / 4;
1489
        my = motion_y / 4;
1490
        uvsx = (2*mx) & s_mask;
1491
        uvsy = (2*my) & s_mask;
1492
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1493
        uvsrc_y =    mb_y*block_s               + (my >> lowres);
1494
    } else {
1495
        mx = motion_x / 2;
1496
        my = motion_y / 2;
1497
        uvsx = mx & s_mask;
1498
        uvsy = my & s_mask;
1499
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1500
        uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1501
    }
1502

    
1503
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1504
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1505
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1506

    
1507
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1508
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1509
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1510
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1511
            ptr_y = s->edge_emu_buffer;
1512
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1513
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1514
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1515
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1516
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1517
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1518
                ptr_cb= uvbuf;
1519
                ptr_cr= uvbuf+16;
1520
            }
1521
    }
1522

    
1523
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1524
        dest_y += s->linesize;
1525
        dest_cb+= s->uvlinesize;
1526
        dest_cr+= s->uvlinesize;
1527
    }
1528

    
1529
    if(field_select){
1530
        ptr_y += s->linesize;
1531
        ptr_cb+= s->uvlinesize;
1532
        ptr_cr+= s->uvlinesize;
1533
    }
1534

    
1535
    sx <<= 2 - lowres;
1536
    sy <<= 2 - lowres;
1537
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1538

    
1539
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1540
        uvsx <<= 2 - lowres;
1541
        uvsy <<= 2 - lowres;
1542
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1543
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1544
    }
1545
    //FIXME h261 lowres loop filter
1546
}
1547

    
1548
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1549
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1550
                                     uint8_t **ref_picture,
1551
                                     h264_chroma_mc_func *pix_op,
1552
                                     int mx, int my){
1553
    const int lowres= s->avctx->lowres;
1554
    const int block_s= 8>>lowres;
1555
    const int s_mask= (2<<lowres)-1;
1556
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1557
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1558
    int emu=0, src_x, src_y, offset, sx, sy;
1559
    uint8_t *ptr;
1560

    
1561
    if(s->quarter_sample){
1562
        mx/=2;
1563
        my/=2;
1564
    }
1565

    
1566
    /* In case of 8X8, we construct a single chroma motion vector
1567
       with a special rounding */
1568
    mx= ff_h263_round_chroma(mx);
1569
    my= ff_h263_round_chroma(my);
1570

    
1571
    sx= mx & s_mask;
1572
    sy= my & s_mask;
1573
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1574
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1575

    
1576
    offset = src_y * s->uvlinesize + src_x;
1577
    ptr = ref_picture[1] + offset;
1578
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1579
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1580
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1581
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1582
            ptr= s->edge_emu_buffer;
1583
            emu=1;
1584
        }
1585
    }
1586
    sx <<= 2 - lowres;
1587
    sy <<= 2 - lowres;
1588
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1589

    
1590
    ptr = ref_picture[2] + offset;
1591
    if(emu){
1592
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1593
        ptr= s->edge_emu_buffer;
1594
    }
1595
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1596
}
1597

    
1598
/**
1599
 * motion compensation of a single macroblock
1600
 * @param s context
1601
 * @param dest_y luma destination pointer
1602
 * @param dest_cb chroma cb/u destination pointer
1603
 * @param dest_cr chroma cr/v destination pointer
1604
 * @param dir direction (0->forward, 1->backward)
1605
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1606
 * @param pic_op halfpel motion compensation function (average or put normally)
1607
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1608
 */
1609
static inline void MPV_motion_lowres(MpegEncContext *s,
1610
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1611
                              int dir, uint8_t **ref_picture,
1612
                              h264_chroma_mc_func *pix_op)
1613
{
1614
    int mx, my;
1615
    int mb_x, mb_y, i;
1616
    const int lowres= s->avctx->lowres;
1617
    const int block_s= 8>>lowres;
1618

    
1619
    mb_x = s->mb_x;
1620
    mb_y = s->mb_y;
1621

    
1622
    switch(s->mv_type) {
1623
    case MV_TYPE_16X16:
1624
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1625
                    0, 0, 0,
1626
                    ref_picture, pix_op,
1627
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1628
        break;
1629
    case MV_TYPE_8X8:
1630
        mx = 0;
1631
        my = 0;
1632
            for(i=0;i<4;i++) {
1633
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1634
                            ref_picture[0], 0, 0,
1635
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1636
                            s->width, s->height, s->linesize,
1637
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1638
                            block_s, block_s, pix_op,
1639
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1640

    
1641
                mx += s->mv[dir][i][0];
1642
                my += s->mv[dir][i][1];
1643
            }
1644

    
1645
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1646
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1647
        break;
1648
    case MV_TYPE_FIELD:
1649
        if (s->picture_structure == PICT_FRAME) {
1650
            /* top field */
1651
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1652
                        1, 0, s->field_select[dir][0],
1653
                        ref_picture, pix_op,
1654
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1655
            /* bottom field */
1656
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1657
                        1, 1, s->field_select[dir][1],
1658
                        ref_picture, pix_op,
1659
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1660
        } else {
1661
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1662
                ref_picture= s->current_picture_ptr->data;
1663
            }
1664

    
1665
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1666
                        0, 0, s->field_select[dir][0],
1667
                        ref_picture, pix_op,
1668
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1669
        }
1670
        break;
1671
    case MV_TYPE_16X8:
1672
        for(i=0; i<2; i++){
1673
            uint8_t ** ref2picture;
1674

    
1675
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1676
                ref2picture= ref_picture;
1677
            }else{
1678
                ref2picture= s->current_picture_ptr->data;
1679
            }
1680

    
1681
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1682
                        0, 0, s->field_select[dir][i],
1683
                        ref2picture, pix_op,
1684
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1685

    
1686
            dest_y += 2*block_s*s->linesize;
1687
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1688
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1689
        }
1690
        break;
1691
    case MV_TYPE_DMV:
1692
        if(s->picture_structure == PICT_FRAME){
1693
            for(i=0; i<2; i++){
1694
                int j;
1695
                for(j=0; j<2; j++){
1696
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1697
                                1, j, j^i,
1698
                                ref_picture, pix_op,
1699
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1700
                }
1701
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1702
            }
1703
        }else{
1704
            for(i=0; i<2; i++){
1705
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1706
                            0, 0, s->picture_structure != i+1,
1707
                            ref_picture, pix_op,
1708
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1709

    
1710
                // after put we make avg of the same block
1711
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1712

    
1713
                //opposite parity is always in the same frame if this is second field
1714
                if(!s->first_field){
1715
                    ref_picture = s->current_picture_ptr->data;
1716
                }
1717
            }
1718
        }
1719
    break;
1720
    default: assert(0);
1721
    }
1722
}
1723

    
1724
/* put block[] to dest[] */
1725
static inline void put_dct(MpegEncContext *s,
1726
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1727
{
1728
    s->dct_unquantize_intra(s, block, i, qscale);
1729
    s->dsp.idct_put (dest, line_size, block);
1730
}
1731

    
1732
/* add block[] to dest[] */
1733
static inline void add_dct(MpegEncContext *s,
1734
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1735
{
1736
    if (s->block_last_index[i] >= 0) {
1737
        s->dsp.idct_add (dest, line_size, block);
1738
    }
1739
}
1740

    
1741
static inline void add_dequant_dct(MpegEncContext *s,
1742
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1743
{
1744
    if (s->block_last_index[i] >= 0) {
1745
        s->dct_unquantize_inter(s, block, i, qscale);
1746

    
1747
        s->dsp.idct_add (dest, line_size, block);
1748
    }
1749
}
1750

    
1751
/**
1752
 * cleans dc, ac, coded_block for the current non intra MB
1753
 */
1754
void ff_clean_intra_table_entries(MpegEncContext *s)
1755
{
1756
    int wrap = s->b8_stride;
1757
    int xy = s->block_index[0];
1758

    
1759
    s->dc_val[0][xy           ] =
1760
    s->dc_val[0][xy + 1       ] =
1761
    s->dc_val[0][xy     + wrap] =
1762
    s->dc_val[0][xy + 1 + wrap] = 1024;
1763
    /* ac pred */
1764
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1765
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1766
    if (s->msmpeg4_version>=3) {
1767
        s->coded_block[xy           ] =
1768
        s->coded_block[xy + 1       ] =
1769
        s->coded_block[xy     + wrap] =
1770
        s->coded_block[xy + 1 + wrap] = 0;
1771
    }
1772
    /* chroma */
1773
    wrap = s->mb_stride;
1774
    xy = s->mb_x + s->mb_y * wrap;
1775
    s->dc_val[1][xy] =
1776
    s->dc_val[2][xy] = 1024;
1777
    /* ac pred */
1778
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1779
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1780

    
1781
    s->mbintra_table[xy]= 0;
1782
}
1783

    
1784
/* generic function called after a macroblock has been parsed by the
1785
   decoder or after it has been encoded by the encoder.
1786

1787
   Important variables used:
1788
   s->mb_intra : true if intra macroblock
1789
   s->mv_dir   : motion vector direction
1790
   s->mv_type  : motion vector type
1791
   s->mv       : motion vector
1792
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1793
 */
1794
static av_always_inline
1795
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1796
                            int lowres_flag, int is_mpeg12)
1797
{
1798
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1799
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1800
        ff_xvmc_decode_mb(s);//xvmc uses pblocks
1801
        return;
1802
    }
1803

    
1804
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1805
       /* save DCT coefficients */
1806
       int i,j;
1807
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1808
       for(i=0; i<6; i++)
1809
           for(j=0; j<64; j++)
1810
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1811
    }
1812

    
1813
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1814

    
1815
    /* update DC predictors for P macroblocks */
1816
    if (!s->mb_intra) {
1817
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1818
            if(s->mbintra_table[mb_xy])
1819
                ff_clean_intra_table_entries(s);
1820
        } else {
1821
            s->last_dc[0] =
1822
            s->last_dc[1] =
1823
            s->last_dc[2] = 128 << s->intra_dc_precision;
1824
        }
1825
    }
1826
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1827
        s->mbintra_table[mb_xy]=1;
1828

    
1829
    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
1830
        uint8_t *dest_y, *dest_cb, *dest_cr;
1831
        int dct_linesize, dct_offset;
1832
        op_pixels_func (*op_pix)[4];
1833
        qpel_mc_func (*op_qpix)[16];
1834
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1835
        const int uvlinesize= s->current_picture.linesize[1];
1836
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1837
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1838

    
1839
        /* avoid copy if macroblock skipped in last frame too */
1840
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1841
        if(!s->encoding){
1842
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1843
            const int age= s->current_picture.age;
1844

    
1845
            assert(age);
1846

    
1847
            if (s->mb_skipped) {
1848
                s->mb_skipped= 0;
1849
                assert(s->pict_type!=FF_I_TYPE);
1850

    
1851
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1852
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1853

    
1854
                /* if previous was skipped too, then nothing to do !  */
1855
                if (*mbskip_ptr >= age && s->current_picture.reference){
1856
                    return;
1857
                }
1858
            } else if(!s->current_picture.reference){
1859
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1860
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1861
            } else{
1862
                *mbskip_ptr = 0; /* not skipped */
1863
            }
1864
        }
1865

    
1866
        dct_linesize = linesize << s->interlaced_dct;
1867
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1868

    
1869
        if(readable){
1870
            dest_y=  s->dest[0];
1871
            dest_cb= s->dest[1];
1872
            dest_cr= s->dest[2];
1873
        }else{
1874
            dest_y = s->b_scratchpad;
1875
            dest_cb= s->b_scratchpad+16*linesize;
1876
            dest_cr= s->b_scratchpad+32*linesize;
1877
        }
1878

    
1879
        if (!s->mb_intra) {
1880
            /* motion handling */
1881
            /* decoding or more than one mb_type (MC was already done otherwise) */
1882
            if(!s->encoding){
1883
                if(lowres_flag){
1884
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1885

    
1886
                    if (s->mv_dir & MV_DIR_FORWARD) {
1887
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1888
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1889
                    }
1890
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1891
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1892
                    }
1893
                }else{
1894
                    op_qpix= s->me.qpel_put;
1895
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1896
                        op_pix = s->dsp.put_pixels_tab;
1897
                    }else{
1898
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1899
                    }
1900
                    if (s->mv_dir & MV_DIR_FORWARD) {
1901
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1902
                        op_pix = s->dsp.avg_pixels_tab;
1903
                        op_qpix= s->me.qpel_avg;
1904
                    }
1905
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1906
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1907
                    }
1908
                }
1909
            }
1910

    
1911
            /* skip dequant / idct if we are really late ;) */
1912
            if(s->hurry_up>1) goto skip_idct;
1913
            if(s->avctx->skip_idct){
1914
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1915
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1916
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1917
                    goto skip_idct;
1918
            }
1919

    
1920
            /* add dct residue */
1921
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1922
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1923
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1924
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1925
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1926
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1927

    
1928
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1929
                    if (s->chroma_y_shift){
1930
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1931
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1932
                    }else{
1933
                        dct_linesize >>= 1;
1934
                        dct_offset >>=1;
1935
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1936
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1937
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1938
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1939
                    }
1940
                }
1941
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1942
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1943
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1944
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1945
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1946

    
1947
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1948
                    if(s->chroma_y_shift){//Chroma420
1949
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
1950
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
1951
                    }else{
1952
                        //chroma422
1953
                        dct_linesize = uvlinesize << s->interlaced_dct;
1954
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1955

    
1956
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
1957
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
1958
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1959
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1960
                        if(!s->chroma_x_shift){//Chroma444
1961
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1962
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1963
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1964
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1965
                        }
1966
                    }
1967
                }//fi gray
1968
            }
1969
            else if (CONFIG_WMV2) {
1970
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1971
            }
1972
        } else {
1973
            /* dct only in intra block */
1974
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1975
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1976
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1977
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1978
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1979

    
1980
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1981
                    if(s->chroma_y_shift){
1982
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1983
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1984
                    }else{
1985
                        dct_offset >>=1;
1986
                        dct_linesize >>=1;
1987
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1988
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1989
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1990
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1991
                    }
1992
                }
1993
            }else{
1994
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1995
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1996
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1997
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1998

    
1999
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2000
                    if(s->chroma_y_shift){
2001
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2002
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2003
                    }else{
2004

    
2005
                        dct_linesize = uvlinesize << s->interlaced_dct;
2006
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2007

    
2008
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2009
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2010
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2011
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2012
                        if(!s->chroma_x_shift){//Chroma444
2013
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2014
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2015
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2016
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2017
                        }
2018
                    }
2019
                }//gray
2020
            }
2021
        }
2022
skip_idct:
2023
        if(!readable){
2024
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2025
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2026
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2027
        }
2028
    }
2029
}
2030

    
2031
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2032
#if !CONFIG_SMALL
2033
    if(s->out_format == FMT_MPEG1) {
2034
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2035
        else                 MPV_decode_mb_internal(s, block, 0, 1);
2036
    } else
2037
#endif
2038
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2039
    else                  MPV_decode_mb_internal(s, block, 0, 0);
2040
}
2041

    
2042
/**
2043
 *
2044
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2045
 */
2046
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2047
    if (s->avctx->draw_horiz_band) {
2048
        AVFrame *src;
2049
        const int field_pic= s->picture_structure != PICT_FRAME;
2050
        int offset[4];
2051

    
2052
        h= FFMIN(h, (s->avctx->height>>field_pic) - y);
2053

    
2054
        if(field_pic && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)){
2055
            h <<= 1;
2056
            y <<= 1;
2057
            if(s->first_field) return;
2058
        }
2059

    
2060
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2061
            src= (AVFrame*)s->current_picture_ptr;
2062
        else if(s->last_picture_ptr)
2063
            src= (AVFrame*)s->last_picture_ptr;
2064
        else
2065
            return;
2066

    
2067
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2068
            offset[0]=
2069
            offset[1]=
2070
            offset[2]=
2071
            offset[3]= 0;
2072
        }else{
2073
            offset[0]= y * s->linesize;
2074
            offset[1]=
2075
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2076
            offset[3]= 0;
2077
        }
2078

    
2079
        emms_c();
2080

    
2081
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2082
                                  y, s->picture_structure, h);
2083
    }
2084
}
2085

    
2086
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2087
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2088
    const int uvlinesize= s->current_picture.linesize[1];
2089
    const int mb_size= 4 - s->avctx->lowres;
2090

    
2091
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2092
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2093
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2094
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2095
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2096
    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;
2097
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2098

    
2099
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2100
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2101
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2102

    
2103
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2104
    {
2105
        if(s->picture_structure==PICT_FRAME){
2106
        s->dest[0] += s->mb_y *   linesize << mb_size;
2107
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2108
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2109
        }else{
2110
            s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2111
            s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2112
            s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2113
            assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2114
        }
2115
    }
2116
}
2117

    
2118
void ff_mpeg_flush(AVCodecContext *avctx){
2119
    int i;
2120
    MpegEncContext *s = avctx->priv_data;
2121

    
2122
    if(s==NULL || s->picture==NULL)
2123
        return;
2124

    
2125
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2126
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2127
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2128
        free_frame_buffer(s, &s->picture[i]);
2129
    }
2130
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2131

    
2132
    s->mb_x= s->mb_y= 0;
2133
    s->closed_gop= 0;
2134

    
2135
    s->parse_context.state= -1;
2136
    s->parse_context.frame_start_found= 0;
2137
    s->parse_context.overread= 0;
2138
    s->parse_context.overread_index= 0;
2139
    s->parse_context.index= 0;
2140
    s->parse_context.last_index= 0;
2141
    s->bitstream_buffer_size=0;
2142
    s->pp_time=0;
2143
}
2144

    
2145
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2146
                                   DCTELEM *block, int n, int qscale)
2147
{
2148
    int i, level, nCoeffs;
2149
    const uint16_t *quant_matrix;
2150

    
2151
    nCoeffs= s->block_last_index[n];
2152

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

    
2177
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2178
                                   DCTELEM *block, int n, int qscale)
2179
{
2180
    int i, level, nCoeffs;
2181
    const uint16_t *quant_matrix;
2182

    
2183
    nCoeffs= s->block_last_index[n];
2184

    
2185
    quant_matrix = s->inter_matrix;
2186
    for(i=0; i<=nCoeffs; i++) {
2187
        int j= s->intra_scantable.permutated[i];
2188
        level = block[j];
2189
        if (level) {
2190
            if (level < 0) {
2191
                level = -level;
2192
                level = (((level << 1) + 1) * qscale *
2193
                         ((int) (quant_matrix[j]))) >> 4;
2194
                level = (level - 1) | 1;
2195
                level = -level;
2196
            } else {
2197
                level = (((level << 1) + 1) * qscale *
2198
                         ((int) (quant_matrix[j]))) >> 4;
2199
                level = (level - 1) | 1;
2200
            }
2201
            block[j] = level;
2202
        }
2203
    }
2204
}
2205

    
2206
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2207
                                   DCTELEM *block, int n, int qscale)
2208
{
2209
    int i, level, nCoeffs;
2210
    const uint16_t *quant_matrix;
2211

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

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

    
2236
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2237
                                   DCTELEM *block, int n, int qscale)
2238
{
2239
    int i, level, nCoeffs;
2240
    const uint16_t *quant_matrix;
2241
    int sum=-1;
2242

    
2243
    if(s->alternate_scan) nCoeffs= 63;
2244
    else nCoeffs= s->block_last_index[n];
2245

    
2246
    if (n < 4)
2247
        block[0] = block[0] * s->y_dc_scale;
2248
    else
2249
        block[0] = block[0] * s->c_dc_scale;
2250
    quant_matrix = s->intra_matrix;
2251
    for(i=1;i<=nCoeffs;i++) {
2252
        int j= s->intra_scantable.permutated[i];
2253
        level = block[j];
2254
        if (level) {
2255
            if (level < 0) {
2256
                level = -level;
2257
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2258
                level = -level;
2259
            } else {
2260
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2261
            }
2262
            block[j] = level;
2263
            sum+=level;
2264
        }
2265
    }
2266
    block[63]^=sum&1;
2267
}
2268

    
2269
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2270
                                   DCTELEM *block, int n, int qscale)
2271
{
2272
    int i, level, nCoeffs;
2273
    const uint16_t *quant_matrix;
2274
    int sum=-1;
2275

    
2276
    if(s->alternate_scan) nCoeffs= 63;
2277
    else nCoeffs= s->block_last_index[n];
2278

    
2279
    quant_matrix = s->inter_matrix;
2280
    for(i=0; i<=nCoeffs; i++) {
2281
        int j= s->intra_scantable.permutated[i];
2282
        level = block[j];
2283
        if (level) {
2284
            if (level < 0) {
2285
                level = -level;
2286
                level = (((level << 1) + 1) * qscale *
2287
                         ((int) (quant_matrix[j]))) >> 4;
2288
                level = -level;
2289
            } else {
2290
                level = (((level << 1) + 1) * qscale *
2291
                         ((int) (quant_matrix[j]))) >> 4;
2292
            }
2293
            block[j] = level;
2294
            sum+=level;
2295
        }
2296
    }
2297
    block[63]^=sum&1;
2298
}
2299

    
2300
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2301
                                  DCTELEM *block, int n, int qscale)
2302
{
2303
    int i, level, qmul, qadd;
2304
    int nCoeffs;
2305

    
2306
    assert(s->block_last_index[n]>=0);
2307

    
2308
    qmul = qscale << 1;
2309

    
2310
    if (!s->h263_aic) {
2311
        if (n < 4)
2312
            block[0] = block[0] * s->y_dc_scale;
2313
        else
2314
            block[0] = block[0] * s->c_dc_scale;
2315
        qadd = (qscale - 1) | 1;
2316
    }else{
2317
        qadd = 0;
2318
    }
2319
    if(s->ac_pred)
2320
        nCoeffs=63;
2321
    else
2322
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2323

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

    
2337
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2338
                                  DCTELEM *block, int n, int qscale)
2339
{
2340
    int i, level, qmul, qadd;
2341
    int nCoeffs;
2342

    
2343
    assert(s->block_last_index[n]>=0);
2344

    
2345
    qadd = (qscale - 1) | 1;
2346
    qmul = qscale << 1;
2347

    
2348
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2349

    
2350
    for(i=0; i<=nCoeffs; i++) {
2351
        level = block[i];
2352
        if (level) {
2353
            if (level < 0) {
2354
                level = level * qmul - qadd;
2355
            } else {
2356
                level = level * qmul + qadd;
2357
            }
2358
            block[i] = level;
2359
        }
2360
    }
2361
}
2362

    
2363
/**
2364
 * set qscale and update qscale dependent variables.
2365
 */
2366
void ff_set_qscale(MpegEncContext * s, int qscale)
2367
{
2368
    if (qscale < 1)
2369
        qscale = 1;
2370
    else if (qscale > 31)
2371
        qscale = 31;
2372

    
2373
    s->qscale = qscale;
2374
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2375

    
2376
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2377
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2378
}