Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ c25a8d7d

History | View | Annotate | Download (100 KB)

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

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

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

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

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

    
62

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

    
66
//#define DEBUG
67

    
68

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

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

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

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

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

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

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

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

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

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

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

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

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

    
152
    return p+4;
153
}
154

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

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

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

    
196
    return 0;
197
}
198

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

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

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

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

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

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

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

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

    
251
    return 0;
252
}
253

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

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

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

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

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

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

    
313
    /* It might be nicer if the application would keep track of these
314
     * but it would require an API change. */
315
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
316
    s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
317
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
318
        pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
319
    pic->owner2 = s;
320

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
479
        MPV_common_init(s);
480
    }
481

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

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

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

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

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

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

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

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

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

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

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

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

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

    
535
    return 0;
536
}
537

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

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

    
554
    s->picture_in_gop_number = 0;
555

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
679
        if(s->avctx->noise_reduction){
680
            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
681
        }
682
    }
683
    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 != AV_PICTURE_TYPE_B && 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 != AV_PICTURE_TYPE_B)
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 == AV_PICTURE_TYPE_I;
1081

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

    
1084
    if (s->pict_type != AV_PICTURE_TYPE_B) {
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!=AV_PICTURE_TYPE_I){
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==AV_PICTURE_TYPE_B){
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 == AV_PICTURE_TYPE_I || (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
    s->error_recognition= avctx->error_recognition;
1135

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

    
1149
    if(s->dct_error_sum){
1150
        assert(s->avctx->noise_reduction && s->encoding);
1151

    
1152
        update_noise_reduction(s);
1153
    }
1154

    
1155
    if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1156
        return ff_xvmc_field_start(s, avctx);
1157

    
1158
    return 0;
1159
}
1160

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

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

    
1182
    }
1183

    
1184
    emms_c();
1185

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

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

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

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

    
1233
    sx= av_clip(sx, 0, w-1);
1234
    sy= av_clip(sy, 0, h-1);
1235
    ex= av_clip(ex, 0, w-1);
1236
    ey= av_clip(ey, 0, h-1);
1237

    
1238
    buf[sy*stride + sx]+= color;
1239

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

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

    
1282
    sx= av_clip(sx, -100, w+100);
1283
    sy= av_clip(sy, -100, h+100);
1284
    ex= av_clip(ex, -100, w+100);
1285
    ey= av_clip(ey, -100, h+100);
1286

    
1287
    dx= ex - sx;
1288
    dy= ey - sy;
1289

    
1290
    if(dx*dx + dy*dy > 3*3){
1291
        int rx=  dx + dy;
1292
        int ry= -dx + dy;
1293
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1294

    
1295
        //FIXME subpixel accuracy
1296
        rx= ROUNDED_DIV(rx*3<<4, length);
1297
        ry= ROUNDED_DIV(ry*3<<4, length);
1298

    
1299
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1300
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1301
    }
1302
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1303
}
1304

    
1305
/**
1306
 * prints debuging info for the given picture.
1307
 */
1308
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1309

    
1310
    if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1311

    
1312
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1313
        int x,y;
1314

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

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

    
1376

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

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

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

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

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

    
1453
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1454
                            my*=2;
1455

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

    
1467
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1468
                            my*=2;
1469

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

    
1498

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

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

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

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

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

    
1582
    if(s->quarter_sample){
1583
        motion_x/=2;
1584
        motion_y/=2;
1585
    }
1586

    
1587
    sx= motion_x & s_mask;
1588
    sy= motion_y & s_mask;
1589
    src_x += motion_x >> (lowres+1);
1590
    src_y += motion_y >> (lowres+1);
1591

    
1592
    src += src_y * stride + src_x;
1593

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

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

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

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

    
1633
    if(field_based){
1634
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1635
    }
1636

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

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

    
1680
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1681
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1682
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1683

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

    
1700
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1701
        dest_y += s->linesize;
1702
        dest_cb+= s->uvlinesize;
