Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 7f802534

History | View | Annotate | Download (87.3 KB)

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

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

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

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

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

    
58

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

    
62
//#define DEBUG
63

    
64

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

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

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

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

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

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

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

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

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

    
115
    return p+4;
116
}
117

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

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

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

    
159
    return 0;
160
}
161

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

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

    
179
    if(shared){
180
        assert(pic->data[0]);
181
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
182
        pic->type= FF_BUFFER_TYPE_SHARED;
183
    }else{
184
        assert(!pic->data[0]);
185

    
186
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
187

    
188
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
189
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
190
            return -1;
191
        }
192

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

    
199
        if(pic->linesize[1] != pic->linesize[2]){
200
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
201
            s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
202
            return -1;
203
        }
204

    
205
        s->linesize  = pic->linesize[0];
206
        s->uvlinesize= pic->linesize[1];
207
    }
208

    
209
    if(pic->qscale_table==NULL){
210
        if (s->encoding) {
211
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
212
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
213
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
214
        }
215

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

    
242
    /* It might be nicer if the application would keep track of these
243
     * but it would require an API change. */
244
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
245
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
246
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
247
        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.
248

    
249
    return 0;
250
fail: //for the CHECKED_ALLOCZ macro
251
    if(r>=0)
252
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
253
    return -1;
254
}
255

    
256
/**
257
 * deallocates a picture
258
 */
259
static void free_picture(MpegEncContext *s, Picture *pic){
260
    int i;
261

    
262
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
263
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
264
    }
265

    
266
    av_freep(&pic->mb_var);
267
    av_freep(&pic->mc_mb_var);
268
    av_freep(&pic->mb_mean);
269
    av_freep(&pic->mbskip_table);
270
    av_freep(&pic->qscale_table);
271
    av_freep(&pic->mb_type_base);
272
    av_freep(&pic->dct_coeff);
273
    av_freep(&pic->pan_scan);
274
    pic->mb_type= NULL;
275
    for(i=0; i<2; i++){
276
        av_freep(&pic->motion_val_base[i]);
277
        av_freep(&pic->ref_index[i]);
278
    }
279

    
280
    if(pic->type == FF_BUFFER_TYPE_SHARED){
281
        for(i=0; i<4; i++){
282
            pic->base[i]=
283
            pic->data[i]= NULL;
284
        }
285
        pic->type= 0;
286
    }
287
}
288

    
289
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
290
    int i;
291

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

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

    
312
    for(i=0;i<12;i++){
313
        s->pblocks[i] = &s->block[i];
314
    }
315
    return 0;
316
fail:
317
    return -1; //free() through MPV_common_end()
318
}
319

    
320
static void free_duplicate_context(MpegEncContext *s){
321
    if(s==NULL) return;
322

    
323
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
324
    av_freep(&s->me.scratchpad);
325
    s->me.temp=
326
    s->rd_scratchpad=
327
    s->b_scratchpad=
328
    s->obmc_scratchpad= NULL;
329

    
330
    av_freep(&s->dct_error_sum);
331
    av_freep(&s->me.map);
332
    av_freep(&s->me.score_map);
333
    av_freep(&s->blocks);
334
    s->block= NULL;
335
}
336

    
337
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
338
#define COPY(a) bak->a= src->a
339
    COPY(allocated_edge_emu_buffer);
340
    COPY(edge_emu_buffer);
341
    COPY(me.scratchpad);
342
    COPY(me.temp);
343
    COPY(rd_scratchpad);
344
    COPY(b_scratchpad);
345
    COPY(obmc_scratchpad);
346
    COPY(me.map);
347
    COPY(me.score_map);
348
    COPY(blocks);
349
    COPY(block);
350
    COPY(start_mb_y);
351
    COPY(end_mb_y);
352
    COPY(me.map_generation);
353
    COPY(pb);
354
    COPY(dct_error_sum);
355
    COPY(dct_count[0]);
356
    COPY(dct_count[1]);
357
#undef COPY
358
}
359

    
360
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
361
    MpegEncContext bak;
362
    int i;
363
    //FIXME copy only needed parts
364
//START_TIMER
365
    backup_duplicate_context(&bak, dst);
366
    memcpy(dst, src, sizeof(MpegEncContext));
367
    backup_duplicate_context(dst, &bak);
368
    for(i=0;i<12;i++){
369
        dst->pblocks[i] = &dst->block[i];
370
    }
371
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
372
}
373

    
374
/**
375
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
376
 * the changed fields will not depend upon the prior state of the MpegEncContext.
377
 */
378
void MPV_common_defaults(MpegEncContext *s){
379
    s->y_dc_scale_table=
380
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
381
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
382
    s->progressive_frame= 1;
383
    s->progressive_sequence= 1;
384
    s->picture_structure= PICT_FRAME;
385

    
386
    s->coded_picture_number = 0;
387
    s->picture_number = 0;
388
    s->input_picture_number = 0;
389

    
390
    s->picture_in_gop_number = 0;
391

    
392
    s->f_code = 1;
393
    s->b_code = 1;
394
}
395

    
396
/**
397
 * sets the given MpegEncContext to defaults for decoding.
398
 * the changed fields will not depend upon the prior state of the MpegEncContext.
399
 */
400
void MPV_decode_defaults(MpegEncContext *s){
401
    MPV_common_defaults(s);
402
}
403

    
404
/**
405
 * init common structure for both encoder and decoder.
406
 * this assumes that some variables like width/height are already set
407
 */
408
av_cold int MPV_common_init(MpegEncContext *s)
409
{
410
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
411

    
412
    s->mb_height = (s->height + 15) / 16;
413

    
414
    if(s->avctx->pix_fmt == PIX_FMT_NONE){
415
        av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
416
        return -1;
417
    }
418

    
419
    if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
420
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
421
        return -1;
422
    }
423

    
424
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
425
        return -1;
426

    
427
    dsputil_init(&s->dsp, s->avctx);
428
    ff_dct_common_init(s);
429

    
430
    s->flags= s->avctx->flags;
431
    s->flags2= s->avctx->flags2;
432

    
433
    s->mb_width  = (s->width  + 15) / 16;
434
    s->mb_stride = s->mb_width + 1;
435
    s->b8_stride = s->mb_width*2 + 1;
436
    s->b4_stride = s->mb_width*4 + 1;
437
    mb_array_size= s->mb_height * s->mb_stride;
438
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
439

    
440
    /* set chroma shifts */
441
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
442
                                                    &(s->chroma_y_shift) );
443

    
444
    /* set default edge pos, will be overriden in decode_header if needed */
445
    s->h_edge_pos= s->mb_width*16;
446
    s->v_edge_pos= s->mb_height*16;
447

    
448
    s->mb_num = s->mb_width * s->mb_height;
449

    
450
    s->block_wrap[0]=
451
    s->block_wrap[1]=
452
    s->block_wrap[2]=
453
    s->block_wrap[3]= s->b8_stride;
