Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 7e2eb4ba

History | View | Annotate | Download (99.3 KB)

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

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

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

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

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

    
62

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

    
66
//#define DEBUG
67

    
68

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

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

    
82
static const uint8_t mpeg2_dc_scale_table1[128]={
83
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
84
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88
};
89

    
90
static const uint8_t mpeg2_dc_scale_table2[128]={
91
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
92
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
96
};
97

    
98
static const uint8_t mpeg2_dc_scale_table3[128]={
99
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
100
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
102
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
103
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
104
};
105

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

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

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

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

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

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

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

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

    
152
    return p+4;
153
}
154

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

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

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

    
196
    return 0;
197
}
198

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

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

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

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

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

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

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

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

    
251
    return 0;
252
}
253

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

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

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

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

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

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

    
313
    /* It might be nicer if the application would keep track of these
314
     * but it would require an API change. */
315
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
316
    s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
317
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
318
        pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
319
    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!=FF_B_TYPE){
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
    s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
684
    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
685
    for(i = 0; i < s->picture_count; i++) {
686
        avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
687
    }
688

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1095
    if(s->codec_id != CODEC_ID_H264){
1096
        if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && s->pict_type!=FF_I_TYPE){
1097
            av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1098
            /* Allocate a dummy frame */
1099
            i= ff_find_unused_picture(s, 0);
1100
            s->last_picture_ptr= &s->picture[i];
1101
            if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1102
                return -1;
1103
            ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1104
            ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1105
        }
1106
        if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
1107
            /* Allocate a dummy frame */
1108
            i= ff_find_unused_picture(s, 0);
1109
            s->next_picture_ptr= &s->picture[i];
1110
            if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1111
                return -1;
1112
            ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1113
            ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1114
        }
1115
    }
1116

    
1117
    if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1118
    if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1119

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

    
1122
    if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1123
        int i;
1124
        for(i=0; i<4; i++){
1125
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1126
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1127
            }
1128
            s->current_picture.linesize[i] *= 2;
1129
            s->last_picture.linesize[i] *=2;
1130
            s->next_picture.linesize[i] *=2;
1131
        }
1132
    }
1133

    
1134
#if FF_API_HURRY_UP
1135
    s->hurry_up= s->avctx->hurry_up;
1136
#endif
1137
    s->error_recognition= avctx->error_recognition;
1138

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

    
1152
    if(s->dct_error_sum){
1153
        assert(s->avctx->noise_reduction && s->encoding);
1154

    
1155
        update_noise_reduction(s);
1156
    }
1157

    
1158
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1159
        return ff_xvmc_field_start(s, avctx);
1160

    
1161
    return 0;
1162
}
1163

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

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

    
1185
    }
1186

    
1187
    emms_c();
1188

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

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

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

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

    
1236
    sx= av_clip(sx, 0, w-1);
1237
    sy= av_clip(sy, 0, h-1);
1238
    ex= av_clip(ex, 0, w-1);
1239
    ey= av_clip(ey, 0, h-1);
1240

    
1241
    buf[sy*stride + sx]+= color;
1242

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

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

    
1285
    sx= av_clip(sx, -100, w+100);
1286
    sy= av_clip(sy, -100, h+100);
1287
    ex= av_clip(ex, -100, w+100);
1288
    ey= av_clip(ey, -100, h+100);
1289

    
1290
    dx= ex - sx;
1291
    dy= ey - sy;
1292

    
1293
    if(dx*dx + dy*dy > 3*3){
1294
        int rx=  dx + dy;
1295
        int ry= -dx + dy;
1296
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1297

    
1298
        //FIXME subpixel accuracy
1299
        rx= ROUNDED_DIV(rx*3<<4, length);
1300
        ry= ROUNDED_DIV(ry*3<<4, length);
1301

    
1302
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1303
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1304
    }
1305
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1306
}
1307

    
1308
/**
1309
 * prints debuging info for the given picture.
1310
 */
1311
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1312

    
1313
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1314

    
1315
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1316
        int x,y;
1317

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

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

    
1379

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

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

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

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

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

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

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

    
1470
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1471
                            my*=2;
