Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 71160c55

History | View | Annotate | Download (236 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
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21
 */
22

    
23
/**
24
 * @file mpegvideo.c
25
 * The simplest mpeg encoder (well, it was the simplest!).
26
 */
27

    
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "mpegvideo.h"
31
#include "faandct.h"
32
#include <limits.h>
33

    
34
#ifdef USE_FASTMEMCPY
35
#include "fastmemcpy.h"
36
#endif
37

    
38
//#undef NDEBUG
39
//#include <assert.h>
40

    
41
#ifdef CONFIG_ENCODERS
42
static void encode_picture(MpegEncContext *s, int picture_number);
43
#endif //CONFIG_ENCODERS
44
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45
                                   DCTELEM *block, int n, int qscale);
46
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47
                                   DCTELEM *block, int n, int qscale);
48
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49
                                   DCTELEM *block, int n, int qscale);
50
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51
                                   DCTELEM *block, int n, int qscale);
52
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53
                                  DCTELEM *block, int n, int qscale);
54
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55
                                  DCTELEM *block, int n, int qscale);
56
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57
#ifdef CONFIG_ENCODERS
58
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61
static int sse_mb(MpegEncContext *s);
62
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63
#endif //CONFIG_ENCODERS
64

    
65
#ifdef HAVE_XVMC
66
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67
extern void XVMC_field_end(MpegEncContext *s);
68
extern void XVMC_decode_mb(MpegEncContext *s);
69
#endif
70

    
71
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
72

    
73

    
74
/* enable all paranoid tests for rounding, overflows, etc... */
75
//#define PARANOID
76

    
77
//#define DEBUG
78

    
79

    
80
/* for jpeg fast DCT */
81
#define CONST_BITS 14
82

    
83
static const uint16_t aanscales[64] = {
84
    /* precomputed values scaled up by 14 bits */
85
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
86
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
87
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
88
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
89
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
90
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
91
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
92
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
93
};
94

    
95
static const uint8_t h263_chroma_roundtab[16] = {
96
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
97
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
98
};
99

    
100
static const uint8_t ff_default_chroma_qscale_table[32]={
101
//  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
102
    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
103
};
104

    
105
#ifdef CONFIG_ENCODERS
106
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107
static uint8_t default_fcode_tab[MAX_MV*2+1];
108

    
109
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
110

    
111
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
113
{
114
    int qscale;
115
    int shift=0;
116

    
117
    for(qscale=qmin; qscale<=qmax; qscale++){
118
        int i;
119
        if (dsp->fdct == ff_jpeg_fdct_islow
120
#ifdef FAAN_POSTSCALE
121
            || dsp->fdct == ff_faandct
122
#endif
123
            ) {
124
            for(i=0;i<64;i++) {
125
                const int j= dsp->idct_permutation[i];
126
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
127
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
128
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130

    
131
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132
                                (qscale * quant_matrix[j]));
133
            }
134
        } else if (dsp->fdct == fdct_ifast
135
#ifndef FAAN_POSTSCALE
136
                   || dsp->fdct == ff_faandct
137
#endif
138
                   ) {
139
            for(i=0;i<64;i++) {
140
                const int j= dsp->idct_permutation[i];
141
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
142
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
143
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145

    
146
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147
                                (aanscales[i] * qscale * quant_matrix[j]));
148
            }
149
        } else {
150
            for(i=0;i<64;i++) {
151
                const int j= dsp->idct_permutation[i];
152
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153
                   So 16           <= qscale * quant_matrix[i]             <= 7905
154
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
156
                */
157
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160

    
161
                if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162
                qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
163
            }
164
        }
165

    
166
        for(i=intra; i<64; i++){
167
            int64_t max= 8191;
168
            if (dsp->fdct == fdct_ifast
169
#ifndef FAAN_POSTSCALE
170
                   || dsp->fdct == ff_faandct
171
#endif
172
                   ) {
173
                max= (8191LL*aanscales[i]) >> 14;
174
            }
175
            while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
176
                shift++;
177
            }
178
        }
179
    }
180
    if(shift){
181
        av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
182
    }
183
}
184

    
185
static inline void update_qscale(MpegEncContext *s){
186
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
188

    
189
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
190
}
191
#endif //CONFIG_ENCODERS
192

    
193
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
194
    int i;
195
    int end;
196

    
197
    st->scantable= src_scantable;
198

    
199
    for(i=0; i<64; i++){
200
        int j;
201
        j = src_scantable[i];
202
        st->permutated[i] = permutation[j];
203
#ifdef ARCH_POWERPC
204
        st->inverse[j] = i;
205
#endif
206
    }
207

    
208
    end=-1;
209
    for(i=0; i<64; i++){
210
        int j;
211
        j = st->permutated[i];
212
        if(j>end) end=j;
213
        st->raster_end[i]= end;
214
    }
215
}
216

    
217
#ifdef CONFIG_ENCODERS
218
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
219
    int i;
220

    
221
    if(matrix){
222
        put_bits(pb, 1, 1);
223
        for(i=0;i<64;i++) {
224
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
225
        }
226
    }else
227
        put_bits(pb, 1, 0);
228
}
229
#endif //CONFIG_ENCODERS
230

    
231
/* init common dct for both encoder and decoder */
232
int DCT_common_init(MpegEncContext *s)
233
{
234
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240

    
241
#ifdef CONFIG_ENCODERS
242
    s->dct_quantize= dct_quantize_c;
243
    s->denoise_dct= denoise_dct_c;
244
#endif //CONFIG_ENCODERS
245

    
246
#ifdef HAVE_MMX
247
    MPV_common_init_mmx(s);
248
#endif
249
#ifdef ARCH_ALPHA
250
    MPV_common_init_axp(s);
251
#endif
252
#ifdef HAVE_MLIB
253
    MPV_common_init_mlib(s);
254
#endif
255
#ifdef HAVE_MMI
256
    MPV_common_init_mmi(s);
257
#endif
258
#ifdef ARCH_ARMV4L
259
    MPV_common_init_armv4l(s);
260
#endif
261
#ifdef ARCH_POWERPC
262
    MPV_common_init_ppc(s);
263
#endif
264

    
265
#ifdef CONFIG_ENCODERS
266
    s->fast_dct_quantize= s->dct_quantize;
267

    
268
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
270
    }
271

    
272
#endif //CONFIG_ENCODERS
273

    
274
    /* load & permutate scantables
275
       note: only wmv uses different ones
276
    */
277
    if(s->alternate_scan){
278
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
279
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
280
    }else{
281
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
282
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
283
    }
284
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286

    
287
    return 0;
288
}
289

    
290
static void copy_picture(Picture *dst, Picture *src){
291
    *dst = *src;
292
    dst->type= FF_BUFFER_TYPE_COPY;
293
}
294

    
295
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
296
    int i;
297

    
298
    dst->pict_type              = src->pict_type;
299
    dst->quality                = src->quality;
300
    dst->coded_picture_number   = src->coded_picture_number;
301
    dst->display_picture_number = src->display_picture_number;
302
//    dst->reference              = src->reference;
303
    dst->pts                    = src->pts;
304
    dst->interlaced_frame       = src->interlaced_frame;
305
    dst->top_field_first        = src->top_field_first;
306

    
307
    if(s->avctx->me_threshold){
308
        if(!src->motion_val[0])
309
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
310
        if(!src->mb_type)
311
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312
        if(!src->ref_index[0])
313
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
316
            src->motion_subsample_log2, dst->motion_subsample_log2);
317

    
318
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
319

    
320
        for(i=0; i<2; i++){
321
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
323

    
324
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
326
            }
327
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329
            }
330
        }
331
    }
332
}
333

    
334
/**
335
 * allocates a Picture
336
 * The pixels are allocated/set by calling get_buffer() if shared=0
337
 */
338
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340
    const int mb_array_size= s->mb_stride*s->mb_height;
341
    const int b8_array_size= s->b8_stride*s->mb_height*2;
342
    const int b4_array_size= s->b4_stride*s->mb_height*4;
343
    int i;
344

    
345
    if(shared){
346
        assert(pic->data[0]);
347
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348
        pic->type= FF_BUFFER_TYPE_SHARED;
349
    }else{
350
        int r;
351

    
352
        assert(!pic->data[0]);
353

    
354
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355

    
356
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
358
            return -1;
359
        }
360

    
361
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
363
            return -1;
364
        }
365

    
366
        if(pic->linesize[1] != pic->linesize[2]){
367
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
368
            return -1;
369
        }
370

    
371
        s->linesize  = pic->linesize[0];
372
        s->uvlinesize= pic->linesize[1];
373
    }
374

    
375
    if(pic->qscale_table==NULL){
376
        if (s->encoding) {
377
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
378
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
380
        }
381

    
382
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
385
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386
        if(s->out_format == FMT_H264){
387
            for(i=0; i<2; i++){
388
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
389
                pic->motion_val[i]= pic->motion_val_base[i]+4;
390
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391
            }
392
            pic->motion_subsample_log2= 2;
393
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394
            for(i=0; i<2; i++){
395
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
396
                pic->motion_val[i]= pic->motion_val_base[i]+4;
397
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398
            }
399
            pic->motion_subsample_log2= 3;
400
        }
401
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
403
        }
404
        pic->qstride= s->mb_stride;
405
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
406
    }
407

    
408
    //it might be nicer if the application would keep track of these but it would require a API change
409
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
410
    s->prev_pict_types[0]= s->pict_type;
411
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412
        pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
413

    
414
    return 0;
415
fail: //for the CHECKED_ALLOCZ macro
416
    return -1;
417
}
418

    
419
/**
420
 * deallocates a picture
421
 */
422
static void free_picture(MpegEncContext *s, Picture *pic){
423
    int i;
424

    
425
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
427
    }
428

    
429
    av_freep(&pic->mb_var);
430
    av_freep(&pic->mc_mb_var);
431
    av_freep(&pic->mb_mean);
432
    av_freep(&pic->mbskip_table);
433
    av_freep(&pic->qscale_table);
434
    av_freep(&pic->mb_type_base);
435
    av_freep(&pic->dct_coeff);
436
    av_freep(&pic->pan_scan);
437
    pic->mb_type= NULL;
438
    for(i=0; i<2; i++){
439
        av_freep(&pic->motion_val_base[i]);
440
        av_freep(&pic->ref_index[i]);
441
    }
442

    
443
    if(pic->type == FF_BUFFER_TYPE_SHARED){
444
        for(i=0; i<4; i++){
445
            pic->base[i]=
446
            pic->data[i]= NULL;
447
        }
448
        pic->type= 0;
449
    }
450
}
451

    
452
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
453
    int i;
454

    
455
    // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
456
    CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457
    s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458

    
459
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
461
    s->rd_scratchpad=   s->me.scratchpad;
462
    s->b_scratchpad=    s->me.scratchpad;
463
    s->obmc_scratchpad= s->me.scratchpad + 16;
464
    if (s->encoding) {
465
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
466
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467
        if(s->avctx->noise_reduction){
468
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
469
        }
470
    }
471
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472
    s->block= s->blocks[0];
473

    
474
    for(i=0;i<12;i++){
475
        s->pblocks[i] = (short *)(&s->block[i]);
476
    }
477
    return 0;
478
fail:
479
    return -1; //free() through MPV_common_end()
480
}
481

    
482
static void free_duplicate_context(MpegEncContext *s){
483
    if(s==NULL) return;
484

    
485
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486
    av_freep(&s->me.scratchpad);
487
    s->rd_scratchpad=
488
    s->b_scratchpad=
489
    s->obmc_scratchpad= NULL;
490

    
491
    av_freep(&s->dct_error_sum);
492
    av_freep(&s->me.map);
493
    av_freep(&s->me.score_map);
494
    av_freep(&s->blocks);
495
    s->block= NULL;
496
}
497

    
498
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499
#define COPY(a) bak->a= src->a
500
    COPY(allocated_edge_emu_buffer);
501
    COPY(edge_emu_buffer);
502
    COPY(me.scratchpad);
503
    COPY(rd_scratchpad);
504
    COPY(b_scratchpad);
505
    COPY(obmc_scratchpad);
506
    COPY(me.map);
507
    COPY(me.score_map);
508
    COPY(blocks);
509
    COPY(block);
510
    COPY(start_mb_y);
511
    COPY(end_mb_y);
512
    COPY(me.map_generation);
513
    COPY(pb);
514
    COPY(dct_error_sum);
515
    COPY(dct_count[0]);
516
    COPY(dct_count[1]);
517
#undef COPY
518
}
519

    
520
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521
    MpegEncContext bak;
522
    int i;
523
    //FIXME copy only needed parts
524
//START_TIMER
525
    backup_duplicate_context(&bak, dst);
526
    memcpy(dst, src, sizeof(MpegEncContext));
527
    backup_duplicate_context(dst, &bak);
528
    for(i=0;i<12;i++){
529
        dst->pblocks[i] = (short *)(&dst->block[i]);
530
    }
531
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
532
}
533

    
534
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535
#define COPY(a) dst->a= src->a
536
    COPY(pict_type);
537
    COPY(current_picture);
538
    COPY(f_code);
539
    COPY(b_code);
540
    COPY(qscale);
541
    COPY(lambda);
542
    COPY(lambda2);
543
    COPY(picture_in_gop_number);
544
    COPY(gop_picture_number);
545
    COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
546
    COPY(progressive_frame); //FIXME don't set in encode_header
547
    COPY(partitioned_frame); //FIXME don't set in encode_header
548
#undef COPY
549
}
550

    
551
/**
552
 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553
 * the changed fields will not depend upon the prior state of the MpegEncContext.
554
 */
555
static void MPV_common_defaults(MpegEncContext *s){
556
    s->y_dc_scale_table=
557
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558
    s->chroma_qscale_table= ff_default_chroma_qscale_table;
559
    s->progressive_frame= 1;
560
    s->progressive_sequence= 1;
561
    s->picture_structure= PICT_FRAME;
562

    
563
    s->coded_picture_number = 0;
564
    s->picture_number = 0;
565
    s->input_picture_number = 0;
566

    
567
    s->picture_in_gop_number = 0;
568

    
569
    s->f_code = 1;
570
    s->b_code = 1;
571
}
572

    
573
/**
574
 * sets the given MpegEncContext to defaults for decoding.
575
 * the changed fields will not depend upon the prior state of the MpegEncContext.
576
 */
577
void MPV_decode_defaults(MpegEncContext *s){
578
    MPV_common_defaults(s);
579
}
580

    
581
/**
582
 * sets the given MpegEncContext to defaults for encoding.
583
 * the changed fields will not depend upon the prior state of the MpegEncContext.
584
 */
585

    
586
#ifdef CONFIG_ENCODERS
587
static void MPV_encode_defaults(MpegEncContext *s){
588
    static int done=0;
589

    
590
    MPV_common_defaults(s);
591

    
592
    if(!done){
593
        int i;
594
        done=1;
595

    
596
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598

    
599
        for(i=-16; i<16; i++){
600
            default_fcode_tab[i + MAX_MV]= 1;
601
        }
602
    }
603
    s->me.mv_penalty= default_mv_penalty;
604
    s->fcode_tab= default_fcode_tab;
605
}
606
#endif //CONFIG_ENCODERS
607

    
608
/**
609
 * init common structure for both encoder and decoder.
610
 * this assumes that some variables like width/height are already set
611
 */
612
int MPV_common_init(MpegEncContext *s)
613
{
614
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615

    
616
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
618
        return -1;
619
    }
620

    
621
    if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
622
        return -1;
623

    
624
    dsputil_init(&s->dsp, s->avctx);
625
    DCT_common_init(s);
626

    
627
    s->flags= s->avctx->flags;
628
    s->flags2= s->avctx->flags2;
629

    
630
    s->mb_width  = (s->width  + 15) / 16;
631
    s->mb_height = (s->height + 15) / 16;
632
    s->mb_stride = s->mb_width + 1;
633
    s->b8_stride = s->mb_width*2 + 1;
634
    s->b4_stride = s->mb_width*4 + 1;
635
    mb_array_size= s->mb_height * s->mb_stride;
636
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637

    
638
    /* set chroma shifts */
639
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640
                                                    &(s->chroma_y_shift) );
641

    
642
    /* set default edge pos, will be overriden in decode_header if needed */
