Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 99e07a44

History | View | Annotate | Download (100 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 ? AV_PICTURE_TYPE_B : s->pict_type;
317
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
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
    pic->owner2 = s;
320

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
479
        MPV_common_init(s);
480
    }
481

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

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

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

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

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

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

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

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

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

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

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

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

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

    
535
    return 0;
536
}
537

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

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

    
554
    s->picture_in_gop_number = 0;
555

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
679
        if(s->avctx->noise_reduction){
680
            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
681
        }
682
    }
683

    
684
    s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
685
    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
686
    for(i = 0; i < s->picture_count; i++) {
687
        avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
688
    }
689

    
690
    FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
691

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

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

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

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

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

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

    
745
    s->context_initialized = 1;
746
    s->thread_context[0]= s;
747

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

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

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

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

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

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

    
788
    av_freep(&s->parse_context.buffer);
789
    s->parse_context.buffer_size=0;
790

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

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

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

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

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

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

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

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

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

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

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

    
911
void init_vlc_rl(RLTable *rl)
912
{
913
    int i, q;
914

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

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

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

    
951
void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
952
{
953
    int i;
954

    
955
    /* release non reference frames */
956
    for(i=0; i<s->picture_count; i++){
957
        if(s->picture[i].data[0] && !s->picture[i].reference
958
           && s->picture[i].owner2 == s
959
           && (remove_current || &s->picture[i] != s->current_picture_ptr)
960
           /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
961
            free_frame_buffer(s, &s->picture[i]);
962
        }
963
    }
964
}
965

    
966
int ff_find_unused_picture(MpegEncContext *s, int shared){
967
    int i;
968

    
969
    if(shared){
970
        for(i=s->picture_range_start; i<s->picture_range_end; i++){
971
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
972
        }
973
    }else{
974
        for(i=s->picture_range_start; i<s->picture_range_end; i++){
975
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
976
        }
977
        for(i=s->picture_range_start; i<s->picture_range_end; i++){
978
            if(s->picture[i].data[0]==NULL) return i;
979
        }
980
    }
981

    
982
    av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
983
    /* We could return -1, but the codec would crash trying to draw into a
984
     * non-existing frame anyway. This is safer than waiting for a random crash.
985
     * Also the return of this is never useful, an encoder must only allocate
986
     * as much as allowed in the specification. This has no relationship to how
987
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
988
     * enough for such valid streams).
989
     * Plus, a decoder has to check stream validity and remove frames if too
990
     * many reference frames are around. Waiting for "OOM" is not correct at
991
     * all. Similarly, missing reference frames have to be replaced by
992
     * interpolated/MC frames, anything else is a bug in the codec ...
993
     */
994
    abort();
995
    return -1;
996
}
997

    
998
static void update_noise_reduction(MpegEncContext *s){
999
    int intra, i;
1000

    
1001
    for(intra=0; intra<2; intra++){
1002
        if(s->dct_count[intra] > (1<<16)){
1003
            for(i=0; i<64; i++){
1004
                s->dct_error_sum[intra][i] >>=1;
1005
            }
1006
            s->dct_count[intra] >>= 1;
1007
        }
1008

    
1009
        for(i=0; i<64; i++){
1010
            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);
1011
        }
1012
    }
1013
}
1014

    
1015
/**
1016
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1017
 */
1018
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1019
{
1020
    int i;
1021
    Picture *pic;
1022
    s->mb_skipped = 0;
1023

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

    
1026
    /* mark&release old frames */
1027
    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1028
      if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1029
          free_frame_buffer(s, s->last_picture_ptr);
1030

    
1031
        /* release forgotten pictures */
1032
        /* if(mpeg124/h263) */
1033
        if(!s->encoding){
1034
            for(i=0; i<s->picture_count; i++){
1035
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1036
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1037
                    free_frame_buffer(s, &s->picture[i]);
1038
                }
1039
            }
1040
        }
1041
      }
1042
    }
1043

    
1044
    if(!s->encoding){
1045
        ff_release_unused_pictures(s, 1);
1046

    
1047
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1048
            pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1049
        else{
1050
            i= ff_find_unused_picture(s, 0);
1051
            pic= &s->picture[i];
1052
        }
1053

    
1054
        pic->reference= 0;
1055
        if (!s->dropable){
1056
            if (s->codec_id == CODEC_ID_H264)
1057
                pic->reference = s->picture_structure;
1058
            else if (s->pict_type != AV_PICTURE_TYPE_B)
1059
                pic->reference = 3;
1060
        }
1061

    
1062
        pic->coded_picture_number= s->coded_picture_number++;
1063

    
1064
        if(ff_alloc_picture(s, pic, 0) < 0)
1065
            return -1;
1066

    
1067
        s->current_picture_ptr= pic;
1068
        //FIXME use only the vars from current_pic
1069
        s->current_picture_ptr->top_field_first= s->top_field_first;
1070
        if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1071
            if(s->picture_structure != PICT_FRAME)
1072
                s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1073
        }
1074
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1075
        s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1076
    }
1077

    
1078
    s->current_picture_ptr->pict_type= s->pict_type;
1079
//    if(s->flags && CODEC_FLAG_QSCALE)
1080
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1081
    s->current_picture_ptr->key_frame= s->pict_type == AV_PICTURE_TYPE_I;
1082

    
1083
    ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1084

    
1085
    if (s->pict_type != AV_PICTURE_TYPE_B) {
1086
        s->last_picture_ptr= s->next_picture_ptr;
1087
        if(!s->dropable)
1088
            s->next_picture_ptr= s->current_picture_ptr;
1089
    }
1090
/*    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,
1091
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1092
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1093
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1094
        s->pict_type, s->dropable);*/
1095

    
1096
    if(s->codec_id != CODEC_ID_H264){
1097
        if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) &&
