Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 5d6c5dd3

History | View | Annotate | Download (99 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
27
 * The simplest mpeg encoder (well, it was the simplest!).
28
 */
29

    
30
#include "libavutil/intmath.h"
31
#include "libavutil/imgutils.h"
32
#include "avcodec.h"
33
#include "dsputil.h"
34
#include "internal.h"
35
#include "mpegvideo.h"
36
#include "mpegvideo_common.h"
37
#include "mjpegenc.h"
38
#include "msmpeg4.h"
39
#include "faandct.h"
40
#include "xvmc_internal.h"
41
#include "thread.h"
42
#include <limits.h>
43

    
44
//#undef NDEBUG
45
//#include <assert.h>
46

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

    
62

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

    
66
//#define DEBUG
67

    
68

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

    
74
const uint8_t ff_mpeg1_dc_scale_table[128]={
75
//  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
76
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79
    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,
80
};
81

    
82
static const uint8_t mpeg2_dc_scale_table1[128]={
83
//  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
84
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88
};
89

    
90
static const uint8_t mpeg2_dc_scale_table2[128]={
91
//  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
92
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
96
};
97

    
98
static const uint8_t mpeg2_dc_scale_table3[128]={
99
//  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
100
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
102
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
103
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
104
};
105

    
106
const uint8_t * const ff_mpeg2_dc_scale_table[4]={
107
    ff_mpeg1_dc_scale_table,
108
    mpeg2_dc_scale_table1,
109
    mpeg2_dc_scale_table2,
110
    mpeg2_dc_scale_table3,
111
};
112

    
113
const enum PixelFormat ff_pixfmt_list_420[] = {
114
    PIX_FMT_YUV420P,
115
    PIX_FMT_NONE
116
};
117

    
118
const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
119
    PIX_FMT_DXVA2_VLD,
120
    PIX_FMT_VAAPI_VLD,
121
    PIX_FMT_YUV420P,
122
    PIX_FMT_NONE
123
};
124

    
125
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
126
    int i;
127

    
128
    assert(p<=end);
129
    if(p>=end)
130
        return end;
131

    
132
    for(i=0; i<3; i++){
133
        uint32_t tmp= *state << 8;
134
        *state= tmp + *(p++);
135
        if(tmp == 0x100 || p==end)
136
            return p;
137
    }
138

    
139
    while(p<end){
140
        if     (p[-1] > 1      ) p+= 3;
141
        else if(p[-2]          ) p+= 2;
142
        else if(p[-3]|(p[-1]-1)) p++;
143
        else{
144
            p++;
145
            break;
146
        }
147
    }
148

    
149
    p= FFMIN(p, end)-4;
150
    *state= AV_RB32(p);
151

    
152
    return p+4;
153
}
154

    
155
/* init common dct for both encoder and decoder */
156
av_cold int ff_dct_common_init(MpegEncContext *s)
157
{
158
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
159
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
160
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
161
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
162
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
163
    if(s->flags & CODEC_FLAG_BITEXACT)
164
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
165
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
166

    
167
#if   HAVE_MMX
168
    MPV_common_init_mmx(s);
169
#elif ARCH_ALPHA
170
    MPV_common_init_axp(s);
171
#elif CONFIG_MLIB
172
    MPV_common_init_mlib(s);
173
#elif HAVE_MMI
174
    MPV_common_init_mmi(s);
175
#elif ARCH_ARM
176
    MPV_common_init_arm(s);
177
#elif HAVE_ALTIVEC
178
    MPV_common_init_altivec(s);
179
#elif ARCH_BFIN
180
    MPV_common_init_bfin(s);
181
#endif
182

    
183
    /* load & permutate scantables
184
       note: only wmv uses different ones
185
    */
186
    if(s->alternate_scan){
187
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
188
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
189
    }else{
190
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
191
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
192
    }
193
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
194
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
195

    
196
    return 0;
197
}
198

    
199
void ff_copy_picture(Picture *dst, Picture *src){
200
    *dst = *src;
201
    dst->type= FF_BUFFER_TYPE_COPY;
202
}
203

    
204
/**
205
 * Release a frame buffer
206
 */
207
static void free_frame_buffer(MpegEncContext *s, Picture *pic)
208
{
209
    ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
210
    av_freep(&pic->hwaccel_picture_private);
211
}
212

    
213
/**
214
 * Allocate a frame buffer
215
 */
216
static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
217
{
218
    int r;
219

    
220
    if (s->avctx->hwaccel) {
221
        assert(!pic->hwaccel_picture_private);
222
        if (s->avctx->hwaccel->priv_data_size) {
223
            pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
224
            if (!pic->hwaccel_picture_private) {
225
                av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
226
                return -1;
227
            }
228
        }
229
    }
230

    
231
    r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
232

    
233
    if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
234
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
235
        av_freep(&pic->hwaccel_picture_private);
236
        return -1;
237
    }
238

    
239
    if (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])) {
240
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
241
        free_frame_buffer(s, pic);
242
        return -1;
243
    }
244

    
245
    if (pic->linesize[1] != pic->linesize[2]) {
246
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
247
        free_frame_buffer(s, pic);
248
        return -1;
249
    }
250

    
251
    return 0;
252
}
253

    
254
/**
255
 * allocates a Picture
256
 * The pixels are allocated/set by calling get_buffer() if shared=0
257
 */
258
int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
259
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
260
    const int mb_array_size= s->mb_stride*s->mb_height;
261
    const int b8_array_size= s->b8_stride*s->mb_height*2;
262
    const int b4_array_size= s->b4_stride*s->mb_height*4;
263
    int i;
264
    int r= -1;
265

    
266
    if(shared){
267
        assert(pic->data[0]);
268
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
269
        pic->type= FF_BUFFER_TYPE_SHARED;
270
    }else{
271
        assert(!pic->data[0]);
272

    
273
        if (alloc_frame_buffer(s, pic) < 0)
274
            return -1;
275

    
276
        s->linesize  = pic->linesize[0];
277
        s->uvlinesize= pic->linesize[1];
278
    }
279

    
280
    if(pic->qscale_table==NULL){
281
        if (s->encoding) {
282
            FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var   , mb_array_size * sizeof(int16_t)  , fail)
283
            FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t)  , fail)
284
            FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean  , mb_array_size * sizeof(int8_t )  , fail)
285
        }
286

    
287
        FF_ALLOCZ_OR_GOTO(s->avctx, pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2, fail) //the +2 is for the slice end check
288
        FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table , mb_array_size * sizeof(uint8_t)  , fail)
289
        FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
290
        pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
291
        if(s->out_format == FMT_H264){
292
            for(i=0; i<2; i++){
293
                FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t), fail)
294
                pic->motion_val[i]= pic->motion_val_base[i]+4;
295
                FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
296
            }
297
            pic->motion_subsample_log2= 2;
298
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
299
            for(i=0; i<2; i++){
300
                FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
301
                pic->motion_val[i]= pic->motion_val_base[i]+4;
302
                FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
303
            }
304
            pic->motion_subsample_log2= 3;
305
        }
306
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
307
            FF_ALLOCZ_OR_GOTO(s->avctx, pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6, fail)
308
        }
309
        pic->qstride= s->mb_stride;
310
        FF_ALLOCZ_OR_GOTO(s->avctx, pic->pan_scan , 1 * sizeof(AVPanScan), fail)
311
    }
312

    
313
    /* It might be nicer if the application would keep track of these
314
     * but it would require an API change. */
315
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
316
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
317
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
318
        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.
319

    
320
    return 0;
321
fail: //for the FF_ALLOCZ_OR_GOTO macro
322
    if(r>=0)
323
        free_frame_buffer(s, pic);
324
    return -1;
325
}
326

    
327
/**
328
 * deallocates a picture
329
 */
330
static void free_picture(MpegEncContext *s, Picture *pic){
331
    int i;
332

    
333
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
334
        free_frame_buffer(s, pic);
335
    }
336

    
337
    av_freep(&pic->mb_var);
338
    av_freep(&pic->mc_mb_var);
339
    av_freep(&pic->mb_mean);
340
    av_freep(&pic->mbskip_table);
341
    av_freep(&pic->qscale_table);
342
    av_freep(&pic->mb_type_base);
343
    av_freep(&pic->dct_coeff);
344
    av_freep(&pic->pan_scan);
345
    pic->mb_type= NULL;
346
    for(i=0; i<2; i++){
347
        av_freep(&pic->motion_val_base[i]);
348
        av_freep(&pic->ref_index[i]);
349
    }
350

    
351
    if(pic->type == FF_BUFFER_TYPE_SHARED){
352
        for(i=0; i<4; i++){
353
            pic->base[i]=
354
            pic->data[i]= NULL;
355
        }
356
        pic->type= 0;
357
    }
358
}
359

    
360
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
361
    int y_size = s->b8_stride * (2 * s->mb_height + 1);
362
    int c_size = s->mb_stride * (s->mb_height + 1);
363
    int yc_size = y_size + 2 * c_size;
364
    int i;
365

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

    
370
     //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
371
    FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t), fail)
372
    s->me.temp=         s->me.scratchpad;
373
    s->rd_scratchpad=   s->me.scratchpad;
374
    s->b_scratchpad=    s->me.scratchpad;
375
    s->obmc_scratchpad= s->me.scratchpad + 16;