454
    s->block_wrap[4]=
455
    s->block_wrap[5]= s->mb_stride;
456

    
457
    y_size = s->b8_stride * (2 * s->mb_height + 1);
458
    c_size = s->mb_stride * (s->mb_height + 1);
459
    yc_size = y_size + 2 * c_size;
460

    
461
    /* convert fourcc to upper case */
462
    s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
463
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
464
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
465
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
466

    
467
    s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
468
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
469
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
470
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
471

    
472
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
473

    
474
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
475
    for(y=0; y<s->mb_height; y++){
476
        for(x=0; x<s->mb_width; x++){
477
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
478
        }
479
    }
480
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
481

    
482
    if (s->encoding) {
483
        /* Allocate MV tables */
484
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
485
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
486
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
487
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
488
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
489
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
490
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
491
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
492
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
493
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
494
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
495
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
496

    
497
        if(s->msmpeg4_version){
498
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
499
        }
500
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
501

    
502
        /* Allocate MB type table */
503
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
504

    
505
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
506

    
507
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
508
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
509
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
510
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
511
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
512
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
513

    
514
        if(s->avctx->noise_reduction){
515
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
516
        }
517
    }
518
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
519

    
520
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
521

    
522
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
523
        /* interlaced direct mode decoding tables */
524
            for(i=0; i<2; i++){
525
                int j, k;
526
                for(j=0; j<2; j++){
527
                    for(k=0; k<2; k++){
528
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
529
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
530
                    }
531
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
532
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
533
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
534
                }
535
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
536
            }
537
    }
538
    if (s->out_format == FMT_H263) {
539
        /* ac values */
540
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
541
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
542
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
543
        s->ac_val[2] = s->ac_val[1] + c_size;
544

    
545
        /* cbp values */
546
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
547
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
548

    
549
        /* cbp, ac_pred, pred_dir */
550
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
551
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
552
    }
553

    
554
    if (s->h263_pred || s->h263_plus || !s->encoding) {
555
        /* dc values */
556
        //MN: we need these for error resilience of intra-frames
557
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
558
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
559
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
560
        s->dc_val[2] = s->dc_val[1] + c_size;
561
        for(i=0;i<yc_size;i++)
562
            s->dc_val_base[i] = 1024;
563
    }
564

    
565
    /* which mb is a intra block */
566
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
567
    memset(s->mbintra_table, 1, mb_array_size);
568

    
569
    /* init macroblock skip table */
570
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
571
    //Note the +1 is for a quicker mpeg4 slice_end detection
572
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
573

    
574
    s->parse_context.state= -1;
575
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
576
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
577
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
578
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
579
    }
580

    
581
    s->context_initialized = 1;
582

    
583
    s->thread_context[0]= s;
584
    threads = s->avctx->thread_count;
585

    
586
    for(i=1; i<threads; i++){
587
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
588
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
589
    }
590

    
591
    for(i=0; i<threads; i++){
592
        if(init_duplicate_context(s->thread_context[i], s) < 0)
593
           goto fail;
594
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
595
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
596
    }
597

    
598
    return 0;
599
 fail:
600
    MPV_common_end(s);
601
    return -1;
