Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ d31dbec3

History | View | Annotate | Download (89 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
alloc:
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->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
950
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
951

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

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

    
960
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
961
        int i;
962
        for(i=0; i<4; i++){
963
            if(s->picture_structure == PICT_BOTTOM_FIELD){
964
                 s->current_picture.data[i] += s->current_picture.linesize[i];
965
            }
966
            s->current_picture.linesize[i] *= 2;
967
            s->last_picture.linesize[i] *=2;
968
            s->next_picture.linesize[i] *=2;
969
        }
970
    }
971

    
972
    s->hurry_up= s->avctx->hurry_up;
973
    s->error_recognition= avctx->error_recognition;
974

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

    
988
    if(s->dct_error_sum){
989
        assert(s->avctx->noise_reduction && s->encoding);
990

    
991
        update_noise_reduction(s);
992
    }
993

    
994
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
995
        return ff_xvmc_field_start(s, avctx);
996

    
997
    return 0;
998
}
999

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

    
1020
    s->last_pict_type    = s->pict_type;
1021
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1022
    if(s->pict_type!=FF_B_TYPE){
1023
        s->last_non_b_pict_type= s->pict_type;
1024
    }
1025
#if 0
1026
        /* copy back current_picture variables */
1027
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1028
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1029
            s->picture[i]= s->current_picture;
1030
            break;
1031
        }
1032
    }
1033
    assert(i<MAX_PICTURE_COUNT);
1034
#endif
1035

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

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

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

    
1068
    buf[sy*stride + sx]+= color;
1069

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

    
1102
/**
1103
 * draws an arrow from (ex, ey) -> (sx, sy).
1104
 * @param w width of the image
1105
 * @param h height of the image
1106
 * @param stride stride/linesize of the image
1107
 * @param color color of the arrow
1108
 */
1109
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1110
    int dx,dy;
1111

    
1112
    sx= av_clip(sx, -100, w+100);
1113
    sy= av_clip(sy, -100, h+100);
1114
    ex= av_clip(ex, -100, w+100);
1115
    ey= av_clip(ey, -100, h+100);
1116

    
1117
    dx= ex - sx;
1118
    dy= ey - sy;
1119

    
1120
    if(dx*dx + dy*dy > 3*3){
1121
        int rx=  dx + dy;
1122
        int ry= -dx + dy;
1123
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1124

    
1125
        //FIXME subpixel accuracy
1126
        rx= ROUNDED_DIV(rx*3<<4, length);
1127
        ry= ROUNDED_DIV(ry*3<<4, length);
1128

    
1129
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1130
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1131
    }
1132
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1133
}
1134

    
1135
/**
1136
 * prints debuging info for the given picture.
1137
 */
1138
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1139

    
1140
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1141

    
1142
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1143
        int x,y;
1144

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

    
1194
                    //segmentation
1195
                    if(IS_8X8(mb_type))
1196
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1197
                    else if(IS_16X8(mb_type))
1198
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1199
                    else if(IS_8X16(mb_type))
1200
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1201
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1202
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1203
                    else
1204
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1205

    
1206

    
1207
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1208
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1209
                    else
1210
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1211
                }
1212
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1213
            }
1214
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1215
        }
1216
    }
1217

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

    
1230
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1231
        for(i=0; i<3; i++){
1232
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1233
            pict->data[i]= s->visualization_buffer[i];
1234
        }
1235
        pict->type= FF_BUFFER_TYPE_COPY;
1236
        ptr= pict->data[0];
1237
        block_height = 16>>v_chroma_shift;
1238

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

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

    
1283
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1284
                            my*=2;
1285

    
1286
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1287
                      }
1288
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1289
                      int i;
1290
                      for(i=0; i<2; i++){
1291
                        int sx=mb_x*16 + 4 + 8*i;
1292
                        int sy=mb_y*16 + 8;
1293
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1294
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1295
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1296

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

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

    
1328

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

    
1355
                    u*= 0x0101010101010101ULL;
1356
                    v*= 0x0101010101010101ULL;
1357
                    for(y=0; y<block_height; y++){
1358
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1359
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1360
                    }
1361

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

    
1387
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1388
                        // hmm
1389
                    }