376
    if (s->encoding) {
377
        FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map      , ME_MAP_SIZE*sizeof(uint32_t), fail)
378
        FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
379
        if(s->avctx->noise_reduction){
380
            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
381
        }
382
    }
383
    FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
384
    s->block= s->blocks[0];
385

    
386
    for(i=0;i<12;i++){
387
        s->pblocks[i] = &s->block[i];
388
    }
389

    
390
    if (s->out_format == FMT_H263) {
391
        /* ac values */
392
        FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
393
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
394
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
395
        s->ac_val[2] = s->ac_val[1] + c_size;
396
    }
397

    
398
    return 0;
399
fail:
400
    return -1; //free() through MPV_common_end()
401
}
402

    
403
static void free_duplicate_context(MpegEncContext *s){
404
    if(s==NULL) return;
405

    
406
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
407
    av_freep(&s->me.scratchpad);
408
    s->me.temp=
409
    s->rd_scratchpad=
410
    s->b_scratchpad=
411
    s->obmc_scratchpad= NULL;
412

    
413
    av_freep(&s->dct_error_sum);
414
    av_freep(&s->me.map);
415
    av_freep(&s->me.score_map);
416
    av_freep(&s->blocks);
417
    av_freep(&s->ac_val_base);
418
    s->block= NULL;
419
}
420

    
421
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
422
#define COPY(a) bak->a= src->a
423
    COPY(allocated_edge_emu_buffer);
424
    COPY(edge_emu_buffer);
425
    COPY(me.scratchpad);
426
    COPY(me.temp);
427
    COPY(rd_scratchpad);
428
    COPY(b_scratchpad);
429
    COPY(obmc_scratchpad);
430
    COPY(me.map);
431
    COPY(me.score_map);
432
    COPY(blocks);
433
    COPY(block);
434
    COPY(start_mb_y);
435
    COPY(end_mb_y);
436
    COPY(me.map_generation);
437
    COPY(pb);
438
    COPY(dct_error_sum);
439
    COPY(dct_count[0]);
440
    COPY(dct_count[1]);
441
    COPY(ac_val_base);
442
    COPY(ac_val[0]);
443
    COPY(ac_val[1]);
444
    COPY(ac_val[2]);
445
#undef COPY
446
}
447

    
448
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
449
    MpegEncContext bak;
450
    int i;
451
    //FIXME copy only needed parts
452
//START_TIMER
453
    backup_duplicate_context(&bak, dst);
454
    memcpy(dst, src, sizeof(MpegEncContext));
455
    backup_duplicate_context(dst, &bak);
456
    for(i=0;i<12;i++){
457
        dst->pblocks[i] = &dst->block[i];
458
    }
459
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
460
}
461

    
462
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
463
{
464
    MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
465

    
466
    if(dst == src || !s1->context_initialized) return 0;
467

    
468
    //FIXME can parameters change on I-frames? in that case dst may need a reinit
469
    if(!s->context_initialized){
470
        memcpy(s, s1, sizeof(MpegEncContext));
471

    
472
        s->avctx                 = dst;
473
        s->picture_range_start  += MAX_PICTURE_COUNT;
474
        s->picture_range_end    += MAX_PICTURE_COUNT;
475
        s->bitstream_buffer      = NULL;
476
        s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
477

    
478
        MPV_common_init(s);
479
    }
480

    
481
    s->avctx->coded_height  = s1->avctx->coded_height;
482
    s->avctx->coded_width   = s1->avctx->coded_width;
483
    s->avctx->width         = s1->avctx->width;
484
    s->avctx->height        = s1->avctx->height;
485

    
486
    s->coded_picture_number = s1->coded_picture_number;
487
    s->picture_number       = s1->picture_number;
488
    s->input_picture_number = s1->input_picture_number;
489

    
490
    memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
491
    memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
492

    
493
    s->last_picture_ptr     = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
494
    s->current_picture_ptr  = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
495
    s->next_picture_ptr     = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
496

    
497
    memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
498

    
499
    //Error/bug resilience
500
    s->next_p_frame_damaged = s1->next_p_frame_damaged;
501
    s->workaround_bugs      = s1->workaround_bugs;
502

    
503
    //MPEG4 timing info
504
    memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
505

    
506
    //B-frame info
507
    s->max_b_frames         = s1->max_b_frames;
508
    s->low_delay            = s1->low_delay;
509
    s->dropable             = s1->dropable;
510

    
511
    //DivX handling (doesn't work)
512
    s->divx_packed          = s1->divx_packed;
513

    
514
    if(s1->bitstream_buffer){
515
        if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
516
            av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
517
        s->bitstream_buffer_size  = s1->bitstream_buffer_size;
518
        memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
519
        memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
520
    }
521

    
522
    //MPEG2/interlacing info
523
    memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
524

    
525
    if(!s1->first_field){
526
        s->last_pict_type= s1->pict_type;
527
        if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality;
528

    
529
        if(s1->pict_type!=FF_B_TYPE){
530
            s->last_non_b_pict_type= s1->pict_type;
531
        }
532
    }
533

    
534
    return 0;
535
}
536

    
537
/**
538
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
539
 * the changed fields will not depend upon the prior state of the MpegEncContext.
540
 */
541
void MPV_common_defaults(MpegEncContext *s){
542
    s->y_dc_scale_table=
543
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
544
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
545
    s->progressive_frame= 1;
546
    s->progressive_sequence= 1;
547
    s->picture_structure= PICT_FRAME;
548

    
549
    s->coded_picture_number = 0;
550
    s->picture_number = 0;
551
    s->input_picture_number = 0;
552

    
553
    s->picture_in_gop_number = 0;
554

    
555
    s->f_code = 1;
556
    s->b_code = 1;
557

    
558
    s->picture_range_start = 0;
559
    s->picture_range_end = MAX_PICTURE_COUNT;
560
}
561

    
562
/**
563
 * sets the given MpegEncContext to defaults for decoding.
564
 * the changed fields will not depend upon the prior state of the MpegEncContext.
565
 */
566
void MPV_decode_defaults(MpegEncContext *s){
567
    MPV_common_defaults(s);
568
}
569

    
570
/**
571
 * init common structure for both encoder and decoder.
572
 * this assumes that some variables like width/height are already set
573
 */
574
av_cold int MPV_common_init(MpegEncContext *s)
575
{
576
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
577

    
578
    if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
579
        s->mb_height = (s->height + 31) / 32 * 2;
580
    else if (s->codec_id != CODEC_ID_H264)
581
        s->mb_height = (s->height + 15) / 16;
582

    
583
    if(s->avctx->pix_fmt == PIX_FMT_NONE){
584
        av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
585
        return -1;
586
    }
587

    
588
    if(s->avctx->active_thread_type&FF_THREAD_SLICE &&
589
       (s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
590
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
591
        return -1;
592
    }
593

    
594
    if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
595
        return -1;
596

    
597
    dsputil_init(&s->dsp, s->avctx);
598
    ff_dct_common_init(s);
599

    
600
    s->flags= s->avctx->flags;
601
    s->flags2= s->avctx->flags2;
602

    
603
    s->mb_width  = (s->width  + 15) / 16;
604
    s->mb_stride = s->mb_width + 1;
605
    s->b8_stride = s->mb_width*2 + 1;
606
    s->b4_stride = s->mb_width*4 + 1;
607
    mb_array_size= s->mb_height * s->mb_stride;
608
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
609

    
610
    /* set chroma shifts */
611
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
612
                                                    &(s->chroma_y_shift) );
613

    
614
    /* set default edge pos, will be overriden in decode_header if needed */
615
    s->h_edge_pos= s->mb_width*16;
616
    s->v_edge_pos= s->mb_height*16;
617

    
618
    s->mb_num = s->mb_width * s->mb_height;
619

    
620
    s->block_wrap[0]=
621
    s->block_wrap[1]=
622
    s->block_wrap[2]=
623
    s->block_wrap[3]= s->b8_stride;
624
    s->block_wrap[4]=
625
    s->block_wrap[5]= s->mb_stride;
626

    
627
    y_size = s->b8_stride * (2 * s->mb_height + 1);
628
    c_size = s->mb_stride * (s->mb_height + 1);
629
    yc_size = y_size + 2 * c_size;
630

    
631
    /* convert fourcc to upper case */
632
    s->codec_tag = ff_toupper4(s->avctx->codec_tag);
633

    
634
    s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
635

    
636
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
637

    
638
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
639
    for(y=0; y<s->mb_height; y++){
640
        for(x=0; x<s->mb_width; x++){
641
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
642
        }
643
    }
644
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
645

    
646
    if (s->encoding) {
647
        /* Allocate MV tables */
648
        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t), fail)
649
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
650
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
651
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
652
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
653
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t), fail)
654
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
655
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
656
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
657
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
658
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
659
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
660

    
661
        if(s->msmpeg4_version){
662
            FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
663
        }
664
        FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
665

    
666
        /* Allocate MB type table */
667
        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type  , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
668

    
669
        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
670

    
671
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix  , 64*32   * sizeof(int), fail)
672
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix  , 64*32   * sizeof(int), fail)
673
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
674
        FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
675
        FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
676
        FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
677

    
678
        if(s->avctx->noise_reduction){
679
            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
680
        }
681
    }
682
    s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
683
    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
684
    for(i = 0; i < s->picture_count; i++) {
685
        avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
686
    }