602
}
603

    
604
/* init common structure for both encoder and decoder */
605
void MPV_common_end(MpegEncContext *s)
606
{
607
    int i, j, k;
608

    
609
    for(i=0; i<s->avctx->thread_count; i++){
610
        free_duplicate_context(s->thread_context[i]);
611
    }
612
    for(i=1; i<s->avctx->thread_count; i++){
613
        av_freep(&s->thread_context[i]);
614
    }
615

    
616
    av_freep(&s->parse_context.buffer);
617
    s->parse_context.buffer_size=0;
618

    
619
    av_freep(&s->mb_type);
620
    av_freep(&s->p_mv_table_base);
621
    av_freep(&s->b_forw_mv_table_base);
622
    av_freep(&s->b_back_mv_table_base);
623
    av_freep(&s->b_bidir_forw_mv_table_base);
624
    av_freep(&s->b_bidir_back_mv_table_base);
625
    av_freep(&s->b_direct_mv_table_base);
626
    s->p_mv_table= NULL;
627
    s->b_forw_mv_table= NULL;
628
    s->b_back_mv_table= NULL;
629
    s->b_bidir_forw_mv_table= NULL;
630
    s->b_bidir_back_mv_table= NULL;
631
    s->b_direct_mv_table= NULL;
632
    for(i=0; i<2; i++){
633
        for(j=0; j<2; j++){
634
            for(k=0; k<2; k++){
635
                av_freep(&s->b_field_mv_table_base[i][j][k]);
636
                s->b_field_mv_table[i][j][k]=NULL;
637
            }
638
            av_freep(&s->b_field_select_table[i][j]);
639
            av_freep(&s->p_field_mv_table_base[i][j]);
640
            s->p_field_mv_table[i][j]=NULL;
641
        }
642
        av_freep(&s->p_field_select_table[i]);
643
    }
644

    
645
    av_freep(&s->dc_val_base);
646
    av_freep(&s->ac_val_base);
647
    av_freep(&s->coded_block_base);
648
    av_freep(&s->mbintra_table);
649
    av_freep(&s->cbp_table);
650
    av_freep(&s->pred_dir_table);
651

    
652
    av_freep(&s->mbskip_table);
653
    av_freep(&s->prev_pict_types);
654
    av_freep(&s->bitstream_buffer);
655
    s->allocated_bitstream_buffer_size=0;
656

    
657
    av_freep(&s->avctx->stats_out);
658
    av_freep(&s->ac_stats);
659
    av_freep(&s->error_status_table);
660
    av_freep(&s->mb_index2xy);
661
    av_freep(&s->lambda_table);
662
    av_freep(&s->q_intra_matrix);
663
    av_freep(&s->q_inter_matrix);
664
    av_freep(&s->q_intra_matrix16);
665
    av_freep(&s->q_inter_matrix16);
666
    av_freep(&s->input_picture);
667
    av_freep(&s->reordered_input_picture);
668
    av_freep(&s->dct_offset);
669

    
670
    if(s->picture){
671
        for(i=0; i<MAX_PICTURE_COUNT; i++){
672
            free_picture(s, &s->picture[i]);
673
        }
674
    }
675
    av_freep(&s->picture);
676
    s->context_initialized = 0;
677
    s->last_picture_ptr=
678
    s->next_picture_ptr=
679
    s->current_picture_ptr= NULL;
680
    s->linesize= s->uvlinesize= 0;
681

    
682
    for(i=0; i<3; i++)
683
        av_freep(&s->visualization_buffer[i]);
684

    
685
    avcodec_default_free_buffers(s->avctx);
686
}
687

    
688
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
689
{
690
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
691
    uint8_t index_run[MAX_RUN+1];
692
    int last, run, level, start, end, i;
693

    
694
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
695
    if(static_store && rl->max_level[0])
696
        return;
697

    
698
    /* compute max_level[], max_run[] and index_run[] */
699
    for(last=0;last<2;last++) {
700
        if (last == 0) {
701
            start = 0;
702
            end = rl->last;
703
        } else {
704
            start = rl->last;
705
            end = rl->n;
706
        }
707

    
708
        memset(max_level, 0, MAX_RUN + 1);
709
        memset(max_run, 0, MAX_LEVEL + 1);
710
        memset(index_run, rl->n, MAX_RUN + 1);
711
        for(i=start;i<end;i++) {
712
            run = rl->table_run[i];
713
            level = rl->table_level[i];
714
            if (index_run[run] == rl->n)
715
                index_run[run] = i;
716
            if (level > max_level[run])
717
                max_level[run] = level;
718
            if (run > max_run[level])
719
                max_run[level] = run;
720
        }
721
        if(static_store)
722
            rl->max_level[last] = static_store[last];
723
        else
724
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
725
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
726
        if(static_store)
727
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
728
        else
729
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
730
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
731
        if(static_store)
732
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
733
        else
734
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
735
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
736
    }
737
}
738

    
739
void init_vlc_rl(RLTable *rl)
740
{
741
    int i, q;
742

    
743
    for(q=0; q<32; q++){
744
        int qmul= q*2;
745
        int qadd= (q-1)|1;
746

    
747
        if(q==0){
748
            qmul=1;
749
            qadd=0;
750
        }
751
        for(i=0; i<rl->vlc.table_size; i++){
752
            int code= rl->vlc.table[i][0];
753
            int len = rl->vlc.table[i][1];
754
            int level, run;
755

    
756
            if(len==0){ // illegal code
757
                run= 66;
758
                level= MAX_LEVEL;
759
            }else if(len<0){ //more bits needed
760
                run= 0;
761
                level= code;
762
            }else{
763
                if(code==rl->n){ //esc
764
                    run= 66;
765
                    level= 0;
766
                }else{
767
                    run=   rl->table_run  [code] + 1;
768
                    level= rl->table_level[code] * qmul + qadd;
769
                    if(code >= rl->last) run+=192;
770
                }
771
            }
772
            rl->rl_vlc[q][i].len= len;
773
            rl->rl_vlc[q][i].level= level;
774
            rl->rl_vlc[q][i].run= run;
775
        }
776
    }
777
}
778

    
779
int ff_find_unused_picture(MpegEncContext *s, int shared){
780
    int i;
781

    
782
    if(shared){
783
        for(i=0; i<MAX_PICTURE_COUNT; i++){
784
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
785
        }
786
    }else{
787
        for(i=0; i<MAX_PICTURE_COUNT; i++){
788
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
789
        }
790
        for(i=0; i<MAX_PICTURE_COUNT; i++){
791
            if(s->picture[i].data[0]==NULL) return i;
792
        }
793
    }
794

    
795
    av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
796
    /* We could return -1, but the codec would crash trying to draw into a
797
     * non-existing frame anyway. This is safer than waiting for a random crash.
798
     * Also the return of this is never useful, an encoder must only allocate
799
     * as much as allowed in the specification. This has no relationship to how
800
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
801
     * enough for such valid streams).
802
     * Plus, a decoder has to check stream validity and remove frames if too
803
     * many reference frames are around. Waiting for "OOM" is not correct at
804
     * all. Similarly, missing reference frames have to be replaced by
805
     * interpolated/MC frames, anything else is a bug in the codec ...
806
     */
807
    abort();
808
    return -1;
809
}
810

    
811
static void update_noise_reduction(MpegEncContext *s){
812
    int intra, i;
813

    
814
    for(intra=0; intra<2; intra++){
815
        if(s->dct_count[intra] > (1<<16)){
816
            for(i=0; i<64; i++){
817
                s->dct_error_sum[intra][i] >>=1;
818
            }
819
            s->dct_count[intra] >>= 1;
820
        }
821

    
822
        for(i=0; i<64; i++){
823
            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);
824
        }
825
    }
826
}
827

    
828
/**
829
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
830
 */
831
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
832
{
833
    int i;
834
    AVFrame *pic;
835
    s->mb_skipped = 0;
836

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

    
839
    /* mark&release old frames */
840
    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]) {
841
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
842
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
843

    
844
        /* release forgotten pictures */
845
        /* if(mpeg124/h263) */
846
        if(!s->encoding){
847
            for(i=0; i<MAX_PICTURE_COUNT; i++){
848
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
849
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
850
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
851
                }
852
            }
853
        }
854
      }
855
    }
856
alloc:
857
    if(!s->encoding){
858
        /* release non reference frames */
859
        for(i=0; i<MAX_PICTURE_COUNT; i++){
860
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
861
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
862
            }
863
        }
864

    
865
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
866
            pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
867
        else{
868
            i= ff_find_unused_picture(s, 0);
869
            pic= (AVFrame*)&s->picture[i];
870
        }
871

    
872
        pic->reference= 0;
873
        if (!s->dropable){
874
            if (s->codec_id == CODEC_ID_H264)
875
                pic->reference = s->picture_structure;
876
            else if (s->pict_type != FF_B_TYPE)
877
                pic->reference = 3;
878
        }
879

    
880
        pic->coded_picture_number= s->coded_picture_number++;
881

    
882
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
883
            return -1;
884

    
885
        s->current_picture_ptr= (Picture*)pic;
886
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
887
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
888
    }
889

    
890
    s->current_picture_ptr->pict_type= s->pict_type;
891
//    if(s->flags && CODEC_FLAG_QSCALE)
892
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
893
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
894

    
895
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
896

    
897
    if (s->pict_type != FF_B_TYPE) {
898
        s->last_picture_ptr= s->next_picture_ptr;
899
        if(!s->dropable)
900
            s->next_picture_ptr= s->current_picture_ptr;
901
    }
902
/*    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,
903
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
904
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
905
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
906
        s->pict_type, s->dropable);*/
907

    
908
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
909
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
910

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

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

    
919
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
920
        int i;
921
        for(i=0; i<4; i++){
922
            if(s->picture_structure == PICT_BOTTOM_FIELD){
923
                 s->current_picture.data[i] += s->current_picture.linesize[i];
924
            }
925
            s->current_picture.linesize[i] *= 2;
926
            s->last_picture.linesize[i] *=2;
927
            s->next_picture.linesize[i] *=2;
928
        }
929
    }
930

    
931
    s->hurry_up= s->avctx->hurry_up;
932
    s->error_recognition= avctx->error_recognition;