1703
        dest_cr+= s->uvlinesize;
1704
    }
1705

    
1706
    if(field_select){
1707
        ptr_y += s->linesize;
1708
        ptr_cb+= s->uvlinesize;
1709
        ptr_cr+= s->uvlinesize;
1710
    }
1711

    
1712
    sx= (sx << 2) >> lowres;
1713
    sy= (sy << 2) >> lowres;
1714
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1715

    
1716
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1717
        uvsx= (uvsx << 2) >> lowres;
1718
        uvsy= (uvsy << 2) >> lowres;
1719
        pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1720
        pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1721
    }
1722
    //FIXME h261 lowres loop filter
1723
}
1724

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

    
1739
    if(s->quarter_sample){
1740
        mx/=2;
1741
        my/=2;
1742
    }
1743

    
1744
    /* In case of 8X8, we construct a single chroma motion vector
1745
       with a special rounding */
1746
    mx= ff_h263_round_chroma(mx);
1747
    my= ff_h263_round_chroma(my);
1748

    
1749
    sx= mx & s_mask;
1750
    sy= my & s_mask;
1751
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
1752
    src_y = s->mb_y*block_s + (my >> (lowres+1));
1753

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

    
1768
    ptr = ref_picture[2] + offset;
1769
    if(emu){
1770
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1771
        ptr= s->edge_emu_buffer;
1772
    }
1773
    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1774
}
1775

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

    
1797
    mb_x = s->mb_x;
1798
    mb_y = s->mb_y;
1799

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

    
1819
                mx += s->mv[dir][i][0];
1820
                my += s->mv[dir][i][1];
1821
            }
1822

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

    
1843
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1844
                        0, 0, s->field_select[dir][0],
1845
                        ref_picture, pix_op,
1846
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1847
        }
1848
        break;
1849
    case MV_TYPE_16X8:
1850
        for(i=0; i<2; i++){
1851
            uint8_t ** ref2picture;
1852

    
1853
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1854
                ref2picture= ref_picture;
1855
            }else{
1856
                ref2picture= s->current_picture_ptr->data;
1857
            }
1858

    
1859
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1860
                        0, 0, s->field_select[dir][i],
1861
                        ref2picture, pix_op,
1862
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1863

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

    
1888
                // after put we make avg of the same block
1889
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1890

    
1891
                //opposite parity is always in the same frame if this is second field
1892
                if(!s->first_field){
1893
                    ref_picture = s->current_picture_ptr->data;
1894
                }
1895
            }
1896
        }
1897
    break;
1898
    default: assert(0);
1899
    }
1900
}
1901

    
1902
/**
1903
 * find the lowest MB row referenced in the MVs
1904
 */