643
    s->h_edge_pos= s->mb_width*16;
644
    s->v_edge_pos= s->mb_height*16;
645

    
646
    s->mb_num = s->mb_width * s->mb_height;
647

    
648
    s->block_wrap[0]=
649
    s->block_wrap[1]=
650
    s->block_wrap[2]=
651
    s->block_wrap[3]= s->b8_stride;
652
    s->block_wrap[4]=
653
    s->block_wrap[5]= s->mb_stride;
654

    
655
    y_size = s->b8_stride * (2 * s->mb_height + 1);
656
    c_size = s->mb_stride * (s->mb_height + 1);
657
    yc_size = y_size + 2 * c_size;
658

    
659
    /* convert fourcc to upper case */
660
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)
661
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664

    
665
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)
666
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
669

    
670
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
671

    
672
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673
    for(y=0; y<s->mb_height; y++){
674
        for(x=0; x<s->mb_width; x++){
675
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
676
        }
677
    }
678
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679

    
680
    if (s->encoding) {
681
        /* Allocate MV tables */
682
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
683
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
684
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
685
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
688
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
689
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
690
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
691
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
694

    
695
        if(s->msmpeg4_version){
696
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
697
        }
698
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699

    
700
        /* Allocate MB type table */
701
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
702

    
703
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704

    
705
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711

    
712
        if(s->avctx->noise_reduction){
713
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
714
        }
715
    }
716
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
717

    
718
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719

    
720
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721
        /* interlaced direct mode decoding tables */
722
            for(i=0; i<2; i++){
723
                int j, k;
724
                for(j=0; j<2; j++){
725
                    for(k=0; k<2; k++){
726
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
727
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
728
                    }
729
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
730
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
731
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
732
                }
733
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
734
            }
735
    }
736
    if (s->out_format == FMT_H263) {
737
        /* ac values */
738
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741
        s->ac_val[2] = s->ac_val[1] + c_size;
742

    
743
        /* cbp values */
744
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
745
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
746

    
747
        /* cbp, ac_pred, pred_dir */
748
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
749
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750
    }
751

    
752
    if (s->h263_pred || s->h263_plus || !s->encoding) {
753
        /* dc values */
754
        //MN: we need these for error resilience of intra-frames
755
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758
        s->dc_val[2] = s->dc_val[1] + c_size;
759
        for(i=0;i<yc_size;i++)
760
            s->dc_val_base[i] = 1024;
761
    }
762

    
763
    /* which mb is a intra block */
764
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765
    memset(s->mbintra_table, 1, mb_array_size);
766

    
767
    /* init macroblock skip table */
768
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769
    //Note the +1 is for a quicker mpeg4 slice_end detection
770
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771

    
772
    s->parse_context.state= -1;
773
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777
    }
778

    
779
    s->context_initialized = 1;
780

    
781
    s->thread_context[0]= s;
782
    for(i=1; i<s->avctx->thread_count; i++){
783
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
785
    }
786

    
787
    for(i=0; i<s->avctx->thread_count; i++){
788
        if(init_duplicate_context(s->thread_context[i], s) < 0)
789
           goto fail;
790
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
792
    }
793

    
794
    return 0;
795
 fail:
796
    MPV_common_end(s);
797
    return -1;
798
}
799

    
800
/* init common structure for both encoder and decoder */
801
void MPV_common_end(MpegEncContext *s)
802
{
803
    int i, j, k;
804

    
805
    for(i=0; i<s->avctx->thread_count; i++){
806
        free_duplicate_context(s->thread_context[i]);
807
    }
808
    for(i=1; i<s->avctx->thread_count; i++){
809
        av_freep(&s->thread_context[i]);
810
    }
811

    
812
    av_freep(&s->parse_context.buffer);
813
    s->parse_context.buffer_size=0;
814

    
815
    av_freep(&s->mb_type);
816
    av_freep(&s->p_mv_table_base);
817
    av_freep(&s->b_forw_mv_table_base);
818
    av_freep(&s->b_back_mv_table_base);
819
    av_freep(&s->b_bidir_forw_mv_table_base);
820
    av_freep(&s->b_bidir_back_mv_table_base);
821
    av_freep(&s->b_direct_mv_table_base);
822
    s->p_mv_table= NULL;
823
    s->b_forw_mv_table= NULL;
824
    s->b_back_mv_table= NULL;
825
    s->b_bidir_forw_mv_table= NULL;
826
    s->b_bidir_back_mv_table= NULL;
827
    s->b_direct_mv_table= NULL;
828
    for(i=0; i<2; i++){
829
        for(j=0; j<2; j++){
830
            for(k=0; k<2; k++){
831
                av_freep(&s->b_field_mv_table_base[i][j][k]);
832
                s->b_field_mv_table[i][j][k]=NULL;
833
            }
834
            av_freep(&s->b_field_select_table[i][j]);
835
            av_freep(&s->p_field_mv_table_base[i][j]);
836
            s->p_field_mv_table[i][j]=NULL;
837
        }
838
        av_freep(&s->p_field_select_table[i]);
839
    }
840

    
841
    av_freep(&s->dc_val_base);
842
    av_freep(&s->ac_val_base);
843
    av_freep(&s->coded_block_base);
844
    av_freep(&s->mbintra_table);
845
    av_freep(&s->cbp_table);
846
    av_freep(&s->pred_dir_table);
847

    
848
    av_freep(&s->mbskip_table);
849
    av_freep(&s->prev_pict_types);
850
    av_freep(&s->bitstream_buffer);
851
    s->allocated_bitstream_buffer_size=0;
852

    
853
    av_freep(&s->avctx->stats_out);
854
    av_freep(&s->ac_stats);
855
    av_freep(&s->error_status_table);
856
    av_freep(&s->mb_index2xy);
857
    av_freep(&s->lambda_table);
858
    av_freep(&s->q_intra_matrix);
859
    av_freep(&s->q_inter_matrix);
860
    av_freep(&s->q_intra_matrix16);
861
    av_freep(&s->q_inter_matrix16);
862
    av_freep(&s->input_picture);
863
    av_freep(&s->reordered_input_picture);
864
    av_freep(&s->dct_offset);
865

    
866
    if(s->picture){
867
        for(i=0; i<MAX_PICTURE_COUNT; i++){
868
            free_picture(s, &s->picture[i]);
869
        }
870
    }
871
    av_freep(&s->picture);
872
    s->context_initialized = 0;
873
    s->last_picture_ptr=
874
    s->next_picture_ptr=
875
    s->current_picture_ptr= NULL;
876
    s->linesize= s->uvlinesize= 0;
877

    
878
    for(i=0; i<3; i++)
879
        av_freep(&s->visualization_buffer[i]);
880

    
881
    avcodec_default_free_buffers(s->avctx);
882
}
883

    
884
#ifdef CONFIG_ENCODERS
885

    
886
/* init video encoder */
887
int MPV_encode_init(AVCodecContext *avctx)
888
{
889
    MpegEncContext *s = avctx->priv_data;
890
    int i;
891
    int chroma_h_shift, chroma_v_shift;
892

    
893
    MPV_encode_defaults(s);
894

    
895
    if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896
        av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
897
        return -1;
898
    }
899

    
900
    if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
903
            return -1;
904
        }
905
    }else{
906
        if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
907
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
908
            return -1;
909
        }
910
    }
911

    
912
    s->bit_rate = avctx->bit_rate;
913
    s->width = avctx->width;
914
    s->height = avctx->height;
915
    if(avctx->gop_size > 600){
916
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917
        avctx->gop_size=600;
918
    }
919
    s->gop_size = avctx->gop_size;
920
    s->avctx = avctx;
921
    s->flags= avctx->flags;
922
    s->flags2= avctx->flags2;
923
    s->max_b_frames= avctx->max_b_frames;
924
    s->codec_id= avctx->codec->id;
925
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
926
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927
    s->strict_std_compliance= avctx->strict_std_compliance;
928
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930
    s->mpeg_quant= avctx->mpeg_quant;
931
    s->rtp_mode= !!avctx->rtp_payload_size;
932
    s->intra_dc_precision= avctx->intra_dc_precision;
933
    s->user_specified_pts = AV_NOPTS_VALUE;
934

    
935
    if (s->gop_size <= 1) {
936
        s->intra_only = 1;
937
        s->gop_size = 12;
938
    } else {
939
        s->intra_only = 0;
940
    }
941

    
942
    s->me_method = avctx->me_method;
943

    
944
    /* Fixed QSCALE */
945
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946

    
947
    s->adaptive_quant= (   s->avctx->lumi_masking
948
                        || s->avctx->dark_masking
949
                        || s->avctx->temporal_cplx_masking
950
                        || s->avctx->spatial_cplx_masking
951
                        || s->avctx->p_masking
952
                        || s->avctx->border_masking
953
                        || (s->flags&CODEC_FLAG_QP_RD))
954
                       && !s->fixed_qscale;
955

    
956
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959

    
960
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
962
        return -1;
963
    }
964

    
965
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
967
    }
968

    
969
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971
        return -1;
972
    }
973

    
974
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976
        return -1;
977
    }
978

    
979
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982

    
983
        av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
984
    }
985

    
986
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989
        return -1;
990
    }
991

    
992
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
994
        return -1;
995
    }
996

    
997
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999
        return -1;
1000
    }
1001

    
1002
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004
        return -1;
1005
    }
1006

    
1007
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009
        return -1;
1010
    }
1011

    
1012
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014
        return -1;
1015
    }
1016

    
1017
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1018
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020
        return -1;
1021
    }
1022

    
1023
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1025
        return -1;
1026
    }
1027

    
1028
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030
        return -1;
1031
    }
1032

    
1033
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035
        return -1;
1036
    }
1037

    
1038
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040
        return -1;
1041
    }
1042

    
1043
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1044
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047
        return -1;
1048
    }
1049

    
1050
    if(s->avctx->thread_count > 1)
1051
        s->rtp_mode= 1;
1052

    
1053
    if(!avctx->time_base.den || !avctx->time_base.num){
1054
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055
        return -1;
1056
    }
1057

    
1058
    i= (INT_MAX/2+128)>>8;
1059
    if(avctx->me_threshold >= i){
1060
        av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1061
        return -1;
1062
    }
1063
    if(avctx->mb_threshold >= i){
1064
        av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1065
        return -1;
1066
    }
1067

    
1068
    if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1069
        av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass");
1070
        return -1;
1071
    }
1072

    
1073
    i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1074
    if(i > 1){
1075
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1076
        avctx->time_base.den /= i;
1077
        avctx->time_base.num /= i;
1078
//        return -1;
1079
    }
1080

    
1081
    if(s->codec_id==CODEC_ID_MJPEG){
1082
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1083
        s->inter_quant_bias= 0;
1084
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1085
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1086
        s->inter_quant_bias= 0;
1087
    }else{
1088
        s->intra_quant_bias=0;
1089
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1090
    }
1091

    
1092
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1093
        s->intra_quant_bias= avctx->intra_quant_bias;
1094
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1095
        s->inter_quant_bias= avctx->inter_quant_bias;
1096

    
1097
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1098

    
1099
    if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1100
        av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1101
        return -1;
1102
    }
1103
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1104

    
1105
    switch(avctx->codec->id) {
1106
    case CODEC_ID_MPEG1VIDEO:
1107
        s->out_format = FMT_MPEG1;
1108
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1109
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1110
        break;
1111
    case CODEC_ID_MPEG2VIDEO:
1112
        s->out_format = FMT_MPEG1;
1113
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1114
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1115
        s->rtp_mode= 1;
1116
        break;
1117
    case CODEC_ID_LJPEG:
1118
    case CODEC_ID_MJPEG:
1119
        s->out_format = FMT_MJPEG;
1120
        s->intra_only = 1; /* force intra only for jpeg */
1121
        s->mjpeg_write_tables = 1; /* write all tables */
1122
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1123
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1124
        s->mjpeg_vsample[1] = 1;
1125
        s->mjpeg_vsample[2] = 1;
1126
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1127
        s->mjpeg_hsample[1] = 1;
1128
        s->mjpeg_hsample[2] = 1;
1129
        if (mjpeg_init(s) < 0)
1130
            return -1;
1131
        avctx->delay=0;
1132
        s->low_delay=1;
1133
        break;
1134
    case CODEC_ID_H261:
1135
        s->out_format = FMT_H261;
1136
        avctx->delay=0;
1137
        s->low_delay=1;
1138
        break;
1139
    case CODEC_ID_H263:
1140
        if (h263_get_picture_format(s->width, s->height) == 7) {
1141
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1142
            return -1;
1143
        }
1144
        s->out_format = FMT_H263;
1145
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1146
        avctx->delay=0;
1147
        s->low_delay=1;
1148
        break;
1149
    case CODEC_ID_H263P:
1150
        s->out_format = FMT_H263;
1151
        s->h263_plus = 1;
1152
        /* Fx */
1153
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1154
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1155
        s->modified_quant= s->h263_aic;
1156
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1157
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1158
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1159
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1160
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1161

    
1162
        /* /Fx */
1163
        /* These are just to be sure */
1164
        avctx->delay=0;
1165
        s->low_delay=1;
1166
        break;
1167
    case CODEC_ID_FLV1:
1168
        s->out_format = FMT_H263;
1169
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1170
        s->unrestricted_mv = 1;
1171
        s->rtp_mode=0; /* don't allow GOB */
1172
        avctx->delay=0;
1173
        s->low_delay=1;
1174
        break;
1175
    case CODEC_ID_RV10:
1176
        s->out_format = FMT_H263;
1177
        avctx->delay=0;
1178
        s->low_delay=1;
1179
        break;
1180
    case CODEC_ID_RV20:
1181
        s->out_format = FMT_H263;
1182
        avctx->delay=0;
1183
        s->low_delay=1;
1184
        s->modified_quant=1;
1185
        s->h263_aic=1;
1186
        s->h263_plus=1;
1187
        s->loop_filter=1;
1188
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1189
        break;
1190
    case CODEC_ID_MPEG4:
1191
        s->out_format = FMT_H263;
1192
        s->h263_pred = 1;
1193
        s->unrestricted_mv = 1;
1194
        s->low_delay= s->max_b_frames ? 0 : 1;
1195
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1196
        break;
1197
    case CODEC_ID_MSMPEG4V1:
1198
        s->out_format = FMT_H263;
1199
        s->h263_msmpeg4 = 1;
1200
        s->h263_pred = 1;
1201
        s->unrestricted_mv = 1;
1202
        s->msmpeg4_version= 1;
1203
        avctx->delay=0;
1204
        s->low_delay=1;
1205
        break;
1206
    case CODEC_ID_MSMPEG4V2:
1207
        s->out_format = FMT_H263;
1208
        s->h263_msmpeg4 = 1;
1209
        s->h263_pred = 1;
1210
        s->unrestricted_mv = 1;
1211
        s->msmpeg4_version= 2;
1212
        avctx->delay=0;
1213
        s->low_delay=1;
1214
        break;
1215
    case CODEC_ID_MSMPEG4V3:
1216
        s->out_format = FMT_H263;
1217
        s->h263_msmpeg4 = 1;
1218
        s->h263_pred = 1;
1219
        s->unrestricted_mv = 1;
1220
        s->msmpeg4_version= 3;
1221
        s->flipflop_rounding=1;
1222
        avctx->delay=0;
1223
        s->low_delay=1;
1224
        break;
1225
    case CODEC_ID_WMV1:
1226
        s->out_format = FMT_H263;
1227
        s->h263_msmpeg4 = 1;
1228
        s->h263_pred = 1;
1229
        s->unrestricted_mv = 1;
1230
        s->msmpeg4_version= 4;
1231
        s->flipflop_rounding=1;
1232
        avctx->delay=0;
1233
        s->low_delay=1;
1234
        break;
1235
    case CODEC_ID_WMV2:
1236
        s->out_format = FMT_H263;
1237
        s->h263_msmpeg4 = 1;
1238
        s->h263_pred = 1;
1239
        s->unrestricted_mv = 1;
1240
        s->msmpeg4_version= 5;
1241
        s->flipflop_rounding=1;
1242
        avctx->delay=0;
1243
        s->low_delay=1;
1244
        break;
1245
    default:
1246
        return -1;
1247
    }