933

    
934
    /* set dequantizer, we can't do it during init as it might change for mpeg4
935
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
936
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
937
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
938
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
939
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
940
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
941
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
942
    }else{
943
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
944
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
945
    }
946

    
947
    if(s->dct_error_sum){
948
        assert(s->avctx->noise_reduction && s->encoding);
949

    
950
        update_noise_reduction(s);
951
    }
952

    
953
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
954
        return ff_xvmc_field_start(s, avctx);
955

    
956
    return 0;
957
}
958

    
959
/* generic function for encode/decode called after a frame has been coded/decoded */
960
void MPV_frame_end(MpegEncContext *s)
961
{
962
    int i;
963
    /* draw edge for correct motion prediction if outside */
964
    //just to make sure that all data is rendered.
965
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
966
        ff_xvmc_field_end(s);
967
    }else if(!s->avctx->hwaccel
968
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
969
       && s->unrestricted_mv
970
       && s->current_picture.reference
971
       && !s->intra_only
972
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
973
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
974
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
975
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
976
    }
977
    emms_c();
978

    
979
    s->last_pict_type    = s->pict_type;
980
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
981
    if(s->pict_type!=FF_B_TYPE){
982
        s->last_non_b_pict_type= s->pict_type;
983
    }
984
#if 0
985
        /* copy back current_picture variables */
986
    for(i=0; i<MAX_PICTURE_COUNT; i++){
987
        if(s->picture[i].data[0] == s->current_picture.data[0]){
988
            s->picture[i]= s->current_picture;
989
            break;
990
        }
991
    }
992
    assert(i<MAX_PICTURE_COUNT);
993
#endif
994

    
995
    if(s->encoding){
996
        /* release non-reference frames */
997
        for(i=0; i<MAX_PICTURE_COUNT; i++){
998
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
999
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1000
            }
1001
        }
1002
    }
1003
    // clear copies, to avoid confusion
1004
#if 0
1005
    memset(&s->last_picture, 0, sizeof(Picture));
1006
    memset(&s->next_picture, 0, sizeof(Picture));
1007
    memset(&s->current_picture, 0, sizeof(Picture));
1008
#endif
1009
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1010
}
1011

    
1012
/**
1013
 * draws an line from (ex, ey) -> (sx, sy).
1014
 * @param w width of the image
1015
 * @param h height of the image
1016
 * @param stride stride/linesize of the image
1017
 * @param color color of the arrow
1018
 */
1019
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1020
    int x, y, fr, f;
1021

    
1022
    sx= av_clip(sx, 0, w-1);
1023
    sy= av_clip(sy, 0, h-1);
1024
    ex= av_clip(ex, 0, w-1);
1025
    ey= av_clip(ey, 0, h-1);
1026

    
1027
    buf[sy*stride + sx]+= color;
1028

    
1029
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1030
        if(sx > ex){
1031
            FFSWAP(int, sx, ex);
1032
            FFSWAP(int, sy, ey);
1033
        }
1034
        buf+= sx + sy*stride;
1035
        ex-= sx;
1036
        f= ((ey-sy)<<16)/ex;
1037
        for(x= 0; x <= ex; x++){
1038
            y = (x*f)>>16;
1039
            fr= (x*f)&0xFFFF;
1040
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1041
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1042
        }
1043
    }else{
1044
        if(sy > ey){
1045
            FFSWAP(int, sx, ex);
1046
            FFSWAP(int, sy, ey);
1047
        }
1048
        buf+= sx + sy*stride;
1049
        ey-= sy;
1050
        if(ey) f= ((ex-sx)<<16)/ey;
1051
        else   f= 0;
1052
        for(y= 0; y <= ey; y++){
1053
            x = (y*f)>>16;
1054
            fr= (y*f)&0xFFFF;
1055
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1056
            buf[y*stride + x+1]+= (color*         fr )>>16;
1057
        }
1058
    }
1059
}
1060

    
1061
/**
1062
 * draws an arrow from (ex, ey) -> (sx, sy).
1063
 * @param w width of the image
1064
 * @param h height of the image
1065
 * @param stride stride/linesize of the image
1066
 * @param color color of the arrow
1067
 */
1068
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1069
    int dx,dy;
1070

    
1071
    sx= av_clip(sx, -100, w+100);
1072
    sy= av_clip(sy, -100, h+100);
1073
    ex= av_clip(ex, -100, w+100);
1074
    ey= av_clip(ey, -100, h+100);
1075

    
1076
    dx= ex - sx;
1077
    dy= ey - sy;
1078

    
1079
    if(dx*dx + dy*dy > 3*3){
1080
        int rx=  dx + dy;
1081
        int ry= -dx + dy;
1082
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1083

    
1084
        //FIXME subpixel accuracy
1085
        rx= ROUNDED_DIV(rx*3<<4, length);
1086
        ry= ROUNDED_DIV(ry*3<<4, length);
1087

    
1088
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1089
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1090
    }
1091
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1092
}
1093

    
1094
/**
1095
 * prints debuging info for the given picture.
1096
 */
1097
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1098

    
1099
    if(s->avctx->hwaccel) return;
1100
    if(!pict || !pict->mb_type) return;
1101

    
1102
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1103
        int x,y;
1104

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

    
1154
                    //segmentation
1155
                    if(IS_8X8(mb_type))
1156
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1157
                    else if(IS_16X8(mb_type))
1158
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1159
                    else if(IS_8X16(mb_type))
1160
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1161
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1162
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1163
                    else
1164
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1165

    
1166

    
1167
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1168
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1169
                    else
1170
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1171
                }
1172
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1173
            }
1174
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1175
        }
1176
    }
1177

    
1178
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1179
        const int shift= 1 + s->quarter_sample;
1180
        int mb_y;
1181
        uint8_t *ptr;
1182
        int i;
1183
        int h_chroma_shift, v_chroma_shift, block_height;
1184
        const int width = s->avctx->width;
1185
        const int height= s->avctx->height;
1186
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1187
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1188
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1189

    
1190
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1191
        for(i=0; i<3; i++){
1192
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1193
            pict->data[i]= s->visualization_buffer[i];
1194
        }
1195
        pict->type= FF_BUFFER_TYPE_COPY;
1196
        ptr= pict->data[0];
1197
        block_height = 16>>v_chroma_shift;
1198

    
1199
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1200
            int mb_x;
1201
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1202
                const int mb_index= mb_x + mb_y*s->mb_stride;
1203
                if((s->avctx->debug_mv) && pict->motion_val){
1204
                  int type;
1205
                  for(type=0; type<3; type++){
1206
                    int direction = 0;
1207
                    switch (type) {
1208
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1209
                                continue;
1210
                              direction = 0;
1211
                              break;
1212
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1213
                                continue;
1214
                              direction = 0;
1215
                              break;
1216
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1217
                                continue;
1218
                              direction = 1;
1219
                              break;
1220
                    }
1221
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1222
                        continue;
1223

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

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

    
1246
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1247
                      }
1248
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1249
                      int i;
1250
                      for(i=0; i<2; i++){
1251
                        int sx=mb_x*16 + 4 + 8*i;
1252
                        int sy=mb_y*16 + 8;
1253
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1254
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1255
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1256

    
1257
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1258
                            my*=2;
1259

    
1260
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1261
                      }
1262
                    }else{
1263
                      int sx= mb_x*16 + 8;
1264
                      int sy= mb_y*16 + 8;
1265
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1266
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1267
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1268
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1269
                    }