1905
int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1906
{
1907
    int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1908
    int my, off, i, mvs;
1909

    
1910
    if (s->picture_structure != PICT_FRAME) goto unhandled;
1911

    
1912
    switch (s->mv_type) {
1913
        case MV_TYPE_16X16:
1914
            mvs = 1;
1915
            break;
1916
        case MV_TYPE_16X8:
1917
            mvs = 2;
1918
            break;
1919
        case MV_TYPE_8X8:
1920
            mvs = 4;
1921
            break;
1922
        default:
1923
            goto unhandled;
1924
    }
1925

    
1926
    for (i = 0; i < mvs; i++) {
1927
        my = s->mv[dir][i][1]<<qpel_shift;
1928
        my_max = FFMAX(my_max, my);
1929
        my_min = FFMIN(my_min, my);
1930
    }
1931

    
1932
    off = (FFMAX(-my_min, my_max) + 63) >> 6;
1933

    
1934
    return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1935
unhandled:
1936
    return s->mb_height-1;
1937
}
1938

    
1939
/* put block[] to dest[] */
1940
static inline void put_dct(MpegEncContext *s,
1941
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1942
{
1943
    s->dct_unquantize_intra(s, block, i, qscale);
1944
    s->dsp.idct_put (dest, line_size, block);
1945
}
1946

    
1947
/* add block[] to dest[] */
1948
static inline void add_dct(MpegEncContext *s,
1949
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
1950
{
1951
    if (s->block_last_index[i] >= 0) {
1952
        s->dsp.idct_add (dest, line_size, block);
1953
    }
1954
}
1955

    
1956
static inline void add_dequant_dct(MpegEncContext *s,
1957
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1958
{
1959
    if (s->block_last_index[i] >= 0) {
1960
        s->dct_unquantize_inter(s, block, i, qscale);
1961

    
1962
        s->dsp.idct_add (dest, line_size, block);
1963
    }
1964
}
1965

    
1966
/**
1967
 * cleans dc, ac, coded_block for the current non intra MB
1968
 */
1969
void ff_clean_intra_table_entries(MpegEncContext *s)
1970
{
1971
    int wrap = s->b8_stride;
1972
    int xy = s->block_index[0];
1973

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

    
1996
    s->mbintra_table[xy]= 0;
1997
}
1998

    
1999
/* generic function called after a macroblock has been parsed by the
2000
   decoder or after it has been encoded by the encoder.
2001

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

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

    
2033
    s->current_picture.qscale_table[mb_xy]= s->qscale;
2034

    
2035
    /* update DC predictors for P macroblocks */
2036
    if (!s->mb_intra) {
2037
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2038
            if(s->mbintra_table[mb_xy])
2039
                ff_clean_intra_table_entries(s);
2040
        } else {
2041
            s->last_dc[0] =
2042
            s->last_dc[1] =
2043
            s->last_dc[2] = 128 << s->intra_dc_precision;
2044
        }
2045
    }
2046
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2047
        s->mbintra_table[mb_xy]=1;
2048

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

    
2059
        /* avoid copy if macroblock skipped in last frame too */
2060
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2061
        if(!s->encoding){
2062
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2063
            const int age= s->current_picture.age;
2064

    
2065
            assert(age);
2066

    
2067
            if (s->mb_skipped) {
2068
                s->mb_skipped= 0;
2069
                assert(s->pict_type!=AV_PICTURE_TYPE_I);
2070

    
2071
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2072
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
2073

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

    
2086
        dct_linesize = linesize << s->interlaced_dct;
2087
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2088

    
2089
        if(readable){
2090
            dest_y=  s->dest[0];
2091
            dest_cb= s->dest[1];
2092
            dest_cr= s->dest[2];
2093
        }else{
2094
            dest_y = s->b_scratchpad;
2095
            dest_cb= s->b_scratchpad+16*linesize;
2096
            dest_cr= s->b_scratchpad+32*linesize;
2097
        }
2098

    
2099
        if (!s->mb_intra) {
2100
            /* motion handling */
2101
            /* decoding or more than one mb_type (MC was already done otherwise) */
2102
            if(!s->encoding){
2103

    
2104
                if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2105
                    if (s->mv_dir & MV_DIR_FORWARD) {
2106
                        ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2107
                    }
2108
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2109
                        ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2110
                    }
2111
                }
2112

    
2113
                if(lowres_flag){
2114
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2115

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

    
2141
            /* skip dequant / idct if we are really late ;) */
2142
            if(s->avctx->skip_idct){
2143
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2144
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2145
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
2146
                    goto skip_idct;
2147
            }
2148

    
2149
            /* add dct residue */
2150
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2151
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2152
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2153
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2154
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2155
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2156

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

    
2176
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2177
                    if(s->chroma_y_shift){//Chroma420
2178
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
2179
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
2180
                    }else{
2181
                        //chroma422
2182
                        dct_linesize = uvlinesize << s->interlaced_dct;
2183
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2184

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

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

    
2228
                if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2229
                    if(s->chroma_y_shift){
2230
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2231
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2232
                    }else{
2233

    
2234
                        dct_linesize = uvlinesize << s->interlaced_dct;
2235
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2236

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

    
2260
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2261
#if !CONFIG_SMALL
2262
    if(s->out_format == FMT_MPEG1) {
2263
        if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2264
        else                 MPV_decode_mb_internal(s, block, 0, 1);
2265
    } else
2266
#endif
2267
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2268
    else                  MPV_decode_mb_internal(s, block, 0, 0);
2269
}
2270

    
2271
/**
2272
 *
2273
 * @param h is the normal height, this will be reduced automatically if needed for the last row
2274
 */
2275
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2276
    const int field_pic= s->picture_structure != PICT_FRAME;
2277
    if(field_pic){
2278
        h <<= 1;
2279
        y <<= 1;
2280
    }
2281

    
2282
    if (!s->avctx->hwaccel
2283
       && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2284
       && s->unrestricted_mv
2285
       && s->current_picture.reference
2286
       && !s->intra_only
2287
       && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2288
        int sides = 0, edge_h;
2289
        if (y==0) sides |= EDGE_TOP;
2290
        if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2291

    
2292
        edge_h= FFMIN(h, s->v_edge_pos - y);
2293

    
2294
        s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2295
        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);
2296
        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);
2297
    }
2298

    
2299
    h= FFMIN(h, s->avctx->height - y);
2300

    
2301
    if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2302

    
2303
    if (s->avctx->draw_horiz_band) {
2304
        AVFrame *src;
2305
        int offset[4];
2306

    
2307
        if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2308
            src= (AVFrame*)s->current_picture_ptr;
2309
        else if(s->last_picture_ptr)
2310
            src= (AVFrame*)s->last_picture_ptr;
2311
        else
2312
            return;
2313

    
2314
        if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2315
            offset[0]=
2316
            offset[1]=
2317
            offset[2]=
2318
            offset[3]= 0;
2319
        }else{
2320
            offset[0]= y * s->linesize;
2321
            offset[1]=
2322
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2323
            offset[3]= 0;
2324
        }
2325

    
2326
        emms_c();
2327

    
2328
        s->avctx->draw_horiz_band(s->avctx, src, offset,
2329
                                  y, s->picture_structure, h);
2330
    }
2331
}
2332

    
2333
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2334
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2335
    const int uvlinesize= s->current_picture.linesize[1];
2336
    const int mb_size= 4 - s->avctx->lowres;
2337

    
2338
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2339
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2340
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2341
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2342
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2343
    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;
2344
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2345

    
2346
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2347
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2348
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2349

    
2350
    if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2351
    {
2352
        if(s->picture_structure==PICT_FRAME){
2353
        s->dest[0] += s->mb_y *   linesize << mb_size;
2354
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2355
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2356
        }else{
2357
            s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2358
            s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2359
            s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2360
            assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2361
        }
2362
    }
2363
}
2364

    
2365
void ff_mpeg_flush(AVCodecContext *avctx){
2366
    int i;
2367
    MpegEncContext *s = avctx->priv_data;
2368

    
2369
    if(s==NULL || s->picture==NULL)
2370
        return;
2371

    
2372
    for(i=0; i<s->picture_count; i++){
2373
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2374
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
2375
        free_frame_buffer(s, &s->picture[i]);
2376
    }
2377
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2378

    
2379
    s->mb_x= s->mb_y= 0;
2380
    s->closed_gop= 0;
2381

    
2382
    s->parse_context.state= -1;
2383
    s->parse_context.frame_start_found= 0;
2384
    s->parse_context.overread= 0;
2385
    s->parse_context.overread_index= 0;
2386
    s->parse_context.index= 0;
2387
    s->parse_context.last_index= 0;
2388
    s->bitstream_buffer_size=0;
2389
    s->pp_time=0;
2390
}
2391

    
2392
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2393
                                   DCTELEM *block, int n, int qscale)