1248

    
1249
    avctx->has_b_frames= !s->low_delay;
1250

    
1251
    s->encoding = 1;
1252

    
1253
    /* init */
1254
    if (MPV_common_init(s) < 0)
1255
        return -1;
1256

    
1257
    if(s->modified_quant)
1258
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1259
    s->progressive_frame=
1260
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1261
    s->quant_precision=5;
1262

    
1263
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1264
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1265

    
1266
#ifdef CONFIG_H261_ENCODER
1267
    if (s->out_format == FMT_H261)
1268
        ff_h261_encode_init(s);
1269
#endif
1270
    if (s->out_format == FMT_H263)
1271
        h263_encode_init(s);
1272
    if(s->msmpeg4_version)
1273
        ff_msmpeg4_encode_init(s);
1274
    if (s->out_format == FMT_MPEG1)
1275
        ff_mpeg1_encode_init(s);
1276

    
1277
    /* init q matrix */
1278
    for(i=0;i<64;i++) {
1279
        int j= s->dsp.idct_permutation[i];
1280
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1281
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1282
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1283
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1284
            s->intra_matrix[j] =
1285
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1286
        }else
1287
        { /* mpeg1/2 */
1288
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1289
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1290
        }
1291
        if(s->avctx->intra_matrix)
1292
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1293
        if(s->avctx->inter_matrix)
1294
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1295
    }
1296

    
1297
    /* precompute matrix */
1298
    /* for mjpeg, we do include qscale in the matrix */
1299
    if (s->out_format != FMT_MJPEG) {
1300
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1301
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1302
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1303
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1304
    }
1305

    
1306
    if(ff_rate_control_init(s) < 0)
1307
        return -1;
1308

    
1309
    return 0;
1310
}
1311

    
1312
int MPV_encode_end(AVCodecContext *avctx)
1313
{
1314
    MpegEncContext *s = avctx->priv_data;
1315

    
1316
#ifdef STATS
1317
    print_stats();
1318
#endif
1319

    
1320
    ff_rate_control_uninit(s);
1321

    
1322
    MPV_common_end(s);
1323
    if (s->out_format == FMT_MJPEG)
1324
        mjpeg_close(s);
1325

    
1326
    av_freep(&avctx->extradata);
1327

    
1328
    return 0;
1329
}
1330

    
1331
#endif //CONFIG_ENCODERS
1332

    
1333
void init_rl(RLTable *rl, int use_static)
1334
{
1335
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1336
    uint8_t index_run[MAX_RUN+1];
1337
    int last, run, level, start, end, i;
1338

    
1339
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1340
    if(use_static && rl->max_level[0])
1341
        return;
1342

    
1343
    /* compute max_level[], max_run[] and index_run[] */
1344
    for(last=0;last<2;last++) {
1345
        if (last == 0) {
1346
            start = 0;
1347
            end = rl->last;
1348
        } else {
1349
            start = rl->last;
1350
            end = rl->n;
1351
        }
1352

    
1353
        memset(max_level, 0, MAX_RUN + 1);
1354
        memset(max_run, 0, MAX_LEVEL + 1);
1355
        memset(index_run, rl->n, MAX_RUN + 1);
1356
        for(i=start;i<end;i++) {
1357
            run = rl->table_run[i];
1358
            level = rl->table_level[i];
1359
            if (index_run[run] == rl->n)
1360
                index_run[run] = i;
1361
            if (level > max_level[run])
1362
                max_level[run] = level;
1363
            if (run > max_run[level])
1364
                max_run[level] = run;
1365
        }
1366
        if(use_static)
1367
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1368
        else
1369
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1370
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1371
        if(use_static)
1372
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1373
        else
1374
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1375
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1376
        if(use_static)
1377
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1378
        else
1379
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1380
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1381
    }
1382
}
1383

    
1384
/* draw the edges of width 'w' of an image of size width, height */
1385
//FIXME check that this is ok for mpeg4 interlaced
1386
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1387
{
1388
    uint8_t *ptr, *last_line;
1389
    int i;
1390

    
1391
    last_line = buf + (height - 1) * wrap;
1392
    for(i=0;i<w;i++) {
1393
        /* top and bottom */
1394
        memcpy(buf - (i + 1) * wrap, buf, width);
1395
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1396
    }
1397
    /* left and right */
1398
    ptr = buf;
1399
    for(i=0;i<height;i++) {
1400
        memset(ptr - w, ptr[0], w);
1401
        memset(ptr + width, ptr[width-1], w);
1402
        ptr += wrap;
1403
    }
1404
    /* corners */
1405
    for(i=0;i<w;i++) {
1406
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1407
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1408
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1409
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1410
    }
1411
}
1412

    
1413
int ff_find_unused_picture(MpegEncContext *s, int shared){
1414
    int i;
1415

    
1416
    if(shared){
1417
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1418
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1419
        }
1420
    }else{
1421
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1422
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1423
        }
1424
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1425
            if(s->picture[i].data[0]==NULL) return i;
1426
        }
1427
    }
1428

    
1429
    assert(0);
1430
    return -1;
1431
}
1432

    
1433
static void update_noise_reduction(MpegEncContext *s){
1434
    int intra, i;
1435

    
1436
    for(intra=0; intra<2; intra++){
1437
        if(s->dct_count[intra] > (1<<16)){
1438
            for(i=0; i<64; i++){
1439
                s->dct_error_sum[intra][i] >>=1;
1440
            }
1441
            s->dct_count[intra] >>= 1;
1442
        }
1443

    
1444
        for(i=0; i<64; i++){
1445
            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);
1446
        }
1447
    }
1448
}
1449

    
1450
/**
1451
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1452
 */
1453
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1454
{
1455
    int i;
1456
    AVFrame *pic;
1457
    s->mb_skipped = 0;
1458

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

    
1461
    /* mark&release old frames */
1462
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1463
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1464

    
1465
        /* release forgotten pictures */
1466
        /* if(mpeg124/h263) */
1467
        if(!s->encoding){
1468
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1469
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1470
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1471
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1472
                }
1473
            }
1474
        }
1475
    }
1476
alloc:
1477
    if(!s->encoding){
1478
        /* release non reference frames */
1479
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1480
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1481
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1482
            }
1483
        }
1484

    
1485
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1486
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1487
        else{
1488
            i= ff_find_unused_picture(s, 0);
1489
            pic= (AVFrame*)&s->picture[i];
1490
        }
1491

    
1492
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1493
                        && !s->dropable ? 3 : 0;
1494

    
1495
        pic->coded_picture_number= s->coded_picture_number++;
1496

    
1497
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1498
            return -1;
1499

    
1500
        s->current_picture_ptr= (Picture*)pic;
1501
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1502
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1503
    }
1504

    
1505
    s->current_picture_ptr->pict_type= s->pict_type;
1506
//    if(s->flags && CODEC_FLAG_QSCALE)
1507
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1508
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1509

    
1510
    copy_picture(&s->current_picture, s->current_picture_ptr);
1511

    
1512
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1513
    if (s->pict_type != B_TYPE) {
1514
        s->last_picture_ptr= s->next_picture_ptr;
1515
        if(!s->dropable)
1516
            s->next_picture_ptr= s->current_picture_ptr;
1517
    }
1518
/*    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,
1519
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1520
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1521
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1522
        s->pict_type, s->dropable);*/
1523

    
1524
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1525
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1526

    
1527
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1528
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1529
        assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1530
        goto alloc;
1531
    }
1532

    
1533
    assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1534

    
1535
    if(s->picture_structure!=PICT_FRAME){
1536
        int i;
1537
        for(i=0; i<4; i++){
1538
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1539
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1540
            }
1541
            s->current_picture.linesize[i] *= 2;
1542
            s->last_picture.linesize[i] *=2;
1543
            s->next_picture.linesize[i] *=2;
1544
        }
1545
    }
1546
  }
1547

    
1548
    s->hurry_up= s->avctx->hurry_up;
1549
    s->error_resilience= avctx->error_resilience;
1550

    
1551
    /* set dequantizer, we can't do it during init as it might change for mpeg4
1552
       and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1553
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1554
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1555
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1556
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1557
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1558
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1559
    }else{
1560
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1561
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1562
    }
1563

    
1564
    if(s->dct_error_sum){
1565
        assert(s->avctx->noise_reduction && s->encoding);
1566

    
1567
        update_noise_reduction(s);
1568
    }
1569

    
1570
#ifdef HAVE_XVMC
1571
    if(s->avctx->xvmc_acceleration)
1572
        return XVMC_field_start(s, avctx);
1573
#endif
1574
    return 0;
1575
}
1576

    
1577
/* generic function for encode/decode called after a frame has been coded/decoded */
1578
void MPV_frame_end(MpegEncContext *s)
1579
{
1580
    int i;
1581
    /* draw edge for correct motion prediction if outside */
1582
#ifdef HAVE_XVMC
1583
//just to make sure that all data is rendered.
1584
    if(s->avctx->xvmc_acceleration){
1585
        XVMC_field_end(s);
1586
    }else
1587
#endif
1588
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1589
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1590
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1591
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1592
    }
1593
    emms_c();
1594

    
1595
    s->last_pict_type    = s->pict_type;
1596
    if(s->pict_type!=B_TYPE){
1597
        s->last_non_b_pict_type= s->pict_type;
1598
    }
1599
#if 0
1600
        /* copy back current_picture variables */
1601
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1602
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1603
            s->picture[i]= s->current_picture;
1604
            break;
1605
        }
1606
    }
1607
    assert(i<MAX_PICTURE_COUNT);
1608
#endif
1609

    
1610
    if(s->encoding){
1611
        /* release non-reference frames */
1612
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1613
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1614
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1615
            }
1616
        }
1617
    }
1618
    // clear copies, to avoid confusion
1619
#if 0
1620
    memset(&s->last_picture, 0, sizeof(Picture));
1621
    memset(&s->next_picture, 0, sizeof(Picture));
1622
    memset(&s->current_picture, 0, sizeof(Picture));
1623
#endif
1624
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1625
}
1626

    
1627
/**
1628
 * draws an line from (ex, ey) -> (sx, sy).
1629
 * @param w width of the image
1630
 * @param h height of the image
1631
 * @param stride stride/linesize of the image
1632
 * @param color color of the arrow
1633
 */
1634
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1635
    int t, x, y, fr, f;
1636

    
1637
    sx= clip(sx, 0, w-1);
1638
    sy= clip(sy, 0, h-1);
1639
    ex= clip(ex, 0, w-1);
1640
    ey= clip(ey, 0, h-1);
1641

    
1642
    buf[sy*stride + sx]+= color;
1643

    
1644
    if(ABS(ex - sx) > ABS(ey - sy)){
1645
        if(sx > ex){
1646
            t=sx; sx=ex; ex=t;
1647
            t=sy; sy=ey; ey=t;
1648
        }
1649
        buf+= sx + sy*stride;
1650
        ex-= sx;
1651
        f= ((ey-sy)<<16)/ex;
1652
        for(x= 0; x <= ex; x++){
1653
            y = (x*f)>>16;
1654
            fr= (x*f)&0xFFFF;
1655
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1656
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1657
        }
1658
    }else{
1659
        if(sy > ey){
1660
            t=sx; sx=ex; ex=t;
1661
            t=sy; sy=ey; ey=t;
1662
        }
1663
        buf+= sx + sy*stride;
1664
        ey-= sy;
1665
        if(ey) f= ((ex-sx)<<16)/ey;
1666
        else   f= 0;
1667
        for(y= 0; y <= ey; y++){
1668
            x = (y*f)>>16;
1669
            fr= (y*f)&0xFFFF;
1670
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1671
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1672
        }
1673
    }
1674
}
1675

    
1676
/**
1677
 * draws an arrow from (ex, ey) -> (sx, sy).
1678
 * @param w width of the image
1679
 * @param h height of the image
1680
 * @param stride stride/linesize of the image
1681
 * @param color color of the arrow
1682
 */
1683
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1684
    int dx,dy;
1685

    
1686
    sx= clip(sx, -100, w+100);
1687
    sy= clip(sy, -100, h+100);
1688
    ex= clip(ex, -100, w+100);
1689
    ey= clip(ey, -100, h+100);
1690

    
1691
    dx= ex - sx;
1692
    dy= ey - sy;
1693

    
1694
    if(dx*dx + dy*dy > 3*3){
1695
        int rx=  dx + dy;
1696
        int ry= -dx + dy;
1697
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1698

    
1699
        //FIXME subpixel accuracy
1700
        rx= ROUNDED_DIV(rx*3<<4, length);
1701
        ry= ROUNDED_DIV(ry*3<<4, length);
1702

    
1703
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1704
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1705
    }
1706
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1707
}
1708

    
1709
/**
1710
 * prints debuging info for the given picture.
1711
 */
1712
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1713

    
1714
    if(!pict || !pict->mb_type) return;
1715

    
1716
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1717
        int x,y;
1718

    
1719
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1720
        switch (pict->pict_type) {
1721
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1722
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1723
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1724
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1725
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1726
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1727
        }
1728
        for(y=0; y<s->mb_height; y++){
1729
            for(x=0; x<s->mb_width; x++){
1730
                if(s->avctx->debug&FF_DEBUG_SKIP){
1731
                    int count= s->mbskip_table[x + y*s->mb_stride];
1732
                    if(count>9) count=9;
1733
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1734
                }
1735
                if(s->avctx->debug&FF_DEBUG_QP){
1736
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1737
                }
1738
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1739
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1740
                    //Type & MV direction
1741
                    if(IS_PCM(mb_type))
1742
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1743
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1744
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1745
                    else if(IS_INTRA4x4(mb_type))
1746
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1747
                    else if(IS_INTRA16x16(mb_type))
1748
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1749
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1750
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1751
                    else if(IS_DIRECT(mb_type))
1752
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1753
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1754
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1755
                    else if(IS_GMC(mb_type))
1756
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1757
                    else if(IS_SKIP(mb_type))
1758
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1759
                    else if(!USES_LIST(mb_type, 1))
1760
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1761
                    else if(!USES_LIST(mb_type, 0))
1762
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1763
                    else{
1764
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1765
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1766
                    }
1767

    
1768
                    //segmentation
1769
                    if(IS_8X8(mb_type))
1770
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1771
                    else if(IS_16X8(mb_type))
1772
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1773
                    else if(IS_8X16(mb_type))
1774
                        av_log(s->avctx, AV_LOG_DEBUG, "|");
1775
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1776
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1777
                    else
1778
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1779

    
1780

    
1781
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1782
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1783
                    else
1784
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1785
                }
1786
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1787
            }
1788
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1789
        }
1790
    }
1791

    
1792
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1793
        const int shift= 1 + s->quarter_sample;
1794
        int mb_y;
1795
        uint8_t *ptr;
1796
        int i;
1797
        int h_chroma_shift, v_chroma_shift;
1798
        const int width = s->avctx->width;
1799
        const int height= s->avctx->height;
1800
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1801
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1802
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1803

    
1804
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1805
        for(i=0; i<3; i++){
1806
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1807
            pict->data[i]= s->visualization_buffer[i];
1808
        }
1809
        pict->type= FF_BUFFER_TYPE_COPY;
1810
        ptr= pict->data[0];
1811

    
1812
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1813
            int mb_x;
1814
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1815
                const int mb_index= mb_x + mb_y*s->mb_stride;
1816
                if((s->avctx->debug_mv) && pict->motion_val){
1817
                  int type;
1818
                  for(type=0; type<3; type++){
1819
                    int direction = 0;
1820
                    switch (type) {
1821
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1822
                                continue;
1823
                              direction = 0;
1824
                              break;
1825
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1826
                                continue;
1827
                              direction = 0;
1828
                              break;
1829
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1830
                                continue;
1831
                              direction = 1;
1832
                              break;
1833
                    }
1834
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1835
                        continue;
1836

    
1837
                    if(IS_8X8(pict->mb_type[mb_index])){
1838
                      int i;
1839
                      for(i=0; i<4; i++){
1840
                        int sx= mb_x*16 + 4 + 8*(i&1);
1841
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1842
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1843
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1844
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1845
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1846
                      }
1847
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1848
                      int i;
1849
                      for(i=0; i<2; i++){
1850
                        int sx=mb_x*16 + 8;
1851
                        int sy=mb_y*16 + 4 + 8*i;
1852
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1853
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1854
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1855

    
1856
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1857
                            my*=2;
1858

    
1859
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1860
                      }
1861
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1862
                      int i;
1863
                      for(i=0; i<2; i++){
1864
                        int sx=mb_x*16 + 4 + 8*i;
1865
                        int sy=mb_y*16 + 8;
1866
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1867
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1868
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1869

    
1870
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1871
                            my*=2;
1872

    
1873
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1874
                      }
1875
                    }else{
1876
                      int sx= mb_x*16 + 8;
1877
                      int sy= mb_y*16 + 8;
1878
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1879
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1880
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1881
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1882
                    }
1883
                  }
1884
                }