1098
           (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1099
            if (s->pict_type != AV_PICTURE_TYPE_I)
1100
                av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1101
            else if (s->picture_structure != PICT_FRAME)
1102
                av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1103

    
1104
            /* Allocate a dummy frame */
1105
            i= ff_find_unused_picture(s, 0);
1106
            s->last_picture_ptr= &s->picture[i];
1107
            if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1108
                return -1;
1109
            ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1110
            ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1111
        }
1112
        if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==AV_PICTURE_TYPE_B){
1113
            /* Allocate a dummy frame */
1114
            i= ff_find_unused_picture(s, 0);
1115
            s->next_picture_ptr= &s->picture[i];
1116
            if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1117
                return -1;
1118
            ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1119
            ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1120
        }
1121
    }
1122

    
1123
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1124
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1125

    
1126
    assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1127

    
1128
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1129
        int i;
1130
        for(i=0; i<4; i++){
1131
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1132
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1133
            }
1134
            s->current_picture.linesize[i] *= 2;
1135
            s->last_picture.linesize[i] *=2;
1136
            s->next_picture.linesize[i] *=2;
1137
        }
1138
    }
1139

    
1140
    s->error_recognition= avctx->error_recognition;
1141

    
1142
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1143
       and we can't do it in the header decode as init is not called for mpeg4 there yet */
1144
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1145
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1146
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1147
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1148
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1149
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1150
    }else{
1151
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1152
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1153
    }
1154

    
1155
    if(s->dct_error_sum){
1156
        assert(s->avctx->noise_reduction && s->encoding);
1157

    
1158
        update_noise_reduction(s);
1159
    }
1160

    
1161
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1162
        return ff_xvmc_field_start(s, avctx);
1163

    
1164
    return 0;
1165
}
1166

    
1167
/* generic function for encode/decode called after a frame has been coded/decoded */
1168
void MPV_frame_end(MpegEncContext *s)
1169
{
1170
    int i;
1171
    /* redraw edges for the frame if decoding didn't complete */
1172
    //just to make sure that all data is rendered.
1173
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1174
        ff_xvmc_field_end(s);
1175
   }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1176
       && !s->avctx->hwaccel
1177
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1178
       && s->unrestricted_mv
1179
       && s->current_picture.reference
1180
       && !s->intra_only
1181
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1182
        int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos;
1183

    
1184
            s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , h   , EDGE_WIDTH  , edges);
1185
            s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1186
            s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1187

    
1188
    }
1189

    
1190
    emms_c();
1191

    
1192
    s->last_pict_type    = s->pict_type;
1193
    s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1194
    if(s->pict_type!=AV_PICTURE_TYPE_B){
1195
        s->last_non_b_pict_type= s->pict_type;
1196
    }
1197
#if 0
1198
        /* copy back current_picture variables */
1199
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1200
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1201
            s->picture[i]= s->current_picture;
1202
            break;
1203
        }
1204
    }
1205
    assert(i<MAX_PICTURE_COUNT);
1206
#endif
1207

    
1208
    if(s->encoding){
1209
        /* release non-reference frames */
1210
        for(i=0; i<s->picture_count; i++){
1211
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1212
                free_frame_buffer(s, &s->picture[i]);
1213
            }
1214
        }
1215
    }
1216
    // clear copies, to avoid confusion
1217
#if 0
1218
    memset(&s->last_picture, 0, sizeof(Picture));
1219
    memset(&s->next_picture, 0, sizeof(Picture));
1220
    memset(&s->current_picture, 0, sizeof(Picture));
1221
#endif
1222
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1223

    
1224
    if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1225
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1226
    }
1227
}
1228

    
1229
/**
1230
 * draws an line from (ex, ey) -> (sx, sy).
1231
 * @param w width of the image
1232
 * @param h height of the image
1233
 * @param stride stride/linesize of the image
1234
 * @param color color of the arrow
1235
 */
1236
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1237
    int x, y, fr, f;
1238

    
1239
    sx= av_clip(sx, 0, w-1);
1240
    sy= av_clip(sy, 0, h-1);
1241
    ex= av_clip(ex, 0, w-1);
1242
    ey= av_clip(ey, 0, h-1);
1243

    
1244
    buf[sy*stride + sx]+= color;
1245

    
1246
    if(FFABS(ex - sx) > FFABS(ey - sy)){
1247
        if(sx > ex){
1248
            FFSWAP(int, sx, ex);
1249
            FFSWAP(int, sy, ey);
1250
        }
1251
        buf+= sx + sy*stride;
1252
        ex-= sx;
1253
        f= ((ey-sy)<<16)/ex;
1254
        for(x= 0; x <= ex; x++){
1255
            y = (x*f)>>16;
1256
            fr= (x*f)&0xFFFF;
1257
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1258
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1259
        }
1260
    }else{
1261
        if(sy > ey){
1262
            FFSWAP(int, sx, ex);
1263
            FFSWAP(int, sy, ey);
1264
        }
1265
        buf+= sx + sy*stride;
1266
        ey-= sy;
1267
        if(ey) f= ((ex-sx)<<16)/ey;
1268
        else   f= 0;
1269
        for(y= 0; y <= ey; y++){
1270
            x = (y*f)>>16;
1271
            fr= (y*f)&0xFFFF;
1272
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1273
            buf[y*stride + x+1]+= (color*         fr )>>16;
1274
        }
1275
    }
1276
}
1277

    
1278
/**
1279
 * draws an arrow from (ex, ey) -> (sx, sy).
1280
 * @param w width of the image
1281
 * @param h height of the image
1282
 * @param stride stride/linesize of the image
1283
 * @param color color of the arrow
1284
 */
1285
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1286
    int dx,dy;
1287

    
1288
    sx= av_clip(sx, -100, w+100);
1289
    sy= av_clip(sy, -100, h+100);
1290
    ex= av_clip(ex, -100, w+100);
1291
    ey= av_clip(ey, -100, h+100);
1292

    
1293
    dx= ex - sx;
1294
    dy= ey - sy;