2394
{
2395
    int i, level, nCoeffs;
2396
    const uint16_t *quant_matrix;
2397

    
2398
    nCoeffs= s->block_last_index[n];
2399

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

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

    
2430
    nCoeffs= s->block_last_index[n];
2431

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

    
2453
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2454
                                   DCTELEM *block, int n, int qscale)
2455
{
2456
    int i, level, nCoeffs;
2457
    const uint16_t *quant_matrix;
2458

    
2459
    if(s->alternate_scan) nCoeffs= 63;
2460
    else nCoeffs= s->block_last_index[n];
2461

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

    
2483
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2484
                                   DCTELEM *block, int n, int qscale)
2485
{
2486
    int i, level, nCoeffs;
2487
    const uint16_t *quant_matrix;
2488
    int sum=-1;
2489

    
2490
    if(s->alternate_scan) nCoeffs= 63;
2491
    else nCoeffs= s->block_last_index[n];
2492

    
2493
    if (n < 4)
2494
        block[0] = block[0] * s->y_dc_scale;
2495
    else
2496
        block[0] = block[0] * s->c_dc_scale;
2497
    quant_matrix = s->intra_matrix;
2498
    for(i=1;i<=nCoeffs;i++) {
2499
        int j= s->intra_scantable.permutated[i];
2500
        level = block[j];
2501
        if (level) {
2502
            if (level < 0) {
2503
                level = -level;
2504
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2505
                level = -level;
2506
            } else {
2507
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
2508
            }
2509
            block[j] = level;
2510
            sum+=level;
2511
        }
2512
    }
2513
    block[63]^=sum&1;
2514
}
2515

    
2516
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2517
                                   DCTELEM *block, int n, int qscale)