1885
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1886
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1887
                    int y;
1888
                    for(y=0; y<8; y++){
1889
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1890
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1891
                    }
1892
                }
1893
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1894
                    int mb_type= pict->mb_type[mb_index];
1895
                    uint64_t u,v;
1896
                    int y;
1897
#define COLOR(theta, r)\
1898
u= (int)(128 + r*cos(theta*3.141592/180));\
1899
v= (int)(128 + r*sin(theta*3.141592/180));
1900

    
1901

    
1902
                    u=v=128;
1903
                    if(IS_PCM(mb_type)){
1904
                        COLOR(120,48)
1905
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1906
                        COLOR(30,48)
1907
                    }else if(IS_INTRA4x4(mb_type)){
1908
                        COLOR(90,48)
1909
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1910
//                        COLOR(120,48)
1911
                    }else if(IS_DIRECT(mb_type)){
1912
                        COLOR(150,48)
1913
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1914
                        COLOR(170,48)
1915
                    }else if(IS_GMC(mb_type)){
1916
                        COLOR(190,48)
1917
                    }else if(IS_SKIP(mb_type)){
1918
//                        COLOR(180,48)
1919
                    }else if(!USES_LIST(mb_type, 1)){
1920
                        COLOR(240,48)
1921
                    }else if(!USES_LIST(mb_type, 0)){
1922
                        COLOR(0,48)
1923
                    }else{
1924
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1925
                        COLOR(300,48)
1926
                    }
1927

    
1928
                    u*= 0x0101010101010101ULL;
1929
                    v*= 0x0101010101010101ULL;
1930
                    for(y=0; y<8; y++){
1931
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1932
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1933
                    }
1934

    
1935
                    //segmentation
1936
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1937
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1938
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1939
                    }
1940
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1941
                        for(y=0; y<16; y++)
1942
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1943
                    }
1944
                    if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1945
                        int dm= 1 << (mv_sample_log2-2);
1946
                        for(i=0; i<4; i++){
1947
                            int sx= mb_x*16 + 8*(i&1);
1948
                            int sy= mb_y*16 + 8*(i>>1);
1949
                            int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1950
                            //FIXME bidir
1951
                            int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1952
                            if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1953
                                for(y=0; y<8; y++)
1954
                                    pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1955
                            if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1956
                                *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1957
                        }
1958
                    }
1959

    
1960
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1961
                        // hmm
1962
                    }
1963
                }
1964
                s->mbskip_table[mb_index]=0;
1965
            }
1966
        }
1967
    }
1968
}
1969

    
1970
#ifdef CONFIG_ENCODERS
1971

    
1972
static int get_sae(uint8_t *src, int ref, int stride){
1973
    int x,y;
1974
    int acc=0;
1975

    
1976
    for(y=0; y<16; y++){
1977
        for(x=0; x<16; x++){
1978
            acc+= ABS(src[x+y*stride] - ref);
1979
        }
1980
    }
1981

    
1982
    return acc;
1983
}
1984

    
1985
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1986
    int x, y, w, h;
1987
    int acc=0;
1988

    
1989
    w= s->width &~15;
1990
    h= s->height&~15;
1991

    
1992
    for(y=0; y<h; y+=16){
1993
        for(x=0; x<w; x+=16){
1994
            int offset= x + y*stride;
1995
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1996
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1997
            int sae = get_sae(src + offset, mean, stride);
1998

    
1999
            acc+= sae + 500 < sad;
2000
        }
2001
    }
2002
    return acc;
2003
}
2004

    
2005

    
2006
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2007
    AVFrame *pic=NULL;
2008
    int64_t pts;
2009
    int i;
2010
    const int encoding_delay= s->max_b_frames;
2011
    int direct=1;
2012

    
2013
    if(pic_arg){
2014
        pts= pic_arg->pts;
2015
        pic_arg->display_picture_number= s->input_picture_number++;
2016

    
2017
        if(pts != AV_NOPTS_VALUE){
2018
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2019
                int64_t time= pts;
2020
                int64_t last= s->user_specified_pts;
2021

    
2022
                if(time <= last){
2023
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2024
                    return -1;
2025
                }
2026
            }
2027
            s->user_specified_pts= pts;
2028
        }else{
2029
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2030
                s->user_specified_pts=
2031
                pts= s->user_specified_pts + 1;
2032
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2033
            }else{
2034
                pts= pic_arg->display_picture_number;
2035
            }
2036
        }
2037
    }
2038

    
2039
  if(pic_arg){
2040
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2041
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2042
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2043
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2044

    
2045
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2046

    
2047
    if(direct){
2048
        i= ff_find_unused_picture(s, 1);
2049

    
2050
        pic= (AVFrame*)&s->picture[i];
2051
        pic->reference= 3;
2052

    
2053
        for(i=0; i<4; i++){
2054
            pic->data[i]= pic_arg->data[i];
2055
            pic->linesize[i]= pic_arg->linesize[i];
2056
        }
2057
        alloc_picture(s, (Picture*)pic, 1);
2058
    }else{
2059
        int offset= 16;
2060
        i= ff_find_unused_picture(s, 0);
2061

    
2062
        pic= (AVFrame*)&s->picture[i];
2063
        pic->reference= 3;
2064

    
2065
        alloc_picture(s, (Picture*)pic, 0);
2066

    
2067
        if(   pic->data[0] + offset == pic_arg->data[0]
2068
           && pic->data[1] + offset == pic_arg->data[1]
2069
           && pic->data[2] + offset == pic_arg->data[2]){
2070
       // empty
2071
        }else{
2072
            int h_chroma_shift, v_chroma_shift;
2073
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2074

    
2075
            for(i=0; i<3; i++){
2076
                int src_stride= pic_arg->linesize[i];
2077
                int dst_stride= i ? s->uvlinesize : s->linesize;
2078
                int h_shift= i ? h_chroma_shift : 0;
2079
                int v_shift= i ? v_chroma_shift : 0;
2080
                int w= s->width >>h_shift;
2081
                int h= s->height>>v_shift;
2082
                uint8_t *src= pic_arg->data[i];
2083
                uint8_t *dst= pic->data[i] + offset;
2084

    
2085
                if(src_stride==dst_stride)
2086
                    memcpy(dst, src, src_stride*h);
2087
                else{
2088
                    while(h--){
2089
                        memcpy(dst, src, w);
2090
                        dst += dst_stride;
2091
                        src += src_stride;
2092
                    }
2093
                }
2094
            }
2095
        }
2096
    }
2097
    copy_picture_attributes(s, pic, pic_arg);
2098
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2099
  }
2100

    
2101
    /* shift buffer entries */
2102
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2103
        s->input_picture[i-1]= s->input_picture[i];
2104

    
2105
    s->input_picture[encoding_delay]= (Picture*)pic;
2106

    
2107
    return 0;
2108
}
2109

    
2110
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2111
    int x, y, plane;
2112
    int score=0;
2113
    int64_t score64=0;
2114

    
2115
    for(plane=0; plane<3; plane++){
2116
        const int stride= p->linesize[plane];
2117
        const int bw= plane ? 1 : 2;
2118
        for(y=0; y<s->mb_height*bw; y++){
2119
            for(x=0; x<s->mb_width*bw; x++){
2120
                int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2121
                int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2122

    
2123
                switch(s->avctx->frame_skip_exp){
2124
                    case 0: score= FFMAX(score, v); break;
2125
                    case 1: score+= ABS(v);break;
2126
                    case 2: score+= v*v;break;
2127
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2128
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2129
                }
2130
            }
2131
        }
2132
    }
2133

    
2134
    if(score) score64= score;
2135

    
2136
    if(score64 < s->avctx->frame_skip_threshold)
2137
        return 1;
2138
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2139
        return 1;
2140
    return 0;
2141
}
2142

    
2143
static void select_input_picture(MpegEncContext *s){
2144
    int i;
2145

    
2146
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2147
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2148
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2149

    
2150
    /* set next picture type & ordering */
2151
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2152
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2153
            s->reordered_input_picture[0]= s->input_picture[0];
2154
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2155
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2156
        }else{
2157
            int b_frames;
2158

    
2159
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2160
                if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2161
                //FIXME check that te gop check above is +-1 correct
2162
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2163

    
2164
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2165
                        for(i=0; i<4; i++)
2166
                            s->input_picture[0]->data[i]= NULL;
2167
                        s->input_picture[0]->type= 0;
2168
                    }else{
2169
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2170
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2171

    
2172
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2173
                    }
2174

    
2175
                    emms_c();
2176
                    ff_vbv_update(s, 0);
2177

    
2178
                    goto no_output_pic;
2179
                }
2180
            }
2181

    
2182
            if(s->flags&CODEC_FLAG_PASS2){
2183
                for(i=0; i<s->max_b_frames+1; i++){
2184
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2185

    
2186
                    if(pict_num >= s->rc_context.num_entries)
2187
                        break;
2188
                    if(!s->input_picture[i]){
2189
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2190
                        break;
2191
                    }
2192

    
2193
                    s->input_picture[i]->pict_type=
2194
                        s->rc_context.entry[pict_num].new_pict_type;
2195
                }
2196
            }
2197

    
2198
            if(s->avctx->b_frame_strategy==0){
2199
                b_frames= s->max_b_frames;
2200
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2201
            }else if(s->avctx->b_frame_strategy==1){
2202
                for(i=1; i<s->max_b_frames+1; i++){
2203
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2204
                        s->input_picture[i]->b_frame_score=
2205
                            get_intra_count(s, s->input_picture[i  ]->data[0],
2206
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2207
                    }
2208
                }
2209
                for(i=0; i<s->max_b_frames+1; i++){
2210
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2211
                }
2212

    
2213
                b_frames= FFMAX(0, i-1);
2214

    
2215
                /* reset scores */
2216
                for(i=0; i<b_frames+1; i++){
2217
                    s->input_picture[i]->b_frame_score=0;
2218
                }
2219
            }else{
2220
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2221
                b_frames=0;
2222
            }
2223

    
2224
            emms_c();
2225
//static int b_count=0;
2226
//b_count+= b_frames;
2227
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2228

    
2229
            for(i= b_frames - 1; i>=0; i--){
2230
                int type= s->input_picture[i]->pict_type;
2231
                if(type && type != B_TYPE)
2232
                    b_frames= i;
2233
            }
2234
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2235
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2236
            }
2237

    
2238
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2239
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2240
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2241
              }else{
2242
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2243
                    b_frames=0;
2244
                s->input_picture[b_frames]->pict_type= I_TYPE;
2245
              }
2246
            }
2247

    
2248
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2249
               && b_frames
2250
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2251
                b_frames--;
2252

    
2253
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2254
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2255
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2256
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2257
            for(i=0; i<b_frames; i++){
2258
                s->reordered_input_picture[i+1]= s->input_picture[i];
2259
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2260
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2261
            }
2262
        }
2263
    }
2264
no_output_pic:
2265
    if(s->reordered_input_picture[0]){
2266
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2267

    
2268
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2269

    
2270
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2271
            // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2272

    
2273
            int i= ff_find_unused_picture(s, 0);
2274
            Picture *pic= &s->picture[i];
2275

    
2276
            /* mark us unused / free shared pic */
2277
            for(i=0; i<4; i++)
2278
                s->reordered_input_picture[0]->data[i]= NULL;
2279
            s->reordered_input_picture[0]->type= 0;
2280

    
2281
            pic->reference              = s->reordered_input_picture[0]->reference;
2282

    
2283
            alloc_picture(s, pic, 0);
2284

    
2285
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2286

    
2287
            s->current_picture_ptr= pic;
2288
        }else{
2289
            // input is not a shared pix -> reuse buffer for current_pix
2290

    
2291
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2292
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2293

    
2294
            s->current_picture_ptr= s->reordered_input_picture[0];
2295
            for(i=0; i<4; i++){
2296
                s->new_picture.data[i]+=16;
2297
            }
2298
        }
2299
        copy_picture(&s->current_picture, s->current_picture_ptr);
2300

    
2301
        s->picture_number= s->new_picture.display_picture_number;
2302
//printf("dpn:%d\n", s->picture_number);
2303
    }else{
2304
       memset(&s->new_picture, 0, sizeof(Picture));
2305
    }
2306
}
2307

    
2308
int MPV_encode_picture(AVCodecContext *avctx,
2309
                       unsigned char *buf, int buf_size, void *data)
2310
{
2311
    MpegEncContext *s = avctx->priv_data;
2312
    AVFrame *pic_arg = data;
2313
    int i, stuffing_count;
2314

    
2315
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2316
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2317
        return -1;
2318
    }
2319

    
2320
    for(i=0; i<avctx->thread_count; i++){
2321
        int start_y= s->thread_context[i]->start_mb_y;
2322
        int   end_y= s->thread_context[i]->  end_mb_y;
2323
        int h= s->mb_height;
2324
        uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2325
        uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
2326

    
2327
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2328
    }
2329

    
2330
    s->picture_in_gop_number++;
2331

    
2332
    if(load_input_picture(s, pic_arg) < 0)
2333
        return -1;
2334

    
2335
    select_input_picture(s);
2336

    
2337
    /* output? */
2338
    if(s->new_picture.data[0]){
2339
        s->pict_type= s->new_picture.pict_type;
2340
//emms_c();
2341
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2342
        MPV_frame_start(s, avctx);
2343

    
2344
        encode_picture(s, s->picture_number);
2345

    
2346
        avctx->real_pict_num  = s->picture_number;
2347
        avctx->header_bits = s->header_bits;
2348
        avctx->mv_bits     = s->mv_bits;
2349
        avctx->misc_bits   = s->misc_bits;
2350
        avctx->i_tex_bits  = s->i_tex_bits;
2351
        avctx->p_tex_bits  = s->p_tex_bits;
2352
        avctx->i_count     = s->i_count;
2353
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2354
        avctx->skip_count  = s->skip_count;
2355

    
2356
        MPV_frame_end(s);
2357

    
2358
        if (s->out_format == FMT_MJPEG)
2359
            mjpeg_picture_trailer(s);
2360

    
2361
        if(s->flags&CODEC_FLAG_PASS1)
2362
            ff_write_pass1_stats(s);
2363

    
2364
        for(i=0; i<4; i++){
2365
            s->current_picture_ptr->error[i]= s->current_picture.error[i];
2366
            avctx->error[i] += s->current_picture_ptr->error[i];
2367
        }
2368

    
2369
        if(s->flags&CODEC_FLAG_PASS1)
2370
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2371
        flush_put_bits(&s->pb);
2372
        s->frame_bits  = put_bits_count(&s->pb);
2373

    
2374
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2375
        if(stuffing_count){
2376
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2377
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2378
                return -1;
2379
            }
2380

    
2381
            switch(s->codec_id){
2382
            case CODEC_ID_MPEG1VIDEO:
2383
            case CODEC_ID_MPEG2VIDEO:
2384
                while(stuffing_count--){
2385
                    put_bits(&s->pb, 8, 0);
2386
                }
2387
            break;
2388
            case CODEC_ID_MPEG4:
2389
                put_bits(&s->pb, 16, 0);
2390
                put_bits(&s->pb, 16, 0x1C3);
2391
                stuffing_count -= 4;
2392
                while(stuffing_count--){
2393
                    put_bits(&s->pb, 8, 0xFF);
2394
                }
2395
            break;
2396
            default:
2397
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2398
            }
2399
            flush_put_bits(&s->pb);
2400
            s->frame_bits  = put_bits_count(&s->pb);
2401
        }
2402

    
2403
        /* update mpeg1/2 vbv_delay for CBR */