1295

    
1296
    if(dx*dx + dy*dy > 3*3){
1297
        int rx=  dx + dy;
1298
        int ry= -dx + dy;
1299
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1300

    
1301
        //FIXME subpixel accuracy
1302
        rx= ROUNDED_DIV(rx*3<<4, length);
1303
        ry= ROUNDED_DIV(ry*3<<4, length);
1304

    
1305
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1306
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1307
    }
1308
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1309
}
1310

    
1311
/**
1312
 * prints debuging info for the given picture.
1313
 */
1314
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1315

    
1316
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1317

    
1318
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1319
        int x,y;
1320

    
1321
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1322
        switch (pict->pict_type) {
1323
            case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1324
            case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1325
            case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1326
            case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1327
            case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1328
            case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1329
        }
1330
        for(y=0; y<s->mb_height; y++){
1331
            for(x=0; x<s->mb_width; x++){
1332
                if(s->avctx->debug&FF_DEBUG_SKIP){
1333
                    int count= s->mbskip_table[x + y*s->mb_stride];
1334
                    if(count>9) count=9;
1335
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1336
                }
1337
                if(s->avctx->debug&FF_DEBUG_QP){
1338
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1339
                }
1340
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1341
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1342
                    //Type & MV direction
1343
                    if(IS_PCM(mb_type))
1344
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1345
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1346
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1347
                    else if(IS_INTRA4x4(mb_type))
1348
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1349
                    else if(IS_INTRA16x16(mb_type))
1350
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1351
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1352
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1353
                    else if(IS_DIRECT(mb_type))
1354
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1355
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1356
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1357
                    else if(IS_GMC(mb_type))
1358
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1359
                    else if(IS_SKIP(mb_type))
1360
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1361
                    else if(!USES_LIST(mb_type, 1))
1362
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1363
                    else if(!USES_LIST(mb_type, 0))
1364
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1365
                    else{
1366
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1367
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1368
                    }
1369

    
1370
                    //segmentation
1371
                    if(IS_8X8(mb_type))
1372
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1373
                    else if(IS_16X8(mb_type))
1374
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1375
                    else if(IS_8X16(mb_type))
1376
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1377
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1378
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1379
                    else
1380
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1381

    
1382

    
1383
                    if(IS_INTERLACED(mb_type))
1384
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1385
                    else
1386
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1387
                }
1388
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1389
            }
1390
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1391
        }
1392
    }
1393

    
1394
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1395
        const int shift= 1 + s->quarter_sample;
1396
        int mb_y;
1397
        uint8_t *ptr;
1398
        int i;
1399
        int h_chroma_shift, v_chroma_shift, block_height;
1400
        const int width = s->avctx->width;
1401
        const int height= s->avctx->height;
1402
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1403
        const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1404
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1405

    
1406
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1407
        for(i=0; i<3; i++){
1408
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1409
            pict->data[i]= s->visualization_buffer[i];
1410
        }
1411
        pict->type= FF_BUFFER_TYPE_COPY;
1412
        ptr= pict->data[0];
1413
        block_height = 16>>v_chroma_shift;
1414

    
1415
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1416
            int mb_x;
1417
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1418
                const int mb_index= mb_x + mb_y*s->mb_stride;
1419
                if((s->avctx->debug_mv) && pict->motion_val){
1420
                  int type;
1421
                  for(type=0; type<3; type++){
1422
                    int direction = 0;
1423
                    switch (type) {
1424
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1425
                                continue;
1426
                              direction = 0;
1427
                              break;
1428
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1429
                                continue;
1430
                              direction = 0;
1431
                              break;
1432
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1433
                                continue;
1434
                              direction = 1;
1435
                              break;
1436
                    }
1437
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1438
                        continue;
1439

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

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

    
1462
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1463
                      }
1464
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1465
                      int i;
1466
                      for(i=0; i<2; i++){
1467
                        int sx=mb_x*16 + 4 + 8*i;
1468
                        int sy=mb_y*16 + 8;
1469
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1470
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1471
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1472

    
1473
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1474
                            my*=2;
1475

    
1476
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1477
                      }
1478
                    }else{
1479
                      int sx= mb_x*16 + 8;
1480
                      int sy= mb_y*16 + 8;
1481
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1482
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1483
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1484
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1485
                    }
1486
                  }
1487
                }
1488
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1489
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1490
                    int y;
1491
                    for(y=0; y<block_height; y++){
1492
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1493
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1494
                    }
1495
                }
1496
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1497
                    int mb_type= pict->mb_type[mb_index];
1498
                    uint64_t u,v;
1499
                    int y;
1500
#define COLOR(theta, r)\
1501
u= (int)(128 + r*cos(theta*3.141592/180));\
1502
v= (int)(128 + r*sin(theta*3.141592/180));
1503

    
1504

    
1505
                    u=v=128;
1506
                    if(IS_PCM(mb_type)){
1507
                        COLOR(120,48)
1508
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1509
                        COLOR(30,48)
1510
                    }else if(IS_INTRA4x4(mb_type)){
1511
                        COLOR(90,48)
1512
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1513
//                        COLOR(120,48)
1514
                    }else if(IS_DIRECT(mb_type)){
1515
                        COLOR(150,48)
1516
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1517
                        COLOR(170,48)
1518
                    }else if(IS_GMC(mb_type)){
1519
                        COLOR(190,48)
1520
                    }else if(IS_SKIP(mb_type)){
1521
//                        COLOR(180,48)
1522
                    }else if(!USES_LIST(mb_type, 1)){
1523
                        COLOR(240,48)
1524
                    }else if(!USES_LIST(mb_type, 0)){
1525
                        COLOR(0,48)
1526
                    }else{
1527
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1528
                        COLOR(300,48)
1529
                    }
1530

    
1531
                    u*= 0x0101010101010101ULL;
1532
                    v*= 0x0101010101010101ULL;
1533
                    for(y=0; y<block_height; y++){
1534
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1535
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1536
                    }
1537

    
1538
                    //segmentation
1539
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1540
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1541
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1542
                    }
1543
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1544
                        for(y=0; y<16; y++)