687

    
688
    FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
689

    
690
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
691
        /* interlaced direct mode decoding tables */
692
            for(i=0; i<2; i++){
693
                int j, k;
694
                for(j=0; j<2; j++){
695
                    for(k=0; k<2; k++){
696
                        FF_ALLOCZ_OR_GOTO(s->avctx,    s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
697
                        s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
698
                    }
699
                    FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
700
                    FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
701
                    s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
702
                }
703
                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
704
            }
705
    }
706
    if (s->out_format == FMT_H263) {
707
        /* cbp values */
708
        FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
709
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
710

    
711
        /* cbp, ac_pred, pred_dir */
712
        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail)
713
        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
714
    }
715

    
716
    if (s->h263_pred || s->h263_plus || !s->encoding) {
717
        /* dc values */
718
        //MN: we need these for error resilience of intra-frames
719
        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
720
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
721
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
722
        s->dc_val[2] = s->dc_val[1] + c_size;
723
        for(i=0;i<yc_size;i++)
724
            s->dc_val_base[i] = 1024;
725
    }
726

    
727
    /* which mb is a intra block */
728
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
729
    memset(s->mbintra_table, 1, mb_array_size);
730

    
731
    /* init macroblock skip table */
732
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
733
    //Note the +1 is for a quicker mpeg4 slice_end detection
734
    FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
735

    
736
    s->parse_context.state= -1;
737
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
738
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
739
       s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
740
       s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
741
    }
742

    
743
    s->context_initialized = 1;
744
    s->thread_context[0]= s;
745

    
746
    if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
747
        threads = s->avctx->thread_count;
748

    
749
        for(i=1; i<threads; i++){
750
            s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
751
            memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
752
        }
753

    
754
        for(i=0; i<threads; i++){
755
            if(init_duplicate_context(s->thread_context[i], s) < 0)
756
               goto fail;
757
            s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
758
            s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
759
        }
760
    } else {
761
        if(init_duplicate_context(s, s) < 0) goto fail;
762
        s->start_mb_y = 0;
763
        s->end_mb_y   = s->mb_height;
764
    }
765

    
766
    return 0;
767
 fail:
768
    MPV_common_end(s);
769
    return -1;
770
}
771

    
772
/* init common structure for both encoder and decoder */
773
void MPV_common_end(MpegEncContext *s)
774
{
775
    int i, j, k;
776

    
777
    if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
778
        for(i=0; i<s->avctx->thread_count; i++){
779
            free_duplicate_context(s->thread_context[i]);
780
        }
781
        for(i=1; i<s->avctx->thread_count; i++){
782
            av_freep(&s->thread_context[i]);
783
        }
784
    } else free_duplicate_context(s);
785

    
786
    av_freep(&s->parse_context.buffer);
787
    s->parse_context.buffer_size=0;
788

    
789
    av_freep(&s->mb_type);
790
    av_freep(&s->p_mv_table_base);
791
    av_freep(&s->b_forw_mv_table_base);
792
    av_freep(&s->b_back_mv_table_base);
793
    av_freep(&s->b_bidir_forw_mv_table_base);
794
    av_freep(&s->b_bidir_back_mv_table_base);
795
    av_freep(&s->b_direct_mv_table_base);
796
    s->p_mv_table= NULL;
797
    s->b_forw_mv_table= NULL;
798
    s->b_back_mv_table= NULL;
799
    s->b_bidir_forw_mv_table= NULL;
800
    s->b_bidir_back_mv_table= NULL;
801
    s->b_direct_mv_table= NULL;
802
    for(i=0; i<2; i++){
803
        for(j=0; j<2; j++){
804
            for(k=0; k<2; k++){
805
                av_freep(&s->b_field_mv_table_base[i][j][k]);
806
                s->b_field_mv_table[i][j][k]=NULL;
807
            }
808
            av_freep(&s->b_field_select_table[i][j]);
809
            av_freep(&s->p_field_mv_table_base[i][j]);
810
            s->p_field_mv_table[i][j]=NULL;
811
        }
812
        av_freep(&s->p_field_select_table[i]);
813
    }
814

    
815
    av_freep(&s->dc_val_base);
816
    av_freep(&s->coded_block_base);
817
    av_freep(&s->mbintra_table);
818
    av_freep(&s->cbp_table);
819
    av_freep(&s->pred_dir_table);
820

    
821
    av_freep(&s->mbskip_table);
822
    av_freep(&s->prev_pict_types);
823
    av_freep(&s->bitstream_buffer);
824
    s->allocated_bitstream_buffer_size=0;
825

    
826
    av_freep(&s->avctx->stats_out);
827
    av_freep(&s->ac_stats);
828
    av_freep(&s->error_status_table);
829
    av_freep(&s->mb_index2xy);
830
    av_freep(&s->lambda_table);
831
    av_freep(&s->q_intra_matrix);
832
    av_freep(&s->q_inter_matrix);
833
    av_freep(&s->q_intra_matrix16);
834
    av_freep(&s->q_inter_matrix16);
835
    av_freep(&s->input_picture);
836
    av_freep(&s->reordered_input_picture);
837
    av_freep(&s->dct_offset);
838

    
839
    if(s->picture && !s->avctx->is_copy){
840
        for(i=0; i<s->picture_count; i++){
841
            free_picture(s, &s->picture[i]);
842
        }
843
    }
844
    av_freep(&s->picture);
845
    s->context_initialized = 0;
846
    s->last_picture_ptr=
847
    s->next_picture_ptr=
848
    s->current_picture_ptr= NULL;
849
    s->linesize= s->uvlinesize= 0;
850

    
851
    for(i=0; i<3; i++)
852
        av_freep(&s->visualization_buffer[i]);
853

    
854
    if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
855
        avcodec_default_free_buffers(s->avctx);
856
}
857

    
858
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
859
{
860
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
861
    uint8_t index_run[MAX_RUN+1];
862
    int last, run, level, start, end, i;
863

    
864
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
865
    if(static_store && rl->max_level[0])
866
        return;
867

    
868
    /* compute max_level[], max_run[] and index_run[] */
869
    for(last=0;last<2;last++) {
870
        if (last == 0) {
871
            start = 0;
872
            end = rl->last;
873
        } else {
874
            start = rl->last;
875
            end = rl->n;
876
        }
877

    
878
        memset(max_level, 0, MAX_RUN + 1);
879
        memset(max_run, 0, MAX_LEVEL + 1);
880
        memset(index_run, rl->n, MAX_RUN + 1);
881
        for(i=start;i<end;i++) {
882
            run = rl->table_run[i];
883
            level = rl->table_level[i];
884
            if (index_run[run] == rl->n)
885
                index_run[run] = i;
886
            if (level > max_level[run])
887
                max_level[run] = level;
888
            if (run > max_run[level])
889
                max_run[level] = run;
890
        }
891
        if(static_store)
892
            rl->max_level[last] = static_store[last];
893
        else
894
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
895
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
896
        if(static_store)
897
            rl->max_run[last] = static_store[last] + MAX_RUN + 1;
898
        else
899
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
900
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
901
        if(static_store)
902
            rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
903
        else
904
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
905
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
906
    }
907
}
908

    
909
void init_vlc_rl(RLTable *rl)
910
{
911
    int i, q;
912

    
913
    for(q=0; q<32; q++){
914
        int qmul= q*2;
915
        int qadd= (q-1)|1;
916

    
917
        if(q==0){
918
            qmul=1;
919
            qadd=0;
920
        }
921
        for(i=0; i<rl->vlc.table_size; i++){
922
            int code= rl->vlc.table[i][0];
923
            int len = rl->vlc.table[i][1];
924
            int level, run;
925

    
926
            if(len==0){ // illegal code
927
                run= 66;
928
                level= MAX_LEVEL;
929
            }else if(len<0){ //more bits needed
930
                run= 0;
931
                level= code;
932
            }else{
933
                if(code==rl->n){ //esc
934
                    run= 66;
935
                    level= 0;
936
                }else{
937
                    run=   rl->table_run  [code] + 1;
938
                    level= rl->table_level[code] * qmul + qadd;
939
                    if(code >= rl->last) run+=192;
940
                }
941
            }
942
            rl->rl_vlc[q][i].len= len;
943
            rl->rl_vlc[q][i].level= level;
944
            rl->rl_vlc[q][i].run= run;
945
        }
946
    }
947
}
948

    
949
int ff_find_unused_picture(MpegEncContext *s, int shared){
950
    int i;
951

    
952
    if(shared){
953
        for(i=s->picture_range_start; i<s->picture_range_end; i++){
954
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
955
        }
956
    }else{
957
        for(i=s->picture_range_start; i<s->picture_range_end; i++){
958
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
959
        }
960
        for(i=s->picture_range_start; i<s->picture_range_end; i++){
961
            if(s->picture[i].data[0]==NULL) return i;
962
        }
963
    }
964

    
965
    av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
966
    /* We could return -1, but the codec would crash trying to draw into a
967
     * non-existing frame anyway. This is safer than waiting for a random crash.
968
     * Also the return of this is never useful, an encoder must only allocate
969
     * as much as allowed in the specification. This has no relationship to how
970
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
971
     * enough for such valid streams).
972
     * Plus, a decoder has to check stream validity and remove frames if too
973
     * many reference frames are around. Waiting for "OOM" is not correct at
974
     * all. Similarly, missing reference frames have to be replaced by
975
     * interpolated/MC frames, anything else is a bug in the codec ...
976
     */
977
    abort();
978
    return -1;
979
}
980

    
981
static void update_noise_reduction(MpegEncContext *s){
982
    int intra, i;
983

    
984
    for(intra=0; intra<2; intra++){
985
        if(s->dct_count[intra] > (1<<16)){
986
            for(i=0; i<64; i++){
987
                s->dct_error_sum[intra][i] >>=1;
988
            }
989
            s->dct_count[intra] >>= 1;
990
        }
991

    
992
        for(i=0; i<64; i++){
993
            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);
994
        }
995
    }