1270
                  }
1271
                }
1272
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1273
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1274
                    int y;
1275
                    for(y=0; y<block_height; y++){
1276
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1277
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1278
                    }
1279
                }
1280
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1281
                    int mb_type= pict->mb_type[mb_index];
1282
                    uint64_t u,v;
1283
                    int y;
1284
#define COLOR(theta, r)\
1285
u= (int)(128 + r*cos(theta*3.141592/180));\
1286
v= (int)(128 + r*sin(theta*3.141592/180));
1287

    
1288

    
1289
                    u=v=128;
1290
                    if(IS_PCM(mb_type)){
1291
                        COLOR(120,48)
1292
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1293
                        COLOR(30,48)
1294
                    }else if(IS_INTRA4x4(mb_type)){
1295
                        COLOR(90,48)
1296
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1297
//                        COLOR(120,48)
1298
                    }else if(IS_DIRECT(mb_type)){
1299
                        COLOR(150,48)
1300
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1301
                        COLOR(170,48)
1302
                    }else if(IS_GMC(mb_type)){
1303
                        COLOR(190,48)
1304
                    }else if(IS_SKIP(mb_type)){
1305
//                        COLOR(180,48)
1306
                    }else if(!USES_LIST(mb_type, 1)){
1307
                        COLOR(240,48)
1308
                    }else if(!USES_LIST(mb_type, 0)){
1309
                        COLOR(0,48)
1310
                    }else{
1311
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1312
                        COLOR(300,48)
1313
                    }
1314

    
1315
                    u*= 0x0101010101010101ULL;
1316
                    v*= 0x0101010101010101ULL;
1317
                    for(y=0; y<block_height; y++){
1318
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1319
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1320
                    }
1321

    
1322
                    //segmentation
1323
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1324
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1325
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1326
                    }
1327
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1328
                        for(y=0; y<16; y++)
1329
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1330
                    }
1331
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1332
                        int dm= 1 << (mv_sample_log2-2);
1333
                        for(i=0; i<4; i++){
1334
                            int sx= mb_x*16 + 8*(i&1);
1335
                            int sy= mb_y*16 + 8*(i>>1);
1336
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1337
                            //FIXME bidir
1338
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1339
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1340
                                for(y=0; y<8; y++)
1341
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1342
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1343
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1344
                        }
1345
                    }
1346

    
1347
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1348
                        // hmm
1349
                    }
1350
                }
1351
                s->mbskip_table[mb_index]=0;
1352
            }
1353
        }
1354
    }
1355
}
1356

    
1357
static inline int hpel_motion_lowres(MpegEncContext *s,
1358
                                  uint8_t *dest, uint8_t *src,
1359
                                  int field_based, int field_select,
1360
                                  int src_x, int src_y,
1361
                                  int width, int height, int stride,
1362
                                  int h_edge_pos, int v_edge_pos,
1363
                                  int w, int h, h264_chroma_mc_func *pix_op,
1364
                                  int motion_x, int motion_y)
1365
{
1366
    const int lowres= s->avctx->lowres;
1367
    const int s_mask= (2<<lowres)-1;
1368
    int emu=0;
1369
    int sx, sy;
1370

    
1371
    if(s->quarter_sample){
1372
        motion_x/=2;
1373
        motion_y/=2;
1374
    }
1375

    
1376
    sx= motion_x & s_mask;
1377
    sy= motion_y & s_mask;
1378
    src_x += motion_x >> (lowres+1);
1379
    src_y += motion_y >> (lowres+1);
1380

    
1381
    src += src_y * stride + src_x;
1382

    
1383
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1384
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1385
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1386
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1387
        src= s->edge_emu_buffer;
1388
        emu=1;
1389
    }
1390

    
1391
    sx <<= 2 - lowres;
1392
    sy <<= 2 - lowres;
1393
    if(field_select)
1394
        src += s->linesize;
1395
    pix_op[lowres](dest, src, stride, h, sx, sy);
1396
    return emu;
1397
}
1398

    
1399
/* apply one mpeg motion vector to the three components */
1400
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1401
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1402
                               int field_based, int bottom_field, int field_select,
1403
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1404
                               int motion_x, int motion_y, int h)
1405
{
1406
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1407
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1408
    const int lowres= s->avctx->lowres;
1409
    const int block_s= 8>>lowres;
1410
    const int s_mask= (2<<lowres)-1;
1411
    const int h_edge_pos = s->h_edge_pos >> lowres;
1412
    const int v_edge_pos = s->v_edge_pos >> lowres;
1413
    linesize   = s->current_picture.linesize[0] << field_based;
1414
    uvlinesize = s->current_picture.linesize[1] << field_based;
1415

    
1416
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1417
        motion_x/=2;
1418
        motion_y/=2;
1419
    }
1420

    
1421
    if(field_based){
1422
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1423
    }
1424

    
1425
    sx= motion_x & s_mask;
1426
    sy= motion_y & s_mask;
1427
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1428
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1429

    
1430
    if (s->out_format == FMT_H263) {
1431
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1432
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1433
        uvsrc_x = src_x>>1;
1434
        uvsrc_y = src_y>>1;
1435
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1436
        mx = motion_x / 4;
1437
        my = motion_y / 4;
1438
        uvsx = (2*mx) & s_mask;
1439
        uvsy = (2*my) & s_mask;
1440
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1441
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
1442
    } else {
1443
        mx = motion_x / 2;
1444
        my = motion_y / 2;
1445
        uvsx = mx & s_mask;
1446
        uvsy = my & s_mask;
1447
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1448
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1449
    }
1450

    
1451
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1452
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1453
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1454

    
1455
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1456
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1457
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1458
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1459
            ptr_y = s->edge_emu_buffer;
1460
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1461
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1462
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1463
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1464
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1465
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1466
                ptr_cb= uvbuf;
1467
                ptr_cr= uvbuf+16;
1468
            }
1469
    }
1470

    
1471
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1472
        dest_y += s->linesize;
1473
        dest_cb+= s->uvlinesize;
1474
        dest_cr+= s->uvlinesize;
1475
    }
1476

    
1477
    if(field_select){
1478
        ptr_y += s->linesize;
1479
        ptr_cb+= s->uvlinesize;
1480
        ptr_cr+= s->uvlinesize;
1481
    }
1482

    
1483
    sx <<= 2 - lowres;
1484
    sy <<= 2 - lowres;
1485
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1486

    
1487
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1488
        uvsx <<= 2 - lowres;
1489
        uvsy <<= 2 - lowres;
1490
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1491
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1492
    }
1493
    //FIXME h261 lowres loop filter
1494
}
1495

    
1496
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1497
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1498
                                     uint8_t **ref_picture,
1499
                                     h264_chroma_mc_func *pix_op,