2518
{
2519
    int i, level, nCoeffs;
2520
    const uint16_t *quant_matrix;
2521
    int sum=-1;
2522

    
2523
    if(s->alternate_scan) nCoeffs= 63;
2524
    else nCoeffs= s->block_last_index[n];
2525

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

    
2547
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2548
                                  DCTELEM *block, int n, int qscale)
2549
{
2550
    int i, level, qmul, qadd;
2551
    int nCoeffs;
2552

    
2553
    assert(s->block_last_index[n]>=0);
2554

    
2555
    qmul = qscale << 1;
2556

    
2557
    if (!s->h263_aic) {
2558
        if (n < 4)
2559
            block[0] = block[0] * s->y_dc_scale;
2560
        else
2561
            block[0] = block[0] * s->c_dc_scale;
2562
        qadd = (qscale - 1) | 1;
2563
    }else{
2564
        qadd = 0;
2565
    }
2566
    if(s->ac_pred)
2567
        nCoeffs=63;
2568
    else
2569
        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2570

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

    
2584
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2585
                                  DCTELEM *block, int n, int qscale)
2586
{
2587
    int i, level, qmul, qadd;
2588
    int nCoeffs;
2589

    
2590
    assert(s->block_last_index[n]>=0);
2591

    
2592
    qadd = (qscale - 1) | 1;
2593
    qmul = qscale << 1;
2594

    
2595
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2596

    
2597
    for(i=0; i<=nCoeffs; i++) {
2598
        level = block[i];
2599
        if (level) {
2600
            if (level < 0) {
2601
                level = level * qmul - qadd;
2602
            } else {
2603
                level = level * qmul + qadd;
2604
            }
2605
            block[i] = level;
2606
        }
2607
    }
2608
}
2609

    
2610
/**
2611
 * set qscale and update qscale dependent variables.
2612
 */
2613
void ff_set_qscale(MpegEncContext * s, int qscale)
2614
{
2615
    if (qscale < 1)
2616
        qscale = 1;
2617
    else if (qscale > 31)
2618
        qscale = 31;
2619

    
2620
    s->qscale = qscale;
2621
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2622

    
2623
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2624
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2625
}
2626

    
2627
void MPV_report_decode_progress(MpegEncContext *s)
2628
{
2629
    if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame)
2630
        ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2631
}