1545
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1546
                    }
1547
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1548
                        int dm= 1 << (mv_sample_log2-2);
1549
                        for(i=0; i<4; i++){
1550
                            int sx= mb_x*16 + 8*(i&1);
1551
                            int sy= mb_y*16 + 8*(i>>1);
1552
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1553
                            //FIXME bidir
1554
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1555
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1556
                                for(y=0; y<8; y++)
1557
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1558
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1559
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1560
                        }
1561
                    }
1562

    
1563
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1564
                        // hmm
1565
                    }
1566
                }
1567
                s->mbskip_table[mb_index]=0;
1568
            }
1569
        }
1570
    }
1571
}
1572

    
1573
static inline int hpel_motion_lowres(MpegEncContext *s,
1574
                                  uint8_t *dest, uint8_t *src,
1575
                                  int field_based, int field_select,
1576
                                  int src_x, int src_y,
1577
                                  int width, int height, int stride,
1578
                                  int h_edge_pos, int v_edge_pos,
1579
                                  int w, int h, h264_chroma_mc_func *pix_op,
1580
                                  int motion_x, int motion_y)
1581
{
1582
    const int lowres= s->avctx->lowres;
1583
    const int op_index= FFMIN(lowres, 2);
1584
    const int s_mask= (2<<lowres)-1;
1585
    int emu=0;
1586
    int sx, sy;
1587

    
1588
    if(s->quarter_sample){
1589
        motion_x/=2;
1590
        motion_y/=2;
1591
    }
1592

    
1593
    sx= motion_x & s_mask;
1594
    sy= motion_y & s_mask;
1595
    src_x += motion_x >> (lowres+1);
1596
    src_y += motion_y >> (lowres+1);
1597

    
1598
    src += src_y * stride + src_x;
1599

    
1600
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1601
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1602
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1603
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1604
        src= s->edge_emu_buffer;
1605
        emu=1;
1606
    }
1607

    
1608
    sx= (sx << 2) >> lowres;
1609
    sy= (sy << 2) >> lowres;
1610
    if(field_select)
1611
        src += s->linesize;
1612
    pix_op[op_index](dest, src, stride, h, sx, sy);
1613
    return emu;
1614
}
1615

    
1616
/* apply one mpeg motion vector to the three components */
1617
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1618
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1619
                               int field_based, int bottom_field, int field_select,
1620
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1621
                               int motion_x, int motion_y, int h, int mb_y)
1622
{
1623
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1624
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1625
    const int lowres= s->avctx->lowres;
1626
    const int op_index= FFMIN(lowres-1+s->chroma_x_shift, 2);
1627
    const int block_s= 8>>lowres;
1628
    const int s_mask= (2<<lowres)-1;
1629
    const int h_edge_pos = s->h_edge_pos >> lowres;
1630
    const int v_edge_pos = s->v_edge_pos >> lowres;
1631
    linesize   = s->current_picture.linesize[0] << field_based;
1632
    uvlinesize = s->current_picture.linesize[1] << field_based;
1633

    
1634
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1635
        motion_x/=2;
1636
        motion_y/=2;
1637
    }
1638

    
1639
    if(field_based){
1640
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1641
    }
1642

    
1643
    sx= motion_x & s_mask;
1644
    sy= motion_y & s_mask;
1645
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1646
    src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1647

    
1648
    if (s->out_format == FMT_H263) {
1649
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1650
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1651
        uvsrc_x = src_x>>1;
1652
        uvsrc_y = src_y>>1;
1653
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1654
        mx = motion_x / 4;
1655
        my = motion_y / 4;
1656
        uvsx = (2*mx) & s_mask;
1657
        uvsy = (2*my) & s_mask;
1658
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1659
        uvsrc_y =    mb_y*block_s               + (my >> lowres);
1660
    } else {
1661
        if(s->chroma_y_shift){
1662
            mx = motion_x / 2;
1663
            my = motion_y / 2;
1664
            uvsx = mx & s_mask;
1665
            uvsy = my & s_mask;
1666
            uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1667
            uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1668
        } else {
1669
            if(s->chroma_x_shift){
1670
            //Chroma422
1671
                mx = motion_x / 2;
1672
                uvsx = mx & s_mask;
1673
                uvsy = motion_y & s_mask;
1674
                uvsrc_y = src_y;
1675
                uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1676
            } else {
1677
            //Chroma444
1678
                uvsx = motion_x & s_mask;
1679
                uvsy = motion_y & s_mask;
1680
                uvsrc_x = src_x;
1681
                uvsrc_y = src_y;
1682
            }
1683
        }
1684
    }
1685

    
1686
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1687
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1688
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1689

    
1690
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1691
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1692
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1693
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1694
            ptr_y = s->edge_emu_buffer;
1695
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1696
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1697
                s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1698
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1699
                s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1700
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1701
                ptr_cb= uvbuf;
1702
                ptr_cr= uvbuf+16;
1703
            }
1704
    }
1705

    
1706
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1707
        dest_y += s->linesize;
1708
        dest_cb+= s->uvlinesize;
1709
        dest_cr+= s->uvlinesize;
1710
    }
1711

    
1712
    if(field_select){
1713
        ptr_y += s->linesize;
1714
        ptr_cb+= s->uvlinesize;
1715
        ptr_cr+= s->uvlinesize;
1716
    }
1717

    
1718
    sx= (sx << 2) >> lowres;
1719
    sy= (sy << 2) >> lowres;
1720
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1721

    
1722
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1723
        uvsx= (uvsx << 2) >> lowres;
1724
        uvsy= (uvsy << 2) >> lowres;
1725
        pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1726
        pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1727
    }
1728
    //FIXME h261 lowres loop filter
1729
}
1730

    
1731
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1732
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1733
                                     uint8_t **ref_picture,
1734
                                     h264_chroma_mc_func *pix_op,