1500
                                     int mx, int my){
1501
    const int lowres= s->avctx->lowres;
1502
    const int block_s= 8>>lowres;
1503
    const int s_mask= (2<<lowres)-1;
1504
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1505
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1506
    int emu=0, src_x, src_y, offset, sx, sy;
1507
    uint8_t *ptr;
1508

    
1509
    if(s->quarter_sample){
1510
        mx/=2;
1511
        my/=2;
1512
    }
1513

    
1514
    /* In case of 8X8, we construct a single chroma motion vector
1515
       with a special rounding */
1516
    mx= ff_h263_round_chroma(mx);
1517
    my= ff_h263_round_chroma(my);
1518

    
1519
    sx= mx & s_mask;
1520
    sy= my & s_mask;
1521
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1522
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1523

    
1524
    offset = src_y * s->uvlinesize + src_x;
1525
    ptr = ref_picture[1] + offset;
1526
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1527
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1528
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1529
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1530
            ptr= s->edge_emu_buffer;
1531
            emu=1;
1532
        }
1533
    }
1534
    sx <<= 2 - lowres;
1535
    sy <<= 2 - lowres;
1536
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1537

    
1538
    ptr = ref_picture[2] + offset;
1539
    if(emu){
1540
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1541
        ptr= s->edge_emu_buffer;
1542
    }
1543
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1544
}
1545

    
1546
/**
1547
 * motion compensation of a single macroblock
1548
 * @param s context
1549
 * @param dest_y luma destination pointer
1550
 * @param dest_cb chroma cb/u destination pointer
1551
 * @param dest_cr chroma cr/v destination pointer
1552
 * @param dir direction (0->forward, 1->backward)
1553
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1554
 * @param pic_op halfpel motion compensation function (average or put normally)
1555
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1556
 */
1557
static inline void MPV_motion_lowres(MpegEncContext *s,
1558
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1559
                              int dir, uint8_t **ref_picture,
1560
                              h264_chroma_mc_func *pix_op)
1561
{
1562
    int mx, my;
1563
    int mb_x, mb_y, i;
1564
    const int lowres= s->avctx->lowres;
1565
    const int block_s= 8>>lowres;
1566

    
1567
    mb_x = s->mb_x;
1568
    mb_y = s->mb_y;
1569

    
1570
    switch(s->mv_type) {
1571
    case MV_TYPE_16X16:
1572
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1573
                    0, 0, 0,
1574
                    ref_picture, pix_op,
1575
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1576
        break;
1577
    case MV_TYPE_8X8:
1578
        mx = 0;
1579
        my = 0;
1580
            for(i=0;i<4;i++) {
1581
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1582
                            ref_picture[0], 0, 0,
1583
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1584
                            s->width, s->height, s->linesize,
1585
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1586
                            block_s, block_s, pix_op,
1587
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1588

    
1589
                mx += s->mv[dir][i][0];
1590
                my += s->mv[dir][i][1];
1591
            }
1592

    
1593
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1594
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1595
        break;
1596
    case MV_TYPE_FIELD:
1597
        if (s->picture_structure == PICT_FRAME) {
1598
            /* top field */
1599
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1600
                        1, 0, s->field_select[dir][0],
1601
                        ref_picture, pix_op,
1602
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1603
            /* bottom field */
1604
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1605
                        1, 1, s->field_select[dir][1],
1606
                        ref_picture, pix_op,
1607
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1608
        } else {
1609
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1610
                ref_picture= s->current_picture_ptr->data;
1611
            }
1612

    
1613
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1614
                        0, 0, s->field_select[dir][0],
1615
                        ref_picture, pix_op,
1616
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1617
        }
1618
        break;
1619
    case MV_TYPE_16X8:
1620
        for(i=0; i<2; i++){
1621
            uint8_t ** ref2picture;
1622

    
1623
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1624
                ref2picture= ref_picture;
1625
            }else{
1626
                ref2picture= s->current_picture_ptr->data;
1627
            }
1628

    
1629
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1630
                        0, 0, s->field_select[dir][i],
1631
                        ref2picture, pix_op,
1632
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1633

    
1634
            dest_y += 2*block_s*s->linesize;
1635
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1636
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1637
        }
1638
        break;
1639
    case MV_TYPE_DMV:
1640
        if(s->picture_structure == PICT_FRAME){
1641
            for(i=0; i<2; i++){
1642
                int j;
1643
                for(j=0; j<2; j++){
1644
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1645
                                1, j, j^i,
1646
                                ref_picture, pix_op,
1647
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1648
                }
1649
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1650
            }
1651
        }else{
1652
            for(i=0; i<2; i++){
1653
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1654
                            0, 0, s->picture_structure != i+1,
1655
                            ref_picture, pix_op,
1656
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1657

    
1658
                // after put we make avg of the same block
1659
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1660

    
1661
                //opposite parity is always in the same frame if this is second field
1662
                if(!s->first_field){
1663
                    ref_picture = s->current_picture_ptr->data;
1664
                }
1665
            }
1666
        }
1667
    break;
1668
    default: assert(0);
1669
    }
1670
}
1671

    
1672
/* put block[] to dest[] */
1673
static inline void put_dct(MpegEncContext *s,
1674
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1675
{
1676
    s->dct_unquantize_intra(s, block, i, qscale);
1677
    s->dsp.idct_put (dest, line_size, block);
1678
}
1679

    
1680
/* add block[] to dest[] */
1681
static inline void add_dct(MpegEncContext *s,
1682
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1683
{
1684
    if (s->block_last_index[i] >= 0) {
1685
        s->dsp.idct_add (dest, line_size, block);
1686
    }
1687
}
1688

    
1689
static inline void add_dequant_dct(MpegEncContext *s,
1690
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1691
{
1692
    if (s->block_last_index[i] >= 0) {
1693
        s->dct_unquantize_inter(s, block, i, qscale);
1694

    
1695
        s->dsp.idct_add (dest, line_size, block);
1696
    }
1697
}
1698

    
1699
/**
1700
 * cleans dc, ac, coded_block for the current non intra MB
1701
 */
1702
void ff_clean_intra_table_entries(MpegEncContext *s)
1703
{
1704
    int wrap = s->b8_stride;
1705
    int xy = s->block_index[0];
1706

    
1707
    s->dc_val[0][xy           ] =
1708
    s->dc_val[0][xy + 1       ] =
1709
    s->dc_val[0][xy     + wrap] =
1710
    s->dc_val[0][xy + 1 + wrap] = 1024;
1711
    /* ac pred */
1712
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1713
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1714
    if (s->msmpeg4_version>=3) {
1715
        s->coded_block[xy           ] =
1716
        s->coded_block[xy + 1       ] =
1717
        s->coded_block[xy     + wrap] =
1718
        s->coded_block[xy + 1 + wrap] = 0;
1719
    }
1720
    /* chroma */
1721
    wrap = s->mb_stride;
1722
    xy = s->mb_x + s->mb_y * wrap;
1723
    s->dc_val[1][xy] =
1724
    s->dc_val[2][xy] = 1024;
1725
    /* ac pred */
1726
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1727
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1728

    
1729
    s->mbintra_table[xy]= 0;
1730
}
1731

    
1732
/* generic function called after a macroblock has been parsed by the
1733
   decoder or after it has been encoded by the encoder.
1734

1735
   Important variables used:
1736
   s->mb_intra : true if intra macroblock
1737
   s->mv_dir   : motion vector direction
1738
   s->mv_type  : motion vector type
1739
   s->mv       : motion vector
1740
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1741
 */
1742
static av_always_inline
1743
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1744
                            int lowres_flag, int is_mpeg12)
1745
{
1746
    int mb_x, mb_y;
1747
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1748
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1749
        ff_xvmc_decode_mb(s);//xvmc uses pblocks
1750
        return;
1751
    }
1752

    
1753
    mb_x = s->mb_x;
1754
    mb_y = s->mb_y;
1755

    
1756
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1757
       /* save DCT coefficients */
1758
       int i,j;
1759
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1760
       for(i=0; i<6; i++)
1761
           for(j=0; j<64; j++)
1762
               *dct++ = block[i][s->dsp.idct_permutation[j]];
1763
    }
1764

    
1765
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1766

    
1767
    /* update DC predictors for P macroblocks */
1768
    if (!s->mb_intra) {
1769
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1770
            if(s->mbintra_table[mb_xy])
1771
                ff_clean_intra_table_entries(s);
1772
        } else {
1773
            s->last_dc[0] =
1774
            s->last_dc[1] =
1775
            s->last_dc[2] = 128 << s->intra_dc_precision;
1776
        }
1777
    }