2404
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2405
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2406
            int vbv_delay;
2407

    
2408
            assert(s->repeat_first_field==0);
2409

    
2410
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2411
            assert(vbv_delay < 0xFFFF);
2412

    
2413
            s->vbv_delay_ptr[0] &= 0xF8;
2414
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2415
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2416
            s->vbv_delay_ptr[2] &= 0x07;
2417
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2418
        }
2419
        s->total_bits += s->frame_bits;
2420
        avctx->frame_bits  = s->frame_bits;
2421
    }else{
2422
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2423
        s->frame_bits=0;
2424
    }
2425
    assert((s->frame_bits&7)==0);
2426

    
2427
    return s->frame_bits/8;
2428
}
2429

    
2430
#endif //CONFIG_ENCODERS
2431

    
2432
static inline void gmc1_motion(MpegEncContext *s,
2433
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2434
                               uint8_t **ref_picture)
2435
{
2436
    uint8_t *ptr;
2437
    int offset, src_x, src_y, linesize, uvlinesize;
2438
    int motion_x, motion_y;
2439
    int emu=0;
2440

    
2441
    motion_x= s->sprite_offset[0][0];
2442
    motion_y= s->sprite_offset[0][1];
2443
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2444
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2445
    motion_x<<=(3-s->sprite_warping_accuracy);
2446
    motion_y<<=(3-s->sprite_warping_accuracy);
2447
    src_x = clip(src_x, -16, s->width);
2448
    if (src_x == s->width)
2449
        motion_x =0;
2450
    src_y = clip(src_y, -16, s->height);
2451
    if (src_y == s->height)
2452
        motion_y =0;
2453

    
2454
    linesize = s->linesize;
2455
    uvlinesize = s->uvlinesize;
2456

    
2457
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2458

    
2459
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2460
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2461
           || (unsigned)src_y >= s->v_edge_pos - 17){
2462
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2463
            ptr= s->edge_emu_buffer;
2464
        }
2465
    }
2466

    
2467
    if((motion_x|motion_y)&7){
2468
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2469
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2470
    }else{
2471
        int dxy;
2472

    
2473
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2474
        if (s->no_rounding){
2475
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2476
        }else{
2477
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2478
        }
2479
    }
2480

    
2481
    if(s->flags&CODEC_FLAG_GRAY) return;
2482

    
2483
    motion_x= s->sprite_offset[1][0];
2484
    motion_y= s->sprite_offset[1][1];
2485
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2486
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2487
    motion_x<<=(3-s->sprite_warping_accuracy);
2488
    motion_y<<=(3-s->sprite_warping_accuracy);
2489
    src_x = clip(src_x, -8, s->width>>1);
2490
    if (src_x == s->width>>1)
2491
        motion_x =0;
2492
    src_y = clip(src_y, -8, s->height>>1);
2493
    if (src_y == s->height>>1)
2494
        motion_y =0;
2495

    
2496
    offset = (src_y * uvlinesize) + src_x;
2497
    ptr = ref_picture[1] + offset;
2498
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2499
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2500
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2501
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2502
            ptr= s->edge_emu_buffer;
2503
            emu=1;
2504
        }
2505
    }
2506
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2507

    
2508
    ptr = ref_picture[2] + offset;
2509
    if(emu){
2510
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2511
        ptr= s->edge_emu_buffer;
2512
    }
2513
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2514

    
2515
    return;
2516
}
2517

    
2518
static inline void gmc_motion(MpegEncContext *s,
2519
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2520
                               uint8_t **ref_picture)
2521
{
2522
    uint8_t *ptr;
2523
    int linesize, uvlinesize;
2524
    const int a= s->sprite_warping_accuracy;
2525
    int ox, oy;
2526

    
2527
    linesize = s->linesize;
2528
    uvlinesize = s->uvlinesize;
2529

    
2530
    ptr = ref_picture[0];
2531

    
2532
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2533
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2534

    
2535
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2536
           ox,
2537
           oy,
2538
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2539
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2540
           a+1, (1<<(2*a+1)) - s->no_rounding,
2541
           s->h_edge_pos, s->v_edge_pos);
2542
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2543
           ox + s->sprite_delta[0][0]*8,
2544
           oy + s->sprite_delta[1][0]*8,
2545
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2546
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2547
           a+1, (1<<(2*a+1)) - s->no_rounding,
2548
           s->h_edge_pos, s->v_edge_pos);
2549

    
2550
    if(s->flags&CODEC_FLAG_GRAY) return;
2551

    
2552
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2553
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2554

    
2555
    ptr = ref_picture[1];
2556
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2557
           ox,
2558
           oy,
2559
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2560
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2561
           a+1, (1<<(2*a+1)) - s->no_rounding,
2562
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2563

    
2564
    ptr = ref_picture[2];
2565
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2566
           ox,
2567
           oy,
2568
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2569
           s->sprite_delta[1][0], s->sprite_delta[1][1],
2570
           a+1, (1<<(2*a+1)) - s->no_rounding,
2571
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2572
}
2573

    
2574
/**
2575
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2576
 * @param buf destination buffer
2577
 * @param src source buffer
2578
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2579
 * @param block_w width of block
2580
 * @param block_h height of block
2581
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2582
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2583
 * @param w width of the source buffer
2584
 * @param h height of the source buffer
2585
 */
2586
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2587
                                    int src_x, int src_y, int w, int h){
2588
    int x, y;
2589
    int start_y, start_x, end_y, end_x;
2590

    
2591
    if(src_y>= h){
2592
        src+= (h-1-src_y)*linesize;
2593
        src_y=h-1;
2594
    }else if(src_y<=-block_h){
2595
        src+= (1-block_h-src_y)*linesize;
2596
        src_y=1-block_h;
2597
    }
2598
    if(src_x>= w){
2599
        src+= (w-1-src_x);
2600
        src_x=w-1;
2601
    }else if(src_x<=-block_w){
2602
        src+= (1-block_w-src_x);
2603
        src_x=1-block_w;
2604
    }
2605

    
2606
    start_y= FFMAX(0, -src_y);
2607
    start_x= FFMAX(0, -src_x);
2608
    end_y= FFMIN(block_h, h-src_y);
2609
    end_x= FFMIN(block_w, w-src_x);
2610

    
2611
    // copy existing part
2612
    for(y=start_y; y<end_y; y++){
2613
        for(x=start_x; x<end_x; x++){
2614
            buf[x + y*linesize]= src[x + y*linesize];
2615
        }
2616
    }
2617

    
2618
    //top
2619
    for(y=0; y<start_y; y++){
2620
        for(x=start_x; x<end_x; x++){
2621
            buf[x + y*linesize]= buf[x + start_y*linesize];
2622
        }
2623
    }
2624

    
2625
    //bottom
2626
    for(y=end_y; y<block_h; y++){
2627
        for(x=start_x; x<end_x; x++){
2628
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2629
        }
2630
    }
2631

    
2632
    for(y=0; y<block_h; y++){
2633
       //left
2634
        for(x=0; x<start_x; x++){
2635
            buf[x + y*linesize]= buf[start_x + y*linesize];
2636
        }
2637

    
2638
       //right
2639
        for(x=end_x; x<block_w; x++){
2640
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2641
        }
2642
    }
2643
}
2644

    
2645
static inline int hpel_motion(MpegEncContext *s,
2646
                                  uint8_t *dest, uint8_t *src,
2647
                                  int field_based, int field_select,
2648
                                  int src_x, int src_y,
2649
                                  int width, int height, int stride,
2650
                                  int h_edge_pos, int v_edge_pos,
2651
                                  int w, int h, op_pixels_func *pix_op,
2652
                                  int motion_x, int motion_y)
2653
{
2654
    int dxy;
2655
    int emu=0;
2656

    
2657
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2658
    src_x += motion_x >> 1;
2659
    src_y += motion_y >> 1;
2660

    
2661
    /* WARNING: do no forget half pels */
2662
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2663
    if (src_x == width)
2664
        dxy &= ~1;
2665
    src_y = clip(src_y, -16, height);
2666
    if (src_y == height)
2667
        dxy &= ~2;
2668
    src += src_y * stride + src_x;
2669

    
2670
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2671
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2672
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2673
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2674
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2675
            src= s->edge_emu_buffer;
2676
            emu=1;
2677
        }
2678
    }
2679
    if(field_select)
2680
        src += s->linesize;
2681
    pix_op[dxy](dest, src, stride, h);
2682
    return emu;
2683
}
2684

    
2685
static inline int hpel_motion_lowres(MpegEncContext *s,
2686
                                  uint8_t *dest, uint8_t *src,
2687
                                  int field_based, int field_select,
2688
                                  int src_x, int src_y,
2689
                                  int width, int height, int stride,
2690
                                  int h_edge_pos, int v_edge_pos,
2691
                                  int w, int h, h264_chroma_mc_func *pix_op,
2692
                                  int motion_x, int motion_y)
2693
{
2694
    const int lowres= s->avctx->lowres;
2695
    const int s_mask= (2<<lowres)-1;
2696
    int emu=0;
2697
    int sx, sy;
2698

    
2699
    if(s->quarter_sample){
2700
        motion_x/=2;
2701
        motion_y/=2;
2702
    }
2703

    
2704
    sx= motion_x & s_mask;
2705
    sy= motion_y & s_mask;
2706
    src_x += motion_x >> (lowres+1);
2707
    src_y += motion_y >> (lowres+1);
2708

    
2709
    src += src_y * stride + src_x;
2710

    
2711
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2712
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2713
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2714
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2715
        src= s->edge_emu_buffer;
2716
        emu=1;
2717
    }
2718

    
2719
    sx <<= 2 - lowres;
2720
    sy <<= 2 - lowres;
2721
    if(field_select)
2722
        src += s->linesize;
2723
    pix_op[lowres](dest, src, stride, h, sx, sy);
2724
    return emu;
2725
}
2726

    
2727
/* apply one mpeg motion vector to the three components */
2728
static always_inline void mpeg_motion(MpegEncContext *s,
2729
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2730
                               int field_based, int bottom_field, int field_select,
2731
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2732
                               int motion_x, int motion_y, int h)
2733
{
2734
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2735
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2736

    
2737
#if 0
2738
if(s->quarter_sample)
2739
{
2740
    motion_x>>=1;
2741
    motion_y>>=1;
2742
}
2743
#endif
2744

    
2745
    v_edge_pos = s->v_edge_pos >> field_based;
2746
    linesize   = s->current_picture.linesize[0] << field_based;
2747
    uvlinesize = s->current_picture.linesize[1] << field_based;
2748

    
2749
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2750
    src_x = s->mb_x* 16               + (motion_x >> 1);
2751
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2752

    
2753
    if (s->out_format == FMT_H263) {
2754
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2755
            mx = (motion_x>>1)|(motion_x&1);
2756
            my = motion_y >>1;
2757
            uvdxy = ((my & 1) << 1) | (mx & 1);
2758
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2759
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2760
        }else{
2761
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2762
            uvsrc_x = src_x>>1;
2763
            uvsrc_y = src_y>>1;
2764
        }
2765
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2766
        mx = motion_x / 4;
2767
        my = motion_y / 4;
2768
        uvdxy = 0;
2769
        uvsrc_x = s->mb_x*8 + mx;
2770
        uvsrc_y = s->mb_y*8 + my;
2771
    } else {
2772
        if(s->chroma_y_shift){
2773
            mx = motion_x / 2;
2774
            my = motion_y / 2;
2775
            uvdxy = ((my & 1) << 1) | (mx & 1);
2776
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2777
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2778
        } else {
2779
            if(s->chroma_x_shift){
2780
            //Chroma422
2781
                mx = motion_x / 2;
2782
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2783
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2784
                uvsrc_y = src_y;
2785
            } else {
2786
            //Chroma444
2787
                uvdxy = dxy;
2788
                uvsrc_x = src_x;
2789
                uvsrc_y = src_y;
2790
            }
2791
        }
2792
    }
2793

    
2794
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2795
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2796
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2797

    
2798
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2799
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2800
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2801
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2802
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2803
                return ;
2804
            }
2805
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2806
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2807
            ptr_y = s->edge_emu_buffer;
2808
            if(!(s->flags&CODEC_FLAG_GRAY)){
2809
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2810
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2811
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2812
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2813
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2814
                ptr_cb= uvbuf;
2815
                ptr_cr= uvbuf+16;
2816
            }
2817
    }
2818

    
2819
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2820
        dest_y += s->linesize;
2821
        dest_cb+= s->uvlinesize;
2822
        dest_cr+= s->uvlinesize;
2823
    }
2824

    
2825
    if(field_select){
2826
        ptr_y += s->linesize;
2827
        ptr_cb+= s->uvlinesize;
2828
        ptr_cr+= s->uvlinesize;
2829
    }
2830

    
2831
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2832

    
2833
    if(!(s->flags&CODEC_FLAG_GRAY)){
2834
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2835
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2836
    }
2837
#if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2838
    if(s->out_format == FMT_H261){
2839
        ff_h261_loop_filter(s);
2840
    }
2841
#endif
2842
}
2843

    
2844
/* apply one mpeg motion vector to the three components */
2845
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2846
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2847
                               int field_based, int bottom_field, int field_select,
2848
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2849
                               int motion_x, int motion_y, int h)
2850
{
2851
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2852
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2853
    const int lowres= s->avctx->lowres;
2854
    const int block_s= 8>>lowres;
2855
    const int s_mask= (2<<lowres)-1;
2856
    const int h_edge_pos = s->h_edge_pos >> lowres;
2857
    const int v_edge_pos = s->v_edge_pos >> lowres;
2858
    linesize   = s->current_picture.linesize[0] << field_based;
2859
    uvlinesize = s->current_picture.linesize[1] << field_based;
2860

    
2861
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2862
        motion_x/=2;
2863
        motion_y/=2;
2864
    }
2865

    
2866
    if(field_based){
2867
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2868
    }
2869

    
2870
    sx= motion_x & s_mask;
2871
    sy= motion_y & s_mask;
2872
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2873
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2874

    
2875
    if (s->out_format == FMT_H263) {
2876
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2877
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2878
        uvsrc_x = src_x>>1;
2879
        uvsrc_y = src_y>>1;
2880
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2881
        mx = motion_x / 4;
2882
        my = motion_y / 4;
2883
        uvsx = (2*mx) & s_mask;
2884
        uvsy = (2*my) & s_mask;
2885
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2886
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2887
    } else {
2888
        mx = motion_x / 2;
2889
        my = motion_y / 2;
2890
        uvsx = mx & s_mask;
2891
        uvsy = my & s_mask;
2892
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2893
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2894
    }
2895

    
2896
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2897
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2898
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2899

    
2900
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2901
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2902
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2903
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2904
            ptr_y = s->edge_emu_buffer;
2905
            if(!(s->flags&CODEC_FLAG_GRAY)){
2906
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2907
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
2908
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2909
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2910
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2911
                ptr_cb= uvbuf;
2912
                ptr_cr= uvbuf+16;
2913
            }
2914
    }
2915

    
2916
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2917
        dest_y += s->linesize;
2918
        dest_cb+= s->uvlinesize;
2919
        dest_cr+= s->uvlinesize;
2920
    }
2921

    
2922
    if(field_select){
2923
        ptr_y += s->linesize;
2924
        ptr_cb+= s->uvlinesize;
2925
        ptr_cr+= s->uvlinesize;
2926
    }
2927

    
2928
    sx <<= 2 - lowres;
2929
    sy <<= 2 - lowres;
2930
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2931

    
2932
    if(!(s->flags&CODEC_FLAG_GRAY)){
2933
        uvsx <<= 2 - lowres;
2934
        uvsy <<= 2 - lowres;
2935
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2936
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2937
    }
2938
    //FIXME h261 lowres loop filter
2939
}
2940

    
2941
//FIXME move to dsputil, avg variant, 16x16 version
2942
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2943
    int x;
2944
    uint8_t * const top   = src[1];
2945
    uint8_t * const left  = src[2];
2946
    uint8_t * const mid   = src[0];
2947
    uint8_t * const right = src[3];
2948
    uint8_t * const bottom= src[4];
2949
#define OBMC_FILTER(x, t, l, m, r, b)\
2950
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2951
#define OBMC_FILTER4(x, t, l, m, r, b)\
2952
    OBMC_FILTER(x         , t, l, m, r, b);\