1390
                }
1391
                s->mbskip_table[mb_index]=0;
1392
            }
1393
        }
1394
    }
1395
}
1396

    
1397
static inline int hpel_motion_lowres(MpegEncContext *s,
1398
                                  uint8_t *dest, uint8_t *src,
1399
                                  int field_based, int field_select,
1400
                                  int src_x, int src_y,
1401
                                  int width, int height, int stride,
1402
                                  int h_edge_pos, int v_edge_pos,
1403
                                  int w, int h, h264_chroma_mc_func *pix_op,
1404
                                  int motion_x, int motion_y)
1405
{
1406
    const int lowres= s->avctx->lowres;
1407
    const int s_mask= (2<<lowres)-1;
1408
    int emu=0;
1409
    int sx, sy;
1410

    
1411
    if(s->quarter_sample){
1412
        motion_x/=2;
1413
        motion_y/=2;
1414
    }
1415

    
1416
    sx= motion_x & s_mask;
1417
    sy= motion_y & s_mask;
1418
    src_x += motion_x >> (lowres+1);
1419
    src_y += motion_y >> (lowres+1);
1420

    
1421
    src += src_y * stride + src_x;
1422

    
1423
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1424
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1425
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1426
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1427
        src= s->edge_emu_buffer;
1428
        emu=1;
1429
    }
1430

    
1431
    sx <<= 2 - lowres;
1432
    sy <<= 2 - lowres;
1433
    if(field_select)
1434
        src += s->linesize;
1435
    pix_op[lowres](dest, src, stride, h, sx, sy);
1436
    return emu;
1437
}
1438

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

    
1456
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1457
        motion_x/=2;
1458
        motion_y/=2;
1459
    }
1460

    
1461
    if(field_based){
1462
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1463
    }
1464

    
1465
    sx= motion_x & s_mask;
1466
    sy= motion_y & s_mask;
1467
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1468
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1469

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

    
1491
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1492
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1493
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1494

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

    
1511
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1512
        dest_y += s->linesize;
1513
        dest_cb+= s->uvlinesize;
1514
        dest_cr+= s->uvlinesize;
1515
    }
1516

    
1517
    if(field_select){
1518
        ptr_y += s->linesize;
1519
        ptr_cb+= s->uvlinesize;
1520
        ptr_cr+= s->uvlinesize;
1521
    }
1522

    
1523
    sx <<= 2 - lowres;
1524
    sy <<= 2 - lowres;
1525
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1526

    
1527
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1528
        uvsx <<= 2 - lowres;
1529
        uvsy <<= 2 - lowres;
1530
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1531
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1532
    }
1533
    //FIXME h261 lowres loop filter
1534
}
1535

    
1536
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1537
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1538
                                     uint8_t **ref_picture,
1539
                                     h264_chroma_mc_func *pix_op,
1540
                                     int mx, int my){
1541
    const int lowres= s->avctx->lowres;
1542
    const int block_s= 8>>lowres;
1543
    const int s_mask= (2<<lowres)-1;
1544
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1545
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1546
    int emu=0, src_x, src_y, offset, sx, sy;
1547
    uint8_t *ptr;
1548

    
1549
    if(s->quarter_sample){
1550
        mx/=2;
1551
        my/=2;
1552
    }
1553

    
1554
    /* In case of 8X8, we construct a single chroma motion vector
1555
       with a special rounding */
1556
    mx= ff_h263_round_chroma(mx);
1557
    my= ff_h263_round_chroma(my);
1558

    
1559
    sx= mx & s_mask;
1560
    sy= my & s_mask;
1561
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1562
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1563

    
1564
    offset = src_y * s->uvlinesize + src_x;
1565
    ptr = ref_picture[1] + offset;
1566
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1567
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1568
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1569
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1570
            ptr= s->edge_emu_buffer;
1571
            emu=1;
1572
        }
1573
    }