1778
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1779
        s->mbintra_table[mb_xy]=1;
1780

    
1781
    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
1782
        uint8_t *dest_y, *dest_cb, *dest_cr;
1783
        int dct_linesize, dct_offset;
1784
        op_pixels_func (*op_pix)[4];
1785
        qpel_mc_func (*op_qpix)[16];
1786
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1787
        const int uvlinesize= s->current_picture.linesize[1];
1788
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1789
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1790

    
1791
        /* avoid copy if macroblock skipped in last frame too */
1792
        /* skip only during decoding as we might trash the buffers during encoding a bit */
1793
        if(!s->encoding){
1794
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1795
            const int age= s->current_picture.age;
1796

    
1797
            assert(age);
1798

    
1799
            if (s->mb_skipped) {
1800
                s->mb_skipped= 0;
1801
                assert(s->pict_type!=FF_I_TYPE);
1802

    
1803
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1804
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1805

    
1806
                /* if previous was skipped too, then nothing to do !  */
1807
                if (*mbskip_ptr >= age && s->current_picture.reference){
1808
                    return;
1809
                }
1810
            } else if(!s->current_picture.reference){
1811
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1812
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
1813
            } else{
1814
                *mbskip_ptr = 0; /* not skipped */
1815
            }
1816
        }
1817

    
1818
        dct_linesize = linesize << s->interlaced_dct;
1819
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1820

    
1821
        if(readable){
1822
            dest_y=  s->dest[0];
1823
            dest_cb= s->dest[1];
1824
            dest_cr= s->dest[2];
1825
        }else{
1826
            dest_y = s->b_scratchpad;
1827
            dest_cb= s->b_scratchpad+16*linesize;
1828
            dest_cr= s->b_scratchpad+32*linesize;
1829
        }
1830

    
1831
        if (!s->mb_intra) {
1832
            /* motion handling */
1833
            /* decoding or more than one mb_type (MC was already done otherwise) */
1834
            if(!s->encoding){
1835
                if(lowres_flag){
1836
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1837

    
1838
                    if (s->mv_dir & MV_DIR_FORWARD) {
1839
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1840
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1841
                    }
1842
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1843
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1844
                    }
1845
                }else{
1846
                    op_qpix= s->me.qpel_put;
1847
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1848
                        op_pix = s->dsp.put_pixels_tab;
1849
                    }else{
1850
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
1851
                    }
1852
                    if (s->mv_dir & MV_DIR_FORWARD) {
1853
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1854
                        op_pix = s->dsp.avg_pixels_tab;
1855
                        op_qpix= s->me.qpel_avg;
1856
                    }
1857
                    if (s->mv_dir & MV_DIR_BACKWARD) {
1858
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1859
                    }
1860
                }
1861
            }
1862

    
1863
            /* skip dequant / idct if we are really late ;) */
1864
            if(s->hurry_up>1) goto skip_idct;
1865
            if(s->avctx->skip_idct){
1866
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1867
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1868
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
1869
                    goto skip_idct;
1870
            }
1871

    
1872
            /* add dct residue */
1873
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1874
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1875
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1876
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1877
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1878
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1879

    
1880
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1881
                    if (s->chroma_y_shift){
1882
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1883
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1884
                    }else{
1885
                        dct_linesize >>= 1;
1886
                        dct_offset >>=1;
1887
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1888
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1889
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1890
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1891
                    }
1892
                }
1893
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1894
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1895
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1896
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1897
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1898

    
1899
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1900
                    if(s->chroma_y_shift){//Chroma420
1901
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
1902
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
1903
                    }else{
1904
                        //chroma422
1905
                        dct_linesize = uvlinesize << s->interlaced_dct;
1906
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1907

    
1908
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
1909
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
1910
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1911
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1912
                        if(!s->chroma_x_shift){//Chroma444
1913
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1914
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1915
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1916
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1917
                        }
1918
                    }
1919
                }//fi gray
1920
            }
1921
            else if (CONFIG_WMV2) {
1922
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1923
            }
1924
        } else {
1925
            /* dct only in intra block */
1926
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1927
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1928
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1929
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1930
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1931

    
1932
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1933
                    if(s->chroma_y_shift){
1934
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1935
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1936
                    }else{
1937
                        dct_offset >>=1;
1938
                        dct_linesize >>=1;
1939
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1940
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1941
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1942
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1943
                    }
1944
                }
1945
            }else{
1946
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1947
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1948
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1949
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1950

    
1951
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1952
                    if(s->chroma_y_shift){
1953
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1954
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1955
                    }else{
1956

    
1957
                        dct_linesize = uvlinesize << s->interlaced_dct;
1958
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1959

    
1960
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1961
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1962
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1963
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1964
                        if(!s->chroma_x_shift){//Chroma444
1965
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1966
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
1967
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1968
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1969
                        }
1970
                    }
1971
                }//gray
1972
            }
1973
        }
1974
skip_idct:
1975
        if(!readable){
1976
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
1977
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1978
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1979
        }
1980
    }
1981
}
1982

    
1983
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1984
#if !CONFIG_SMALL
1985
    if(s->out_format == FMT_MPEG1) {
1986
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1987
        else                 MPV_decode_mb_internal(s, block, 0, 1);
1988
    } else