2953
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2954
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2955
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2956

    
2957
    x=0;
2958
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2959
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2960
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2961
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2962
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2963
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2964
    x+= stride;
2965
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2966
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2967
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2968
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2969
    x+= stride;
2970
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2971
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2972
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2973
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2974
    x+= 2*stride;
2975
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2976
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2977
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2978
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2979
    x+= 2*stride;
2980
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2981
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2982
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2983
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2984
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2985
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2986
    x+= stride;
2987
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2988
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2989
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2990
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2991
}
2992

    
2993
/* obmc for 1 8x8 luma block */
2994
static inline void obmc_motion(MpegEncContext *s,
2995
                               uint8_t *dest, uint8_t *src,
2996
                               int src_x, int src_y,
2997
                               op_pixels_func *pix_op,
2998
                               int16_t mv[5][2]/* mid top left right bottom*/)
2999
#define MID    0
3000
{
3001
    int i;
3002
    uint8_t *ptr[5];
3003

    
3004
    assert(s->quarter_sample==0);
3005

    
3006
    for(i=0; i<5; i++){
3007
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3008
            ptr[i]= ptr[MID];
3009
        }else{
3010
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3011
            hpel_motion(s, ptr[i], src, 0, 0,
3012
                        src_x, src_y,
3013
                        s->width, s->height, s->linesize,
3014
                        s->h_edge_pos, s->v_edge_pos,
3015
                        8, 8, pix_op,
3016
                        mv[i][0], mv[i][1]);
3017
        }
3018
    }
3019

    
3020
    put_obmc(dest, ptr, s->linesize);
3021
}
3022

    
3023
static inline void qpel_motion(MpegEncContext *s,
3024
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3025
                               int field_based, int bottom_field, int field_select,
3026
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3027
                               qpel_mc_func (*qpix_op)[16],
3028
                               int motion_x, int motion_y, int h)
3029
{
3030
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3031
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3032

    
3033
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3034
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3035
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3036

    
3037
    v_edge_pos = s->v_edge_pos >> field_based;
3038
    linesize = s->linesize << field_based;
3039
    uvlinesize = s->uvlinesize << field_based;
3040

    
3041
    if(field_based){
3042
        mx= motion_x/2;
3043
        my= motion_y>>1;
3044
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3045
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3046
        mx= (motion_x>>1) + rtab[motion_x&7];
3047
        my= (motion_y>>1) + rtab[motion_y&7];
3048
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3049
        mx= (motion_x>>1)|(motion_x&1);
3050
        my= (motion_y>>1)|(motion_y&1);
3051
    }else{
3052
        mx= motion_x/2;
3053
        my= motion_y/2;
3054
    }
3055
    mx= (mx>>1)|(mx&1);
3056
    my= (my>>1)|(my&1);
3057

    
3058
    uvdxy= (mx&1) | ((my&1)<<1);
3059
    mx>>=1;
3060
    my>>=1;
3061

    
3062
    uvsrc_x = s->mb_x *  8                 + mx;
3063
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3064

    
3065
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3066
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3067
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3068

    
3069
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3070
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3071
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3072
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3073
        ptr_y= s->edge_emu_buffer;
3074
        if(!(s->flags&CODEC_FLAG_GRAY)){
3075
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3076
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3077
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3078
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3079
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3080
            ptr_cb= uvbuf;
3081
            ptr_cr= uvbuf + 16;
3082
        }
3083
    }
3084

    
3085
    if(!field_based)
3086
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3087
    else{
3088
        if(bottom_field){
3089
            dest_y += s->linesize;
3090
            dest_cb+= s->uvlinesize;
3091
            dest_cr+= s->uvlinesize;
3092
        }
3093

    
3094
        if(field_select){
3095
            ptr_y  += s->linesize;
3096
            ptr_cb += s->uvlinesize;
3097
            ptr_cr += s->uvlinesize;
3098
        }
3099
        //damn interlaced mode
3100
        //FIXME boundary mirroring is not exactly correct here
3101
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3102
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3103
    }
3104
    if(!(s->flags&CODEC_FLAG_GRAY)){
3105
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3106
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3107
    }
3108
}
3109

    
3110
inline int ff_h263_round_chroma(int x){
3111
    if (x >= 0)
3112
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3113
    else {
3114
        x = -x;
3115
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3116
    }
3117
}
3118

    
3119
/**
3120
 * h263 chorma 4mv motion compensation.
3121
 */
3122
static inline void chroma_4mv_motion(MpegEncContext *s,
3123
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3124
                                     uint8_t **ref_picture,
3125
                                     op_pixels_func *pix_op,
3126
                                     int mx, int my){
3127
    int dxy, emu=0, src_x, src_y, offset;
3128
    uint8_t *ptr;
3129

    
3130
    /* In case of 8X8, we construct a single chroma motion vector
3131
       with a special rounding */
3132
    mx= ff_h263_round_chroma(mx);
3133
    my= ff_h263_round_chroma(my);
3134

    
3135
    dxy = ((my & 1) << 1) | (mx & 1);
3136
    mx >>= 1;
3137
    my >>= 1;
3138

    
3139
    src_x = s->mb_x * 8 + mx;
3140
    src_y = s->mb_y * 8 + my;
3141
    src_x = clip(src_x, -8, s->width/2);
3142
    if (src_x == s->width/2)
3143
        dxy &= ~1;
3144
    src_y = clip(src_y, -8, s->height/2);
3145
    if (src_y == s->height/2)
3146
        dxy &= ~2;
3147

    
3148
    offset = (src_y * (s->uvlinesize)) + src_x;
3149
    ptr = ref_picture[1] + offset;
3150
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3151
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3152
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3153
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3154
            ptr= s->edge_emu_buffer;
3155
            emu=1;
3156
        }
3157
    }
3158
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3159

    
3160
    ptr = ref_picture[2] + offset;
3161
    if(emu){
3162
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3163
        ptr= s->edge_emu_buffer;
3164
    }
3165
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3166
}
3167

    
3168
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3169
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3170
                                     uint8_t **ref_picture,
3171
                                     h264_chroma_mc_func *pix_op,
3172
                                     int mx, int my){
3173
    const int lowres= s->avctx->lowres;
3174
    const int block_s= 8>>lowres;
3175
    const int s_mask= (2<<lowres)-1;
3176
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3177
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3178
    int emu=0, src_x, src_y, offset, sx, sy;
3179
    uint8_t *ptr;
3180

    
3181
    if(s->quarter_sample){
3182
        mx/=2;
3183
        my/=2;
3184
    }
3185

    
3186
    /* In case of 8X8, we construct a single chroma motion vector
3187
       with a special rounding */
3188
    mx= ff_h263_round_chroma(mx);
3189
    my= ff_h263_round_chroma(my);
3190

    
3191
    sx= mx & s_mask;
3192
    sy= my & s_mask;
3193
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3194
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3195

    
3196
    offset = src_y * s->uvlinesize + src_x;
3197
    ptr = ref_picture[1] + offset;
3198
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3199
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3200
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3201
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3202
            ptr= s->edge_emu_buffer;
3203
            emu=1;
3204
        }
3205
    }
3206
    sx <<= 2 - lowres;
3207
    sy <<= 2 - lowres;
3208
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3209

    
3210
    ptr = ref_picture[2] + offset;
3211
    if(emu){
3212
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3213
        ptr= s->edge_emu_buffer;
3214
    }
3215
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3216
}
3217

    
3218
/**
3219
 * motion compensation of a single macroblock
3220
 * @param s context
3221
 * @param dest_y luma destination pointer
3222
 * @param dest_cb chroma cb/u destination pointer
3223
 * @param dest_cr chroma cr/v destination pointer
3224
 * @param dir direction (0->forward, 1->backward)
3225
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3226
 * @param pic_op halfpel motion compensation function (average or put normally)
3227
 * @param pic_op qpel motion compensation function (average or put normally)
3228
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3229
 */
3230
static inline void MPV_motion(MpegEncContext *s,
3231
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3232
                              int dir, uint8_t **ref_picture,
3233
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3234
{
3235
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3236
    int mb_x, mb_y, i;
3237
    uint8_t *ptr, *dest;
3238

    
3239
    mb_x = s->mb_x;
3240
    mb_y = s->mb_y;
3241

    
3242
    if(s->obmc && s->pict_type != B_TYPE){
3243
        int16_t mv_cache[4][4][2];
3244
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3245
        const int mot_stride= s->b8_stride;
3246
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3247

    
3248
        assert(!s->mb_skipped);
3249

    
3250
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3251
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3252
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3253

    
3254
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3255
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3256
        }else{
3257
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3258
        }
3259

    
3260
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3261
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3262
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3263
        }else{
3264
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3265
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3266
        }
3267

    
3268
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3269
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3270
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3271
        }else{
3272
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3273
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3274
        }
3275

    
3276
        mx = 0;
3277
        my = 0;
3278
        for(i=0;i<4;i++) {
3279
            const int x= (i&1)+1;
3280
            const int y= (i>>1)+1;
3281
            int16_t mv[5][2]= {
3282
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3283
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3284
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3285
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3286
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3287
            //FIXME cleanup
3288
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3289
                        ref_picture[0],
3290
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3291
                        pix_op[1],
3292
                        mv);
3293

    
3294
            mx += mv[0][0];
3295
            my += mv[0][1];
3296
        }
3297
        if(!(s->flags&CODEC_FLAG_GRAY))
3298
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3299

    
3300
        return;
3301
    }
3302

    
3303
    switch(s->mv_type) {
3304
    case MV_TYPE_16X16:
3305
        if(s->mcsel){
3306
            if(s->real_sprite_warping_points==1){
3307
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3308
                            ref_picture);
3309
            }else{
3310
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3311
                            ref_picture);
3312
            }
3313
        }else if(s->quarter_sample){
3314
            qpel_motion(s, dest_y, dest_cb, dest_cr,
3315
                        0, 0, 0,
3316
                        ref_picture, pix_op, qpix_op,
3317
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3318
        }else if(s->mspel){
3319
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3320
                        ref_picture, pix_op,
3321
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3322
        }else
3323
        {
3324
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3325
                        0, 0, 0,
3326
                        ref_picture, pix_op,
3327
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3328
        }
3329
        break;
3330
    case MV_TYPE_8X8:
3331
        mx = 0;
3332
        my = 0;
3333
        if(s->quarter_sample){
3334
            for(i=0;i<4;i++) {
3335
                motion_x = s->mv[dir][i][0];
3336
                motion_y = s->mv[dir][i][1];
3337

    
3338
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3339
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3340
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3341

    
3342
                /* WARNING: do no forget half pels */
3343
                src_x = clip(src_x, -16, s->width);
3344
                if (src_x == s->width)
3345
                    dxy &= ~3;
3346
                src_y = clip(src_y, -16, s->height);
3347
                if (src_y == s->height)
3348
                    dxy &= ~12;
3349

    
3350
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3351
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3352
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3353
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3354
                        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
3355
                        ptr= s->edge_emu_buffer;
3356
                    }
3357
                }
3358
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3359
                qpix_op[1][dxy](dest, ptr, s->linesize);
3360

    
3361
                mx += s->mv[dir][i][0]/2;
3362
                my += s->mv[dir][i][1]/2;
3363
            }
3364
        }else{
3365
            for(i=0;i<4;i++) {
3366
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3367
                            ref_picture[0], 0, 0,
3368
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3369
                            s->width, s->height, s->linesize,
3370
                            s->h_edge_pos, s->v_edge_pos,
3371
                            8, 8, pix_op[1],
3372
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3373

    
3374
                mx += s->mv[dir][i][0];
3375
                my += s->mv[dir][i][1];
3376
            }
3377
        }
3378

    
3379
        if(!(s->flags&CODEC_FLAG_GRAY))
3380
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3381
        break;
3382
    case MV_TYPE_FIELD:
3383
        if (s->picture_structure == PICT_FRAME) {
3384
            if(s->quarter_sample){
3385
                for(i=0; i<2; i++){
3386
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3387
                                1, i, s->field_select[dir][i],
3388
                                ref_picture, pix_op, qpix_op,
3389
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3390
                }
3391
            }else{
3392
                /* top field */
3393
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3394
                            1, 0, s->field_select[dir][0],
3395
                            ref_picture, pix_op,
3396
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3397
                /* bottom field */
3398
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3399
                            1, 1, s->field_select[dir][1],
3400
                            ref_picture, pix_op,
3401
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3402
            }
3403
        } else {
3404
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3405
                ref_picture= s->current_picture_ptr->data;
3406
            }
3407

    
3408
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3409
                        0, 0, s->field_select[dir][0],
3410
                        ref_picture, pix_op,
3411
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3412
        }
3413
        break;
3414
    case MV_TYPE_16X8:
3415
        for(i=0; i<2; i++){
3416
            uint8_t ** ref2picture;
3417

    
3418
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3419
                ref2picture= ref_picture;
3420
            }else{
3421
                ref2picture= s->current_picture_ptr->data;
3422
            }
3423

    
3424
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3425
                        0, 0, s->field_select[dir][i],
3426
                        ref2picture, pix_op,
3427
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3428

    
3429
            dest_y += 16*s->linesize;
3430
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3431
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3432
        }
3433
        break;
3434
    case MV_TYPE_DMV:
3435
        if(s->picture_structure == PICT_FRAME){
3436
            for(i=0; i<2; i++){
3437
                int j;
3438
                for(j=0; j<2; j++){
3439
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3440
                                1, j, j^i,
3441
                                ref_picture, pix_op,
3442
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3443
                }
3444
                pix_op = s->dsp.avg_pixels_tab;
3445
            }
3446
        }else{
3447
            for(i=0; i<2; i++){
3448
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3449
                            0, 0, s->picture_structure != i+1,
3450
                            ref_picture, pix_op,
3451
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3452

    
3453
                // after put we make avg of the same block
3454
                pix_op=s->dsp.avg_pixels_tab;
3455

    
3456
                //opposite parity is always in the same frame if this is second field
3457
                if(!s->first_field){
3458
                    ref_picture = s->current_picture_ptr->data;
3459
                }
3460
            }
3461
        }
3462
    break;
3463
    default: assert(0);
3464
    }
3465
}
3466

    
3467
/**
3468
 * motion compensation of a single macroblock
3469
 * @param s context
3470
 * @param dest_y luma destination pointer
3471
 * @param dest_cb chroma cb/u destination pointer
3472
 * @param dest_cr chroma cr/v destination pointer
3473
 * @param dir direction (0->forward, 1->backward)
3474
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3475
 * @param pic_op halfpel motion compensation function (average or put normally)
3476
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3477
 */
3478
static inline void MPV_motion_lowres(MpegEncContext *s,
3479
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3480
                              int dir, uint8_t **ref_picture,
3481
                              h264_chroma_mc_func *pix_op)
3482
{
3483
    int mx, my;
3484
    int mb_x, mb_y, i;
3485
    const int lowres= s->avctx->lowres;
3486
    const int block_s= 8>>lowres;
3487

    
3488
    mb_x = s->mb_x;
3489
    mb_y = s->mb_y;
3490

    
3491
    switch(s->mv_type) {
3492
    case MV_TYPE_16X16:
3493
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3494
                    0, 0, 0,
3495
                    ref_picture, pix_op,
3496
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3497
        break;
3498
    case MV_TYPE_8X8:
3499
        mx = 0;
3500
        my = 0;
3501
            for(i=0;i<4;i++) {
3502
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3503
                            ref_picture[0], 0, 0,
3504
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3505
                            s->width, s->height, s->linesize,
3506
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3507
                            block_s, block_s, pix_op,
3508
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3509

    
3510
                mx += s->mv[dir][i][0];
3511
                my += s->mv[dir][i][1];
3512
            }
3513

    
3514
        if(!(s->flags&CODEC_FLAG_GRAY))
3515
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3516
        break;
3517
    case MV_TYPE_FIELD:
3518
        if (s->picture_structure == PICT_FRAME) {
3519
            /* top field */
3520
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3521
                        1, 0, s->field_select[dir][0],
3522
                        ref_picture, pix_op,
3523
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3524
            /* bottom field */
3525
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3526
                        1, 1, s->field_select[dir][1],
3527
                        ref_picture, pix_op,
3528
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3529
        } else {
3530
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3531
                ref_picture= s->current_picture_ptr->data;
3532
            }
3533

    
3534
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3535
                        0, 0, s->field_select[dir][0],
3536
                        ref_picture, pix_op,
3537
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3538
        }
3539
        break;
3540
    case MV_TYPE_16X8:
3541
        for(i=0; i<2; i++){
3542
            uint8_t ** ref2picture;
3543

    
3544
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3545
                ref2picture= ref_picture;
3546
            }else{
3547
                ref2picture= s->current_picture_ptr->data;
3548
            }
3549

    
3550
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3551
                        0, 0, s->field_select[dir][i],
3552
                        ref2picture, pix_op,
3553
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3554

    
3555
            dest_y += 2*block_s*s->linesize;
3556
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3557
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3558
        }