1472

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

    
1501

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

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

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

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

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

    
1585
    if(s->quarter_sample){
1586
        motion_x/=2;
1587
        motion_y/=2;
1588
    }
1589

    
1590
    sx= motion_x & s_mask;
1591
    sy= motion_y & s_mask;
1592
    src_x += motion_x >> (lowres+1);
1593
    src_y += motion_y >> (lowres+1);
1594

    
1595
    src += src_y * stride + src_x;
1596

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

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

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

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

    
1636
    if(field_based){
1637
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1638
    }
1639

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

    
1645
    if (s->out_format == FMT_H263) {
1646
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1647
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1648
        uvsrc_x = src_x>>1;
1649
        uvsrc_y = src_y>>1;
1650
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1651
        mx = motion_x / 4;
1652
        my = motion_y / 4;
1653
        uvsx = (2*mx) & s_mask;
1654
        uvsy = (2*my) & s_mask;
1655
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1656
        uvsrc_y =    mb_y*block_s               + (my >> lowres);
1657
    } else {
1658
        mx = motion_x / 2;
1659
        my = motion_y / 2;
1660
        uvsx = mx & s_mask;
1661
        uvsy = my & s_mask;
1662
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1663
        uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1664
    }
1665

    
1666
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1667
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1668
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1669

    
1670
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1671
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1672
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1673
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1674
            ptr_y = s->edge_emu_buffer;
1675
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1676
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1677
                s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1678
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1679
                s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1680
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1681
                ptr_cb= uvbuf;
1682
                ptr_cr= uvbuf+16;
1683
            }
1684
    }
1685

    
1686
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1687
        dest_y += s->linesize;
1688
        dest_cb+= s->uvlinesize;
1689
        dest_cr+= s->uvlinesize;
1690
    }
1691

    
1692
    if(field_select){
1693
        ptr_y += s->linesize;
1694
        ptr_cb+= s->uvlinesize;
1695
        ptr_cr+= s->uvlinesize;
1696
    }
1697

    
1698
    sx= (sx << 2) >> lowres;
1699
    sy= (sy << 2) >> lowres;
1700
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1701

    
1702
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1703
        uvsx= (uvsx << 2) >> lowres;
1704
        uvsy= (uvsy << 2) >> lowres;
1705
        pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1706
        pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1707
    }
1708
    //FIXME h261 lowres loop filter
1709
}
1710

    
1711
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1712
                                     uint8_t *dest_cb, uint8_t *dest_cr,
1713
                                     uint8_t **ref_picture,
1714
                                     h264_chroma_mc_func *pix_op,
1715
                                     int mx, int my){
1716
    const int lowres= s->avctx->lowres;
1717
    const int op_index= FFMIN(lowres, 2);
1718
    const int block_s= 8>>lowres;
1719
    const int s_mask= (2<<lowres)-1;
1720
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1721
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1722
    int emu=0, src_x, src_y, offset, sx, sy;
1723
    uint8_t *ptr;
1724

    
1725
    if(s->quarter_sample){
1726
        mx/=2;
1727
        my/=2;
1728
    }
1729

    
1730
    /* In case of 8X8, we construct a single chroma motion vector
1731
       with a special rounding */
1732
    mx= ff_h263_round_chroma(mx);
1733
    my= ff_h263_round_chroma(my);
1734

    
1735
    sx= mx & s_mask;
1736
    sy= my & s_mask;
1737
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1738
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1739

    
1740
    offset = src_y * s->uvlinesize + src_x;
1741
    ptr = ref_picture[1] + offset;
1742
    if(s->flags&CODEC_FLAG_EMU_EDGE){
1743
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1744
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1745
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1746
            ptr= s->edge_emu_buffer;
1747
            emu=1;
1748
        }
1749
    }
1750
    sx= (sx << 2) >> lowres;
1751
    sy= (sy << 2) >> lowres;
1752
    pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1753

    
1754
    ptr = ref_picture[2] + offset;
1755
    if(emu){
1756
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1757
        ptr= s->edge_emu_buffer;
1758
    }