1574
    sx <<= 2 - lowres;
1575
    sy <<= 2 - lowres;
1576
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1577

    
1578
    ptr = ref_picture[2] + offset;
1579
    if(emu){
1580
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1581
        ptr= s->edge_emu_buffer;
1582
    }
1583
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1584
}
1585

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

    
1607
    mb_x = s->mb_x;
1608
    mb_y = s->mb_y;
1609

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

    
1629
                mx += s->mv[dir][i][0];
1630
                my += s->mv[dir][i][1];
1631
            }
1632

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

    
1653
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1654
                        0, 0, s->field_select[dir][0],
1655
                        ref_picture, pix_op,
1656
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1657
        }
1658
        break;
1659
    case MV_TYPE_16X8:
1660
        for(i=0; i<2; i++){
1661
            uint8_t ** ref2picture;
1662

    
1663
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1664
                ref2picture= ref_picture;
1665
            }else{
1666
                ref2picture= s->current_picture_ptr->data;
1667
            }
1668

    
1669
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1670
                        0, 0, s->field_select[dir][i],
1671
                        ref2picture, pix_op,
1672
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1673

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

    
1698
                // after put we make avg of the same block
1699
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1700

    
1701
                //opposite parity is always in the same frame if this is second field
1702
                if(!s->first_field){
1703
                    ref_picture = s->current_picture_ptr->data;
1704
                }
1705
            }
1706
        }
1707
    break;
1708
    default: assert(0);
1709
    }