3559
        break;
3560
    case MV_TYPE_DMV:
3561
        if(s->picture_structure == PICT_FRAME){
3562
            for(i=0; i<2; i++){
3563
                int j;
3564
                for(j=0; j<2; j++){
3565
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3566
                                1, j, j^i,
3567
                                ref_picture, pix_op,
3568
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3569
                }
3570
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3571
            }
3572
        }else{
3573
            for(i=0; i<2; i++){
3574
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3575
                            0, 0, s->picture_structure != i+1,
3576
                            ref_picture, pix_op,
3577
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3578

    
3579
                // after put we make avg of the same block
3580
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3581

    
3582
                //opposite parity is always in the same frame if this is second field
3583
                if(!s->first_field){
3584
                    ref_picture = s->current_picture_ptr->data;
3585
                }
3586
            }
3587
        }
3588
    break;
3589
    default: assert(0);
3590
    }
3591
}
3592

    
3593
/* put block[] to dest[] */
3594
static inline void put_dct(MpegEncContext *s,
3595
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3596
{
3597
    s->dct_unquantize_intra(s, block, i, qscale);
3598
    s->dsp.idct_put (dest, line_size, block);
3599
}
3600

    
3601
/* add block[] to dest[] */
3602
static inline void add_dct(MpegEncContext *s,
3603
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3604
{
3605
    if (s->block_last_index[i] >= 0) {
3606
        s->dsp.idct_add (dest, line_size, block);
3607
    }
3608
}
3609

    
3610
static inline void add_dequant_dct(MpegEncContext *s,
3611
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3612
{
3613
    if (s->block_last_index[i] >= 0) {
3614
        s->dct_unquantize_inter(s, block, i, qscale);
3615

    
3616
        s->dsp.idct_add (dest, line_size, block);
3617
    }
3618
}
3619

    
3620
/**
3621
 * cleans dc, ac, coded_block for the current non intra MB
3622
 */
3623
void ff_clean_intra_table_entries(MpegEncContext *s)
3624
{
3625
    int wrap = s->b8_stride;
3626
    int xy = s->block_index[0];
3627

    
3628
    s->dc_val[0][xy           ] =
3629
    s->dc_val[0][xy + 1       ] =
3630
    s->dc_val[0][xy     + wrap] =
3631
    s->dc_val[0][xy + 1 + wrap] = 1024;
3632
    /* ac pred */
3633
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3634
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3635
    if (s->msmpeg4_version>=3) {
3636
        s->coded_block[xy           ] =
3637
        s->coded_block[xy + 1       ] =
3638
        s->coded_block[xy     + wrap] =
3639
        s->coded_block[xy + 1 + wrap] = 0;
3640
    }
3641
    /* chroma */
3642
    wrap = s->mb_stride;
3643
    xy = s->mb_x + s->mb_y * wrap;
3644
    s->dc_val[1][xy] =
3645
    s->dc_val[2][xy] = 1024;
3646
    /* ac pred */
3647
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3648
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3649

    
3650
    s->mbintra_table[xy]= 0;
3651
}
3652

    
3653
/* generic function called after a macroblock has been parsed by the
3654
   decoder or after it has been encoded by the encoder.
3655

3656
   Important variables used:
3657
   s->mb_intra : true if intra macroblock
3658
   s->mv_dir   : motion vector direction
3659
   s->mv_type  : motion vector type
3660
   s->mv       : motion vector
3661
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3662
 */
3663
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3664
{
3665
    int mb_x, mb_y;
3666
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3667
#ifdef HAVE_XVMC
3668
    if(s->avctx->xvmc_acceleration){
3669
        XVMC_decode_mb(s);//xvmc uses pblocks
3670
        return;
3671
    }
3672
#endif
3673

    
3674
    mb_x = s->mb_x;
3675
    mb_y = s->mb_y;
3676

    
3677
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3678
       /* save DCT coefficients */
3679
       int i,j;
3680
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3681
       for(i=0; i<6; i++)
3682
           for(j=0; j<64; j++)
3683
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3684
    }
3685

    
3686
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3687

    
3688
    /* update DC predictors for P macroblocks */
3689
    if (!s->mb_intra) {
3690
        if (s->h263_pred || s->h263_aic) {
3691
            if(s->mbintra_table[mb_xy])
3692
                ff_clean_intra_table_entries(s);
3693
        } else {
3694
            s->last_dc[0] =
3695
            s->last_dc[1] =
3696
            s->last_dc[2] = 128 << s->intra_dc_precision;
3697
        }
3698
    }
3699
    else if (s->h263_pred || s->h263_aic)
3700
        s->mbintra_table[mb_xy]=1;
3701

    
3702
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3703
        uint8_t *dest_y, *dest_cb, *dest_cr;
3704
        int dct_linesize, dct_offset;
3705
        op_pixels_func (*op_pix)[4];
3706
        qpel_mc_func (*op_qpix)[16];
3707
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3708
        const int uvlinesize= s->current_picture.linesize[1];
3709
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3710
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3711

    
3712
        /* avoid copy if macroblock skipped in last frame too */
3713
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3714
        if(!s->encoding){
3715
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3716
            const int age= s->current_picture.age;
3717

    
3718
            assert(age);
3719

    
3720
            if (s->mb_skipped) {
3721
                s->mb_skipped= 0;
3722
                assert(s->pict_type!=I_TYPE);
3723

    
3724
                (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3725
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3726

    
3727
                /* if previous was skipped too, then nothing to do !  */
3728
                if (*mbskip_ptr >= age && s->current_picture.reference){
3729
                    return;
3730
                }
3731
            } else if(!s->current_picture.reference){
3732
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3733
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3734
            } else{
3735
                *mbskip_ptr = 0; /* not skipped */
3736
            }
3737
        }
3738

    
3739
        dct_linesize = linesize << s->interlaced_dct;
3740
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3741

    
3742
        if(readable){
3743
            dest_y=  s->dest[0];
3744
            dest_cb= s->dest[1];
3745
            dest_cr= s->dest[2];
3746
        }else{
3747
            dest_y = s->b_scratchpad;
3748
            dest_cb= s->b_scratchpad+16*linesize;
3749
            dest_cr= s->b_scratchpad+32*linesize;
3750
        }
3751

    
3752
        if (!s->mb_intra) {
3753
            /* motion handling */
3754
            /* decoding or more than one mb_type (MC was already done otherwise) */
3755
            if(!s->encoding){
3756
                if(lowres_flag){
3757
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3758

    
3759
                    if (s->mv_dir & MV_DIR_FORWARD) {
3760
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3761
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3762
                    }
3763
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3764
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3765
                    }
3766
                }else{
3767
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){
3768
                        op_pix = s->dsp.put_pixels_tab;
3769
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3770
                    }else{
3771
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3772
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3773
                    }
3774
                    if (s->mv_dir & MV_DIR_FORWARD) {
3775
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3776
                        op_pix = s->dsp.avg_pixels_tab;
3777
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3778
                    }
3779
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3780
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3781
                    }
3782
                }
3783
            }
3784

    
3785
            /* skip dequant / idct if we are really late ;) */
3786
            if(s->hurry_up>1) goto skip_idct;
3787
            if(s->avctx->skip_idct){
3788
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3789
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3790
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
3791
                    goto skip_idct;
3792
            }
3793

    
3794
            /* add dct residue */
3795
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3796
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3797
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3798
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3799
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3800
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3801

    
3802
                if(!(s->flags&CODEC_FLAG_GRAY)){
3803
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3804
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3805
                }
3806
            } else if(s->codec_id != CODEC_ID_WMV2){
3807
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3808
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3809
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3810
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3811

    
3812
                if(!(s->flags&CODEC_FLAG_GRAY)){
3813
                    if(s->chroma_y_shift){//Chroma420
3814
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3815
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3816
                    }else{
3817
                        //chroma422
3818
                        dct_linesize = uvlinesize << s->interlaced_dct;
3819
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3820

    
3821
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3822
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3823
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3824
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3825
                        if(!s->chroma_x_shift){//Chroma444
3826
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3827
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3828
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3829
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3830
                        }
3831
                    }
3832
                }//fi gray
3833
            }
3834
            else{
3835
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3836
            }
3837
        } else {
3838
            /* dct only in intra block */
3839
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3840
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3841
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3842
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3843
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3844

    
3845
                if(!(s->flags&CODEC_FLAG_GRAY)){
3846
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3847
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3848
                }
3849
            }else{
3850
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3851
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3852
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3853
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3854

    
3855
                if(!(s->flags&CODEC_FLAG_GRAY)){
3856
                    if(s->chroma_y_shift){
3857
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3858
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3859
                    }else{
3860

    
3861
                        dct_linesize = uvlinesize << s->interlaced_dct;
3862
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3863

    
3864
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3865
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3866
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3867
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3868
                        if(!s->chroma_x_shift){//Chroma444
3869
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3870
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3871
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3872
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3873
                        }
3874
                    }
3875
                }//gray
3876
            }
3877
        }
3878
skip_idct:
3879
        if(!readable){
3880
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3881
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3882
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3883
        }
3884
    }
3885
}
3886

    
3887
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3888
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3889
    else                  MPV_decode_mb_internal(s, block, 0);
3890
}
3891

    
3892
#ifdef CONFIG_ENCODERS
3893

    
3894
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3895
{
3896
    static const char tab[64]=
3897
        {3,2,2,1,1,1,1,1,
3898
         1,1,1,1,1,1,1,1,
3899
         1,1,1,1,1,1,1,1,
3900
         0,0,0,0,0,0,0,0,
3901
         0,0,0,0,0,0,0,0,
3902
         0,0,0,0,0,0,0,0,
3903
         0,0,0,0,0,0,0,0,
3904
         0,0,0,0,0,0,0,0};
3905
    int score=0;
3906
    int run=0;
3907
    int i;
3908
    DCTELEM *block= s->block[n];
3909
    const int last_index= s->block_last_index[n];
3910
    int skip_dc;
3911

    
3912
    if(threshold<0){
3913
        skip_dc=0;
3914
        threshold= -threshold;
3915
    }else
3916
        skip_dc=1;
3917

    
3918
    /* are all which we could set to zero are allready zero? */
3919
    if(last_index<=skip_dc - 1) return;
3920

    
3921
    for(i=0; i<=last_index; i++){
3922
        const int j = s->intra_scantable.permutated[i];
3923
        const int level = ABS(block[j]);
3924
        if(level==1){
3925
            if(skip_dc && i==0) continue;
3926
            score+= tab[run];
3927
            run=0;
3928
        }else if(level>1){
3929
            return;
3930
        }else{
3931
            run++;
3932
        }
3933
    }
3934
    if(score >= threshold) return;
3935
    for(i=skip_dc; i<=last_index; i++){
3936
        const int j = s->intra_scantable.permutated[i];
3937
        block[j]=0;
3938
    }
3939
    if(block[0]) s->block_last_index[n]= 0;
3940
    else         s->block_last_index[n]= -1;
3941
}
3942

    
3943
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3944
{
3945
    int i;
3946
    const int maxlevel= s->max_qcoeff;
3947
    const int minlevel= s->min_qcoeff;
3948
    int overflow=0;
3949

    
3950
    if(s->mb_intra){
3951
        i=1; //skip clipping of intra dc
3952
    }else
3953
        i=0;
3954

    
3955
    for(;i<=last_index; i++){
3956
        const int j= s->intra_scantable.permutated[i];
3957
        int level = block[j];
3958

    
3959
        if     (level>maxlevel){
3960
            level=maxlevel;
3961
            overflow++;
3962
        }else if(level<minlevel){
3963
            level=minlevel;
3964
            overflow++;
3965
        }
3966

    
3967
        block[j]= level;
3968
    }
3969

    
3970
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3971
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
3972
}
3973

    
3974
#endif //CONFIG_ENCODERS
3975

    
3976
/**
3977
 *
3978
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3979
 */
3980
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3981
    if (s->avctx->draw_horiz_band) {
3982
        AVFrame *src;
3983
        int offset[4];
3984

    
3985
        if(s->picture_structure != PICT_FRAME){
3986
            h <<= 1;
3987
            y <<= 1;
3988
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3989
        }
3990

    
3991
        h= FFMIN(h, s->avctx->height - y);
3992

    
3993
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
3994
            src= (AVFrame*)s->current_picture_ptr;
3995
        else if(s->last_picture_ptr)
3996
            src= (AVFrame*)s->last_picture_ptr;
3997
        else
3998
            return;
3999

    
4000
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4001
            offset[0]=
4002
            offset[1]=
4003
            offset[2]=
4004
            offset[3]= 0;
4005
        }else{
4006
            offset[0]= y * s->linesize;;
4007
            offset[1]=
4008
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4009
            offset[3]= 0;
4010
        }
4011

    
4012
        emms_c();
4013

    
4014
        s->avctx->draw_horiz_band(s->avctx, src, offset,
4015
                                  y, s->picture_structure, h);
4016
    }
4017
}
4018

    
4019
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4020
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4021
    const int uvlinesize= s->current_picture.linesize[1];
4022
    const int mb_size= 4 - s->avctx->lowres;
4023

    
4024
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
4025
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
4026
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4027
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4028
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4029
    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;
4030
    //block_index is not used by mpeg2, so it is not affected by chroma_format
4031

    
4032
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4033
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4034
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4035

    
4036
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4037
    {
4038
        s->dest[0] += s->mb_y *   linesize << mb_size;
4039
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4040
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4041
    }
4042
}
4043

    
4044
#ifdef CONFIG_ENCODERS
4045

    
4046
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4047
    int x, y;
4048
//FIXME optimize
4049
    for(y=0; y<8; y++){
4050
        for(x=0; x<8; x++){
4051
            int x2, y2;
4052
            int sum=0;
4053
            int sqr=0;
4054
            int count=0;
4055

    
4056
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4057
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4058
                    int v= ptr[x2 + y2*stride];
4059
                    sum += v;
4060
                    sqr += v*v;
4061
                    count++;
4062
                }
4063
            }
4064
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4065
        }
4066
    }
4067
}
4068

    
4069
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4070
{
4071
    int16_t weight[6][64];
4072
    DCTELEM orig[6][64];
4073
    const int mb_x= s->mb_x;
4074
    const int mb_y= s->mb_y;
4075
    int i;
4076
    int skip_dct[6];
4077
    int dct_offset   = s->linesize*8; //default for progressive frames
4078
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4079
    int wrap_y, wrap_c;
4080

    
4081
    for(i=0; i<6; i++) skip_dct[i]=0;
4082

    
4083
    if(s->adaptive_quant){
4084
        const int last_qp= s->qscale;
4085
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4086

    
4087
        s->lambda= s->lambda_table[mb_xy];
4088
        update_qscale(s);
4089

    
4090
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4091
            s->dquant= s->qscale - last_qp;
4092

    
4093
            if(s->out_format==FMT_H263){
4094
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4095

    
4096
                if(s->codec_id==CODEC_ID_MPEG4){
4097
                    if(!s->mb_intra){
4098
                        if(s->pict_type == B_TYPE){
4099
                            if(s->dquant&1)
4100
                                s->dquant= (s->dquant/2)*2;
4101
                            if(s->mv_dir&MV_DIRECT)
4102
                                s->dquant= 0;
4103
                        }
4104
                        if(s->mv_type==MV_TYPE_8X8)
4105
                            s->dquant=0;
4106
                    }
4107
                }
4108
            }
4109
        }
4110
        ff_set_qscale(s, last_qp + s->dquant);
4111
    }else if(s->flags&CODEC_FLAG_QP_RD)