1735
                                     int mx, int my){
1736
    const int lowres= s->avctx->lowres;
1737
    const int op_index= FFMIN(lowres, 2);
1738
    const int block_s= 8>>lowres;
1739
    const int s_mask= (2<<lowres)-1;
1740
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1741
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1742
    int emu=0, src_x, src_y, offset, sx, sy;
1743
    uint8_t *ptr;
1744

    
1745
    if(s->quarter_sample){
1746
        mx/=2;
1747
        my/=2;
1748
    }
1749

    
1750
    /* In case of 8X8, we construct a single chroma motion vector
1751
       with a special rounding */
1752
    mx= ff_h263_round_chroma(mx);
1753
    my= ff_h263_round_chroma(my);
1754

    
1755
    sx= mx & s_mask;
1756
    sy= my & s_mask;
1757
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1758
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1759

    
1760
    offset = src_y * s->uvlinesize + src_x;
1761
    ptr = ref_picture[1] + offset;
1762
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1763
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1764
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1765
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1766
            ptr= s->edge_emu_buffer;
1767
            emu=1;
1768
        }
1769
    }
1770
    sx= (sx << 2) >> lowres;
1771
    sy= (sy << 2) >> lowres;
1772
    pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1773

    
1774
    ptr = ref_picture[2] + offset;
1775
    if(emu){
1776
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1777
        ptr= s->edge_emu_buffer;
1778
    }
1779
    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1780
}
1781

    
1782
/**
1783
 * motion compensation of a single macroblock
1784
 * @param s context
1785
 * @param dest_y luma destination pointer
1786
 * @param dest_cb chroma cb/u destination pointer
1787
 * @param dest_cr chroma cr/v destination pointer
1788
 * @param dir direction (0->forward, 1->backward)
1789
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1790
 * @param pix_op halfpel motion compensation function (average or put normally)
1791
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1792
 */
1793
static inline void MPV_motion_lowres(MpegEncContext *s,
1794
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1795
                              int dir, uint8_t **ref_picture,
1796
                              h264_chroma_mc_func *pix_op)
1797
{
1798
    int mx, my;
1799
    int mb_x, mb_y, i;
1800
    const int lowres= s->avctx->lowres;
1801
    const int block_s= 8>>lowres;
1802

    
1803
    mb_x = s->mb_x;
1804
    mb_y = s->mb_y;
1805

    
1806
    switch(s->mv_type) {
1807
    case MV_TYPE_16X16:
1808
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1809
                    0, 0, 0,
1810
                    ref_picture, pix_op,
1811
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1812
        break;
1813
    case MV_TYPE_8X8:
1814
        mx = 0;
1815
        my = 0;
1816
            for(i=0;i<4;i++) {
1817
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1818
                            ref_picture[0], 0, 0,
1819
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1820
                            s->width, s->height, s->linesize,
1821
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1822
                            block_s, block_s, pix_op,
1823
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1824

    
1825
                mx += s->mv[dir][i][0];
1826
                my += s->mv[dir][i][1];
1827
            }
1828

    
1829
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1830
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1831
        break;
1832
    case MV_TYPE_FIELD:
1833
        if (s->picture_structure == PICT_FRAME) {
1834
            /* top field */
1835
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1836
                        1, 0, s->field_select[dir][0],
1837
                        ref_picture, pix_op,
1838
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1839
            /* bottom field */
1840
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1841
                        1, 1, s->field_select[dir][1],
1842
                        ref_picture, pix_op,
1843
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1844
        } else {
1845
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1846
                ref_picture= s->current_picture_ptr->data;
1847
            }
1848

    
1849
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1850
                        0, 0, s->field_select[dir][0],
1851
                        ref_picture, pix_op,
1852
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1853
        }
1854
        break;
1855
    case MV_TYPE_16X8:
1856
        for(i=0; i<2; i++){
1857
            uint8_t ** ref2picture;
1858

    
1859
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1860
                ref2picture= ref_picture;
1861
            }else{
1862
                ref2picture= s->current_picture_ptr->data;
1863
            }
1864

    
1865
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1866
                        0, 0, s->field_select[dir][i],
1867
                        ref2picture, pix_op,
1868
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1869

    
1870
            dest_y += 2*block_s*s->linesize;
1871
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1872
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1873
        }
1874
        break;
1875
    case MV_TYPE_DMV:
1876
        if(s->picture_structure == PICT_FRAME){
1877
            for(i=0; i<2; i++){
1878
                int j;
1879
                for(j=0; j<2; j++){
1880
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1881
                                1, j, j^i,
1882
                                ref_picture, pix_op,
1883
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1884
                }
1885
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1886
            }
1887
        }else{
1888
            for(i=0; i<2; i++){
1889
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1890
                            0, 0, s->picture_structure != i+1,
1891
                            ref_picture, pix_op,
1892
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1893

    
1894
                // after put we make avg of the same block
1895
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1896

    
1897
                //opposite parity is always in the same frame if this is second field
1898
                if(!s->first_field){
1899
                    ref_picture = s->current_picture_ptr->data;
1900
                }
1901
            }
1902
        }
1903
    break;
1904
    default: assert(0);
1905
    }
1906
}
1907

    
1908
/**
1909
 * find the lowest MB row referenced in the MVs
1910
 */