1759
    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1760
}
1761

    
1762
/**
1763
 * motion compensation of a single macroblock
1764
 * @param s context
1765
 * @param dest_y luma destination pointer
1766
 * @param dest_cb chroma cb/u destination pointer
1767
 * @param dest_cr chroma cr/v destination pointer
1768
 * @param dir direction (0->forward, 1->backward)
1769
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1770
 * @param pix_op halfpel motion compensation function (average or put normally)
1771
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1772
 */
1773
static inline void MPV_motion_lowres(MpegEncContext *s,
1774
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1775
                              int dir, uint8_t **ref_picture,
1776
                              h264_chroma_mc_func *pix_op)
1777
{
1778
    int mx, my;
1779
    int mb_x, mb_y, i;
1780
    const int lowres= s->avctx->lowres;
1781
    const int block_s= 8>>lowres;
1782

    
1783
    mb_x = s->mb_x;
1784
    mb_y = s->mb_y;
1785

    
1786
    switch(s->mv_type) {
1787
    case MV_TYPE_16X16:
1788
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1789
                    0, 0, 0,
1790
                    ref_picture, pix_op,
1791
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1792
        break;
1793
    case MV_TYPE_8X8:
1794
        mx = 0;
1795
        my = 0;
1796
            for(i=0;i<4;i++) {
1797
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1798
                            ref_picture[0], 0, 0,
1799
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1800
                            s->width, s->height, s->linesize,
1801
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1802
                            block_s, block_s, pix_op,
1803
                            s->mv[dir][i][0], s->mv[dir][i][1]);
1804

    
1805
                mx += s->mv[dir][i][0];
1806
                my += s->mv[dir][i][1];
1807
            }
1808

    
1809
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1810
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1811
        break;
1812
    case MV_TYPE_FIELD:
1813
        if (s->picture_structure == PICT_FRAME) {
1814
            /* top field */
1815
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1816
                        1, 0, s->field_select[dir][0],
1817
                        ref_picture, pix_op,
1818
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1819
            /* bottom field */
1820
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1821
                        1, 1, s->field_select[dir][1],
1822
                        ref_picture, pix_op,
1823
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1824
        } else {
1825
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1826
                ref_picture= s->current_picture_ptr->data;
1827
            }
1828

    
1829
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1830
                        0, 0, s->field_select[dir][0],
1831
                        ref_picture, pix_op,
1832
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1833
        }
1834
        break;
1835
    case MV_TYPE_16X8:
1836
        for(i=0; i<2; i++){
1837
            uint8_t ** ref2picture;
1838

    
1839
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1840
                ref2picture= ref_picture;
1841
            }else{
1842
                ref2picture= s->current_picture_ptr->data;
1843
            }
1844

    
1845
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1846
                        0, 0, s->field_select[dir][i],
1847
                        ref2picture, pix_op,
1848
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1849

    
1850
            dest_y += 2*block_s*s->linesize;
1851
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1852
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1853
        }
1854
        break;
1855
    case MV_TYPE_DMV:
1856
        if(s->picture_structure == PICT_FRAME){
1857
            for(i=0; i<2; i++){
1858
                int j;
1859
                for(j=0; j<2; j++){
1860
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1861
                                1, j, j^i,
1862
                                ref_picture, pix_op,
1863
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1864
                }
1865
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1866
            }
1867
        }else{
1868
            for(i=0; i<2; i++){
1869
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1870
                            0, 0, s->picture_structure != i+1,
1871
                            ref_picture, pix_op,
1872
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1873

    
1874
                // after put we make avg of the same block
1875
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1876

    
1877
                //opposite parity is always in the same frame if this is second field
1878
                if(!s->first_field){
1879
                    ref_picture = s->current_picture_ptr->data;
1880
                }
1881
            }
1882
        }
1883
    break;
1884
    default: assert(0);
1885
    }
1886
}
1887

    
1888
/**
1889
 * find the lowest MB row referenced in the MVs
1890
 */