1710
}
1711

    
1712
/* put block[] to dest[] */
1713
static inline void put_dct(MpegEncContext *s,
1714
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1715
{
1716
    s->dct_unquantize_intra(s, block, i, qscale);
1717
    s->dsp.idct_put (dest, line_size, block);
1718
}
1719

    
1720
/* add block[] to dest[] */
1721
static inline void add_dct(MpegEncContext *s,
1722
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1723
{
1724
    if (s->block_last_index[i] >= 0) {
1725
        s->dsp.idct_add (dest, line_size, block);
1726
    }
1727
}
1728

    
1729
static inline void add_dequant_dct(MpegEncContext *s,
1730
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1731
{
1732
    if (s->block_last_index[i] >= 0) {
1733
        s->dct_unquantize_inter(s, block, i, qscale);
1734

    
1735
        s->dsp.idct_add (dest, line_size, block);
1736
    }
1737
}
1738

    
1739
/**
1740
 * cleans dc, ac, coded_block for the current non intra MB
1741
 */
1742
void ff_clean_intra_table_entries(MpegEncContext *s)
1743
{
1744
    int wrap = s->b8_stride;
1745
    int xy = s->block_index[0];
1746

    
1747
    s->dc_val[0][xy           ] =
1748
    s->dc_val[0][xy + 1       ] =
1749
    s->dc_val[0][xy     + wrap] =
1750
    s->dc_val[0][xy + 1 + wrap] = 1024;
1751
    /* ac pred */
1752
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1753
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1754
    if (s->msmpeg4_version>=3) {
1755
        s->coded_block[xy           ] =
1756
        s->coded_block[xy + 1       ] =
1757
        s->coded_block[xy     + wrap] =
1758
        s->coded_block[xy + 1 + wrap] = 0;
1759
    }
1760
    /* chroma */
1761
    wrap = s->mb_stride;
1762
    xy = s->mb_x + s->mb_y * wrap;
1763
    s->dc_val[1][xy] =
1764
    s->dc_val[2][xy] = 1024;
1765
    /* ac pred */
1766
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1767
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1768

    
1769
    s->mbintra_table[xy]= 0;
1770
}
1771

    
1772
/* generic function called after a macroblock has been parsed by the
1773
   decoder or after it has been encoded by the encoder.
1774

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

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

    
1801
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1802

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

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

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

    
1833
            assert(age);
1834

    
1835
            if (s->mb_skipped) {
1836
                s->mb_skipped= 0;
1837
                assert(s->pict_type!=FF_I_TYPE);
1838

    
1839
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1840
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1841

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

    
1854
        dct_linesize = linesize << s->interlaced_dct;
1855
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1856

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

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

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

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

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

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

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

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

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

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

    
1993
                        dct_linesize = uvlinesize << s->interlaced_dct;
1994
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1995

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

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

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

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

    
2045
        h= FFMIN(h, s->avctx->height - y);
2046

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

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

    
2066
        emms_c();
2067

    
2068
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2069
                                  y, s->picture_structure, h);
2070
    }
2071
}
2072

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

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

    
2086
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2087
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2088
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2089

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

    
2098
void ff_mpeg_flush(AVCodecContext *avctx){
2099
    int i;
2100
    MpegEncContext *s = avctx->priv_data;
2101

    
2102
    if(s==NULL || s->picture==NULL)
2103
        return;
2104

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

    
2112
    s->mb_x= s->mb_y= 0;
2113
    s->closed_gop= 0;
2114

    
2115
    s->parse_context.state= -1;
2116
    s->parse_context.frame_start_found= 0;
2117
    s->parse_context.overread= 0;
2118
    s->parse_context.overread_index= 0;
2119
    s->parse_context.index= 0;
2120
    s->parse_context.last_index= 0;
2121
    s->bitstream_buffer_size=0;
2122
    s->pp_time=0;
2123
}
2124

    
2125
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2126
                                   DCTELEM *block, int n, int qscale)
2127
{
2128
    int i, level, nCoeffs;
2129
    const uint16_t *quant_matrix;
2130

    
2131
    nCoeffs= s->block_last_index[n];
2132

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

    
2157
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2158
                                   DCTELEM *block, int n, int qscale)
2159
{
2160
    int i, level, nCoeffs;
2161
    const uint16_t *quant_matrix;
2162

    
2163
    nCoeffs= s->block_last_index[n];
2164

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

    
2186
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2187
                                   DCTELEM *block, int n, int qscale)
2188
{
2189
    int i, level, nCoeffs;
2190
    const uint16_t *quant_matrix;
2191

    
2192
    if(s->alternate_scan) nCoeffs= 63;
2193
    else nCoeffs= s->block_last_index[n];
2194

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

    
2216
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2217
                                   DCTELEM *block, int n, int qscale)
2218
{
2219
    int i, level, nCoeffs;
2220
    const uint16_t *quant_matrix;
2221
    int sum=-1;
2222

    
2223
    if(s->alternate_scan) nCoeffs= 63;
2224
    else nCoeffs= s->block_last_index[n];
2225

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

    
2249
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2250
                                   DCTELEM *block, int n, int qscale)
2251
{
2252
    int i, level, nCoeffs;
2253
    const uint16_t *quant_matrix;
2254
    int sum=-1;
2255

    
2256
    if(s->alternate_scan) nCoeffs= 63;
2257
    else nCoeffs= s->block_last_index[n];
2258

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

    
2280
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2281
                                  DCTELEM *block, int n, int qscale)
2282
{
2283
    int i, level, qmul, qadd;
2284
    int nCoeffs;
2285

    
2286
    assert(s->block_last_index[n]>=0);
2287

    
2288
    qmul = qscale << 1;
2289

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

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

    
2317
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2318
                                  DCTELEM *block, int n, int qscale)
2319
{
2320
    int i, level, qmul, qadd;
2321
    int nCoeffs;
2322

    
2323
    assert(s->block_last_index[n]>=0);
2324

    
2325
    qadd = (qscale - 1) | 1;
2326
    qmul = qscale << 1;
2327

    
2328
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2329

    
2330
    for(i=0; i<=nCoeffs; i++) {
2331
        level = block[i];
2332
        if (level) {
2333
            if (level < 0) {
2334
                level = level * qmul - qadd;
2335
            } else {
2336
                level = level * qmul + qadd;
2337
            }
2338
            block[i] = level;
2339
        }
2340
    }
2341
}
2342

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

    
2353
    s->qscale = qscale;
2354
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2355

    
2356
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2357
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2358
}