996
}
997

    
998
/**
999
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1000
 */
1001
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1002
{
1003
    int i;
1004
    Picture *pic;
1005
    s->mb_skipped = 0;
1006

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

    
1009
    /* mark&release old frames */
1010
    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]) {
1011
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1012
          free_frame_buffer(s, s->last_picture_ptr);
1013

    
1014
        /* release forgotten pictures */
1015
        /* if(mpeg124/h263) */
1016
        if(!s->encoding){
1017
            for(i=0; i<s->picture_count; i++){
1018
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1019
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1020
                    free_frame_buffer(s, &s->picture[i]);
1021
                }
1022
            }
1023
        }
1024
      }
1025
    }
1026

    
1027
    if(!s->encoding){
1028
        /* release non reference frames */
1029
        for(i=0; i<s->picture_count; i++){
1030
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1031
                free_frame_buffer(s, &s->picture[i]);
1032
            }
1033
        }
1034

    
1035
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1036
            pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1037
        else{
1038
            i= ff_find_unused_picture(s, 0);
1039
            pic= &s->picture[i];
1040
        }
1041

    
1042
        pic->reference= 0;
1043
        if (!s->dropable){
1044
            if (s->codec_id == CODEC_ID_H264)
1045
                pic->reference = s->picture_structure;
1046
            else if (s->pict_type != FF_B_TYPE)
1047
                pic->reference = 3;
1048
        }
1049

    
1050
        pic->coded_picture_number= s->coded_picture_number++;
1051

    
1052
        if(ff_alloc_picture(s, pic, 0) < 0)
1053
            return -1;
1054

    
1055
        s->current_picture_ptr= pic;
1056
        //FIXME use only the vars from current_pic
1057
        s->current_picture_ptr->top_field_first= s->top_field_first;
1058
        if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1059
            if(s->picture_structure != PICT_FRAME)
1060
                s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1061
        }
1062
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1063
        s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1064
    }
1065

    
1066
    s->current_picture_ptr->pict_type= s->pict_type;
1067
//    if(s->flags && CODEC_FLAG_QSCALE)
1068
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1069
    s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
1070

    
1071
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1072

    
1073
    if (s->pict_type != FF_B_TYPE) {
1074
        s->last_picture_ptr= s->next_picture_ptr;
1075
        if(!s->dropable)
1076
            s->next_picture_ptr= s->current_picture_ptr;
1077
    }
1078
/*    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,
1079
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1080
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1081
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1082
        s->pict_type, s->dropable);*/
1083

    
1084
    if(s->codec_id != CODEC_ID_H264){
1085
        if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && s->pict_type!=FF_I_TYPE){
1086
            av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1087
            /* Allocate a dummy frame */
1088
            i= ff_find_unused_picture(s, 0);
1089
            s->last_picture_ptr= &s->picture[i];
1090
            if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1091
                return -1;
1092
            ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1093
            ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1094
        }
1095
        if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
1096
            /* Allocate a dummy frame */
1097
            i= ff_find_unused_picture(s, 0);
1098
            s->next_picture_ptr= &s->picture[i];
1099
            if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1100
                return -1;
1101
            ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1102
            ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1103
        }
1104
    }
1105

    
1106
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1107
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1108

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

    
1111
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1112
        int i;
1113
        for(i=0; i<4; i++){
1114
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1115
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1116
            }
1117
            s->current_picture.linesize[i] *= 2;
1118
            s->last_picture.linesize[i] *=2;
1119
            s->next_picture.linesize[i] *=2;
1120
        }
1121
    }
1122

    
1123
    s->hurry_up= s->avctx->hurry_up;
1124
    s->error_recognition= avctx->error_recognition;
1125

    
1126
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1127
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
1128
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1129
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1130
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1131
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1132
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1133
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1134
    }else{
1135
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1136
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1137
    }
1138

    
1139
    if(s->dct_error_sum){
1140
        assert(s->avctx->noise_reduction && s->encoding);
1141

    
1142
        update_noise_reduction(s);
1143
    }
1144

    
1145
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1146
        return ff_xvmc_field_start(s, avctx);
1147

    
1148
    return 0;
1149
}
1150

    
1151
/* generic function for encode/decode called after a frame has been coded/decoded */
1152
void MPV_frame_end(MpegEncContext *s)
1153
{
1154
    int i;
1155
    /* redraw edges for the frame if decoding didn't complete */
1156
    //just to make sure that all data is rendered.
1157
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1158
        ff_xvmc_field_end(s);
1159
   }else if((s->error_count || s->encoding)
1160
       && !s->avctx->hwaccel
1161
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1162
       && s->unrestricted_mv
1163
       && s->current_picture.reference
1164
       && !s->intra_only
1165
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1166
        int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos;
1167

    
1168
            s->dsp.draw_edges(s->current_picture_ptr->data[0], s->linesize  , s->h_edge_pos   , h   , EDGE_WIDTH  , edges);
1169
            s->dsp.draw_edges(s->current_picture_ptr->data[1], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1170
            s->dsp.draw_edges(s->current_picture_ptr->data[2], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1171

    
1172
    }
1173

    
1174
    emms_c();
1175

    
1176
    s->last_pict_type    = s->pict_type;
1177
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1178
    if(s->pict_type!=FF_B_TYPE){
1179
        s->last_non_b_pict_type= s->pict_type;
1180
    }
1181
#if 0
1182
        /* copy back current_picture variables */
1183
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1184
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1185
            s->picture[i]= s->current_picture;
1186
            break;
1187
        }
1188
    }
1189
    assert(i<MAX_PICTURE_COUNT);
1190
#endif
1191

    
1192
    if(s->encoding){
1193
        /* release non-reference frames */
1194
        for(i=0; i<s->picture_count; i++){
1195
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1196
                free_frame_buffer(s, &s->picture[i]);
1197
            }
1198
        }
1199
    }
1200
    // clear copies, to avoid confusion
1201
#if 0
1202
    memset(&s->last_picture, 0, sizeof(Picture));
1203
    memset(&s->next_picture, 0, sizeof(Picture));
1204
    memset(&s->current_picture, 0, sizeof(Picture));
1205
#endif
1206
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1207

    
1208
    if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1209
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1210
    }
1211
}
1212

    
1213
/**
1214
 * draws an line from (ex, ey) -> (sx, sy).
1215
 * @param w width of the image
1216
 * @param h height of the image
1217
 * @param stride stride/linesize of the image
1218
 * @param color color of the arrow
1219
 */
1220
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1221
    int x, y, fr, f;
1222

    
1223
    sx= av_clip(sx, 0, w-1);
1224
    sy= av_clip(sy, 0, h-1);
1225
    ex= av_clip(ex, 0, w-1);
1226
    ey= av_clip(ey, 0, h-1);
1227

    
1228
    buf[sy*stride + sx]+= color;
1229

    
1230
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1231
        if(sx > ex){
1232
            FFSWAP(int, sx, ex);
1233
            FFSWAP(int, sy, ey);
1234
        }
1235
        buf+= sx + sy*stride;
1236
        ex-= sx;
1237
        f= ((ey-sy)<<16)/ex;
1238
        for(x= 0; x <= ex; x++){
1239
            y = (x*f)>>16;
1240
            fr= (x*f)&0xFFFF;
1241
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1242
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1243
        }
1244
    }else{
1245
        if(sy > ey){
1246
            FFSWAP(int, sx, ex);
1247
            FFSWAP(int, sy, ey);
1248
        }
1249
        buf+= sx + sy*stride;
1250
        ey-= sy;
1251
        if(ey) f= ((ex-sx)<<16)/ey;
1252
        else   f= 0;
1253
        for(y= 0; y <= ey; y++){
1254
            x = (y*f)>>16;
1255
            fr= (y*f)&0xFFFF;
1256
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1257
            buf[y*stride + x+1]+= (color*         fr )>>16;
1258
        }
1259
    }
1260
}
1261

    
1262
/**
1263
 * draws an arrow from (ex, ey) -> (sx, sy).
1264
 * @param w width of the image
1265
 * @param h height of the image
1266
 * @param stride stride/linesize of the image
1267
 * @param color color of the arrow
1268
 */
1269
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1270
    int dx,dy;
1271

    
1272
    sx= av_clip(sx, -100, w+100);
1273
    sy= av_clip(sy, -100, h+100);
1274
    ex= av_clip(ex, -100, w+100);
1275
    ey= av_clip(ey, -100, h+100);
1276

    
1277
    dx= ex - sx;
1278
    dy= ey - sy;