1891
int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1892
{
1893
    int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1894
    int my, off, i, mvs;
1895

    
1896
    if (s->picture_structure != PICT_FRAME) goto unhandled;
1897

    
1898
    switch (s->mv_type) {
1899
        case MV_TYPE_16X16:
1900
            mvs = 1;
1901
            break;
1902
        case MV_TYPE_16X8:
1903
            mvs = 2;
1904
            break;
1905
        case MV_TYPE_8X8:
1906
            mvs = 4;
1907
            break;
1908
        default:
1909
            goto unhandled;
1910
    }
1911

    
1912
    for (i = 0; i < mvs; i++) {
1913
        my = s->mv[dir][i][1]<<qpel_shift;
1914
        my_max = FFMAX(my_max, my);
1915
        my_min = FFMIN(my_min, my);
1916
    }
1917

    
1918
    off = (FFMAX(-my_min, my_max) + 63) >> 6;
1919

    
1920
    return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1921
unhandled:
1922
    return s->mb_height-1;
1923
}
1924

    
1925
/* put block[] to dest[] */
1926
static inline void put_dct(MpegEncContext *s,
1927
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1928
{
1929
    s->dct_unquantize_intra(s, block, i, qscale);
1930
    s->dsp.idct_put (dest, line_size, block);
1931
}
1932

    
1933
/* add block[] to dest[] */
1934
static inline void add_dct(MpegEncContext *s,
1935
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1936
{
1937
    if (s->block_last_index[i] >= 0) {
1938
        s->dsp.idct_add (dest, line_size, block);
1939
    }
1940
}
1941

    
1942
static inline void add_dequant_dct(MpegEncContext *s,
1943
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1944
{
1945
    if (s->block_last_index[i] >= 0) {
1946
        s->dct_unquantize_inter(s, block, i, qscale);
1947

    
1948
        s->dsp.idct_add (dest, line_size, block);
1949
    }
1950
}
1951

    
1952
/**
1953
 * cleans dc, ac, coded_block for the current non intra MB
1954
 */
1955
void ff_clean_intra_table_entries(MpegEncContext *s)
1956
{
1957
    int wrap = s->b8_stride;
1958
    int xy = s->block_index[0];
1959

    
1960
    s->dc_val[0][xy           ] =
1961
    s->dc_val[0][xy + 1       ] =
1962
    s->dc_val[0][xy     + wrap] =
1963
    s->dc_val[0][xy + 1 + wrap] = 1024;
1964
    /* ac pred */
1965
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1966
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1967
    if (s->msmpeg4_version>=3) {
1968
        s->coded_block[xy           ] =
1969
        s->coded_block[xy + 1       ] =
1970
        s->coded_block[xy     + wrap] =
1971
        s->coded_block[xy + 1 + wrap] = 0;
1972
    }
1973
    /* chroma */
1974
    wrap = s->mb_stride;
1975
    xy = s->mb_x + s->mb_y * wrap;
1976
    s->dc_val[1][xy] =
1977
    s->dc_val[2][xy] = 1024;
1978
    /* ac pred */
1979
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1980
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1981

    
1982
    s->mbintra_table[xy]= 0;
1983
}
1984

    
1985
/* generic function called after a macroblock has been parsed by the
1986
   decoder or after it has been encoded by the encoder.
1987

1988
   Important variables used:
1989
   s->mb_intra : true if intra macroblock
1990
   s->mv_dir   : motion vector direction
1991
   s->mv_type  : motion vector type
1992
   s->mv       : motion vector
1993
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1994
 */
1995
static av_always_inline
1996
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1997
                            int lowres_flag, int is_mpeg12)
1998
{
1999
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2000
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2001
        ff_xvmc_decode_mb(s);//xvmc uses pblocks
2002
        return;
2003
    }
2004

    
2005
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2006
       /* save DCT coefficients */
2007
       int i,j;
2008
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
2009
       av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2010
       for(i=0; i<6; i++){
2011
           for(j=0; j<64; j++){
2012
               *dct++ = block[i][s->dsp.idct_permutation[j]];
2013
               av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2014
           }
2015
           av_log(s->avctx, AV_LOG_DEBUG, "\n");
2016
       }
2017
    }
2018

    
2019
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2020

    
2021
    /* update DC predictors for P macroblocks */
2022
    if (!s->mb_intra) {
2023
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2024
            if(s->mbintra_table[mb_xy])
2025
                ff_clean_intra_table_entries(s);
2026
        } else {
2027
            s->last_dc[0] =
2028
            s->last_dc[1] =
2029
            s->last_dc[2] = 128 << s->intra_dc_precision;
2030
        }
2031
    }