4112
        ff_set_qscale(s, s->qscale + s->dquant);
4113

    
4114
    wrap_y = s->linesize;
4115
    wrap_c = s->uvlinesize;
4116
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4117
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4118
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4119

    
4120
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4121
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4122
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4123
        ptr_y= ebuf;
4124
        ff_emulated_edge_mc(ebuf+18*wrap_y  , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4125
        ptr_cb= ebuf+18*wrap_y;
4126
        ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4127
        ptr_cr= ebuf+18*wrap_y+8;
4128
    }
4129

    
4130
    if (s->mb_intra) {
4131
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4132
            int progressive_score, interlaced_score;
4133

    
4134
            s->interlaced_dct=0;
4135
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
4136
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4137

    
4138
            if(progressive_score > 0){
4139
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
4140
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4141
                if(progressive_score > interlaced_score){
4142
                    s->interlaced_dct=1;
4143

    
4144
                    dct_offset= wrap_y;
4145
                    wrap_y<<=1;
4146
                }
4147
            }
4148
        }
4149

    
4150
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4151
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4152
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4153
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4154

    
4155
        if(s->flags&CODEC_FLAG_GRAY){
4156
            skip_dct[4]= 1;
4157
            skip_dct[5]= 1;
4158
        }else{
4159
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4160
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4161
        }
4162
    }else{
4163
        op_pixels_func (*op_pix)[4];
4164
        qpel_mc_func (*op_qpix)[16];
4165
        uint8_t *dest_y, *dest_cb, *dest_cr;
4166

    
4167
        dest_y  = s->dest[0];
4168
        dest_cb = s->dest[1];
4169
        dest_cr = s->dest[2];
4170

    
4171
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4172
            op_pix = s->dsp.put_pixels_tab;
4173
            op_qpix= s->dsp.put_qpel_pixels_tab;
4174
        }else{
4175
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4176
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4177
        }
4178

    
4179
        if (s->mv_dir & MV_DIR_FORWARD) {
4180
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4181
            op_pix = s->dsp.avg_pixels_tab;
4182
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4183
        }
4184
        if (s->mv_dir & MV_DIR_BACKWARD) {
4185
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4186
        }
4187

    
4188
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4189
            int progressive_score, interlaced_score;
4190

    
4191
            s->interlaced_dct=0;
4192
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
4193
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4194

    
4195
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4196

    
4197
            if(progressive_score>0){
4198
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
4199
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4200

    
4201
                if(progressive_score > interlaced_score){
4202
                    s->interlaced_dct=1;
4203

    
4204
                    dct_offset= wrap_y;
4205
                    wrap_y<<=1;
4206
                }
4207
            }
4208
        }
4209

    
4210
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4211
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4212
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4213
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4214

    
4215
        if(s->flags&CODEC_FLAG_GRAY){
4216
            skip_dct[4]= 1;
4217
            skip_dct[5]= 1;
4218
        }else{
4219
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4220
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4221
        }
4222
        /* pre quantization */
4223
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4224
            //FIXME optimize
4225
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4226
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4227
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4228
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
4229
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4230
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4231
        }
4232
    }
4233

    
4234
    if(s->avctx->quantizer_noise_shaping){
4235
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4236
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4237
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4238
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4239
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4240
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4241
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4242
    }
4243

    
4244
    /* DCT & quantize */
4245
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4246
    {
4247
        for(i=0;i<6;i++) {
4248
            if(!skip_dct[i]){
4249
                int overflow;
4250
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4251
            // FIXME we could decide to change to quantizer instead of clipping
4252
            // JS: I don't think that would be a good idea it could lower quality instead
4253
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4254
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4255
            }else
4256
                s->block_last_index[i]= -1;
4257
        }
4258
        if(s->avctx->quantizer_noise_shaping){
4259
            for(i=0;i<6;i++) {
4260
                if(!skip_dct[i]){
4261
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4262
                }
4263
            }
4264
        }
4265

    
4266
        if(s->luma_elim_threshold && !s->mb_intra)
4267
            for(i=0; i<4; i++)
4268
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4269
        if(s->chroma_elim_threshold && !s->mb_intra)
4270
            for(i=4; i<6; i++)
4271
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4272

    
4273
        if(s->flags & CODEC_FLAG_CBP_RD){
4274
            for(i=0;i<6;i++) {
4275
                if(s->block_last_index[i] == -1)
4276
                    s->coded_score[i]= INT_MAX/256;
4277
            }
4278
        }
4279
    }
4280

    
4281
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4282
        s->block_last_index[4]=
4283
        s->block_last_index[5]= 0;
4284
        s->block[4][0]=
4285
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4286
    }
4287

    
4288
    //non c quantize code returns incorrect block_last_index FIXME
4289
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4290
        for(i=0; i<6; i++){
4291
            int j;
4292
            if(s->block_last_index[i]>0){
4293
                for(j=63; j>0; j--){
4294
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4295
                }
4296
                s->block_last_index[i]= j;
4297
            }
4298
        }
4299
    }
4300

    
4301
    /* huffman encode */
4302
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4303
    case CODEC_ID_MPEG1VIDEO:
4304
    case CODEC_ID_MPEG2VIDEO:
4305
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4306
    case CODEC_ID_MPEG4:
4307
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4308
    case CODEC_ID_MSMPEG4V2:
4309
    case CODEC_ID_MSMPEG4V3:
4310
    case CODEC_ID_WMV1:
4311
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4312
    case CODEC_ID_WMV2:
4313
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4314
#ifdef CONFIG_H261_ENCODER
4315
    case CODEC_ID_H261:
4316
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4317
#endif
4318
    case CODEC_ID_H263:
4319
    case CODEC_ID_H263P:
4320
    case CODEC_ID_FLV1:
4321
    case CODEC_ID_RV10:
4322
    case CODEC_ID_RV20:
4323
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4324
    case CODEC_ID_MJPEG:
4325
        mjpeg_encode_mb(s, s->block); break;
4326
    default:
4327
        assert(0);
4328
    }
4329
}
4330

    
4331
#endif //CONFIG_ENCODERS
4332

    
4333
void ff_mpeg_flush(AVCodecContext *avctx){
4334
    int i;
4335
    MpegEncContext *s = avctx->priv_data;
4336

    
4337
    if(s==NULL || s->picture==NULL)
4338
        return;
4339

    
4340
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4341
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4342
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4343
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4344
    }
4345
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4346

    
4347
    s->mb_x= s->mb_y= 0;
4348

    
4349
    s->parse_context.state= -1;
4350
    s->parse_context.frame_start_found= 0;
4351
    s->parse_context.overread= 0;
4352
    s->parse_context.overread_index= 0;
4353
    s->parse_context.index= 0;
4354
    s->parse_context.last_index= 0;
4355
    s->bitstream_buffer_size=0;
4356
}
4357

    
4358
#ifdef CONFIG_ENCODERS
4359
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4360
{
4361
    const uint16_t *srcw= (uint16_t*)src;
4362
    int words= length>>4;
4363
    int bits= length&15;
4364
    int i;
4365

    
4366
    if(length==0) return;
4367

    
4368
    if(words < 16){
4369
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4370
    }else if(put_bits_count(pb)&7){
4371
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4372
    }else{
4373
        for(i=0; put_bits_count(pb)&31; i++)
4374
            put_bits(pb, 8, src[i]);
4375
        flush_put_bits(pb);
4376
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4377
        skip_put_bytes(pb, 2*words-i);
4378
    }
4379

    
4380
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4381
}
4382

    
4383
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4384
    int i;
4385

    
4386
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4387

    
4388
    /* mpeg1 */
4389
    d->mb_skip_run= s->mb_skip_run;
4390
    for(i=0; i<3; i++)
4391
        d->last_dc[i]= s->last_dc[i];
4392

    
4393
    /* statistics */
4394
    d->mv_bits= s->mv_bits;
4395
    d->i_tex_bits= s->i_tex_bits;
4396
    d->p_tex_bits= s->p_tex_bits;
4397
    d->i_count= s->i_count;
4398
    d->f_count= s->f_count;
4399
    d->b_count= s->b_count;
4400
    d->skip_count= s->skip_count;
4401
    d->misc_bits= s->misc_bits;
4402
    d->last_bits= 0;
4403

    
4404
    d->mb_skipped= 0;
4405
    d->qscale= s->qscale;
4406
    d->dquant= s->dquant;
4407
}
4408

    
4409
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4410
    int i;
4411

    
4412
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4413
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4414

    
4415
    /* mpeg1 */
4416
    d->mb_skip_run= s->mb_skip_run;
4417
    for(i=0; i<3; i++)
4418
        d->last_dc[i]= s->last_dc[i];
4419

    
4420
    /* statistics */
4421
    d->mv_bits= s->mv_bits;
4422
    d->i_tex_bits= s->i_tex_bits;
4423
    d->p_tex_bits= s->p_tex_bits;
4424
    d->i_count= s->i_count;
4425
    d->f_count= s->f_count;
4426
    d->b_count= s->b_count;
4427
    d->skip_count= s->skip_count;
4428
    d->misc_bits= s->misc_bits;
4429

    
4430
    d->mb_intra= s->mb_intra;
4431
    d->mb_skipped= s->mb_skipped;
4432
    d->mv_type= s->mv_type;
4433
    d->mv_dir= s->mv_dir;
4434
    d->pb= s->pb;
4435
    if(s->data_partitioning){
4436
        d->pb2= s->pb2;
4437
        d->tex_pb= s->tex_pb;
4438
    }
4439
    d->block= s->block;
4440
    for(i=0; i<6; i++)
4441
        d->block_last_index[i]= s->block_last_index[i];
4442
    d->interlaced_dct= s->interlaced_dct;
4443
    d->qscale= s->qscale;
4444
}
4445

    
4446
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4447
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4448
                           int *dmin, int *next_block, int motion_x, int motion_y)
4449
{
4450
    int score;
4451
    uint8_t *dest_backup[3];
4452

    
4453
    copy_context_before_encode(s, backup, type);
4454

    
4455
    s->block= s->blocks[*next_block];
4456
    s->pb= pb[*next_block];
4457
    if(s->data_partitioning){
4458
        s->pb2   = pb2   [*next_block];
4459
        s->tex_pb= tex_pb[*next_block];
4460
    }
4461

    
4462
    if(*next_block){
4463
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4464
        s->dest[0] = s->rd_scratchpad;
4465
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4466
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4467
        assert(s->linesize >= 32); //FIXME
4468
    }
4469

    
4470
    encode_mb(s, motion_x, motion_y);
4471

    
4472
    score= put_bits_count(&s->pb);
4473
    if(s->data_partitioning){
4474
        score+= put_bits_count(&s->pb2);
4475
        score+= put_bits_count(&s->tex_pb);
4476
    }
4477

    
4478
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4479
        MPV_decode_mb(s, s->block);
4480

    
4481
        score *= s->lambda2;
4482
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4483
    }
4484

    
4485
    if(*next_block){
4486
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4487
    }
4488

    
4489
    if(score<*dmin){
4490
        *dmin= score;
4491
        *next_block^=1;
4492

    
4493
        copy_context_after_encode(best, s, type);
4494
    }
4495
}
4496

    
4497
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4498
    uint32_t *sq = squareTbl + 256;
4499
    int acc=0;
4500
    int x,y;
4501

    
4502
    if(w==16 && h==16)
4503
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4504
    else if(w==8 && h==8)
4505
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4506

    
4507
    for(y=0; y<h; y++){
4508
        for(x=0; x<w; x++){
4509
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4510
        }
4511
    }
4512

    
4513
    assert(acc>=0);
4514

    
4515
    return acc;
4516
}
4517

    
4518
static int sse_mb(MpegEncContext *s){
4519
    int w= 16;
4520
    int h= 16;
4521

    
4522
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4523
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4524

    
4525
    if(w==16 && h==16)
4526
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4527
        return  s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4528
               +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4529
               +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4530
      }else{
4531
        return  s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4532
               +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4533
               +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4534
      }
4535
    else
4536
        return  sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
4537
               +sse(s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
4538
               +sse(s, s->new_picture.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
4539
}
4540

    
4541
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4542
    MpegEncContext *s= arg;
4543

    
4544

    
4545
    s->me.pre_pass=1;
4546
    s->me.dia_size= s->avctx->pre_dia_size;
4547
    s->first_slice_line=1;
4548
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4549
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4550
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4551
        }
4552
        s->first_slice_line=0;
4553
    }
4554

    
4555
    s->me.pre_pass=0;
4556

    
4557
    return 0;
4558
}
4559

    
4560
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4561
    MpegEncContext *s= arg;
4562

    
4563
    s->me.dia_size= s->avctx->dia_size;
4564
    s->first_slice_line=1;
4565
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4566
        s->mb_x=0; //for block init below
4567
        ff_init_block_index(s);
4568
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4569
            s->block_index[0]+=2;
4570
            s->block_index[1]+=2;
4571
            s->block_index[2]+=2;
4572
            s->block_index[3]+=2;
4573

    
4574
            /* compute motion vector & mb_type and store in context */
4575
            if(s->pict_type==B_TYPE)
4576
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4577
            else
4578
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4579
        }
4580
        s->first_slice_line=0;
4581
    }
4582
    return 0;
4583
}
4584

    
4585
static int mb_var_thread(AVCodecContext *c, void *arg){
4586
    MpegEncContext *s= arg;
4587
    int mb_x, mb_y;
4588

    
4589
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4590
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4591
            int xx = mb_x * 16;
4592
            int yy = mb_y * 16;
4593
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4594
            int varc;
4595
            int sum = s->dsp.pix_sum(pix, s->linesize);
4596

    
4597
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4598

    
4599
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4600
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4601
            s->me.mb_var_sum_temp    += varc;
4602
        }
4603
    }
4604
    return 0;
4605
}
4606

    
4607
static void write_slice_end(MpegEncContext *s){
4608
    if(s->codec_id==CODEC_ID_MPEG4){
4609
        if(s->partitioned_frame){
4610
            ff_mpeg4_merge_partitions(s);
4611
        }
4612

    
4613
        ff_mpeg4_stuffing(&s->pb);
4614
    }else if(s->out_format == FMT_MJPEG){
4615
        ff_mjpeg_stuffing(&s->pb);
4616
    }
4617

    
4618
    align_put_bits(&s->pb);
4619
    flush_put_bits(&s->pb);
4620

    
4621
    if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4622
        s->misc_bits+= get_bits_diff(s);
4623
}
4624

    
4625
static int encode_thread(AVCodecContext *c, void *arg){
4626
    MpegEncContext *s= arg;
4627
    int mb_x, mb_y, pdif = 0;
4628
    int i, j;
4629
    MpegEncContext best_s, backup_s;
4630
    uint8_t bit_buf[2][MAX_MB_BYTES];
4631
    uint8_t bit_buf2[2][MAX_MB_BYTES];
4632
    uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4633
    PutBitContext pb[2], pb2[2], tex_pb[2];
4634
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4635

    
4636
    for(i=0; i<2; i++){
4637
        init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
4638
        init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
4639
        init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4640
    }
4641

    
4642
    s->last_bits= put_bits_count(&s->pb);
4643
    s->mv_bits=0;
4644
    s->misc_bits=0;
4645
    s->i_tex_bits=0;
4646
    s->p_tex_bits=0;
4647
    s->i_count=0;
4648
    s->f_count=0;
4649
    s->b_count=0;
4650
    s->skip_count=0;
4651

    
4652
    for(i=0; i<3; i++){
4653
        /* init last dc values */
4654
        /* note: quant matrix value (8) is implied here */
4655
        s->last_dc[i] = 128 << s->intra_dc_precision;
4656

    
4657
        s->current_picture.error[i] = 0;
4658
    }
4659
    s->mb_skip_run = 0;
4660
    memset(s->last_mv, 0, sizeof(s->last_mv));
4661

    
4662
    s->last_mv_dir = 0;
4663

    
4664
    switch(s->codec_id){
4665
    case CODEC_ID_H263:
4666
    case CODEC_ID_H263P:
4667
    case CODEC_ID_FLV1:
4668
        s->gob_index = ff_h263_get_gob_height(s);
4669