1279

    
1280
    if(dx*dx + dy*dy > 3*3){
1281
        int rx=  dx + dy;
1282
        int ry= -dx + dy;
1283
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1284

    
1285
        //FIXME subpixel accuracy
1286
        rx= ROUNDED_DIV(rx*3<<4, length);
1287
        ry= ROUNDED_DIV(ry*3<<4, length);
1288

    
1289
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1290
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1291
    }
1292
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1293
}
1294

    
1295
/**
1296
 * prints debuging info for the given picture.
1297
 */
1298
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1299

    
1300
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1301

    
1302
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1303
        int x,y;
1304

    
1305
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1306
        switch (pict->pict_type) {
1307
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1308
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1309
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1310
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1311
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1312
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1313
        }
1314
        for(y=0; y<s->mb_height; y++){
1315
            for(x=0; x<s->mb_width; x++){
1316
                if(s->avctx->debug&FF_DEBUG_SKIP){
1317
                    int count= s->mbskip_table[x + y*s->mb_stride];
1318
                    if(count>9) count=9;
1319
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1320
                }
1321
                if(s->avctx->debug&FF_DEBUG_QP){
1322
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1323
                }
1324
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1325
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1326
                    //Type & MV direction
1327
                    if(IS_PCM(mb_type))
1328
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1329
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1330
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1331
                    else if(IS_INTRA4x4(mb_type))
1332
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1333
                    else if(IS_INTRA16x16(mb_type))
1334
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1335
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1336
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1337
                    else if(IS_DIRECT(mb_type))
1338
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1339
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1340
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1341
                    else if(IS_GMC(mb_type))
1342
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1343
                    else if(IS_SKIP(mb_type))
1344
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1345
                    else if(!USES_LIST(mb_type, 1))
1346
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1347
                    else if(!USES_LIST(mb_type, 0))
1348
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1349
                    else{
1350
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1351
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1352
                    }
1353

    
1354
                    //segmentation
1355
                    if(IS_8X8(mb_type))
1356
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1357
                    else if(IS_16X8(mb_type))
1358
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1359
                    else if(IS_8X16(mb_type))
1360
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1361
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1362
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1363
                    else
1364
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1365

    
1366

    
1367
                    if(IS_INTERLACED(mb_type))
1368
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1369
                    else
1370
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1371
                }
1372
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1373
            }
1374
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1375
        }
1376
    }
1377

    
1378
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1379
        const int shift= 1 + s->quarter_sample;
1380
        int mb_y;
1381
        uint8_t *ptr;
1382
        int i;
1383
        int h_chroma_shift, v_chroma_shift, block_height;
1384
        const int width = s->avctx->width;
1385
        const int height= s->avctx->height;
1386
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1387
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1388
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1389

    
1390
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1391
        for(i=0; i<3; i++){
1392
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1393
            pict->data[i]= s->visualization_buffer[i];
1394
        }
1395
        pict->type= FF_BUFFER_TYPE_COPY;
1396
        ptr= pict->data[0];
1397
        block_height = 16>>v_chroma_shift;
1398

    
1399
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1400
            int mb_x;
1401
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1402
                const int mb_index= mb_x + mb_y*s->mb_stride;
1403
                if((s->avctx->debug_mv) && pict->motion_val){
1404
                  int type;
1405
                  for(type=0; type<3; type++){
1406
                    int direction = 0;
1407
                    switch (type) {
1408
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1409
                                continue;
1410
                              direction = 0;
1411
                              break;
1412
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1413
                                continue;
1414
                              direction = 0;
1415
                              break;
1416
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1417
                                continue;
1418
                              direction = 1;
1419
                              break;
1420
                    }
1421
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1422
                        continue;
1423

    
1424
                    if(IS_8X8(pict->mb_type[mb_index])){
1425
                      int i;
1426
                      for(i=0; i<4; i++){
1427
                        int sx= mb_x*16 + 4 + 8*(i&1);
1428
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1429
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1430
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1431
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1432
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1433
                      }
1434
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1435
                      int i;
1436
                      for(i=0; i<2; i++){
1437
                        int sx=mb_x*16 + 8;
1438
                        int sy=mb_y*16 + 4 + 8*i;
1439
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1440
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1441
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1442

    
1443
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1444
                            my*=2;
1445

    
1446
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1447
                      }
1448
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1449
                      int i;
1450
                      for(i=0; i<2; i++){
1451
                        int sx=mb_x*16 + 4 + 8*i;
1452
                        int sy=mb_y*16 + 8;
1453
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1454
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1455
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1456

    
1457
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1458
                            my*=2;
1459

    
1460
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1461
                      }
1462
                    }else{
1463
                      int sx= mb_x*16 + 8;
1464
                      int sy= mb_y*16 + 8;
1465
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1466
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1467
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1468
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1469
                    }
1470
                  }
1471
                }
1472
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1473
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1474
                    int y;
1475
                    for(y=0; y<block_height; y++){
1476
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1477
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1478
                    }
1479
                }
1480
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1481
                    int mb_type= pict->mb_type[mb_index];
1482
                    uint64_t u,v;
1483
                    int y;
1484
#define COLOR(theta, r)\
1485
u= (int)(128 + r*cos(theta*3.141592/180));\
1486
v= (int)(128 + r*sin(theta*3.141592/180));
1487

    
1488

    
1489
                    u=v=128;
1490
                    if(IS_PCM(mb_type)){
1491
                        COLOR(120,48)
1492
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1493
                        COLOR(30,48)
1494
                    }else if(IS_INTRA4x4(mb_type)){
1495
                        COLOR(90,48)
1496
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1497
//                        COLOR(120,48)
1498
                    }else if(IS_DIRECT(mb_type)){
1499
                        COLOR(150,48)
1500
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1501
                        COLOR(170,48)
1502
                    }else if(IS_GMC(mb_type)){
1503
                        COLOR(190,48)
1504
                    }else if(IS_SKIP(mb_type)){
1505
//                        COLOR(180,48)
1506
                    }else if(!USES_LIST(mb_type, 1)){
1507
                        COLOR(240,48)
1508
                    }else if(!USES_LIST(mb_type, 0)){
1509
                        COLOR(0,48)
1510
                    }else{
1511
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1512
                        COLOR(300,48)
1513
                    }
1514

    
1515
                    u*= 0x0101010101010101ULL;
1516
                    v*= 0x0101010101010101ULL;
1517
                    for(y=0; y<block_height; y++){
1518
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1519
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1520
                    }
1521

    
1522
                    //segmentation
1523
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1524
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1525
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1526
                    }
1527
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1528
                        for(y=0; y<16; y++)
1529
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1530
                    }
1531
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1532
                        int dm= 1 << (mv_sample_log2-2);
1533
                        for(i=0; i<4; i++){
1534
                            int sx= mb_x*16 + 8*(i&1);
1535
                            int sy= mb_y*16 + 8*(i>>1);
1536
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1537
                            //FIXME bidir
1538
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1539
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1540
                                for(y=0; y<8; y++)
1541
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1542
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1543
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1544
                        }
1545
                    }
1546

    
1547
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1548
                        // hmm
1549
                    }
1550
                }
1551
                s->mbskip_table[mb_index]=0;
1552
            }
1553
        }
1554
    }
1555
}
1556

    
1557
static inline int hpel_motion_lowres(MpegEncContext *s,
1558
                                  uint8_t *dest, uint8_t *src,
1559
                                  int field_based, int field_select,
1560
                                  int src_x, int src_y,
1561
                                  int width, int height, int stride,
1562
                                  int h_edge_pos, int v_edge_pos,
1563
                                  int w, int h, h264_chroma_mc_func *pix_op,
1564
                                  int motion_x, int motion_y)
1565
{
1566
    const int lowres= s->avctx->lowres;
1567
    const int op_index= FFMIN(lowres, 2);
1568
    const int s_mask= (2<<lowres)-1;
1569
    int emu=0;
1570
    int sx, sy;
1571

    
1572
    if(s->quarter_sample){
1573
        motion_x/=2;
1574
        motion_y/=2;
1575
    }
1576

    
1577
    sx= motion_x & s_mask;
1578
    sy= motion_y & s_mask;
1579
    src_x += motion_x >> (lowres+1);
1580
    src_y += motion_y >> (lowres+1);
1581

    
1582
    src += src_y * stride + src_x;
1583

    
1584
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1585
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1586
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1587
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1588
        src= s->edge_emu_buffer;
1589
        emu=1;
1590
    }
1591

    
1592
    sx= (sx << 2) >> lowres;
1593
    sy= (sy << 2) >> lowres;
1594
    if(field_select)
1595
        src += s->linesize;
1596
    pix_op[op_index](dest, src, stride, h, sx, sy);
1597
    return emu;
1598
}
1599

    
1600
/* apply one mpeg motion vector to the three components */
1601
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1602
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1603
                               int field_based, int bottom_field, int field_select,
1604
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1605
                               int motion_x, int motion_y, int h, int mb_y)
1606
{
1607
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1608
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1609
    const int lowres= s->avctx->lowres;
1610
    const int op_index= FFMIN(lowres, 2);
1611
    const int block_s= 8>>lowres;
1612
    const int s_mask= (2<<lowres)-1;
1613
    const int h_edge_pos = s->h_edge_pos >> lowres;
1614
    const int v_edge_pos = s->v_edge_pos >> lowres;
1615
    linesize   = s->current_picture.linesize[0] << field_based;
1616
    uvlinesize = s->current_picture.linesize[1] << field_based;
1617

    
1618
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1619
        motion_x/=2;
1620
        motion_y/=2;
1621
    }