2032
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2033
        s->mbintra_table[mb_xy]=1;
2034

    
2035
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2036
        uint8_t *dest_y, *dest_cb, *dest_cr;
2037
        int dct_linesize, dct_offset;
2038
        op_pixels_func (*op_pix)[4];
2039
        qpel_mc_func (*op_qpix)[16];
2040
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2041
        const int uvlinesize= s->current_picture.linesize[1];
2042
        const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2043
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2044

    
2045
        /* avoid copy if macroblock skipped in last frame too */
2046
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2047
        if(!s->encoding){
2048
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2049
            const int age= s->current_picture.age;
2050

    
2051
            assert(age);
2052

    
2053
            if (s->mb_skipped) {
2054
                s->mb_skipped= 0;
2055
                assert(s->pict_type!=FF_I_TYPE);
2056

    
2057
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2058
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2059

    
2060
                /* if previous was skipped too, then nothing to do !  */
2061
                if (*mbskip_ptr >= age && s->current_picture.reference){
2062
                    return;
2063
                }
2064
            } else if(!s->current_picture.reference){
2065
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2066
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2067
            } else{
2068
                *mbskip_ptr = 0; /* not skipped */
2069
            }
2070
        }
2071

    
2072
        dct_linesize = linesize << s->interlaced_dct;
2073
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2074

    
2075
        if(readable){
2076
            dest_y=  s->dest[0];
2077
            dest_cb= s->dest[1];
2078
            dest_cr= s->dest[2];
2079
        }else{
2080
            dest_y = s->b_scratchpad;
2081
            dest_cb= s->b_scratchpad+16*linesize;
2082
            dest_cr= s->b_scratchpad+32*linesize;
2083
        }
2084

    
2085
        if (!s->mb_intra) {
2086
            /* motion handling */
2087
            /* decoding or more than one mb_type (MC was already done otherwise) */
2088
            if(!s->encoding){
2089

    
2090
                if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2091
                    if (s->mv_dir & MV_DIR_FORWARD) {
2092
                        ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2093
                    }
2094
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2095
                        ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2096
                    }
2097
                }
2098

    
2099
                if(lowres_flag){
2100
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2101

    
2102
                    if (s->mv_dir & MV_DIR_FORWARD) {
2103
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2104
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2105
                    }
2106
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2107
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2108
                    }
2109
                }else{
2110
                    op_qpix= s->me.qpel_put;
2111
                    if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
2112
                        op_pix = s->dsp.put_pixels_tab;
2113
                    }else{
2114
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
2115
                    }
2116
                    if (s->mv_dir & MV_DIR_FORWARD) {
2117
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2118
                        op_pix = s->dsp.avg_pixels_tab;
2119
                        op_qpix= s->me.qpel_avg;
2120
                    }
2121
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2122
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2123
                    }
2124
                }
2125
            }
2126

    
2127
            /* skip dequant / idct if we are really late ;) */
2128
#if FF_API_HURRY_UP
2129
            if(s->hurry_up>1) goto skip_idct;
2130
#endif
2131
            if(s->avctx->skip_idct){
2132
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
2133
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
2134
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
2135
                    goto skip_idct;
2136
            }
2137

    
2138
            /* add dct residue */
2139
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2140
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2141
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2142
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2143
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2144
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2145

    
2146
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2147
                    if (s->chroma_y_shift){
2148
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2149
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2150
                    }else{
2151
                        dct_linesize >>= 1;
2152
                        dct_offset >>=1;
2153
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2154
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2155
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2156
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2157
                    }
2158
                }
2159
            } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2160
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2161
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2162
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2163
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2164

    
2165
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2166
                    if(s->chroma_y_shift){//Chroma420
2167
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
2168
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
2169
                    }else{
2170
                        //chroma422
2171
                        dct_linesize = uvlinesize << s->interlaced_dct;
2172
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2173

    
2174
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
2175
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
2176
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2177
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2178
                        if(!s->chroma_x_shift){//Chroma444
2179
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2180
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2181
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2182
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2183
                        }
2184
                    }