1911
int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1912
{
1913
    int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1914
    int my, off, i, mvs;
1915

    
1916
    if (s->picture_structure != PICT_FRAME) goto unhandled;
1917

    
1918
    switch (s->mv_type) {
1919
        case MV_TYPE_16X16:
1920
            mvs = 1;
1921
            break;
1922
        case MV_TYPE_16X8:
1923
            mvs = 2;
1924
            break;
1925
        case MV_TYPE_8X8:
1926
            mvs = 4;
1927
            break;
1928
        default:
1929
            goto unhandled;
1930
    }
1931

    
1932
    for (i = 0; i < mvs; i++) {
1933
        my = s->mv[dir][i][1]<<qpel_shift;
1934
        my_max = FFMAX(my_max, my);
1935
        my_min = FFMIN(my_min, my);
1936
    }
1937

    
1938
    off = (FFMAX(-my_min, my_max) + 63) >> 6;
1939

    
1940
    return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1941
unhandled:
1942
    return s->mb_height-1;
1943
}
1944

    
1945
/* put block[] to dest[] */
1946
static inline void put_dct(MpegEncContext *s,
1947
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1948
{
1949
    s->dct_unquantize_intra(s, block, i, qscale);
1950
    s->dsp.idct_put (dest, line_size, block);
1951
}
1952

    
1953
/* add block[] to dest[] */
1954
static inline void add_dct(MpegEncContext *s,
1955
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1956
{
1957
    if (s->block_last_index[i] >= 0) {
1958
        s->dsp.idct_add (dest, line_size, block);
1959
    }
1960
}
1961

    
1962
static inline void add_dequant_dct(MpegEncContext *s,
1963
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1964
{
1965
    if (s->block_last_index[i] >= 0) {
1966
        s->dct_unquantize_inter(s, block, i, qscale);
1967

    
1968
        s->dsp.idct_add (dest, line_size, block);
1969
    }
1970
}
1971

    
1972
/**
1973
 * cleans dc, ac, coded_block for the current non intra MB
1974
 */
1975
void ff_clean_intra_table_entries(MpegEncContext *s)
1976
{
1977
    int wrap = s->b8_stride;
1978
    int xy = s->block_index[0];
1979

    
1980
    s->dc_val[0][xy           ] =
1981
    s->dc_val[0][xy + 1       ] =
1982
    s->dc_val[0][xy     + wrap] =
1983
    s->dc_val[0][xy + 1 + wrap] = 1024;
1984
    /* ac pred */
1985
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1986
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1987
    if (s->msmpeg4_version>=3) {
1988
        s->coded_block[xy           ] =
1989
        s->coded_block[xy + 1       ] =
1990
        s->coded_block[xy     + wrap] =
1991
        s->coded_block[xy + 1 + wrap] = 0;
1992
    }
1993
    /* chroma */
1994
    wrap = s->mb_stride;
1995
    xy = s->mb_x + s->mb_y * wrap;
1996
    s->dc_val[1][xy] =
1997
    s->dc_val[2][xy] = 1024;
1998
    /* ac pred */
1999
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2000
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2001

    
2002
    s->mbintra_table[xy]= 0;
2003
}
2004

    
2005
/* generic function called after a macroblock has been parsed by the
2006
   decoder or after it has been encoded by the encoder.
2007

2008
   Important variables used:
2009
   s->mb_intra : true if intra macroblock
2010
   s->mv_dir   : motion vector direction
2011
   s->mv_type  : motion vector type
2012
   s->mv       : motion vector
2013
   s->interlaced_dct : true if interlaced dct used (mpeg2)
2014
 */
2015
static av_always_inline
2016
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2017
                            int lowres_flag, int is_mpeg12)
2018
{
2019
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2020
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2021
        ff_xvmc_decode_mb(s);//xvmc uses pblocks
2022
        return;
2023
    }
2024

    
2025
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2026
       /* save DCT coefficients */
2027
       int i,j;
2028
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
2029
       av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2030
       for(i=0; i<6; i++){
2031
           for(j=0; j<64; j++){
2032
               *dct++ = block[i][s->dsp.idct_permutation[j]];
2033
               av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2034
           }
2035
           av_log(s->avctx, AV_LOG_DEBUG, "\n");
2036
       }
2037
    }
2038

    
2039
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2040

    
2041
    /* update DC predictors for P macroblocks */
2042
    if (!s->mb_intra) {
2043
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2044
            if(s->mbintra_table[mb_xy])
2045
                ff_clean_intra_table_entries(s);
2046
        } else {
2047
            s->last_dc[0] =
2048
            s->last_dc[1] =
2049
            s->last_dc[2] = 128 << s->intra_dc_precision;
2050
        }
2051
    }
2052
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2053
        s->mbintra_table[mb_xy]=1;
2054

    
2055
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2056
        uint8_t *dest_y, *dest_cb, *dest_cr;
2057
        int dct_linesize, dct_offset;
2058
        op_pixels_func (*op_pix)[4];
2059
        qpel_mc_func (*op_qpix)[16];
2060
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2061
        const int uvlinesize= s->current_picture.linesize[1];
2062
        const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2063
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2064

    
2065
        /* avoid copy if macroblock skipped in last frame too */
2066
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2067
        if(!s->encoding){
2068
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2069
            const int age= s->current_picture.age;
2070

    
2071
            assert(age);
2072

    
2073
            if (s->mb_skipped) {
2074
                s->mb_skipped= 0;
2075
                assert(s->pict_type!=AV_PICTURE_TYPE_I);
2076

    
2077
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2078
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2079

    
2080
                /* if previous was skipped too, then nothing to do !  */
2081
                if (*mbskip_ptr >= age && s->current_picture.reference){
2082
                    return;
2083
                }
2084
            } else if(!s->current_picture.reference){
2085
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2086
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2087
            } else{
2088
                *mbskip_ptr = 0; /* not skipped */
2089
            }
2090
        }
2091

    
2092
        dct_linesize = linesize << s->interlaced_dct;
2093
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2094

    
2095
        if(readable){
2096
            dest_y=  s->dest[0];
2097
            dest_cb= s->dest[1];
2098
            dest_cr= s->dest[2];
2099
        }else{
2100
            dest_y = s->b_scratchpad;
2101
            dest_cb= s->b_scratchpad+16*linesize;
2102
            dest_cr= s->b_scratchpad+32*linesize;
2103
        }
2104

    
2105
        if (!s->mb_intra) {
2106
            /* motion handling */
2107
            /* decoding or more than one mb_type (MC was already done otherwise) */
2108
            if(!s->encoding){
2109

    
2110
                if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2111
                    if (s->mv_dir & MV_DIR_FORWARD) {
2112
                        ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2113
                    }
2114
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2115
                        ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2116
                    }
2117
                }