1622

    
1623
    if(field_based){
1624
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1625
    }
1626

    
1627
    sx= motion_x & s_mask;
1628
    sy= motion_y & s_mask;
1629
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1630
    src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1631

    
1632
    if (s->out_format == FMT_H263) {
1633
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1634
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1635
        uvsrc_x = src_x>>1;
1636
        uvsrc_y = src_y>>1;
1637
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1638
        mx = motion_x / 4;
1639
        my = motion_y / 4;
1640
        uvsx = (2*mx) & s_mask;
1641
        uvsy = (2*my) & s_mask;
1642
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1643
        uvsrc_y =    mb_y*block_s               + (my >> lowres);
1644
    } else {
1645
        mx = motion_x / 2;
1646
        my = motion_y / 2;
1647
        uvsx = mx & s_mask;
1648
        uvsy = my & s_mask;
1649
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1650
        uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1651
    }
1652

    
1653
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1654
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1655
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1656

    
1657
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1658
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1659
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1660
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1661
            ptr_y = s->edge_emu_buffer;
1662
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1663
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1664
                s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1665
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1666
                s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1667
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1668
                ptr_cb= uvbuf;
1669
                ptr_cr= uvbuf+16;
1670
            }
1671
    }
1672

    
1673
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1674
        dest_y += s->linesize;
1675
        dest_cb+= s->uvlinesize;
1676
        dest_cr+= s->uvlinesize;
1677
    }
1678

    
1679
    if(field_select){
1680
        ptr_y += s->linesize;
1681
        ptr_cb+= s->uvlinesize;
1682
        ptr_cr+= s->uvlinesize;
1683
    }
1684

    
1685
    sx= (sx << 2) >> lowres;
1686
    sy= (sy << 2) >> lowres;
1687
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1688

    
1689
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1690
        uvsx= (uvsx << 2) >> lowres;
1691
        uvsy= (uvsy << 2) >> lowres;
1692
        pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1693
        pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1694
    }
1695
    //FIXME h261 lowres loop filter
1696
}
1697

    
1698
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1699
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1700
                                     uint8_t **ref_picture,
1701
                                     h264_chroma_mc_func *pix_op,
1702
                                     int mx, int my){
1703
    const int lowres= s->avctx->lowres;
1704
    const int op_index= FFMIN(lowres, 2);
1705
    const int block_s= 8>>lowres;
1706
    const int s_mask= (2<<lowres)-1;
1707
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1708
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1709
    int emu=0, src_x, src_y, offset, sx, sy;
1710
    uint8_t *ptr;
1711

    
1712
    if(s->quarter_sample){
1713
        mx/=2;
1714
        my/=2;
1715
    }
1716

    
1717
    /* In case of 8X8, we construct a single chroma motion vector
1718
       with a special rounding */
1719
    mx= ff_h263_round_chroma(mx);
1720
    my= ff_h263_round_chroma(my);
1721

    
1722
    sx= mx & s_mask;
1723
    sy= my & s_mask;
1724
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1725
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1726

    
1727
    offset = src_y * s->uvlinesize + src_x;
1728
    ptr = ref_picture[1] + offset;
1729
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1730
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1731
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1732
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1733
            ptr= s->edge_emu_buffer;
1734
            emu=1;
1735
        }
1736
    }
1737
    sx= (sx << 2) >> lowres;
1738
    sy= (sy << 2) >> lowres;
1739
    pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1740

    
1741
    ptr = ref_picture[2] + offset;
1742
    if(emu){
1743
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1744
        ptr= s->edge_emu_buffer;
1745
    }
1746
    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1747
}
1748

    
1749
/**
1750
 * motion compensation of a single macroblock
1751
 * @param s context
1752
 * @param dest_y luma destination pointer
1753
 * @param dest_cb chroma cb/u destination pointer
1754
 * @param dest_cr chroma cr/v destination pointer
1755
 * @param dir direction (0->forward, 1->backward)
1756
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1757
 * @param pix_op halfpel motion compensation function (average or put normally)
1758
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1759
 */
1760
static inline void MPV_motion_lowres(MpegEncContext *s,
1761
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1762
                              int dir, uint8_t **ref_picture,
1763
                              h264_chroma_mc_func *pix_op)
1764
{
1765
    int mx, my;
1766
    int mb_x, mb_y, i;
1767
    const int lowres= s->avctx->lowres;
1768
    const int block_s= 8>>lowres;
1769

    
1770
    mb_x = s->mb_x;
1771
    mb_y = s->mb_y;
1772

    
1773
    switch(s->mv_type) {
1774
    case MV_TYPE_16X16:
1775
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1776
                    0, 0, 0,
1777
                    ref_picture, pix_op,
1778
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1779
        break;
1780
    case MV_TYPE_8X8:
1781
        mx = 0;
1782
        my = 0;
1783
            for(i=0;i<4;i++) {
1784
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1785
                            ref_picture[0], 0, 0,
1786
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1787
                            s->width, s->height, s->linesize,
1788
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1789
                            block_s, block_s, pix_op,
1790
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1791

    
1792
                mx += s->mv[dir][i][0];
1793
                my += s->mv[dir][i][1];
1794
            }
1795

    
1796
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1797
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1798
        break;
1799
    case MV_TYPE_FIELD:
1800
        if (s->picture_structure == PICT_FRAME) {
1801
            /* top field */
1802
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1803
                        1, 0, s->field_select[dir][0],
1804
                        ref_picture, pix_op,
1805
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1806
            /* bottom field */
1807
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1808
                        1, 1, s->field_select[dir][1],
1809
                        ref_picture, pix_op,
1810
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1811
        } else {
1812
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1813
                ref_picture= s->current_picture_ptr->data;
1814
            }
1815

    
1816
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1817
                        0, 0, s->field_select[dir][0],
1818
                        ref_picture, pix_op,
1819
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1820
        }
1821
        break;
1822
    case MV_TYPE_16X8:
1823
        for(i=0; i<2; i++){
1824
            uint8_t ** ref2picture;
1825

    
1826
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1827
                ref2picture= ref_picture;
1828
            }else{
1829
                ref2picture= s->current_picture_ptr->data;
1830
            }
1831

    
1832
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1833
                        0, 0, s->field_select[dir][i],
1834
                        ref2picture, pix_op,
1835
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1836

    
1837
            dest_y += 2*block_s*s->linesize;
1838
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1839
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1840
        }
1841
        break;
1842
    case MV_TYPE_DMV:
1843
        if(s->picture_structure == PICT_FRAME){
1844
            for(i=0; i<2; i++){
1845
                int j;
1846
                for(j=0; j<2; j++){
1847
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1848
                                1, j, j^i,
1849
                                ref_picture, pix_op,
1850
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1851
                }
1852
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1853
            }
1854
        }else{
1855
            for(i=0; i<2; i++){
1856
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1857
                            0, 0, s->picture_structure != i+1,
1858
                            ref_picture, pix_op,
1859
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1860

    
1861
                // after put we make avg of the same block
1862
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1863

    
1864
                //opposite parity is always in the same frame if this is second field
1865
                if(!s->first_field){
1866
                    ref_picture = s->current_picture_ptr->data;
1867
                }
1868
            }
1869
        }
1870
    break;
1871
    default: assert(0);
1872
    }
1873
}
1874

    
1875
/**
1876
 * find the lowest MB row referenced in the MVs
1877
 */