1989
#endif
1990
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1991
    else                  MPV_decode_mb_internal(s, block, 0, 0);
1992
}
1993

    
1994
/**
1995
 *
1996
 * @param h is the normal height, this will be reduced automatically if needed for the last row
1997
 */
1998
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1999
    if (s->avctx->draw_horiz_band) {
2000
        AVFrame *src;
2001
        int offset[4];
2002

    
2003
        if(s->picture_structure != PICT_FRAME){
2004
            h <<= 1;
2005
            y <<= 1;
2006
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2007
        }
2008

    
2009
        h= FFMIN(h, s->avctx->height - y);
2010

    
2011
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2012
            src= (AVFrame*)s->current_picture_ptr;
2013
        else if(s->last_picture_ptr)
2014
            src= (AVFrame*)s->last_picture_ptr;
2015
        else
2016
            return;
2017

    
2018
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2019
            offset[0]=
2020
            offset[1]=
2021
            offset[2]=
2022
            offset[3]= 0;
2023
        }else{
2024
            offset[0]= y * s->linesize;
2025
            offset[1]=
2026
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2027
            offset[3]= 0;
2028
        }
2029

    
2030
        emms_c();
2031

    
2032
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2033
                                  y, s->picture_structure, h);
2034
    }
2035
}
2036

    
2037
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2038
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2039
    const int uvlinesize= s->current_picture.linesize[1];
2040
    const int mb_size= 4 - s->avctx->lowres;
2041

    
2042
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2043
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2044
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2045
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2046
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2047
    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;
2048
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2049

    
2050
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2051
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2052
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2053

    
2054
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2055
    {
2056
        s->dest[0] += s->mb_y *   linesize << mb_size;
2057
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2058
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2059
    }
2060
}
2061

    
2062
void ff_mpeg_flush(AVCodecContext *avctx){
2063
    int i;
2064
    MpegEncContext *s = avctx->priv_data;
2065

    
2066
    if(s==NULL || s->picture==NULL)
2067
        return;
2068

    
2069
    for(i=0; i<MAX_PICTURE_COUNT; i++){
2070
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2071
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2072
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2073
    }
2074
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2075

    
2076
    s->mb_x= s->mb_y= 0;
2077

    
2078
    s->parse_context.state= -1;
2079
    s->parse_context.frame_start_found= 0;
2080
    s->parse_context.overread= 0;
2081
    s->parse_context.overread_index= 0;
2082
    s->parse_context.index= 0;
2083
    s->parse_context.last_index= 0;
2084
    s->bitstream_buffer_size=0;
2085
    s->pp_time=0;
2086
}
2087

    
2088
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2089
                                   DCTELEM *block, int n, int qscale)
2090
{
2091
    int i, level, nCoeffs;
2092
    const uint16_t *quant_matrix;
2093

    
2094
    nCoeffs= s->block_last_index[n];
2095

    
2096
    if (n < 4)
2097
        block[0] = block[0] * s->y_dc_scale;
2098
    else
2099
        block[0] = block[0] * s->c_dc_scale;
2100
    /* XXX: only mpeg1 */
2101
    quant_matrix = s->intra_matrix;
2102
    for(i=1;i<=nCoeffs;i++) {
2103
        int j= s->intra_scantable.permutated[i];
2104
        level = block[j];
2105
        if (level) {
2106
            if (level < 0) {
2107
                level = -level;
2108
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2109
                level = (level - 1) | 1;
2110
                level = -level;
2111
            } else {
2112
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2113
                level = (level - 1) | 1;
2114
            }
2115
            block[j] = level;
2116
        }
2117
    }
2118
}
2119

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

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

    
2128
    quant_matrix = s->inter_matrix;
2129
    for(i=0; i<=nCoeffs; i++) {
2130
        int j= s->intra_scantable.permutated[i];
2131
        level = block[j];
2132
        if (level) {
2133
            if (level < 0) {
2134
                level = -level;
2135
                level = (((level << 1) + 1) * qscale *
2136
                         ((int) (quant_matrix[j]))) >> 4;
2137
                level = (level - 1) | 1;
2138
                level = -level;
2139
            } else {
2140
                level = (((level << 1) + 1) * qscale *
2141
                         ((int) (quant_matrix[j]))) >> 4;
2142
                level = (level - 1) | 1;
2143
            }
2144
            block[j] = level;
2145
        }
2146
    }
2147
}
2148

    
2149
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2150
                                   DCTELEM *block, int n, int qscale)
2151
{
2152
    int i, level, nCoeffs;
2153
    const uint16_t *quant_matrix;
2154

    
2155
    if(s->alternate_scan) nCoeffs= 63;
2156
    else nCoeffs= s->block_last_index[n];
2157

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

    
2179
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2180
                                   DCTELEM *block, int n, int qscale)
2181
{
2182
    int i, level, nCoeffs;
2183
    const uint16_t *quant_matrix;
2184
    int sum=-1;
2185

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

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

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

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

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

    
2243
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2244
                                  DCTELEM *block, int n, int qscale)
2245
{
2246
    int i, level, qmul, qadd;
2247
    int nCoeffs;
2248

    
2249
    assert(s->block_last_index[n]>=0);
2250

    
2251
    qmul = qscale << 1;
2252

    
2253
    if (!s->h263_aic) {
2254
        if (n < 4)
2255
            block[0] = block[0] * s->y_dc_scale;
2256
        else
2257
            block[0] = block[0] * s->c_dc_scale;
2258
        qadd = (qscale - 1) | 1;
2259
    }else{
2260
        qadd = 0;
2261
    }
2262
    if(s->ac_pred)
2263
        nCoeffs=63;
2264
    else
2265
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2266

    
2267
    for(i=1; i<=nCoeffs; i++) {
2268
        level = block[i];
2269
        if (level) {
2270
            if (level < 0) {
2271
                level = level * qmul - qadd;
2272
            } else {
2273
                level = level * qmul + qadd;
2274
            }
2275
            block[i] = level;
2276
        }
2277
    }
2278
}
2279

    
2280
static void dct_unquantize_h263_inter_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
    qadd = (qscale - 1) | 1;
2289
    qmul = qscale << 1;
2290

    
2291
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2292

    
2293
    for(i=0; i<=nCoeffs; i++) {
2294
        level = block[i];
2295
        if (level) {
2296
            if (level < 0) {
2297
                level = level * qmul - qadd;
2298
            } else {
2299
                level = level * qmul + qadd;
2300
            }
2301
            block[i] = level;
2302
        }
2303
    }
2304
}
2305

    
2306
/**
2307
 * set qscale and update qscale dependent variables.
2308
 */
2309
void ff_set_qscale(MpegEncContext * s, int qscale)
2310
{
2311
    if (qscale < 1)
2312
        qscale = 1;
2313
    else if (qscale > 31)
2314
        qscale = 31;
2315

    
2316
    s->qscale = qscale;
2317
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2318

    
2319
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2320
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2321
}