2185
                }//fi gray
2186
            }
2187
            else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2188
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2189
            }
2190
        } else {
2191
            /* dct only in intra block */
2192
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2193
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2194
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2195
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2196
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2197

    
2198
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2199
                    if(s->chroma_y_shift){
2200
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2201
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2202
                    }else{
2203
                        dct_offset >>=1;
2204
                        dct_linesize >>=1;
2205
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2206
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2207
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2208
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2209
                    }
2210
                }
2211
            }else{
2212
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2213
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2214
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2215
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2216

    
2217
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2218
                    if(s->chroma_y_shift){
2219
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2220
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2221
                    }else{
2222

    
2223
                        dct_linesize = uvlinesize << s->interlaced_dct;
2224
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2225

    
2226
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2227
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2228
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2229
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2230
                        if(!s->chroma_x_shift){//Chroma444
2231
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2232
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2233
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2234
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2235
                        }
2236
                    }
2237
                }//gray
2238
            }
2239
        }
2240
skip_idct:
2241
        if(!readable){
2242
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2243
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2244
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2245
        }
2246
    }
2247
}
2248

    
2249
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2250
#if !CONFIG_SMALL
2251
    if(s->out_format == FMT_MPEG1) {
2252
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2253
        else                 MPV_decode_mb_internal(s, block, 0, 1);
2254
    } else
2255
#endif
2256
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2257
    else                  MPV_decode_mb_internal(s, block, 0, 0);
2258
}
2259

    
2260
/**
2261
 *
2262
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2263
 */
2264
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2265
    const int field_pic= s->picture_structure != PICT_FRAME;
2266
    if(field_pic){
2267
        h <<= 1;
2268
        y <<= 1;
2269
    }
2270

    
2271
    if (!s->avctx->hwaccel
2272
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2273
       && s->unrestricted_mv
2274
       && s->current_picture.reference
2275
       && !s->intra_only
2276
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2277
        int sides = 0, edge_h;
2278
        if (y==0) sides |= EDGE_TOP;
2279
        if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2280

    
2281
        edge_h= FFMIN(h, s->v_edge_pos - y);
2282

    
2283
        s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2284
        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);
2285
        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);
2286
    }
2287

    
2288
    h= FFMIN(h, s->avctx->height - y);
2289

    
2290
    if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2291

    
2292
    if (s->avctx->draw_horiz_band) {
2293
        AVFrame *src;
2294
        int offset[4];
2295

    
2296
        if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2297
            src= (AVFrame*)s->current_picture_ptr;
2298
        else if(s->last_picture_ptr)
2299
            src= (AVFrame*)s->last_picture_ptr;
2300
        else
2301
            return;
2302

    
2303
        if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2304
            offset[0]=
2305
            offset[1]=
2306
            offset[2]=
2307
            offset[3]= 0;
2308
        }else{
2309
            offset[0]= y * s->linesize;
2310
            offset[1]=
2311
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2312
            offset[3]= 0;
2313
        }
2314

    
2315
        emms_c();
2316

    
2317
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2318
                                  y, s->picture_structure, h);
2319
    }
2320
}
2321

    
2322
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2323
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2324
    const int uvlinesize= s->current_picture.linesize[1];
2325
    const int mb_size= 4 - s->avctx->lowres;
2326

    
2327
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2328
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2329
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2330
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2331
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2332
    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;
2333
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2334

    
2335
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2336
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2337
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2338

    
2339
    if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2340
    {
2341
        if(s->picture_structure==PICT_FRAME){
2342
        s->dest[0] += s->mb_y *   linesize << mb_size;
2343
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2344
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2345
        }else{
2346
            s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2347
            s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2348
            s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2349
            assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2350
        }
2351
    }