1878
int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1879
{
1880
    int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1881
    int my, off, i, mvs;
1882

    
1883
    if (s->picture_structure != PICT_FRAME) goto unhandled;
1884

    
1885
    switch (s->mv_type) {
1886
        case MV_TYPE_16X16:
1887
            mvs = 1;
1888
            break;
1889
        case MV_TYPE_16X8:
1890
            mvs = 2;
1891
            break;
1892
        case MV_TYPE_8X8:
1893
            mvs = 4;
1894
            break;
1895
        default:
1896
            goto unhandled;
1897
    }
1898

    
1899
    for (i = 0; i < mvs; i++) {
1900
        my = s->mv[dir][i][1]<<qpel_shift;
1901
        my_max = FFMAX(my_max, my);
1902
        my_min = FFMIN(my_min, my);
1903
    }
1904

    
1905
    off = (FFMAX(-my_min, my_max) + 63) >> 6;
1906

    
1907
    return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1908
unhandled:
1909
    return s->mb_height-1;
1910
}
1911

    
1912
/* put block[] to dest[] */
1913
static inline void put_dct(MpegEncContext *s,
1914
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1915
{
1916
    s->dct_unquantize_intra(s, block, i, qscale);
1917
    s->dsp.idct_put (dest, line_size, block);
1918
}
1919

    
1920
/* add block[] to dest[] */
1921
static inline void add_dct(MpegEncContext *s,
1922
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1923
{
1924
    if (s->block_last_index[i] >= 0) {
1925
        s->dsp.idct_add (dest, line_size, block);
1926
    }
1927
}
1928

    
1929
static inline void add_dequant_dct(MpegEncContext *s,
1930
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1931
{
1932
    if (s->block_last_index[i] >= 0) {
1933
        s->dct_unquantize_inter(s, block, i, qscale);
1934

    
1935
        s->dsp.idct_add (dest, line_size, block);
1936
    }
1937
}
1938

    
1939
/**
1940
 * cleans dc, ac, coded_block for the current non intra MB
1941
 */
1942
void ff_clean_intra_table_entries(MpegEncContext *s)
1943
{
1944
    int wrap = s->b8_stride;
1945
    int xy = s->block_index[0];
1946

    
1947
    s->dc_val[0][xy           ] =
1948
    s->dc_val[0][xy + 1       ] =
1949
    s->dc_val[0][xy     + wrap] =
1950
    s->dc_val[0][xy + 1 + wrap] = 1024;
1951
    /* ac pred */
1952
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1953
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1954
    if (s->msmpeg4_version>=3) {
1955
        s->coded_block[xy           ] =
1956
        s->coded_block[xy + 1       ] =
1957
        s->coded_block[xy     + wrap] =
1958
        s->coded_block[xy + 1 + wrap] = 0;
1959
    }
1960
    /* chroma */
1961
    wrap = s->mb_stride;
1962
    xy = s->mb_x + s->mb_y * wrap;
1963
    s->dc_val[1][xy] =
1964
    s->dc_val[2][xy] = 1024;
1965
    /* ac pred */
1966
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1967
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1968

    
1969
    s->mbintra_table[xy]= 0;
1970
}
1971

    
1972
/* generic function called after a macroblock has been parsed by the
1973
   decoder or after it has been encoded by the encoder.
1974

1975
   Important variables used:
1976
   s->mb_intra : true if intra macroblock
1977
   s->mv_dir   : motion vector direction
1978
   s->mv_type  : motion vector type
1979
   s->mv       : motion vector
1980
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1981
 */
1982
static av_always_inline
1983
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1984
                            int lowres_flag, int is_mpeg12)
1985
{
1986
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1987
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1988
        ff_xvmc_decode_mb(s);//xvmc uses pblocks
1989
        return;
1990
    }
1991

    
1992
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1993
       /* save DCT coefficients */
1994
       int i,j;
1995
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1996
       av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1997
       for(i=0; i<6; i++){
1998
           for(j=0; j<64; j++){
1999
               *dct++ = block[i][s->dsp.idct_permutation[j]];
2000
               av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2001
           }
2002
           av_log(s->avctx, AV_LOG_DEBUG, "\n");
2003
       }
2004
    }
2005

    
2006
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2007

    
2008
    /* update DC predictors for P macroblocks */
2009
    if (!s->mb_intra) {
2010
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2011
            if(s->mbintra_table[mb_xy])
2012
                ff_clean_intra_table_entries(s);
2013
        } else {
2014
            s->last_dc[0] =
2015
            s->last_dc[1] =
2016
            s->last_dc[2] = 128 << s->intra_dc_precision;
2017
        }
2018
    }
2019
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2020
        s->mbintra_table[mb_xy]=1;
2021

    
2022
    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
2023
        uint8_t *dest_y, *dest_cb, *dest_cr;
2024
        int dct_linesize, dct_offset;
2025
        op_pixels_func (*op_pix)[4];
2026
        qpel_mc_func (*op_qpix)[16];
2027
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2028
        const int uvlinesize= s->current_picture.linesize[1];
2029
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2030
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2031

    
2032
        /* avoid copy if macroblock skipped in last frame too */
2033
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2034
        if(!s->encoding){
2035
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2036
            const int age= s->current_picture.age;
2037

    
2038
            assert(age);
2039

    
2040
            if (s->mb_skipped) {
2041
                s->mb_skipped= 0;
2042
                assert(s->pict_type!=FF_I_TYPE);
2043

    
2044
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2045
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2046

    
2047
                /* if previous was skipped too, then nothing to do !  */
2048
                if (*mbskip_ptr >= age && s->current_picture.reference){
2049
                    return;
2050
                }
2051
            } else if(!s->current_picture.reference){
2052
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2053
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2054
            } else{
2055
                *mbskip_ptr = 0; /* not skipped */
2056
            }
2057
        }
2058

    
2059
        dct_linesize = linesize << s->interlaced_dct;
2060
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2061

    
2062
        if(readable){
2063
            dest_y=  s->dest[0];
2064
            dest_cb= s->dest[1];
2065
            dest_cr= s->dest[2];
2066
        }else{
2067
            dest_y = s->b_scratchpad;
2068
            dest_cb= s->b_scratchpad+16*linesize;
2069
            dest_cr= s->b_scratchpad+32*linesize;
2070
        }
2071

    
2072
        if (!s->mb_intra) {
2073
            /* motion handling */
2074
            /* decoding or more than one mb_type (MC was already done otherwise) */
2075
            if(!s->encoding){
2076

    
2077
                if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2078
                    if (s->mv_dir & MV_DIR_FORWARD) {
2079
                        ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2080
                    }
2081
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2082
                        ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2083
                    }
2084
                }
2085

    
2086
                if(lowres_flag){
2087
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2088

    
2089
                    if (s->mv_dir & MV_DIR_FORWARD) {
2090
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2091
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2092
                    }
2093
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2094
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2095
                    }
2096
                }else{
2097
                    op_qpix= s->me.qpel_put;
2098
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
2099
                        op_pix = s->dsp.put_pixels_tab;
2100
                    }else{
2101
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
2102
                    }
2103
                    if (s->mv_dir & MV_DIR_FORWARD) {
2104
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2105
                        op_pix = s->dsp.avg_pixels_tab;
2106
                        op_qpix= s->me.qpel_avg;
2107
                    }
2108
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2109
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2110
                    }
2111
                }
2112
            }
2113

    
2114
            /* skip dequant / idct if we are really late ;) */
2115
            if(s->hurry_up>1) goto skip_idct;
2116
            if(s->avctx->skip_idct){
2117
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
2118
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
2119
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
2120
                    goto skip_idct;
2121
            }
2122

    
2123
            /* add dct residue */
2124
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2125
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2126
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2127
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2128
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2129
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2130

    
2131
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2132
                    if (s->chroma_y_shift){
2133
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2134
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2135
                    }else{
2136
                        dct_linesize >>= 1;
2137
                        dct_offset >>=1;
2138
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2139
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2140
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2141
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2142
                    }
2143
                }
2144
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2145
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2146
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2147
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2148
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2149

    
2150
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2151
                    if(s->chroma_y_shift){//Chroma420
2152
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
2153
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
2154
                    }else{
2155
                        //chroma422
2156
                        dct_linesize = uvlinesize << s->interlaced_dct;
2157
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2158

    
2159
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
2160
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
2161
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2162
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2163
                        if(!s->chroma_x_shift){//Chroma444
2164
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2165
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2166
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2167
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2168
                        }
2169
                    }
2170
                }//fi gray
2171
            }
2172
            else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2173
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2174
            }
2175
        } else {
2176
            /* dct only in intra block */
2177
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2178
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2179
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2180
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2181
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2182

    
2183
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2184
                    if(s->chroma_y_shift){
2185
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2186
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2187
                    }else{
2188
                        dct_offset >>=1;
2189
                        dct_linesize >>=1;
2190
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2191
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2192
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2193
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2194
                    }
2195
                }
2196
            }else{
2197
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2198
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2199
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2200
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2201

    
2202
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2203
                    if(s->chroma_y_shift){
2204
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2205
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2206
                    }else{
2207

    
2208
                        dct_linesize = uvlinesize << s->interlaced_dct;
2209
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2210

    
2211
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2212
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2213
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2214
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2215
                        if(!s->chroma_x_shift){//Chroma444
2216
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2217
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2218
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2219
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2220
                        }
2221
                    }
2222
                }//gray
2223
            }
2224
        }
2225
skip_idct:
2226
        if(!readable){
2227
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2228
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2229
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2230
        }
2231
    }
2232
}
2233

    
2234
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2235
#if !CONFIG_SMALL
2236
    if(s->out_format == FMT_MPEG1) {
2237
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2238
        else                 MPV_decode_mb_internal(s, block, 0, 1);
2239
    } else
2240
#endif
2241
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2242
    else                  MPV_decode_mb_internal(s, block, 0, 0);
2243
}
2244

    
2245
/**
2246
 *
2247
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2248
 */
2249
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2250
    const int field_pic= s->picture_structure != PICT_FRAME;
2251
    if(field_pic){
2252
        h <<= 1;
2253
        y <<= 1;
2254
    }
2255

    
2256
    if (!s->avctx->hwaccel
2257
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2258
       && s->unrestricted_mv
2259
       && s->current_picture.reference
2260
       && !s->intra_only
2261
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2262
        int sides = 0, edge_h;
2263
        if (y==0) sides |= EDGE_TOP;
2264
        if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2265

    
2266
        edge_h= FFMIN(h, s->v_edge_pos - y);
2267

    
2268
        s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2269
        s->dsp.draw_edges(s->current_picture_ptr->data[1] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
2270
        s->dsp.draw_edges(s->current_picture_ptr->data[2] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
2271
    }
2272

    
2273
    h= FFMIN(h, s->avctx->height - y);
2274

    
2275
    if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2276

    
2277
    if (s->avctx->draw_horiz_band) {
2278
        AVFrame *src;
2279
        int offset[4];
2280

    
2281
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2282
            src= (AVFrame*)s->current_picture_ptr;
2283
        else if(s->last_picture_ptr)
2284
            src= (AVFrame*)s->last_picture_ptr;
2285
        else
2286
            return;
2287

    
2288
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2289
            offset[0]=
2290
            offset[1]=
2291
            offset[2]=
2292
            offset[3]= 0;
2293
        }else{
2294
            offset[0]= y * s->linesize;
2295
            offset[1]=
2296
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2297
            offset[3]= 0;
2298
        }
2299

    
2300
        emms_c();
2301

    
2302
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2303
                                  y, s->picture_structure, h);
2304
    }
