Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 3eb9e571

History | View | Annotate | Download (98.9 KB)

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

    
25
/**
26
 * @file
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->avctx->hwaccel
1160
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1161
       && s->unrestricted_mv
1162
       && s->current_picture.reference
1163
       && !s->intra_only
1164
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1165
        int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos;
1166

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

    
1171
    }
1172

    
1173
    emms_c();
1174

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1365

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

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

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

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

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

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

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

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

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

    
1487

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

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

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

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

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

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

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

    
1581
    src += src_y * stride + src_x;
1582

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2037
            assert(age);
2038

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2267
        s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2268
        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);
2269
        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);
2270
    }
2271

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

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

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

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

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

    
2299
        emms_c();
2300

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2528
    qmul = qscale << 1;
2529

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

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

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

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

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

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

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

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

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

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

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