2352
}
2353

    
2354
void ff_mpeg_flush(AVCodecContext *avctx){
2355
    int i;
2356
    MpegEncContext *s = avctx->priv_data;
2357

    
2358
    if(s==NULL || s->picture==NULL)
2359
        return;
2360

    
2361
    for(i=0; i<s->picture_count; i++){
2362
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2363
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2364
        free_frame_buffer(s, &s->picture[i]);
2365
    }
2366
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2367

    
2368
    s->mb_x= s->mb_y= 0;
2369
    s->closed_gop= 0;
2370

    
2371
    s->parse_context.state= -1;
2372
    s->parse_context.frame_start_found= 0;
2373
    s->parse_context.overread= 0;
2374
    s->parse_context.overread_index= 0;
2375
    s->parse_context.index= 0;
2376
    s->parse_context.last_index= 0;
2377
    s->bitstream_buffer_size=0;
2378
    s->pp_time=0;
2379
}
2380

    
2381
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2382
                                   DCTELEM *block, int n, int qscale)
2383
{
2384
    int i, level, nCoeffs;
2385
    const uint16_t *quant_matrix;
2386

    
2387
    nCoeffs= s->block_last_index[n];
2388

    
2389
    if (n < 4)
2390
        block[0] = block[0] * s->y_dc_scale;
2391
    else
2392
        block[0] = block[0] * s->c_dc_scale;
2393
    /* XXX: only mpeg1 */
2394
    quant_matrix = s->intra_matrix;
2395
    for(i=1;i<=nCoeffs;i++) {
2396
        int j= s->intra_scantable.permutated[i];
2397
        level = block[j];
2398
        if (level) {
2399
            if (level < 0) {
2400
                level = -level;
2401
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2402
                level = (level - 1) | 1;
2403
                level = -level;
2404
            } else {
2405
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2406
                level = (level - 1) | 1;
2407
            }
2408
            block[j] = level;
2409
        }
2410
    }
2411
}
2412

    
2413
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2414
                                   DCTELEM *block, int n, int qscale)
2415
{
2416
    int i, level, nCoeffs;
2417
    const uint16_t *quant_matrix;
2418

    
2419
    nCoeffs= s->block_last_index[n];
2420

    
2421
    quant_matrix = s->inter_matrix;
2422
    for(i=0; i<=nCoeffs; i++) {
2423
        int j= s->intra_scantable.permutated[i];
2424
        level = block[j];
2425
        if (level) {
2426
            if (level < 0) {
2427
                level = -level;
2428
                level = (((level << 1) + 1) * qscale *
2429
                         ((int) (quant_matrix[j]))) >> 4;
2430
                level = (level - 1) | 1;
2431
                level = -level;
2432
            } else {
2433
                level = (((level << 1) + 1) * qscale *
2434
                         ((int) (quant_matrix[j]))) >> 4;
2435
                level = (level - 1) | 1;
2436
            }
2437
            block[j] = level;
2438
        }
2439
    }
2440
}
2441

    
2442
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2443
                                   DCTELEM *block, int n, int qscale)
2444
{
2445
    int i, level, nCoeffs;
2446
    const uint16_t *quant_matrix;
2447

    
2448
    if(s->alternate_scan) nCoeffs= 63;
2449
    else nCoeffs= s->block_last_index[n];
2450

    
2451
    if (n < 4)
2452
        block[0] = block[0] * s->y_dc_scale;
2453
    else
2454
        block[0] = block[0] * s->c_dc_scale;
2455
    quant_matrix = s->intra_matrix;
2456
    for(i=1;i<=nCoeffs;i++) {
2457
        int j= s->intra_scantable.permutated[i];
2458
        level = block[j];
2459
        if (level) {
2460
            if (level < 0) {
2461
                level = -level;
2462
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2463
                level = -level;
2464
            } else {
2465
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2466
            }
2467
            block[j] = level;
2468
        }
2469
    }
2470
}
2471

    
2472
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2473
                                   DCTELEM *block, int n, int qscale)