2305
}
2306

    
2307
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2308
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2309
    const int uvlinesize= s->current_picture.linesize[1];
2310
    const int mb_size= 4 - s->avctx->lowres;
2311

    
2312
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2313
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2314
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2315
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2316
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2317
    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;
2318
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2319

    
2320
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2321
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2322
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2323

    
2324
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2325
    {
2326
        if(s->picture_structure==PICT_FRAME){
2327
        s->dest[0] += s->mb_y *   linesize << mb_size;
2328
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2329
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2330
        }else{
2331
            s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2332
            s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2333
            s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2334
            assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2335
        }
2336
    }
2337
}
2338

    
2339
void ff_mpeg_flush(AVCodecContext *avctx){
2340
    int i;
2341
    MpegEncContext *s = avctx->priv_data;
2342

    
2343
    if(s==NULL || s->picture==NULL)
2344
        return;
2345

    
2346
    for(i=0; i<s->picture_count; i++){
2347
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2348
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2349
        free_frame_buffer(s, &s->picture[i]);
2350
    }
2351
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2352

    
2353
    s->mb_x= s->mb_y= 0;
2354
    s->closed_gop= 0;
2355

    
2356
    s->parse_context.state= -1;
2357
    s->parse_context.frame_start_found= 0;
2358
    s->parse_context.overread= 0;
2359
    s->parse_context.overread_index= 0;
2360
    s->parse_context.index= 0;
2361
    s->parse_context.last_index= 0;
2362
    s->bitstream_buffer_size=0;
2363
    s->pp_time=0;
2364
}
2365

    
2366
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2367
                                   DCTELEM *block, int n, int qscale)
2368
{
2369
    int i, level, nCoeffs;
2370
    const uint16_t *quant_matrix;
2371

    
2372
    nCoeffs= s->block_last_index[n];
2373

    
2374
    if (n < 4)
2375
        block[0] = block[0] * s->y_dc_scale;
2376
    else
2377
        block[0] = block[0] * s->c_dc_scale;
2378
    /* XXX: only mpeg1 */
2379
    quant_matrix = s->intra_matrix;
2380
    for(i=1;i<=nCoeffs;i++) {
2381
        int j= s->intra_scantable.permutated[i];
2382
        level = block[j];
2383
        if (level) {
2384
            if (level < 0) {
2385
                level = -level;
2386
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2387
                level = (level - 1) | 1;
2388
                level = -level;
2389
            } else {
2390
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2391
                level = (level - 1) | 1;
2392
            }
2393
            block[j] = level;
2394
        }
2395
    }
2396
}
2397

    
2398
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2399
                                   DCTELEM *block, int n, int qscale)
2400
{
2401
    int i, level, nCoeffs;
2402
    const uint16_t *quant_matrix;
2403

    
2404
    nCoeffs= s->block_last_index[n];
2405

    
2406
    quant_matrix = s->inter_matrix;
2407
    for(i=0; i<=nCoeffs; i++) {
2408
        int j= s->intra_scantable.permutated[i];
2409
        level = block[j];
2410
        if (level) {
2411
            if (level < 0) {
2412
                level = -level;
2413
                level = (((level << 1) + 1) * qscale *
2414
                         ((int) (quant_matrix[j]))) >> 4;
2415
                level = (level - 1) | 1;
2416
                level = -level;
2417
            } else {
2418
                level = (((level << 1) + 1) * qscale *
2419
                         ((int) (quant_matrix[j]))) >> 4;
2420
                level = (level - 1) | 1;
2421
            }
2422
            block[j] = level;
2423
        }
2424
    }
2425
}
2426

    
2427
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2428
                                   DCTELEM *block, int n, int qscale)
2429
{
2430
    int i, level, nCoeffs;
2431
    const uint16_t *quant_matrix;
2432

    
2433
    if(s->alternate_scan) nCoeffs= 63;
2434
    else nCoeffs= s->block_last_index[n];
2435

    
2436
    if (n < 4)
2437
        block[0] = block[0] * s->y_dc_scale;
2438
    else
2439
        block[0] = block[0] * s->c_dc_scale;
2440
    quant_matrix = s->intra_matrix;
2441
    for(i=1;i<=nCoeffs;i++) {
2442
        int j= s->intra_scantable.permutated[i];
2443
        level = block[j];
2444
        if (level) {
2445
            if (level < 0) {
2446
                level = -level;
2447
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2448
                level = -level;
2449
            } else {
2450
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2451
            }
2452
            block[j] = level;
2453
        }
2454
    }
2455
}
2456

    
2457
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2458
                                   DCTELEM *block, int n, int qscale)
2459
{
2460
    int i, level, nCoeffs;
2461
    const uint16_t *quant_matrix;
2462
    int sum=-1;
2463

    
2464
    if(s->alternate_scan) nCoeffs= 63;
2465
    else nCoeffs= s->block_last_index[n];
2466

    
2467
    if (n < 4)
2468
        block[0] = block[0] * s->y_dc_scale;
2469
    else
2470
        block[0] = block[0] * s->c_dc_scale;
2471
    quant_matrix = s->intra_matrix;
2472
    for(i=1;i<=nCoeffs;i++) {
2473
        int j= s->intra_scantable.permutated[i];
2474
        level = block[j];
2475
        if (level) {
2476
            if (level < 0) {
2477
                level = -level;
2478
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2479
                level = -level;
2480
            } else {
2481
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2482
            }
2483
            block[j] = level;
2484
            sum+=level;
2485
        }
2486
    }
2487
    block[63]^=sum&1;
2488
}
2489

    
2490
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2491
                                   DCTELEM *block, int n, int qscale)
2492
{
2493
    int i, level, nCoeffs;
2494
    const uint16_t *quant_matrix;
2495
    int sum=-1;
2496

    
2497
    if(s->alternate_scan) nCoeffs= 63;
2498
    else nCoeffs= s->block_last_index[n];
2499

    
2500
    quant_matrix = s->inter_matrix;
2501
    for(i=0; i<=nCoeffs; i++) {
2502
        int j= s->intra_scantable.permutated[i];
2503
        level = block[j];
2504
        if (level) {
2505
            if (level < 0) {
2506
                level = -level;
2507
                level = (((level << 1) + 1) * qscale *
2508
                         ((int) (quant_matrix[j]))) >> 4;
2509
                level = -level;
2510
            } else {
2511
                level = (((level << 1) + 1) * qscale *
2512
                         ((int) (quant_matrix[j]))) >> 4;
2513
            }
2514
            block[j] = level;
2515
            sum+=level;
2516
        }
2517
    }
2518
    block[63]^=sum&1;
2519
}
2520

    
2521
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2522
                                  DCTELEM *block, int n, int qscale)
2523
{
2524
    int i, level, qmul, qadd;
2525
    int nCoeffs;
2526

    
2527
    assert(s->block_last_index[n]>=0);
2528

    
2529
    qmul = qscale << 1;
2530

    
2531
    if (!s->h263_aic) {
2532
        if (n < 4)
2533
            block[0] = block[0] * s->y_dc_scale;
2534
        else
2535
            block[0] = block[0] * s->c_dc_scale;
2536
        qadd = (qscale - 1) | 1;
2537
    }else{
2538
        qadd = 0;
2539
    }
2540
    if(s->ac_pred)
2541
        nCoeffs=63;
2542
    else
2543
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2544

    
2545
    for(i=1; i<=nCoeffs; i++) {
2546
        level = block[i];
2547
        if (level) {
2548
            if (level < 0) {
2549
                level = level * qmul - qadd;
2550
            } else {
2551
                level = level * qmul + qadd;
2552
            }
2553
            block[i] = level;
2554
        }
2555
    }
2556
}
2557

    
2558
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2559
                                  DCTELEM *block, int n, int qscale)
2560
{
2561
    int i, level, qmul, qadd;
2562
    int nCoeffs;
2563

    
2564
    assert(s->block_last_index[n]>=0);
2565

    
2566
    qadd = (qscale - 1) | 1;
2567
    qmul = qscale << 1;
2568

    
2569
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2570

    
2571
    for(i=0; i<=nCoeffs; i++) {
2572
        level = block[i];
2573
        if (level) {
2574
            if (level < 0) {
2575
                level = level * qmul - qadd;
2576
            } else {
2577
                level = level * qmul + qadd;
2578
            }
2579
            block[i] = level;
2580
        }
2581
    }
2582
}
2583

    
2584
/**
2585
 * set qscale and update qscale dependent variables.
2586
 */
2587
void ff_set_qscale(MpegEncContext * s, int qscale)
2588
{
2589
    if (qscale < 1)
2590
        qscale = 1;
2591
    else if (qscale > 31)
2592
        qscale = 31;
2593

    
2594
    s->qscale = qscale;
2595
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2596

    
2597
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2598
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2599
}
2600

    
2601
void MPV_report_decode_progress(MpegEncContext *s)
2602
{
2603
    if (s->pict_type != FF_B_TYPE && !s->partitioned_frame)
2604
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2605
}