2118

    
2119
                if(lowres_flag){
2120
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2121

    
2122
                    if (s->mv_dir & MV_DIR_FORWARD) {
2123
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2124
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2125
                    }
2126
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2127
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2128
                    }
2129
                }else{
2130
                    op_qpix= s->me.qpel_put;
2131
                    if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2132
                        op_pix = s->dsp.put_pixels_tab;
2133
                    }else{
2134
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
2135
                    }
2136
                    if (s->mv_dir & MV_DIR_FORWARD) {
2137
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2138
                        op_pix = s->dsp.avg_pixels_tab;
2139
                        op_qpix= s->me.qpel_avg;
2140
                    }
2141
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2142
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2143
                    }
2144
                }
2145
            }
2146

    
2147
            /* skip dequant / idct if we are really late ;) */
2148
            if(s->avctx->skip_idct){
2149
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2150
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2151
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
2152
                    goto skip_idct;
2153
            }
2154

    
2155
            /* add dct residue */
2156
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2157
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2158
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2159
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2160
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2161
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2162

    
2163
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2164
                    if (s->chroma_y_shift){
2165
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2166
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2167
                    }else{
2168
                        dct_linesize >>= 1;
2169
                        dct_offset >>=1;
2170
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2171
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2172
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2173
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2174
                    }
2175
                }
2176
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2177
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2178
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2179
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2180
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2181

    
2182
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2183
                    if(s->chroma_y_shift){//Chroma420
2184
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
2185
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
2186
                    }else{
2187
                        //chroma422
2188
                        dct_linesize = uvlinesize << s->interlaced_dct;
2189
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2190

    
2191
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
2192
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
2193
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2194
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2195
                        if(!s->chroma_x_shift){//Chroma444
2196
                            add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2197
                            add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2198
                            add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2199
                            add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2200
                        }
2201
                    }
2202
                }//fi gray
2203
            }
2204
            else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2205
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2206
            }
2207
        } else {
2208
            /* dct only in intra block */
2209
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2210
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2211
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2212
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2213
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2214

    
2215
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2216
                    if(s->chroma_y_shift){
2217
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2218
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2219
                    }else{
2220
                        dct_offset >>=1;
2221
                        dct_linesize >>=1;
2222
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2223
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2224
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2225
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2226
                    }
2227
                }
2228
            }else{
2229
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2230
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2231
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2232
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2233

    
2234
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2235
                    if(s->chroma_y_shift){
2236
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2237
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2238
                    }else{
2239

    
2240
                        dct_linesize = uvlinesize << s->interlaced_dct;
2241
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2242

    
2243
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2244
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2245
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2246
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2247
                        if(!s->chroma_x_shift){//Chroma444
2248
                            s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2249
                            s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2250
                            s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2251
                            s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2252
                        }
2253
                    }
2254
                }//gray
2255
            }
2256
        }
2257
skip_idct:
2258
        if(!readable){
2259
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2260
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2261
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2262
        }
2263
    }
2264
}
2265

    
2266
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2267
#if !CONFIG_SMALL
2268
    if(s->out_format == FMT_MPEG1) {
2269
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2270
        else                 MPV_decode_mb_internal(s, block, 0, 1);
2271
    } else
2272
#endif
2273
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2274
    else                  MPV_decode_mb_internal(s, block, 0, 0);
2275
}
2276

    
2277
/**
2278
 *
2279
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2280
 */
2281
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2282
    const int field_pic= s->picture_structure != PICT_FRAME;
2283
    if(field_pic){
2284
        h <<= 1;
2285
        y <<= 1;
2286
    }
2287

    
2288
    if (!s->avctx->hwaccel
2289
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2290
       && s->unrestricted_mv
2291
       && s->current_picture.reference
2292
       && !s->intra_only
2293
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2294
        int sides = 0, edge_h;
2295
        if (y==0) sides |= EDGE_TOP;
2296
        if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2297

    
2298
        edge_h= FFMIN(h, s->v_edge_pos - y);
2299

    
2300
        s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2301
        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);
2302
        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);
2303
    }
2304

    
2305
    h= FFMIN(h, s->avctx->height - y);
2306

    
2307
    if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2308

    
2309
    if (s->avctx->draw_horiz_band) {
2310
        AVFrame *src;
2311
        int offset[4];
2312

    
2313
        if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2314
            src= (AVFrame*)s->current_picture_ptr;
2315
        else if(s->last_picture_ptr)
2316
            src= (AVFrame*)s->last_picture_ptr;
2317
        else
2318
            return;
2319

    
2320
        if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2321
            offset[0]=
2322
            offset[1]=
2323
            offset[2]=
2324
            offset[3]= 0;
2325
        }else{
2326
            offset[0]= y * s->linesize;
2327
            offset[1]=
2328
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2329
            offset[3]= 0;
2330
        }
2331

    
2332
        emms_c();
2333

    
2334
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2335
                                  y, s->picture_structure, h);
2336
    }
2337
}
2338

    
2339
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2340
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2341
    const int uvlinesize= s->current_picture.linesize[1];
2342
    const int mb_size= 4 - s->avctx->lowres;
2343

    
2344
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2345
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2346
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2347
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2348
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2349
    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;
2350
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2351

    
2352
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2353
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2354
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2355

    
2356
    if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2357
    {
2358
        if(s->picture_structure==PICT_FRAME){
2359
        s->dest[0] += s->mb_y *   linesize << mb_size;
2360
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2361
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2362
        }else{
2363
            s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2364
            s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2365
            s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2366
            assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2367
        }
2368
    }