2474
{
2475
    int i, level, nCoeffs;
2476
    const uint16_t *quant_matrix;
2477
    int sum=-1;
2478

    
2479
    if(s->alternate_scan) nCoeffs= 63;
2480
    else nCoeffs= s->block_last_index[n];
2481

    
2482
    if (n < 4)
2483
        block[0] = block[0] * s->y_dc_scale;
2484
    else
2485
        block[0] = block[0] * s->c_dc_scale;
2486
    quant_matrix = s->intra_matrix;
2487
    for(i=1;i<=nCoeffs;i++) {
2488
        int j= s->intra_scantable.permutated[i];
2489
        level = block[j];
2490
        if (level) {
2491
            if (level < 0) {
2492
                level = -level;
2493
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2494
                level = -level;
2495
            } else {
2496
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2497
            }
2498
            block[j] = level;
2499
            sum+=level;
2500
        }
2501
    }
2502
    block[63]^=sum&1;
2503
}
2504

    
2505
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2506
                                   DCTELEM *block, int n, int qscale)
2507
{
2508
    int i, level, nCoeffs;
2509
    const uint16_t *quant_matrix;
2510
    int sum=-1;
2511

    
2512
    if(s->alternate_scan) nCoeffs= 63;
2513
    else nCoeffs= s->block_last_index[n];
2514

    
2515
    quant_matrix = s->inter_matrix;
2516
    for(i=0; i<=nCoeffs; i++) {
2517
        int j= s->intra_scantable.permutated[i];
2518
        level = block[j];
2519
        if (level) {
2520
            if (level < 0) {
2521
                level = -level;
2522
                level = (((level << 1) + 1) * qscale *
2523
                         ((int) (quant_matrix[j]))) >> 4;
2524
                level = -level;
2525
            } else {
2526
                level = (((level << 1) + 1) * qscale *
2527
                         ((int) (quant_matrix[j]))) >> 4;
2528
            }
2529
            block[j] = level;
2530
            sum+=level;
2531
        }
2532
    }
2533
    block[63]^=sum&1;
2534
}
2535

    
2536
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2537
                                  DCTELEM *block, int n, int qscale)
2538
{
2539
    int i, level, qmul, qadd;
2540
    int nCoeffs;
2541

    
2542
    assert(s->block_last_index[n]>=0);
2543

    
2544
    qmul = qscale << 1;
2545

    
2546
    if (!s->h263_aic) {
2547
        if (n < 4)
2548
            block[0] = block[0] * s->y_dc_scale;
2549
        else
2550
            block[0] = block[0] * s->c_dc_scale;
2551
        qadd = (qscale - 1) | 1;
2552
    }else{
2553
        qadd = 0;
2554
    }
2555
    if(s->ac_pred)
2556
        nCoeffs=63;
2557
    else
2558
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2559

    
2560
    for(i=1; i<=nCoeffs; i++) {
2561
        level = block[i];
2562
        if (level) {
2563
            if (level < 0) {
2564
                level = level * qmul - qadd;
2565
            } else {
2566
                level = level * qmul + qadd;
2567
            }
2568
            block[i] = level;
2569
        }
2570
    }
2571
}
2572

    
2573
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2574
                                  DCTELEM *block, int n, int qscale)
2575
{
2576
    int i, level, qmul, qadd;
2577
    int nCoeffs;
2578

    
2579
    assert(s->block_last_index[n]>=0);
2580

    
2581
    qadd = (qscale - 1) | 1;
2582
    qmul = qscale << 1;
2583

    
2584
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2585

    
2586
    for(i=0; i<=nCoeffs; i++) {
2587
        level = block[i];
2588
        if (level) {
2589
            if (level < 0) {
2590
                level = level * qmul - qadd;
2591
            } else {
2592
                level = level * qmul + qadd;
2593
            }
2594
            block[i] = level;
2595
        }
2596
    }
2597
}
2598

    
2599
/**
2600
 * set qscale and update qscale dependent variables.
2601
 */
2602
void ff_set_qscale(MpegEncContext * s, int qscale)
2603
{
2604
    if (qscale < 1)
2605
        qscale = 1;
2606
    else if (qscale > 31)
2607
        qscale = 31;
2608

    
2609
    s->qscale = qscale;
2610
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2611

    
2612
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2613
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2614
}
2615

    
2616
void MPV_report_decode_progress(MpegEncContext *s)
2617
{
2618
    if (s->pict_type != FF_B_TYPE && !s->partitioned_frame)
2619
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2620
}