2369
}
2370

    
2371
void ff_mpeg_flush(AVCodecContext *avctx){
2372
    int i;
2373
    MpegEncContext *s = avctx->priv_data;
2374

    
2375
    if(s==NULL || s->picture==NULL)
2376
        return;
2377

    
2378
    for(i=0; i<s->picture_count; i++){
2379
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2380
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2381
        free_frame_buffer(s, &s->picture[i]);
2382
    }
2383
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2384

    
2385
    s->mb_x= s->mb_y= 0;
2386
    s->closed_gop= 0;
2387

    
2388
    s->parse_context.state= -1;
2389
    s->parse_context.frame_start_found= 0;
2390
    s->parse_context.overread= 0;
2391
    s->parse_context.overread_index= 0;
2392
    s->parse_context.index= 0;
2393
    s->parse_context.last_index= 0;
2394
    s->bitstream_buffer_size=0;
2395
    s->pp_time=0;
2396
}
2397

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

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

    
2406
    if (n < 4)
2407
        block[0] = block[0] * s->y_dc_scale;
2408
    else
2409
        block[0] = block[0] * s->c_dc_scale;
2410
    /* XXX: only mpeg1 */
2411
    quant_matrix = s->intra_matrix;
2412
    for(i=1;i<=nCoeffs;i++) {
2413
        int j= s->intra_scantable.permutated[i];
2414
        level = block[j];
2415
        if (level) {
2416
            if (level < 0) {
2417
                level = -level;
2418
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2419
                level = (level - 1) | 1;
2420
                level = -level;
2421
            } else {
2422
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2423
                level = (level - 1) | 1;
2424
            }
2425
            block[j] = level;
2426
        }
2427
    }
2428
}
2429

    
2430
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2431
                                   DCTELEM *block, int n, int qscale)
2432
{
2433
    int i, level, nCoeffs;
2434
    const uint16_t *quant_matrix;
2435

    
2436
    nCoeffs= s->block_last_index[n];
2437

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

    
2459
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2460
                                   DCTELEM *block, int n, int qscale)
2461
{
2462
    int i, level, nCoeffs;
2463
    const uint16_t *quant_matrix;
2464

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

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

    
2489
static void dct_unquantize_mpeg2_intra_bitexact(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
    if (n < 4)
2500
        block[0] = block[0] * s->y_dc_scale;
2501
    else
2502
        block[0] = block[0] * s->c_dc_scale;
2503
    quant_matrix = s->intra_matrix;
2504
    for(i=1;i<=nCoeffs;i++) {
2505
        int j= s->intra_scantable.permutated[i];
2506
        level = block[j];
2507
        if (level) {
2508
            if (level < 0) {
2509
                level = -level;
2510
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2511
                level = -level;
2512
            } else {
2513
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2514
            }
2515
            block[j] = level;
2516
            sum+=level;
2517
        }
2518
    }
2519
    block[63]^=sum&1;
2520
}
2521

    
2522
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2523
                                   DCTELEM *block, int n, int qscale)
2524
{
2525
    int i, level, nCoeffs;
2526
    const uint16_t *quant_matrix;
2527
    int sum=-1;
2528

    
2529
    if(s->alternate_scan) nCoeffs= 63;
2530
    else nCoeffs= s->block_last_index[n];
2531

    
2532
    quant_matrix = s->inter_matrix;
2533
    for(i=0; i<=nCoeffs; i++) {
2534
        int j= s->intra_scantable.permutated[i];
2535
        level = block[j];
2536
        if (level) {
2537
            if (level < 0) {
2538
                level = -level;
2539
                level = (((level << 1) + 1) * qscale *
2540
                         ((int) (quant_matrix[j]))) >> 4;
2541
                level = -level;
2542
            } else {
2543
                level = (((level << 1) + 1) * qscale *
2544
                         ((int) (quant_matrix[j]))) >> 4;
2545
            }
2546
            block[j] = level;
2547
            sum+=level;
2548
        }
2549
    }
2550
    block[63]^=sum&1;
2551
}
2552

    
2553
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2554
                                  DCTELEM *block, int n, int qscale)
2555
{
2556
    int i, level, qmul, qadd;
2557
    int nCoeffs;
2558

    
2559
    assert(s->block_last_index[n]>=0);
2560

    
2561
    qmul = qscale << 1;
2562

    
2563
    if (!s->h263_aic) {
2564
        if (n < 4)
2565
            block[0] = block[0] * s->y_dc_scale;
2566
        else
2567
            block[0] = block[0] * s->c_dc_scale;
2568
        qadd = (qscale - 1) | 1;
2569
    }else{
2570
        qadd = 0;
2571
    }
2572
    if(s->ac_pred)
2573
        nCoeffs=63;
2574
    else
2575
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2576

    
2577
    for(i=1; i<=nCoeffs; i++) {
2578
        level = block[i];
2579
        if (level) {
2580
            if (level < 0) {
2581
                level = level * qmul - qadd;
2582
            } else {
2583
                level = level * qmul + qadd;
2584
            }
2585
            block[i] = level;
2586
        }
2587
    }
2588
}
2589

    
2590
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2591
                                  DCTELEM *block, int n, int qscale)
2592
{
2593
    int i, level, qmul, qadd;
2594
    int nCoeffs;
2595

    
2596
    assert(s->block_last_index[n]>=0);
2597

    
2598
    qadd = (qscale - 1) | 1;
2599
    qmul = qscale << 1;
2600

    
2601
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2602

    
2603
    for(i=0; i<=nCoeffs; i++) {
2604
        level = block[i];
2605
        if (level) {
2606
            if (level < 0) {
2607
                level = level * qmul - qadd;
2608
            } else {
2609
                level = level * qmul + qadd;
2610
            }
2611
            block[i] = level;
2612
        }
2613
    }
2614
}
2615

    
2616
/**
2617
 * set qscale and update qscale dependent variables.
2618
 */
2619
void ff_set_qscale(MpegEncContext * s, int qscale)
2620
{
2621
    if (qscale < 1)
2622
        qscale = 1;
2623
    else if (qscale > 31)
2624
        qscale = 31;
2625

    
2626
    s->qscale = qscale;
2627
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2628

    
2629
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2630
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2631
}
2632

    
2633
void MPV_report_decode_progress(MpegEncContext *s)
2634
{
2635
    if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame)
2636
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2637
}