Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ dfb706da

History | View | Annotate | Download (237 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 missmatch)\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; // skiped 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 dont set in encode_header
546
    COPY(progressive_frame); //FIXME dont set in encode_header
547
    COPY(partitioned_frame); //FIXME dont 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, dummy;
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>=0 && 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>=0 && 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->frame_rate || !avctx->frame_rate_base){
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
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1069
    if(i > 1){
1070
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1071
        avctx->frame_rate /= i;
1072
        avctx->frame_rate_base /= i;
1073
//        return -1;
1074
    }
1075
    
1076
    if(s->codec_id==CODEC_ID_MJPEG){
1077
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1078
        s->inter_quant_bias= 0;
1079
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1080
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1081
        s->inter_quant_bias= 0;
1082
    }else{
1083
        s->intra_quant_bias=0;
1084
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1085
    }
1086
    
1087
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1088
        s->intra_quant_bias= avctx->intra_quant_bias;
1089
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1090
        s->inter_quant_bias= avctx->inter_quant_bias;
1091
        
1092
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1093

    
1094
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1095
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1096

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

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

    
1243
    s->encoding = 1;
1244

    
1245
    /* init */
1246
    if (MPV_common_init(s) < 0)
1247
        return -1;
1248

    
1249
    if(s->modified_quant)
1250
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1251
    s->progressive_frame= 
1252
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1253
    s->quant_precision=5;
1254
    
1255
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1256
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1257
    
1258
    if (s->out_format == FMT_H261)
1259
        ff_h261_encode_init(s);
1260
    if (s->out_format == FMT_H263)
1261
        h263_encode_init(s);
1262
    if(s->msmpeg4_version)
1263
        ff_msmpeg4_encode_init(s);
1264
    if (s->out_format == FMT_MPEG1)
1265
        ff_mpeg1_encode_init(s);
1266

    
1267
    /* init q matrix */
1268
    for(i=0;i<64;i++) {
1269
        int j= s->dsp.idct_permutation[i];
1270
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1271
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1272
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1273
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1274
            s->intra_matrix[j] =
1275
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1276
        }else
1277
        { /* mpeg1/2 */
1278
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1279
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1280
        }
1281
        if(s->avctx->intra_matrix)
1282
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1283
        if(s->avctx->inter_matrix)
1284
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1285
    }
1286

    
1287
    /* precompute matrix */
1288
    /* for mjpeg, we do include qscale in the matrix */
1289
    if (s->out_format != FMT_MJPEG) {
1290
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1291
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1292
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1293
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1294
    }
1295

    
1296
    if(ff_rate_control_init(s) < 0)
1297
        return -1;
1298
    
1299
    return 0;
1300
}
1301

    
1302
int MPV_encode_end(AVCodecContext *avctx)
1303
{
1304
    MpegEncContext *s = avctx->priv_data;
1305

    
1306
#ifdef STATS
1307
    print_stats();
1308
#endif
1309

    
1310
    ff_rate_control_uninit(s);
1311

    
1312
    MPV_common_end(s);
1313
    if (s->out_format == FMT_MJPEG)
1314
        mjpeg_close(s);
1315

    
1316
    av_freep(&avctx->extradata);
1317
      
1318
    return 0;
1319
}
1320

    
1321
#endif //CONFIG_ENCODERS
1322

    
1323
void init_rl(RLTable *rl, int use_static)
1324
{
1325
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1326
    uint8_t index_run[MAX_RUN+1];
1327
    int last, run, level, start, end, i;
1328

    
1329
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1330
    if(use_static && rl->max_level[0])
1331
        return;
1332

    
1333
    /* compute max_level[], max_run[] and index_run[] */
1334
    for(last=0;last<2;last++) {
1335
        if (last == 0) {
1336
            start = 0;
1337
            end = rl->last;
1338
        } else {
1339
            start = rl->last;
1340
            end = rl->n;
1341
        }
1342

    
1343
        memset(max_level, 0, MAX_RUN + 1);
1344
        memset(max_run, 0, MAX_LEVEL + 1);
1345
        memset(index_run, rl->n, MAX_RUN + 1);
1346
        for(i=start;i<end;i++) {
1347
            run = rl->table_run[i];
1348
            level = rl->table_level[i];
1349
            if (index_run[run] == rl->n)
1350
                index_run[run] = i;
1351
            if (level > max_level[run])
1352
                max_level[run] = level;
1353
            if (run > max_run[level])
1354
                max_run[level] = run;
1355
        }
1356
        if(use_static)
1357
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1358
        else
1359
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1360
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1361
        if(use_static)
1362
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1363
        else
1364
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1365
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1366
        if(use_static)
1367
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1368
        else
1369
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1370
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1371
    }
1372
}
1373

    
1374
/* draw the edges of width 'w' of an image of size width, height */
1375
//FIXME check that this is ok for mpeg4 interlaced
1376
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1377
{
1378
    uint8_t *ptr, *last_line;
1379
    int i;
1380

    
1381
    last_line = buf + (height - 1) * wrap;
1382
    for(i=0;i<w;i++) {
1383
        /* top and bottom */
1384
        memcpy(buf - (i + 1) * wrap, buf, width);
1385
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1386
    }
1387
    /* left and right */
1388
    ptr = buf;
1389
    for(i=0;i<height;i++) {
1390
        memset(ptr - w, ptr[0], w);
1391
        memset(ptr + width, ptr[width-1], w);
1392
        ptr += wrap;
1393
    }
1394
    /* corners */
1395
    for(i=0;i<w;i++) {
1396
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1397
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1398
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1399
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1400
    }
1401
}
1402

    
1403
int ff_find_unused_picture(MpegEncContext *s, int shared){
1404
    int i;
1405
    
1406
    if(shared){
1407
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1408
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1409
        }
1410
    }else{
1411
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1412
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1413
        }
1414
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1415
            if(s->picture[i].data[0]==NULL) return i;
1416
        }
1417
    }
1418

    
1419
    assert(0);
1420
    return -1;
1421
}
1422

    
1423
static void update_noise_reduction(MpegEncContext *s){
1424
    int intra, i;
1425

    
1426
    for(intra=0; intra<2; intra++){
1427
        if(s->dct_count[intra] > (1<<16)){
1428
            for(i=0; i<64; i++){
1429
                s->dct_error_sum[intra][i] >>=1;
1430
            }
1431
            s->dct_count[intra] >>= 1;
1432
        }
1433
        
1434
        for(i=0; i<64; i++){
1435
            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);
1436
        }
1437
    }
1438
}
1439

    
1440
/**
1441
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1442
 */
1443
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1444
{
1445
    int i;
1446
    AVFrame *pic;
1447
    s->mb_skiped = 0;
1448

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

    
1451
    /* mark&release old frames */
1452
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1453
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1454

    
1455
        /* release forgotten pictures */
1456
        /* if(mpeg124/h263) */
1457
        if(!s->encoding){
1458
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1459
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1460
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1461
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1462
                }
1463
            }
1464
        }
1465
    }
1466
alloc:
1467
    if(!s->encoding){
1468
        /* release non refernce frames */
1469
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1470
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1471
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1472
            }
1473
        }
1474

    
1475
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1476
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1477
        else{
1478
            i= ff_find_unused_picture(s, 0);
1479
            pic= (AVFrame*)&s->picture[i];
1480
        }
1481

    
1482
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1483
                        && !s->dropable ? 3 : 0;
1484

    
1485
        pic->coded_picture_number= s->coded_picture_number++;
1486
        
1487
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1488
            return -1;
1489

    
1490
        s->current_picture_ptr= (Picture*)pic;
1491
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1492
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1493
    }
1494

    
1495
    s->current_picture_ptr->pict_type= s->pict_type;
1496
//    if(s->flags && CODEC_FLAG_QSCALE) 
1497
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1498
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1499

    
1500
    copy_picture(&s->current_picture, s->current_picture_ptr);
1501
  
1502
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1503
    if (s->pict_type != B_TYPE) {
1504
        s->last_picture_ptr= s->next_picture_ptr;
1505
        if(!s->dropable)
1506
            s->next_picture_ptr= s->current_picture_ptr;
1507
    }
1508
/*    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,
1509
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1510
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1511
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1512
        s->pict_type, s->dropable);*/
1513
    
1514
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1515
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1516
    
1517
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1518
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1519
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1520
        goto alloc;
1521
    }
1522

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

    
1525
    if(s->picture_structure!=PICT_FRAME){
1526
        int i;
1527
        for(i=0; i<4; i++){
1528
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1529
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1530
            } 
1531
            s->current_picture.linesize[i] *= 2;
1532
            s->last_picture.linesize[i] *=2;
1533
            s->next_picture.linesize[i] *=2;
1534
        }
1535
    }
1536
  }
1537
   
1538
    s->hurry_up= s->avctx->hurry_up;
1539
    s->error_resilience= avctx->error_resilience;
1540

    
1541
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1542
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1543
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1544
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1545
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1546
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1547
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1548
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1549
    }else{
1550
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1551
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1552
    }
1553

    
1554
    if(s->dct_error_sum){
1555
        assert(s->avctx->noise_reduction && s->encoding);
1556

    
1557
        update_noise_reduction(s);
1558
    }
1559
        
1560
#ifdef HAVE_XVMC
1561
    if(s->avctx->xvmc_acceleration)
1562
        return XVMC_field_start(s, avctx);
1563
#endif
1564
    return 0;
1565
}
1566

    
1567
/* generic function for encode/decode called after a frame has been coded/decoded */
1568
void MPV_frame_end(MpegEncContext *s)
1569
{
1570
    int i;
1571
    /* draw edge for correct motion prediction if outside */
1572
#ifdef HAVE_XVMC
1573
//just to make sure that all data is rendered.
1574
    if(s->avctx->xvmc_acceleration){
1575
        XVMC_field_end(s);
1576
    }else
1577
#endif
1578
    if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1579
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1580
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1581
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1582
    }
1583
    emms_c();
1584
    
1585
    s->last_pict_type    = s->pict_type;
1586
    if(s->pict_type!=B_TYPE){
1587
        s->last_non_b_pict_type= s->pict_type;
1588
    }
1589
#if 0
1590
        /* copy back current_picture variables */
1591
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1592
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1593
            s->picture[i]= s->current_picture;
1594
            break;
1595
        }    
1596
    }
1597
    assert(i<MAX_PICTURE_COUNT);
1598
#endif    
1599

    
1600
    if(s->encoding){
1601
        /* release non refernce frames */
1602
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1603
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1604
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1605
            }
1606
        }
1607
    }
1608
    // clear copies, to avoid confusion
1609
#if 0
1610
    memset(&s->last_picture, 0, sizeof(Picture));
1611
    memset(&s->next_picture, 0, sizeof(Picture));
1612
    memset(&s->current_picture, 0, sizeof(Picture));
1613
#endif
1614
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1615
}
1616

    
1617
/**
1618
 * draws an line from (ex, ey) -> (sx, sy).
1619
 * @param w width of the image
1620
 * @param h height of the image
1621
 * @param stride stride/linesize of the image
1622
 * @param color color of the arrow
1623
 */
1624
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1625
    int t, x, y, fr, f;
1626
    
1627
    sx= clip(sx, 0, w-1);
1628
    sy= clip(sy, 0, h-1);
1629
    ex= clip(ex, 0, w-1);
1630
    ey= clip(ey, 0, h-1);
1631
    
1632
    buf[sy*stride + sx]+= color;
1633
    
1634
    if(ABS(ex - sx) > ABS(ey - sy)){
1635
        if(sx > ex){
1636
            t=sx; sx=ex; ex=t;
1637
            t=sy; sy=ey; ey=t;
1638
        }
1639
        buf+= sx + sy*stride;
1640
        ex-= sx;
1641
        f= ((ey-sy)<<16)/ex;
1642
        for(x= 0; x <= ex; x++){
1643
            y = (x*f)>>16;
1644
            fr= (x*f)&0xFFFF;
1645
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1646
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1647
        }
1648
    }else{
1649
        if(sy > ey){
1650
            t=sx; sx=ex; ex=t;
1651
            t=sy; sy=ey; ey=t;
1652
        }
1653
        buf+= sx + sy*stride;
1654
        ey-= sy;
1655
        if(ey) f= ((ex-sx)<<16)/ey;
1656
        else   f= 0;
1657
        for(y= 0; y <= ey; y++){
1658
            x = (y*f)>>16;
1659
            fr= (y*f)&0xFFFF;
1660
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1661
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1662
        }
1663
    }
1664
}
1665

    
1666
/**
1667
 * draws an arrow from (ex, ey) -> (sx, sy).
1668
 * @param w width of the image
1669
 * @param h height of the image
1670
 * @param stride stride/linesize of the image
1671
 * @param color color of the arrow
1672
 */
1673
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1674
    int dx,dy;
1675

    
1676
    sx= clip(sx, -100, w+100);
1677
    sy= clip(sy, -100, h+100);
1678
    ex= clip(ex, -100, w+100);
1679
    ey= clip(ey, -100, h+100);
1680
    
1681
    dx= ex - sx;
1682
    dy= ey - sy;
1683
    
1684
    if(dx*dx + dy*dy > 3*3){
1685
        int rx=  dx + dy;
1686
        int ry= -dx + dy;
1687
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1688
        
1689
        //FIXME subpixel accuracy
1690
        rx= ROUNDED_DIV(rx*3<<4, length);
1691
        ry= ROUNDED_DIV(ry*3<<4, length);
1692
        
1693
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1694
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1695
    }
1696
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1697
}
1698

    
1699
/**
1700
 * prints debuging info for the given picture.
1701
 */
1702
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1703

    
1704
    if(!pict || !pict->mb_type) return;
1705

    
1706
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1707
        int x,y;
1708
        
1709
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1710
        switch (pict->pict_type) {
1711
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1712
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1713
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1714
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1715
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1716
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1717
        }
1718
        for(y=0; y<s->mb_height; y++){
1719
            for(x=0; x<s->mb_width; x++){
1720
                if(s->avctx->debug&FF_DEBUG_SKIP){
1721
                    int count= s->mbskip_table[x + y*s->mb_stride];
1722
                    if(count>9) count=9;
1723
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1724
                }
1725
                if(s->avctx->debug&FF_DEBUG_QP){
1726
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1727
                }
1728
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1729
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1730
                    //Type & MV direction
1731
                    if(IS_PCM(mb_type))
1732
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1733
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1734
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1735
                    else if(IS_INTRA4x4(mb_type))
1736
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1737
                    else if(IS_INTRA16x16(mb_type))
1738
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1739
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1740
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1741
                    else if(IS_DIRECT(mb_type))
1742
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1743
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1744
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1745
                    else if(IS_GMC(mb_type))
1746
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1747
                    else if(IS_SKIP(mb_type))
1748
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1749
                    else if(!USES_LIST(mb_type, 1))
1750
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1751
                    else if(!USES_LIST(mb_type, 0))
1752
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1753
                    else{
1754
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1755
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1756
                    }
1757
                    
1758
                    //segmentation
1759
                    if(IS_8X8(mb_type))
1760
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1761
                    else if(IS_16X8(mb_type))
1762
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1763
                    else if(IS_8X16(mb_type))
1764
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1765
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1766
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1767
                    else
1768
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1769
                    
1770
                        
1771
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1772
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1773
                    else
1774
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1775
                }
1776
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1777
            }
1778
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1779
        }
1780
    }
1781

    
1782
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1783
        const int shift= 1 + s->quarter_sample;
1784
        int mb_y;
1785
        uint8_t *ptr;
1786
        int i;
1787
        int h_chroma_shift, v_chroma_shift;
1788
        const int width = s->avctx->width;
1789
        const int height= s->avctx->height;
1790
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1791
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1792
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1793

    
1794
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1795
        for(i=0; i<3; i++){
1796
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1797
            pict->data[i]= s->visualization_buffer[i];
1798
        }
1799
        pict->type= FF_BUFFER_TYPE_COPY;
1800
        ptr= pict->data[0];
1801

    
1802
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1803
            int mb_x;
1804
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1805
                const int mb_index= mb_x + mb_y*s->mb_stride;
1806
                if((s->avctx->debug_mv) && pict->motion_val){
1807
                  int type;
1808
                  for(type=0; type<3; type++){
1809
                    int direction = 0;
1810
                    switch (type) {
1811
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1812
                                continue;
1813
                              direction = 0;
1814
                              break;
1815
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1816
                                continue;
1817
                              direction = 0;
1818
                              break;
1819
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1820
                                continue;
1821
                              direction = 1;
1822
                              break;
1823
                    }
1824
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1825
                        continue;
1826

    
1827
                    if(IS_8X8(pict->mb_type[mb_index])){
1828
                      int i;
1829
                      for(i=0; i<4; i++){
1830
                        int sx= mb_x*16 + 4 + 8*(i&1);
1831
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1832
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1833
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1834
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1835
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1836
                      }
1837
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1838
                      int i;
1839
                      for(i=0; i<2; i++){
1840
                        int sx=mb_x*16 + 8;
1841
                        int sy=mb_y*16 + 4 + 8*i;
1842
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1843
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1844
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1845
                        
1846
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1847
                            my*=2;
1848
                        
1849
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1850
                      }
1851
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1852
                      int i;
1853
                      for(i=0; i<2; i++){
1854
                        int sx=mb_x*16 + 4 + 8*i;
1855
                        int sy=mb_y*16 + 8;
1856
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1857
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1858
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1859
                        
1860
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1861
                            my*=2;
1862
                        
1863
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1864
                      }
1865
                    }else{
1866
                      int sx= mb_x*16 + 8;
1867
                      int sy= mb_y*16 + 8;
1868
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1869
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1870
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1871
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1872
                    }
1873
                  }                  
1874
                }
1875
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1876
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1877
                    int y;
1878
                    for(y=0; y<8; y++){
1879
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1880
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1881
                    }
1882
                }
1883
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1884
                    int mb_type= pict->mb_type[mb_index];
1885
                    uint64_t u,v;
1886
                    int y;
1887
#define COLOR(theta, r)\
1888
u= (int)(128 + r*cos(theta*3.141592/180));\
1889
v= (int)(128 + r*sin(theta*3.141592/180));
1890

    
1891
                    
1892
                    u=v=128;
1893
                    if(IS_PCM(mb_type)){
1894
                        COLOR(120,48)
1895
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1896
                        COLOR(30,48)
1897
                    }else if(IS_INTRA4x4(mb_type)){
1898
                        COLOR(90,48)
1899
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1900
//                        COLOR(120,48)
1901
                    }else if(IS_DIRECT(mb_type)){
1902
                        COLOR(150,48)
1903
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1904
                        COLOR(170,48)
1905
                    }else if(IS_GMC(mb_type)){
1906
                        COLOR(190,48)
1907
                    }else if(IS_SKIP(mb_type)){
1908
//                        COLOR(180,48)
1909
                    }else if(!USES_LIST(mb_type, 1)){
1910
                        COLOR(240,48)
1911
                    }else if(!USES_LIST(mb_type, 0)){
1912
                        COLOR(0,48)
1913
                    }else{
1914
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1915
                        COLOR(300,48)
1916
                    }
1917

    
1918
                    u*= 0x0101010101010101ULL;
1919
                    v*= 0x0101010101010101ULL;
1920
                    for(y=0; y<8; y++){
1921
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1922
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1923
                    }
1924

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

    
1960
#ifdef CONFIG_ENCODERS
1961

    
1962
static int get_sae(uint8_t *src, int ref, int stride){
1963
    int x,y;
1964
    int acc=0;
1965
    
1966
    for(y=0; y<16; y++){
1967
        for(x=0; x<16; x++){
1968
            acc+= ABS(src[x+y*stride] - ref);
1969
        }
1970
    }
1971
    
1972
    return acc;
1973
}
1974

    
1975
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1976
    int x, y, w, h;
1977
    int acc=0;
1978
    
1979
    w= s->width &~15;
1980
    h= s->height&~15;
1981
    
1982
    for(y=0; y<h; y+=16){
1983
        for(x=0; x<w; x+=16){
1984
            int offset= x + y*stride;
1985
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1986
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1987
            int sae = get_sae(src + offset, mean, stride);
1988
            
1989
            acc+= sae + 500 < sad;
1990
        }
1991
    }
1992
    return acc;
1993
}
1994

    
1995

    
1996
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1997
    AVFrame *pic=NULL;
1998
    int64_t pts;
1999
    int i;
2000
    const int encoding_delay= s->max_b_frames;
2001
    int direct=1;
2002
    
2003
    if(pic_arg){
2004
        pts= pic_arg->pts;
2005
        pic_arg->display_picture_number= s->input_picture_number++;
2006

    
2007
        if(pts != AV_NOPTS_VALUE){ 
2008
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2009
                int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2010
                int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2011
            
2012
                if(time <= last){            
2013
                    av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2014
                    return -1;
2015
                }
2016
            }
2017
            s->user_specified_pts= pts;
2018
        }else{
2019
            if(s->user_specified_pts != AV_NOPTS_VALUE){
2020
                s->user_specified_pts= 
2021
                pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2022
                av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2023
            }else{
2024
                pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2025
            }
2026
        }
2027
    }
2028

    
2029
  if(pic_arg){
2030
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2031
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2032
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2033
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2034
  
2035
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2036
    
2037
    if(direct){
2038
        i= ff_find_unused_picture(s, 1);
2039

    
2040
        pic= (AVFrame*)&s->picture[i];
2041
        pic->reference= 3;
2042
    
2043
        for(i=0; i<4; i++){
2044
            pic->data[i]= pic_arg->data[i];
2045
            pic->linesize[i]= pic_arg->linesize[i];
2046
        }
2047
        alloc_picture(s, (Picture*)pic, 1);
2048
    }else{
2049
        int offset= 16;
2050
        i= ff_find_unused_picture(s, 0);
2051

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

    
2055
        alloc_picture(s, (Picture*)pic, 0);
2056

    
2057
        if(   pic->data[0] + offset == pic_arg->data[0] 
2058
           && pic->data[1] + offset == pic_arg->data[1]
2059
           && pic->data[2] + offset == pic_arg->data[2]){
2060
       // empty
2061
        }else{
2062
            int h_chroma_shift, v_chroma_shift;
2063
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2064
        
2065
            for(i=0; i<3; i++){
2066
                int src_stride= pic_arg->linesize[i];
2067
                int dst_stride= i ? s->uvlinesize : s->linesize;
2068
                int h_shift= i ? h_chroma_shift : 0;
2069
                int v_shift= i ? v_chroma_shift : 0;
2070
                int w= s->width >>h_shift;
2071
                int h= s->height>>v_shift;
2072
                uint8_t *src= pic_arg->data[i];
2073
                uint8_t *dst= pic->data[i] + offset;
2074
            
2075
                if(src_stride==dst_stride)
2076
                    memcpy(dst, src, src_stride*h);
2077
                else{
2078
                    while(h--){
2079
                        memcpy(dst, src, w);
2080
                        dst += dst_stride;
2081
                        src += src_stride;
2082
                    }
2083
                }
2084
            }
2085
        }
2086
    }
2087
    copy_picture_attributes(s, pic, pic_arg);
2088
    pic->pts= pts; //we set this here to avoid modifiying pic_arg
2089
  }
2090
  
2091
    /* shift buffer entries */
2092
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2093
        s->input_picture[i-1]= s->input_picture[i];
2094
        
2095
    s->input_picture[encoding_delay]= (Picture*)pic;
2096

    
2097
    return 0;
2098
}
2099

    
2100
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2101
    int x, y, plane;
2102
    int score=0;
2103
    int64_t score64=0;
2104

    
2105
    for(plane=0; plane<3; plane++){
2106
        const int stride= p->linesize[plane];
2107
        const int bw= plane ? 1 : 2;
2108
        for(y=0; y<s->mb_height*bw; y++){
2109
            for(x=0; x<s->mb_width*bw; x++){
2110
                int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride), ref->data[plane] + 8*(x + y*stride), stride, 8);
2111
                
2112
                switch(s->avctx->frame_skip_exp){
2113
                    case 0: score= FFMAX(score, v); break;
2114
                    case 1: score+= ABS(v);break;
2115
                    case 2: score+= v*v;break;
2116
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2117
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2118
                }
2119
            }
2120
        }
2121
    }
2122
    
2123
    if(score) score64= score;
2124

    
2125
    if(score64 < s->avctx->frame_skip_threshold)
2126
        return 1;
2127
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2128
        return 1;
2129
    return 0;
2130
}
2131

    
2132
static void select_input_picture(MpegEncContext *s){
2133
    int i;
2134

    
2135
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2136
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2137
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2138

    
2139
    /* set next picture types & ordering */
2140
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2141
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2142
            s->reordered_input_picture[0]= s->input_picture[0];
2143
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2144
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2145
        }else{
2146
            int b_frames;
2147

    
2148
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2149
                if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2150
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2151
                
2152
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2153
                        for(i=0; i<4; i++)
2154
                            s->input_picture[0]->data[i]= NULL;
2155
                        s->input_picture[0]->type= 0;            
2156
                    }else{
2157
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2158
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2159
            
2160
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2161
                    }
2162

    
2163
                    goto no_output_pic;
2164
                }
2165
            }
2166

    
2167
            if(s->flags&CODEC_FLAG_PASS2){
2168
                for(i=0; i<s->max_b_frames+1; i++){
2169
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2170

    
2171
                    if(pict_num >= s->rc_context.num_entries) 
2172
                        break;
2173
                    if(!s->input_picture[i]){
2174
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2175
                        break;
2176
                    }
2177

    
2178
                    s->input_picture[i]->pict_type= 
2179
                        s->rc_context.entry[pict_num].new_pict_type;
2180
                }
2181
            }
2182

    
2183
            if(s->avctx->b_frame_strategy==0){
2184
                b_frames= s->max_b_frames;
2185
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2186
            }else if(s->avctx->b_frame_strategy==1){
2187
                for(i=1; i<s->max_b_frames+1; i++){
2188
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2189
                        s->input_picture[i]->b_frame_score= 
2190
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2191
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2192
                    }
2193
                }
2194
                for(i=0; i<s->max_b_frames; i++){
2195
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2196
                }
2197
                                
2198
                b_frames= FFMAX(0, i-1);
2199
                
2200
                /* reset scores */
2201
                for(i=0; i<b_frames+1; i++){
2202
                    s->input_picture[i]->b_frame_score=0;
2203
                }
2204
            }else{
2205
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2206
                b_frames=0;
2207
            }
2208

    
2209
            emms_c();
2210
//static int b_count=0;
2211
//b_count+= b_frames;
2212
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2213

    
2214
            for(i= b_frames - 1; i>=0; i--){
2215
                int type= s->input_picture[i]->pict_type;
2216
                if(type && type != B_TYPE)
2217
                    b_frames= i;
2218
            }
2219
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2220
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2221
            }
2222

    
2223
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2224
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2225
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2226
              }else{
2227
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2228
                    b_frames=0;
2229
                s->input_picture[b_frames]->pict_type= I_TYPE;
2230
              }
2231
            }
2232
            
2233
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2234
               && b_frames
2235
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2236
                b_frames--;
2237

    
2238
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2239
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2240
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2241
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2242
            for(i=0; i<b_frames; i++){
2243
                s->reordered_input_picture[i+1]= s->input_picture[i];
2244
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2245
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2246
            }
2247
        }
2248
    }
2249
no_output_pic:
2250
    if(s->reordered_input_picture[0]){
2251
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2252

    
2253
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2254

    
2255
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2256
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2257
        
2258
            int i= ff_find_unused_picture(s, 0);
2259
            Picture *pic= &s->picture[i];
2260

    
2261
            /* mark us unused / free shared pic */
2262
            for(i=0; i<4; i++)
2263
                s->reordered_input_picture[0]->data[i]= NULL;
2264
            s->reordered_input_picture[0]->type= 0;
2265
            
2266
            pic->reference              = s->reordered_input_picture[0]->reference;
2267
            
2268
            alloc_picture(s, pic, 0);
2269

    
2270
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2271

    
2272
            s->current_picture_ptr= pic;
2273
        }else{
2274
            // input is not a shared pix -> reuse buffer for current_pix
2275

    
2276
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2277
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2278
            
2279
            s->current_picture_ptr= s->reordered_input_picture[0];
2280
            for(i=0; i<4; i++){
2281
                s->new_picture.data[i]+=16;
2282
            }
2283
        }
2284
        copy_picture(&s->current_picture, s->current_picture_ptr);
2285
    
2286
        s->picture_number= s->new_picture.display_picture_number;
2287
//printf("dpn:%d\n", s->picture_number);
2288
    }else{
2289
       memset(&s->new_picture, 0, sizeof(Picture));
2290
    }
2291
}
2292

    
2293
int MPV_encode_picture(AVCodecContext *avctx,
2294
                       unsigned char *buf, int buf_size, void *data)
2295
{
2296
    MpegEncContext *s = avctx->priv_data;
2297
    AVFrame *pic_arg = data;
2298
    int i, stuffing_count;
2299

    
2300
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2301
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2302
        return -1;
2303
    }
2304
    
2305
    for(i=0; i<avctx->thread_count; i++){
2306
        int start_y= s->thread_context[i]->start_mb_y;
2307
        int   end_y= s->thread_context[i]->  end_mb_y;
2308
        int h= s->mb_height;
2309
        uint8_t *start= buf + buf_size*start_y/h;
2310
        uint8_t *end  = buf + buf_size*  end_y/h;
2311

    
2312
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2313
    }
2314

    
2315
    s->picture_in_gop_number++;
2316

    
2317
    if(load_input_picture(s, pic_arg) < 0)
2318
        return -1;
2319
    
2320
    select_input_picture(s);
2321
    
2322
    /* output? */
2323
    if(s->new_picture.data[0]){
2324
        s->pict_type= s->new_picture.pict_type;
2325
//emms_c();
2326
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2327
        MPV_frame_start(s, avctx);
2328

    
2329
        encode_picture(s, s->picture_number);
2330
        
2331
        avctx->real_pict_num  = s->picture_number;
2332
        avctx->header_bits = s->header_bits;
2333
        avctx->mv_bits     = s->mv_bits;
2334
        avctx->misc_bits   = s->misc_bits;
2335
        avctx->i_tex_bits  = s->i_tex_bits;
2336
        avctx->p_tex_bits  = s->p_tex_bits;
2337
        avctx->i_count     = s->i_count;
2338
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2339
        avctx->skip_count  = s->skip_count;
2340

    
2341
        MPV_frame_end(s);
2342

    
2343
        if (s->out_format == FMT_MJPEG)
2344
            mjpeg_picture_trailer(s);
2345
        
2346
        if(s->flags&CODEC_FLAG_PASS1)
2347
            ff_write_pass1_stats(s);
2348

    
2349
        for(i=0; i<4; i++){
2350
            avctx->error[i] += s->current_picture_ptr->error[i];
2351
        }
2352

    
2353
        if(s->flags&CODEC_FLAG_PASS1)
2354
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2355
        flush_put_bits(&s->pb);
2356
        s->frame_bits  = put_bits_count(&s->pb);
2357

    
2358
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2359
        if(stuffing_count){
2360
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2361
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2362
                return -1;
2363
            }
2364

    
2365
            switch(s->codec_id){
2366
            case CODEC_ID_MPEG1VIDEO:
2367
            case CODEC_ID_MPEG2VIDEO:
2368
                while(stuffing_count--){
2369
                    put_bits(&s->pb, 8, 0);
2370
                }
2371
            break;
2372
            case CODEC_ID_MPEG4:
2373
                put_bits(&s->pb, 16, 0);
2374
                put_bits(&s->pb, 16, 0x1C3);
2375
                stuffing_count -= 4;
2376
                while(stuffing_count--){
2377
                    put_bits(&s->pb, 8, 0xFF);
2378
                }
2379
            break;
2380
            default:
2381
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2382
            }
2383
            flush_put_bits(&s->pb);
2384
            s->frame_bits  = put_bits_count(&s->pb);
2385
        }
2386

    
2387
        /* update mpeg1/2 vbv_delay for CBR */    
2388
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2389
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2390
            int vbv_delay;
2391

    
2392
            assert(s->repeat_first_field==0);
2393
            
2394
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2395
            assert(vbv_delay < 0xFFFF);
2396

    
2397
            s->vbv_delay_ptr[0] &= 0xF8;
2398
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2399
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2400
            s->vbv_delay_ptr[2] &= 0x07;
2401
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2402
        }
2403
        s->total_bits += s->frame_bits;
2404
        avctx->frame_bits  = s->frame_bits;
2405
    }else{
2406
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2407
        s->frame_bits=0;
2408
    }
2409
    assert((s->frame_bits&7)==0);
2410
    
2411
    return s->frame_bits/8;
2412
}
2413

    
2414
#endif //CONFIG_ENCODERS
2415

    
2416
static inline void gmc1_motion(MpegEncContext *s,
2417
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2418
                               uint8_t **ref_picture)
2419
{
2420
    uint8_t *ptr;
2421
    int offset, src_x, src_y, linesize, uvlinesize;
2422
    int motion_x, motion_y;
2423
    int emu=0;
2424

    
2425
    motion_x= s->sprite_offset[0][0];
2426
    motion_y= s->sprite_offset[0][1];
2427
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2428
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2429
    motion_x<<=(3-s->sprite_warping_accuracy);
2430
    motion_y<<=(3-s->sprite_warping_accuracy);
2431
    src_x = clip(src_x, -16, s->width);
2432
    if (src_x == s->width)
2433
        motion_x =0;
2434
    src_y = clip(src_y, -16, s->height);
2435
    if (src_y == s->height)
2436
        motion_y =0;
2437

    
2438
    linesize = s->linesize;
2439
    uvlinesize = s->uvlinesize;
2440
    
2441
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2442

    
2443
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2444
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2445
           || (unsigned)src_y >= s->v_edge_pos - 17){
2446
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2447
            ptr= s->edge_emu_buffer;
2448
        }
2449
    }
2450
    
2451
    if((motion_x|motion_y)&7){
2452
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2453
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2454
    }else{
2455
        int dxy;
2456
        
2457
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2458
        if (s->no_rounding){
2459
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2460
        }else{
2461
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2462
        }
2463
    }
2464
    
2465
    if(s->flags&CODEC_FLAG_GRAY) return;
2466

    
2467
    motion_x= s->sprite_offset[1][0];
2468
    motion_y= s->sprite_offset[1][1];
2469
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2470
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2471
    motion_x<<=(3-s->sprite_warping_accuracy);
2472
    motion_y<<=(3-s->sprite_warping_accuracy);
2473
    src_x = clip(src_x, -8, s->width>>1);
2474
    if (src_x == s->width>>1)
2475
        motion_x =0;
2476
    src_y = clip(src_y, -8, s->height>>1);
2477
    if (src_y == s->height>>1)
2478
        motion_y =0;
2479

    
2480
    offset = (src_y * uvlinesize) + src_x;
2481
    ptr = ref_picture[1] + offset;
2482
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2483
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2484
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2485
            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);
2486
            ptr= s->edge_emu_buffer;
2487
            emu=1;
2488
        }
2489
    }
2490
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2491
    
2492
    ptr = ref_picture[2] + offset;
2493
    if(emu){
2494
        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);
2495
        ptr= s->edge_emu_buffer;
2496
    }
2497
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2498
    
2499
    return;
2500
}
2501

    
2502
static inline void gmc_motion(MpegEncContext *s,
2503
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2504
                               uint8_t **ref_picture)
2505
{
2506
    uint8_t *ptr;
2507
    int linesize, uvlinesize;
2508
    const int a= s->sprite_warping_accuracy;
2509
    int ox, oy;
2510

    
2511
    linesize = s->linesize;
2512
    uvlinesize = s->uvlinesize;
2513

    
2514
    ptr = ref_picture[0];
2515

    
2516
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2517
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2518

    
2519
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2520
           ox, 
2521
           oy, 
2522
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2523
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2524
           a+1, (1<<(2*a+1)) - s->no_rounding,
2525
           s->h_edge_pos, s->v_edge_pos);
2526
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2527
           ox + s->sprite_delta[0][0]*8, 
2528
           oy + s->sprite_delta[1][0]*8, 
2529
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2530
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2531
           a+1, (1<<(2*a+1)) - s->no_rounding,
2532
           s->h_edge_pos, s->v_edge_pos);
2533

    
2534
    if(s->flags&CODEC_FLAG_GRAY) return;
2535

    
2536
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2537
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2538

    
2539
    ptr = ref_picture[1];
2540
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2541
           ox, 
2542
           oy, 
2543
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2544
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2545
           a+1, (1<<(2*a+1)) - s->no_rounding,
2546
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2547
    
2548
    ptr = ref_picture[2];
2549
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2550
           ox, 
2551
           oy, 
2552
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2553
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2554
           a+1, (1<<(2*a+1)) - s->no_rounding,
2555
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2556
}
2557

    
2558
/**
2559
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2560
 * @param buf destination buffer
2561
 * @param src source buffer
2562
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2563
 * @param block_w width of block
2564
 * @param block_h height of block
2565
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2566
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2567
 * @param w width of the source buffer
2568
 * @param h height of the source buffer
2569
 */
2570
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2571
                                    int src_x, int src_y, int w, int h){
2572
    int x, y;
2573
    int start_y, start_x, end_y, end_x;
2574

    
2575
    if(src_y>= h){
2576
        src+= (h-1-src_y)*linesize;
2577
        src_y=h-1;
2578
    }else if(src_y<=-block_h){
2579
        src+= (1-block_h-src_y)*linesize;
2580
        src_y=1-block_h;
2581
    }
2582
    if(src_x>= w){
2583
        src+= (w-1-src_x);
2584
        src_x=w-1;
2585
    }else if(src_x<=-block_w){
2586
        src+= (1-block_w-src_x);
2587
        src_x=1-block_w;
2588
    }
2589

    
2590
    start_y= FFMAX(0, -src_y);
2591
    start_x= FFMAX(0, -src_x);
2592
    end_y= FFMIN(block_h, h-src_y);
2593
    end_x= FFMIN(block_w, w-src_x);
2594

    
2595
    // copy existing part
2596
    for(y=start_y; y<end_y; y++){
2597
        for(x=start_x; x<end_x; x++){
2598
            buf[x + y*linesize]= src[x + y*linesize];
2599
        }
2600
    }
2601

    
2602
    //top
2603
    for(y=0; y<start_y; y++){
2604
        for(x=start_x; x<end_x; x++){
2605
            buf[x + y*linesize]= buf[x + start_y*linesize];
2606
        }
2607
    }
2608

    
2609
    //bottom
2610
    for(y=end_y; y<block_h; y++){
2611
        for(x=start_x; x<end_x; x++){
2612
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2613
        }
2614
    }
2615
                                    
2616
    for(y=0; y<block_h; y++){
2617
       //left
2618
        for(x=0; x<start_x; x++){
2619
            buf[x + y*linesize]= buf[start_x + y*linesize];
2620
        }
2621
       
2622
       //right
2623
        for(x=end_x; x<block_w; x++){
2624
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2625
        }
2626
    }
2627
}
2628

    
2629
static inline int hpel_motion(MpegEncContext *s, 
2630
                                  uint8_t *dest, uint8_t *src,
2631
                                  int field_based, int field_select,
2632
                                  int src_x, int src_y,
2633
                                  int width, int height, int stride,
2634
                                  int h_edge_pos, int v_edge_pos,
2635
                                  int w, int h, op_pixels_func *pix_op,
2636
                                  int motion_x, int motion_y)
2637
{
2638
    int dxy;
2639
    int emu=0;
2640

    
2641
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2642
    src_x += motion_x >> 1;
2643
    src_y += motion_y >> 1;
2644
                
2645
    /* WARNING: do no forget half pels */
2646
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2647
    if (src_x == width)
2648
        dxy &= ~1;
2649
    src_y = clip(src_y, -16, height);
2650
    if (src_y == height)
2651
        dxy &= ~2;
2652
    src += src_y * stride + src_x;
2653

    
2654
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2655
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2656
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2657
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2658
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2659
            src= s->edge_emu_buffer;
2660
            emu=1;
2661
        }
2662
    }
2663
    if(field_select)
2664
        src += s->linesize;
2665
    pix_op[dxy](dest, src, stride, h);
2666
    return emu;
2667
}
2668

    
2669
static inline int hpel_motion_lowres(MpegEncContext *s, 
2670
                                  uint8_t *dest, uint8_t *src,
2671
                                  int field_based, int field_select,
2672
                                  int src_x, int src_y,
2673
                                  int width, int height, int stride,
2674
                                  int h_edge_pos, int v_edge_pos,
2675
                                  int w, int h, h264_chroma_mc_func *pix_op,
2676
                                  int motion_x, int motion_y)
2677
{
2678
    const int lowres= s->avctx->lowres;
2679
    const int s_mask= (2<<lowres)-1;
2680
    int emu=0;
2681
    int sx, sy;
2682

    
2683
    if(s->quarter_sample){
2684
        motion_x/=2;
2685
        motion_y/=2;
2686
    }
2687

    
2688
    sx= motion_x & s_mask;
2689
    sy= motion_y & s_mask;
2690
    src_x += motion_x >> (lowres+1);
2691
    src_y += motion_y >> (lowres+1);
2692
                
2693
    src += src_y * stride + src_x;
2694

    
2695
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2696
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2697
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2698
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2699
        src= s->edge_emu_buffer;
2700
        emu=1;
2701
    }
2702

    
2703
    sx <<= 2 - lowres;
2704
    sy <<= 2 - lowres;
2705
    if(field_select)
2706
        src += s->linesize;
2707
    pix_op[lowres](dest, src, stride, h, sx, sy);
2708
    return emu;
2709
}
2710

    
2711
/* apply one mpeg motion vector to the three components */
2712
static always_inline void mpeg_motion(MpegEncContext *s,
2713
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2714
                               int field_based, int bottom_field, int field_select,
2715
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2716
                               int motion_x, int motion_y, int h)
2717
{
2718
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2719
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2720
    
2721
#if 0    
2722
if(s->quarter_sample)
2723
{
2724
    motion_x>>=1;
2725
    motion_y>>=1;
2726
}
2727
#endif
2728

    
2729
    v_edge_pos = s->v_edge_pos >> field_based;
2730
    linesize   = s->current_picture.linesize[0] << field_based;
2731
    uvlinesize = s->current_picture.linesize[1] << field_based;
2732

    
2733
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2734
    src_x = s->mb_x* 16               + (motion_x >> 1);
2735
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2736

    
2737
    if (s->out_format == FMT_H263) {
2738
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2739
            mx = (motion_x>>1)|(motion_x&1);
2740
            my = motion_y >>1;
2741
            uvdxy = ((my & 1) << 1) | (mx & 1);
2742
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2743
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2744
        }else{
2745
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2746
            uvsrc_x = src_x>>1;
2747
            uvsrc_y = src_y>>1;
2748
        }
2749
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2750
        mx = motion_x / 4;
2751
        my = motion_y / 4;
2752
        uvdxy = 0;
2753
        uvsrc_x = s->mb_x*8 + mx;
2754
        uvsrc_y = s->mb_y*8 + my;
2755
    } else {
2756
        if(s->chroma_y_shift){
2757
            mx = motion_x / 2;
2758
            my = motion_y / 2;
2759
            uvdxy = ((my & 1) << 1) | (mx & 1);
2760
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2761
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2762
        } else {
2763
            if(s->chroma_x_shift){
2764
            //Chroma422
2765
                mx = motion_x / 2;
2766
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2767
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2768
                uvsrc_y = src_y;
2769
            } else {
2770
            //Chroma444
2771
                uvdxy = dxy;
2772
                uvsrc_x = src_x;
2773
                uvsrc_y = src_y;
2774
            }
2775
        }
2776
    }
2777

    
2778
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2779
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2780
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2781

    
2782
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2783
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2784
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2785
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2786
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2787
                return ;
2788
            }
2789
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2790
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2791
            ptr_y = s->edge_emu_buffer;
2792
            if(!(s->flags&CODEC_FLAG_GRAY)){
2793
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2794
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2795
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2796
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2797
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2798
                ptr_cb= uvbuf;
2799
                ptr_cr= uvbuf+16;
2800
            }
2801
    }
2802

    
2803
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2804
        dest_y += s->linesize;
2805
        dest_cb+= s->uvlinesize;
2806
        dest_cr+= s->uvlinesize;
2807
    }
2808

    
2809
    if(field_select){
2810
        ptr_y += s->linesize;
2811
        ptr_cb+= s->uvlinesize;
2812
        ptr_cr+= s->uvlinesize;
2813
    }
2814

    
2815
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2816
    
2817
    if(!(s->flags&CODEC_FLAG_GRAY)){
2818
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2819
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2820
    }
2821
    if(s->out_format == FMT_H261){
2822
        ff_h261_loop_filter(s);
2823
    }
2824
}
2825

    
2826
/* apply one mpeg motion vector to the three components */
2827
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2828
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2829
                               int field_based, int bottom_field, int field_select,
2830
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2831
                               int motion_x, int motion_y, int h)
2832
{
2833
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2834
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2835
    const int lowres= s->avctx->lowres;
2836
    const int block_s= 8>>lowres;
2837
    const int s_mask= (2<<lowres)-1;
2838
    const int h_edge_pos = s->h_edge_pos >> lowres;
2839
    const int v_edge_pos = s->v_edge_pos >> lowres;
2840
    linesize   = s->current_picture.linesize[0] << field_based;
2841
    uvlinesize = s->current_picture.linesize[1] << field_based;
2842

    
2843
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2844
        motion_x/=2;
2845
        motion_y/=2;
2846
    }
2847
    
2848
    if(field_based){
2849
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2850
    }
2851

    
2852
    sx= motion_x & s_mask;
2853
    sy= motion_y & s_mask;
2854
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2855
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2856
    
2857
    if (s->out_format == FMT_H263) {
2858
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2859
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2860
        uvsrc_x = src_x>>1;
2861
        uvsrc_y = src_y>>1;
2862
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2863
        mx = motion_x / 4;
2864
        my = motion_y / 4;
2865
        uvsx = (2*mx) & s_mask;
2866
        uvsy = (2*my) & s_mask;
2867
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2868
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2869
    } else {
2870
        mx = motion_x / 2;
2871
        my = motion_y / 2;
2872
        uvsx = mx & s_mask;
2873
        uvsy = my & s_mask;
2874
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2875
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2876
    }
2877

    
2878
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2879
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2880
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2881

    
2882
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2883
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2884
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2885
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2886
            ptr_y = s->edge_emu_buffer;
2887
            if(!(s->flags&CODEC_FLAG_GRAY)){
2888
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2889
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2890
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2891
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2892
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2893
                ptr_cb= uvbuf;
2894
                ptr_cr= uvbuf+16;
2895
            }
2896
    }
2897

    
2898
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2899
        dest_y += s->linesize;
2900
        dest_cb+= s->uvlinesize;
2901
        dest_cr+= s->uvlinesize;
2902
    }
2903

    
2904
    if(field_select){
2905
        ptr_y += s->linesize;
2906
        ptr_cb+= s->uvlinesize;
2907
        ptr_cr+= s->uvlinesize;
2908
    }
2909

    
2910
    sx <<= 2 - lowres;
2911
    sy <<= 2 - lowres;
2912
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2913
    
2914
    if(!(s->flags&CODEC_FLAG_GRAY)){
2915
        uvsx <<= 2 - lowres;
2916
        uvsy <<= 2 - lowres;
2917
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2918
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2919
    }
2920
    //FIXME h261 lowres loop filter
2921
}
2922

    
2923
//FIXME move to dsputil, avg variant, 16x16 version
2924
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2925
    int x;
2926
    uint8_t * const top   = src[1];
2927
    uint8_t * const left  = src[2];
2928
    uint8_t * const mid   = src[0];
2929
    uint8_t * const right = src[3];
2930
    uint8_t * const bottom= src[4];
2931
#define OBMC_FILTER(x, t, l, m, r, b)\
2932
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2933
#define OBMC_FILTER4(x, t, l, m, r, b)\
2934
    OBMC_FILTER(x         , t, l, m, r, b);\
2935
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2936
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2937
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2938
    
2939
    x=0;
2940
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2941
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2942
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2943
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2944
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2945
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2946
    x+= stride;
2947
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2948
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2949
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2950
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2951
    x+= stride;
2952
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2953
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2954
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2955
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2956
    x+= 2*stride;
2957
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2958
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2959
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2960
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2961
    x+= 2*stride;
2962
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2963
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2964
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2965
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2966
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2967
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2968
    x+= stride;
2969
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2970
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2971
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2972
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2973
}
2974

    
2975
/* obmc for 1 8x8 luma block */
2976
static inline void obmc_motion(MpegEncContext *s,
2977
                               uint8_t *dest, uint8_t *src,
2978
                               int src_x, int src_y,
2979
                               op_pixels_func *pix_op,
2980
                               int16_t mv[5][2]/* mid top left right bottom*/)
2981
#define MID    0
2982
{
2983
    int i;
2984
    uint8_t *ptr[5];
2985
    
2986
    assert(s->quarter_sample==0);
2987
    
2988
    for(i=0; i<5; i++){
2989
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2990
            ptr[i]= ptr[MID];
2991
        }else{
2992
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2993
            hpel_motion(s, ptr[i], src, 0, 0,
2994
                        src_x, src_y,
2995
                        s->width, s->height, s->linesize,
2996
                        s->h_edge_pos, s->v_edge_pos,
2997
                        8, 8, pix_op,
2998
                        mv[i][0], mv[i][1]);
2999
        }
3000
    }
3001

    
3002
    put_obmc(dest, ptr, s->linesize);                
3003
}
3004

    
3005
static inline void qpel_motion(MpegEncContext *s,
3006
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3007
                               int field_based, int bottom_field, int field_select,
3008
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3009
                               qpel_mc_func (*qpix_op)[16],
3010
                               int motion_x, int motion_y, int h)
3011
{
3012
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3013
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3014

    
3015
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3016
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3017
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3018

    
3019
    v_edge_pos = s->v_edge_pos >> field_based;
3020
    linesize = s->linesize << field_based;
3021
    uvlinesize = s->uvlinesize << field_based;
3022
    
3023
    if(field_based){
3024
        mx= motion_x/2;
3025
        my= motion_y>>1;
3026
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3027
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3028
        mx= (motion_x>>1) + rtab[motion_x&7];
3029
        my= (motion_y>>1) + rtab[motion_y&7];
3030
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3031
        mx= (motion_x>>1)|(motion_x&1);
3032
        my= (motion_y>>1)|(motion_y&1);
3033
    }else{
3034
        mx= motion_x/2;
3035
        my= motion_y/2;
3036
    }
3037
    mx= (mx>>1)|(mx&1);
3038
    my= (my>>1)|(my&1);
3039

    
3040
    uvdxy= (mx&1) | ((my&1)<<1);
3041
    mx>>=1;
3042
    my>>=1;
3043

    
3044
    uvsrc_x = s->mb_x *  8                 + mx;
3045
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3046

    
3047
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3048
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3049
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3050

    
3051
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
3052
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3053
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
3054
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3055
        ptr_y= s->edge_emu_buffer;
3056
        if(!(s->flags&CODEC_FLAG_GRAY)){
3057
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3058
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
3059
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3060
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
3061
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3062
            ptr_cb= uvbuf;
3063
            ptr_cr= uvbuf + 16;
3064
        }
3065
    }
3066

    
3067
    if(!field_based)
3068
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3069
    else{
3070
        if(bottom_field){
3071
            dest_y += s->linesize;
3072
            dest_cb+= s->uvlinesize;
3073
            dest_cr+= s->uvlinesize;
3074
        }
3075

    
3076
        if(field_select){
3077
            ptr_y  += s->linesize;
3078
            ptr_cb += s->uvlinesize;
3079
            ptr_cr += s->uvlinesize;
3080
        }
3081
        //damn interlaced mode
3082
        //FIXME boundary mirroring is not exactly correct here
3083
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3084
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3085
    }
3086
    if(!(s->flags&CODEC_FLAG_GRAY)){
3087
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3088
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3089
    }
3090
}
3091

    
3092
inline int ff_h263_round_chroma(int x){
3093
    if (x >= 0)
3094
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3095
    else {
3096
        x = -x;
3097
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3098
    }
3099
}
3100

    
3101
/**
3102
 * h263 chorma 4mv motion compensation.
3103
 */
3104
static inline void chroma_4mv_motion(MpegEncContext *s,
3105
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3106
                                     uint8_t **ref_picture,
3107
                                     op_pixels_func *pix_op,
3108
                                     int mx, int my){
3109
    int dxy, emu=0, src_x, src_y, offset;
3110
    uint8_t *ptr;
3111
    
3112
    /* In case of 8X8, we construct a single chroma motion vector
3113
       with a special rounding */
3114
    mx= ff_h263_round_chroma(mx);
3115
    my= ff_h263_round_chroma(my);
3116
    
3117
    dxy = ((my & 1) << 1) | (mx & 1);
3118
    mx >>= 1;
3119
    my >>= 1;
3120

    
3121
    src_x = s->mb_x * 8 + mx;
3122
    src_y = s->mb_y * 8 + my;
3123
    src_x = clip(src_x, -8, s->width/2);
3124
    if (src_x == s->width/2)
3125
        dxy &= ~1;
3126
    src_y = clip(src_y, -8, s->height/2);
3127
    if (src_y == s->height/2)
3128
        dxy &= ~2;
3129
    
3130
    offset = (src_y * (s->uvlinesize)) + src_x;
3131
    ptr = ref_picture[1] + offset;
3132
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3133
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3134
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3135
            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);
3136
            ptr= s->edge_emu_buffer;
3137
            emu=1;
3138
        }
3139
    }
3140
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3141

    
3142
    ptr = ref_picture[2] + offset;
3143
    if(emu){
3144
        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);
3145
        ptr= s->edge_emu_buffer;
3146
    }
3147
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3148
}
3149

    
3150
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3151
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3152
                                     uint8_t **ref_picture,
3153
                                     h264_chroma_mc_func *pix_op,
3154
                                     int mx, int my){
3155
    const int lowres= s->avctx->lowres;
3156
    const int block_s= 8>>lowres;
3157
    const int s_mask= (2<<lowres)-1;
3158
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3159
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3160
    int emu=0, src_x, src_y, offset, sx, sy;
3161
    uint8_t *ptr;
3162
    
3163
    if(s->quarter_sample){
3164
        mx/=2;
3165
        my/=2;
3166
    }
3167

    
3168
    /* In case of 8X8, we construct a single chroma motion vector
3169
       with a special rounding */
3170
    mx= ff_h263_round_chroma(mx);
3171
    my= ff_h263_round_chroma(my);
3172
    
3173
    sx= mx & s_mask;
3174
    sy= my & s_mask;
3175
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3176
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3177
    
3178
    offset = src_y * s->uvlinesize + src_x;
3179
    ptr = ref_picture[1] + offset;
3180
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3181
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3182
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3183
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3184
            ptr= s->edge_emu_buffer;
3185
            emu=1;
3186
        }
3187
    }     
3188
    sx <<= 2 - lowres;
3189
    sy <<= 2 - lowres;
3190
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3191
          
3192
    ptr = ref_picture[2] + offset;
3193
    if(emu){
3194
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3195
        ptr= s->edge_emu_buffer;
3196
    }
3197
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3198
}
3199

    
3200
/**
3201
 * motion compesation of a single macroblock
3202
 * @param s context
3203
 * @param dest_y luma destination pointer
3204
 * @param dest_cb chroma cb/u destination pointer
3205
 * @param dest_cr chroma cr/v destination pointer
3206
 * @param dir direction (0->forward, 1->backward)
3207
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3208
 * @param pic_op halfpel motion compensation function (average or put normally)
3209
 * @param pic_op qpel motion compensation function (average or put normally)
3210
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3211
 */
3212
static inline void MPV_motion(MpegEncContext *s, 
3213
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3214
                              int dir, uint8_t **ref_picture, 
3215
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3216
{
3217
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3218
    int mb_x, mb_y, i;
3219
    uint8_t *ptr, *dest;
3220

    
3221
    mb_x = s->mb_x;
3222
    mb_y = s->mb_y;
3223

    
3224
    if(s->obmc && s->pict_type != B_TYPE){
3225
        int16_t mv_cache[4][4][2];
3226
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3227
        const int mot_stride= s->b8_stride;
3228
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3229

    
3230
        assert(!s->mb_skiped);
3231
                
3232
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3233
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3234
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3235

    
3236
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3237
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3238
        }else{
3239
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3240
        }
3241

    
3242
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3243
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3244
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3245
        }else{
3246
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3247
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3248
        }
3249

    
3250
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3251
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3252
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3253
        }else{
3254
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3255
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3256
        }
3257
        
3258
        mx = 0;
3259
        my = 0;
3260
        for(i=0;i<4;i++) {
3261
            const int x= (i&1)+1;
3262
            const int y= (i>>1)+1;
3263
            int16_t mv[5][2]= {
3264
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3265
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3266
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3267
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3268
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3269
            //FIXME cleanup
3270
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3271
                        ref_picture[0],
3272
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3273
                        pix_op[1],
3274
                        mv);
3275

    
3276
            mx += mv[0][0];
3277
            my += mv[0][1];
3278
        }
3279
        if(!(s->flags&CODEC_FLAG_GRAY))
3280
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3281

    
3282
        return;
3283
    }
3284
   
3285
    switch(s->mv_type) {
3286
    case MV_TYPE_16X16:
3287
        if(s->mcsel){
3288
            if(s->real_sprite_warping_points==1){
3289
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3290
                            ref_picture);
3291
            }else{
3292
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3293
                            ref_picture);
3294
            }
3295
        }else if(s->quarter_sample){
3296
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
3297
                        0, 0, 0,
3298
                        ref_picture, pix_op, qpix_op,
3299
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3300
        }else if(s->mspel){
3301
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3302
                        ref_picture, pix_op,
3303
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3304
        }else
3305
        {
3306
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3307
                        0, 0, 0,
3308
                        ref_picture, pix_op,
3309
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3310
        }           
3311
        break;
3312
    case MV_TYPE_8X8:
3313
        mx = 0;
3314
        my = 0;
3315
        if(s->quarter_sample){
3316
            for(i=0;i<4;i++) {
3317
                motion_x = s->mv[dir][i][0];
3318
                motion_y = s->mv[dir][i][1];
3319

    
3320
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3321
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3322
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3323
                    
3324
                /* WARNING: do no forget half pels */
3325
                src_x = clip(src_x, -16, s->width);
3326
                if (src_x == s->width)
3327
                    dxy &= ~3;
3328
                src_y = clip(src_y, -16, s->height);
3329
                if (src_y == s->height)
3330
                    dxy &= ~12;
3331
                    
3332
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3333
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3334
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3335
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3336
                        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);
3337
                        ptr= s->edge_emu_buffer;
3338
                    }
3339
                }
3340
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3341
                qpix_op[1][dxy](dest, ptr, s->linesize);
3342

    
3343
                mx += s->mv[dir][i][0]/2;
3344
                my += s->mv[dir][i][1]/2;
3345
            }
3346
        }else{
3347
            for(i=0;i<4;i++) {
3348
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3349
                            ref_picture[0], 0, 0,
3350
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3351
                            s->width, s->height, s->linesize,
3352
                            s->h_edge_pos, s->v_edge_pos,
3353
                            8, 8, pix_op[1],
3354
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3355

    
3356
                mx += s->mv[dir][i][0];
3357
                my += s->mv[dir][i][1];
3358
            }
3359
        }
3360

    
3361
        if(!(s->flags&CODEC_FLAG_GRAY))
3362
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3363
        break;
3364
    case MV_TYPE_FIELD:
3365
        if (s->picture_structure == PICT_FRAME) {
3366
            if(s->quarter_sample){
3367
                for(i=0; i<2; i++){
3368
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3369
                                1, i, s->field_select[dir][i],
3370
                                ref_picture, pix_op, qpix_op,
3371
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3372
                }
3373
            }else{
3374
                /* top field */       
3375
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3376
                            1, 0, s->field_select[dir][0],
3377
                            ref_picture, pix_op,
3378
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3379
                /* bottom field */
3380
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3381
                            1, 1, s->field_select[dir][1],
3382
                            ref_picture, pix_op,
3383
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3384
            }
3385
        } else {
3386
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3387
                ref_picture= s->current_picture_ptr->data;
3388
            } 
3389

    
3390
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3391
                        0, 0, s->field_select[dir][0],
3392
                        ref_picture, pix_op,
3393
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3394
        }
3395
        break;
3396
    case MV_TYPE_16X8:
3397
        for(i=0; i<2; i++){
3398
            uint8_t ** ref2picture;
3399

    
3400
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3401
                ref2picture= ref_picture;
3402
            }else{
3403
                ref2picture= s->current_picture_ptr->data;
3404
            } 
3405

    
3406
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3407
                        0, 0, s->field_select[dir][i],
3408
                        ref2picture, pix_op,
3409
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3410
                
3411
            dest_y += 16*s->linesize;
3412
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3413
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3414
        }        
3415
        break;
3416
    case MV_TYPE_DMV:
3417
        if(s->picture_structure == PICT_FRAME){
3418
            for(i=0; i<2; i++){
3419
                int j;
3420
                for(j=0; j<2; j++){
3421
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3422
                                1, j, j^i,
3423
                                ref_picture, pix_op,
3424
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3425
                }
3426
                pix_op = s->dsp.avg_pixels_tab; 
3427
            }
3428
        }else{
3429
            for(i=0; i<2; i++){
3430
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3431
                            0, 0, s->picture_structure != i+1,
3432
                            ref_picture, pix_op,
3433
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3434

    
3435
                // after put we make avg of the same block
3436
                pix_op=s->dsp.avg_pixels_tab; 
3437

    
3438
                //opposite parity is always in the same frame if this is second field
3439
                if(!s->first_field){
3440
                    ref_picture = s->current_picture_ptr->data;    
3441
                }
3442
            }
3443
        }
3444
    break;
3445
    default: assert(0);
3446
    }
3447
}
3448

    
3449
/**
3450
 * motion compesation of a single macroblock
3451
 * @param s context
3452
 * @param dest_y luma destination pointer
3453
 * @param dest_cb chroma cb/u destination pointer
3454
 * @param dest_cr chroma cr/v destination pointer
3455
 * @param dir direction (0->forward, 1->backward)
3456
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3457
 * @param pic_op halfpel motion compensation function (average or put normally)
3458
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3459
 */
3460
static inline void MPV_motion_lowres(MpegEncContext *s, 
3461
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3462
                              int dir, uint8_t **ref_picture, 
3463
                              h264_chroma_mc_func *pix_op)
3464
{
3465
    int mx, my;
3466
    int mb_x, mb_y, i;
3467
    const int lowres= s->avctx->lowres;
3468
    const int block_s= 8>>lowres;    
3469

    
3470
    mb_x = s->mb_x;
3471
    mb_y = s->mb_y;
3472

    
3473
    switch(s->mv_type) {
3474
    case MV_TYPE_16X16:
3475
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3476
                    0, 0, 0,
3477
                    ref_picture, pix_op,
3478
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3479
        break;
3480
    case MV_TYPE_8X8:
3481
        mx = 0;
3482
        my = 0;
3483
            for(i=0;i<4;i++) {
3484
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3485
                            ref_picture[0], 0, 0,
3486
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3487
                            s->width, s->height, s->linesize,
3488
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3489
                            block_s, block_s, pix_op,
3490
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3491

    
3492
                mx += s->mv[dir][i][0];
3493
                my += s->mv[dir][i][1];
3494
            }
3495

    
3496
        if(!(s->flags&CODEC_FLAG_GRAY))
3497
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3498
        break;
3499
    case MV_TYPE_FIELD:
3500
        if (s->picture_structure == PICT_FRAME) {
3501
            /* top field */       
3502
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3503
                        1, 0, s->field_select[dir][0],
3504
                        ref_picture, pix_op,
3505
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3506
            /* bottom field */
3507
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3508
                        1, 1, s->field_select[dir][1],
3509
                        ref_picture, pix_op,
3510
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3511
        } else {
3512
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3513
                ref_picture= s->current_picture_ptr->data;
3514
            } 
3515

    
3516
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3517
                        0, 0, s->field_select[dir][0],
3518
                        ref_picture, pix_op,
3519
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3520
        }
3521
        break;
3522
    case MV_TYPE_16X8:
3523
        for(i=0; i<2; i++){
3524
            uint8_t ** ref2picture;
3525

    
3526
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3527
                ref2picture= ref_picture;
3528
            }else{
3529
                ref2picture= s->current_picture_ptr->data;
3530
            } 
3531

    
3532
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3533
                        0, 0, s->field_select[dir][i],
3534
                        ref2picture, pix_op,
3535
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3536
                
3537
            dest_y += 2*block_s*s->linesize;
3538
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3539
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3540
        }        
3541
        break;
3542
    case MV_TYPE_DMV:
3543
        if(s->picture_structure == PICT_FRAME){
3544
            for(i=0; i<2; i++){
3545
                int j;
3546
                for(j=0; j<2; j++){
3547
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3548
                                1, j, j^i,
3549
                                ref_picture, pix_op,
3550
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3551
                }
3552
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3553
            }
3554
        }else{
3555
            for(i=0; i<2; i++){
3556
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3557
                            0, 0, s->picture_structure != i+1,
3558
                            ref_picture, pix_op,
3559
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3560

    
3561
                // after put we make avg of the same block
3562
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3563

    
3564
                //opposite parity is always in the same frame if this is second field
3565
                if(!s->first_field){
3566
                    ref_picture = s->current_picture_ptr->data;    
3567
                }
3568
            }
3569
        }
3570
    break;
3571
    default: assert(0);
3572
    }
3573
}
3574

    
3575
/* put block[] to dest[] */
3576
static inline void put_dct(MpegEncContext *s, 
3577
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3578
{
3579
    s->dct_unquantize_intra(s, block, i, qscale);
3580
    s->dsp.idct_put (dest, line_size, block);
3581
}
3582

    
3583
/* add block[] to dest[] */
3584
static inline void add_dct(MpegEncContext *s, 
3585
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3586
{
3587
    if (s->block_last_index[i] >= 0) {
3588
        s->dsp.idct_add (dest, line_size, block);
3589
    }
3590
}
3591

    
3592
static inline void add_dequant_dct(MpegEncContext *s, 
3593
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3594
{
3595
    if (s->block_last_index[i] >= 0) {
3596
        s->dct_unquantize_inter(s, block, i, qscale);
3597

    
3598
        s->dsp.idct_add (dest, line_size, block);
3599
    }
3600
}
3601

    
3602
/**
3603
 * cleans dc, ac, coded_block for the current non intra MB
3604
 */
3605
void ff_clean_intra_table_entries(MpegEncContext *s)
3606
{
3607
    int wrap = s->b8_stride;
3608
    int xy = s->block_index[0];
3609
    
3610
    s->dc_val[0][xy           ] = 
3611
    s->dc_val[0][xy + 1       ] = 
3612
    s->dc_val[0][xy     + wrap] =
3613
    s->dc_val[0][xy + 1 + wrap] = 1024;
3614
    /* ac pred */
3615
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3616
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3617
    if (s->msmpeg4_version>=3) {
3618
        s->coded_block[xy           ] =
3619
        s->coded_block[xy + 1       ] =
3620
        s->coded_block[xy     + wrap] =
3621
        s->coded_block[xy + 1 + wrap] = 0;
3622
    }
3623
    /* chroma */
3624
    wrap = s->mb_stride;
3625
    xy = s->mb_x + s->mb_y * wrap;
3626
    s->dc_val[1][xy] =
3627
    s->dc_val[2][xy] = 1024;
3628
    /* ac pred */
3629
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3630
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3631
    
3632
    s->mbintra_table[xy]= 0;
3633
}
3634

    
3635
/* generic function called after a macroblock has been parsed by the
3636
   decoder or after it has been encoded by the encoder.
3637

3638
   Important variables used:
3639
   s->mb_intra : true if intra macroblock
3640
   s->mv_dir   : motion vector direction
3641
   s->mv_type  : motion vector type
3642
   s->mv       : motion vector
3643
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3644
 */
3645
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3646
{
3647
    int mb_x, mb_y;
3648
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3649
#ifdef HAVE_XVMC
3650
    if(s->avctx->xvmc_acceleration){
3651
        XVMC_decode_mb(s);//xvmc uses pblocks
3652
        return;
3653
    }
3654
#endif
3655

    
3656
    mb_x = s->mb_x;
3657
    mb_y = s->mb_y;
3658

    
3659
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3660
       /* save DCT coefficients */
3661
       int i,j;
3662
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3663
       for(i=0; i<6; i++)
3664
           for(j=0; j<64; j++)
3665
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3666
    }
3667

    
3668
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3669

    
3670
    /* update DC predictors for P macroblocks */
3671
    if (!s->mb_intra) {
3672
        if (s->h263_pred || s->h263_aic) {
3673
            if(s->mbintra_table[mb_xy])
3674
                ff_clean_intra_table_entries(s);
3675
        } else {
3676
            s->last_dc[0] =
3677
            s->last_dc[1] =
3678
            s->last_dc[2] = 128 << s->intra_dc_precision;
3679
        }
3680
    }
3681
    else if (s->h263_pred || s->h263_aic)
3682
        s->mbintra_table[mb_xy]=1;
3683

    
3684
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3685
        uint8_t *dest_y, *dest_cb, *dest_cr;
3686
        int dct_linesize, dct_offset;
3687
        op_pixels_func (*op_pix)[4];
3688
        qpel_mc_func (*op_qpix)[16];
3689
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3690
        const int uvlinesize= s->current_picture.linesize[1];
3691
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3692
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3693

    
3694
        /* avoid copy if macroblock skipped in last frame too */
3695
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3696
        if(!s->encoding){
3697
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3698
            const int age= s->current_picture.age;
3699

    
3700
            assert(age);
3701

    
3702
            if (s->mb_skiped) {
3703
                s->mb_skiped= 0;
3704
                assert(s->pict_type!=I_TYPE);
3705
 
3706
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3707
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3708

    
3709
                /* if previous was skipped too, then nothing to do !  */
3710
                if (*mbskip_ptr >= age && s->current_picture.reference){
3711
                    return;
3712
                }
3713
            } else if(!s->current_picture.reference){
3714
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3715
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3716
            } else{
3717
                *mbskip_ptr = 0; /* not skipped */
3718
            }
3719
        }
3720
        
3721
        dct_linesize = linesize << s->interlaced_dct;
3722
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3723
        
3724
        if(readable){
3725
            dest_y=  s->dest[0];
3726
            dest_cb= s->dest[1];
3727
            dest_cr= s->dest[2];
3728
        }else{
3729
            dest_y = s->b_scratchpad;
3730
            dest_cb= s->b_scratchpad+16*linesize;
3731
            dest_cr= s->b_scratchpad+32*linesize;
3732
        }
3733

    
3734
        if (!s->mb_intra) {
3735
            /* motion handling */
3736
            /* decoding or more than one mb_type (MC was already done otherwise) */
3737
            if(!s->encoding){
3738
                if(lowres_flag){
3739
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3740

    
3741
                    if (s->mv_dir & MV_DIR_FORWARD) {
3742
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3743
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3744
                    }
3745
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3746
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3747
                    }
3748
                }else{
3749
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3750
                        op_pix = s->dsp.put_pixels_tab;
3751
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3752
                    }else{
3753
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3754
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3755
                    }
3756
                    if (s->mv_dir & MV_DIR_FORWARD) {
3757
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3758
                        op_pix = s->dsp.avg_pixels_tab;
3759
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3760
                    }
3761
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3762
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3763
                    }
3764
                }
3765
            }
3766

    
3767
            /* skip dequant / idct if we are really late ;) */
3768
            if(s->hurry_up>1) return;
3769

    
3770
            /* add dct residue */
3771
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3772
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3773
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3774
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3775
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3776
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3777

    
3778
                if(!(s->flags&CODEC_FLAG_GRAY)){
3779
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3780
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3781
                }
3782
            } else if(s->codec_id != CODEC_ID_WMV2){
3783
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3784
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3785
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3786
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3787

    
3788
                if(!(s->flags&CODEC_FLAG_GRAY)){
3789
                    if(s->chroma_y_shift){//Chroma420
3790
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3791
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3792
                    }else{
3793
                        //chroma422
3794
                        dct_linesize = uvlinesize << s->interlaced_dct;
3795
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3796

    
3797
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3798
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3799
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3800
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3801
                        if(!s->chroma_x_shift){//Chroma444
3802
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3803
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3804
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3805
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3806
                        }
3807
                    }
3808
                }//fi gray
3809
            }
3810
            else{
3811
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3812
            }
3813
        } else {
3814
            /* dct only in intra block */
3815
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3816
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3817
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3818
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3819
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3820

    
3821
                if(!(s->flags&CODEC_FLAG_GRAY)){
3822
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3823
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3824
                }
3825
            }else{
3826
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3827
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3828
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3829
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3830

    
3831
                if(!(s->flags&CODEC_FLAG_GRAY)){
3832
                    if(s->chroma_y_shift){
3833
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3834
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3835
                    }else{
3836

    
3837
                        dct_linesize = uvlinesize << s->interlaced_dct;
3838
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3839

    
3840
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3841
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3842
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3843
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3844
                        if(!s->chroma_x_shift){//Chroma444
3845
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3846
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3847
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3848
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3849
                        }
3850
                    }
3851
                }//gray
3852
            }
3853
        }
3854
        if(!readable){
3855
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3856
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3857
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3858
        }
3859
    }
3860
}
3861

    
3862
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3863
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3864
    else                  MPV_decode_mb_internal(s, block, 0);
3865
}
3866

    
3867
#ifdef CONFIG_ENCODERS
3868

    
3869
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3870
{
3871
    static const char tab[64]=
3872
        {3,2,2,1,1,1,1,1,
3873
         1,1,1,1,1,1,1,1,
3874
         1,1,1,1,1,1,1,1,
3875
         0,0,0,0,0,0,0,0,
3876
         0,0,0,0,0,0,0,0,
3877
         0,0,0,0,0,0,0,0,
3878
         0,0,0,0,0,0,0,0,
3879
         0,0,0,0,0,0,0,0};
3880
    int score=0;
3881
    int run=0;
3882
    int i;
3883
    DCTELEM *block= s->block[n];
3884
    const int last_index= s->block_last_index[n];
3885
    int skip_dc;
3886

    
3887
    if(threshold<0){
3888
        skip_dc=0;
3889
        threshold= -threshold;
3890
    }else
3891
        skip_dc=1;
3892

    
3893
    /* are all which we could set to zero are allready zero? */
3894
    if(last_index<=skip_dc - 1) return;
3895

    
3896
    for(i=0; i<=last_index; i++){
3897
        const int j = s->intra_scantable.permutated[i];
3898
        const int level = ABS(block[j]);
3899
        if(level==1){
3900
            if(skip_dc && i==0) continue;
3901
            score+= tab[run];
3902
            run=0;
3903
        }else if(level>1){
3904
            return;
3905
        }else{
3906
            run++;
3907
        }
3908
    }
3909
    if(score >= threshold) return;
3910
    for(i=skip_dc; i<=last_index; i++){
3911
        const int j = s->intra_scantable.permutated[i];
3912
        block[j]=0;
3913
    }
3914
    if(block[0]) s->block_last_index[n]= 0;
3915
    else         s->block_last_index[n]= -1;
3916
}
3917

    
3918
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3919
{
3920
    int i;
3921
    const int maxlevel= s->max_qcoeff;
3922
    const int minlevel= s->min_qcoeff;
3923
    int overflow=0;
3924
    
3925
    if(s->mb_intra){
3926
        i=1; //skip clipping of intra dc
3927
    }else
3928
        i=0;
3929
    
3930
    for(;i<=last_index; i++){
3931
        const int j= s->intra_scantable.permutated[i];
3932
        int level = block[j];
3933
       
3934
        if     (level>maxlevel){
3935
            level=maxlevel;
3936
            overflow++;
3937
        }else if(level<minlevel){
3938
            level=minlevel;
3939
            overflow++;
3940
        }
3941
        
3942
        block[j]= level;
3943
    }
3944
    
3945
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3946
        av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
3947
}
3948

    
3949
#endif //CONFIG_ENCODERS
3950

    
3951
/**
3952
 *
3953
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3954
 */
3955
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3956
    if (s->avctx->draw_horiz_band) {
3957
        AVFrame *src;
3958
        int offset[4];
3959
        
3960
        if(s->picture_structure != PICT_FRAME){
3961
            h <<= 1;
3962
            y <<= 1;
3963
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3964
        }
3965

    
3966
        h= FFMIN(h, s->avctx->height - y);
3967

    
3968
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3969
            src= (AVFrame*)s->current_picture_ptr;
3970
        else if(s->last_picture_ptr)
3971
            src= (AVFrame*)s->last_picture_ptr;
3972
        else
3973
            return;
3974
            
3975
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3976
            offset[0]=
3977
            offset[1]=
3978
            offset[2]=
3979
            offset[3]= 0;
3980
        }else{
3981
            offset[0]= y * s->linesize;;
3982
            offset[1]= 
3983
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3984
            offset[3]= 0;
3985
        }
3986

    
3987
        emms_c();
3988

    
3989
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3990
                                  y, s->picture_structure, h);
3991
    }
3992
}
3993

    
3994
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3995
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3996
    const int uvlinesize= s->current_picture.linesize[1];
3997
    const int mb_size= 4 - s->avctx->lowres;
3998
        
3999
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
4000
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
4001
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4002
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4003
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4004
    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;
4005
    //block_index is not used by mpeg2, so it is not affected by chroma_format
4006

    
4007
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4008
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4009
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4010

    
4011
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4012
    {
4013
        s->dest[0] += s->mb_y *   linesize << mb_size;
4014
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4015
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4016
    }
4017
}
4018

    
4019
#ifdef CONFIG_ENCODERS
4020

    
4021
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4022
    int x, y;
4023
//FIXME optimize
4024
    for(y=0; y<8; y++){
4025
        for(x=0; x<8; x++){
4026
            int x2, y2;
4027
            int sum=0;
4028
            int sqr=0;
4029
            int count=0;
4030

    
4031
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4032
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4033
                    int v= ptr[x2 + y2*stride];
4034
                    sum += v;
4035
                    sqr += v*v;
4036
                    count++;
4037
                }
4038
            }
4039
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4040
        }
4041
    }
4042
}
4043

    
4044
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4045
{
4046
    int16_t weight[6][64];
4047
    DCTELEM orig[6][64];
4048
    const int mb_x= s->mb_x;
4049
    const int mb_y= s->mb_y;
4050
    int i;
4051
    int skip_dct[6];
4052
    int dct_offset   = s->linesize*8; //default for progressive frames
4053
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4054
    int wrap_y, wrap_c;
4055
    
4056
    for(i=0; i<6; i++) skip_dct[i]=0;
4057
    
4058
    if(s->adaptive_quant){
4059
        const int last_qp= s->qscale;
4060
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4061

    
4062
        s->lambda= s->lambda_table[mb_xy];
4063
        update_qscale(s);
4064
    
4065
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4066
            s->dquant= s->qscale - last_qp;
4067

    
4068
            if(s->out_format==FMT_H263){
4069
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4070
            
4071
                if(s->codec_id==CODEC_ID_MPEG4){        
4072
                    if(!s->mb_intra){
4073
                        if(s->pict_type == B_TYPE){
4074
                            if(s->dquant&1) 
4075
                                s->dquant= (s->dquant/2)*2;
4076
                            if(s->mv_dir&MV_DIRECT)
4077
                                s->dquant= 0;
4078
                        }
4079
                        if(s->mv_type==MV_TYPE_8X8)
4080
                            s->dquant=0;
4081
                    }
4082
                }
4083
            }
4084
        }
4085
        ff_set_qscale(s, last_qp + s->dquant);
4086
    }else if(s->flags&CODEC_FLAG_QP_RD)
4087
        ff_set_qscale(s, s->qscale + s->dquant);
4088

    
4089
    wrap_y = s->linesize;
4090
    wrap_c = s->uvlinesize;
4091
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4092
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4093
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4094

    
4095
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4096
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4097
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4098
        ptr_y= ebuf;
4099
        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);
4100
        ptr_cb= ebuf+18*wrap_y;
4101
        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);
4102
        ptr_cr= ebuf+18*wrap_y+8;
4103
    }
4104

    
4105
    if (s->mb_intra) {
4106
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4107
            int progressive_score, interlaced_score;
4108

    
4109
            s->interlaced_dct=0;
4110
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
4111
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4112

    
4113
            if(progressive_score > 0){
4114
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
4115
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4116
                if(progressive_score > interlaced_score){
4117
                    s->interlaced_dct=1;
4118
            
4119
                    dct_offset= wrap_y;
4120
                    wrap_y<<=1;
4121
                }
4122
            }
4123
        }
4124
        
4125
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4126
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4127
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4128
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4129

    
4130
        if(s->flags&CODEC_FLAG_GRAY){
4131
            skip_dct[4]= 1;
4132
            skip_dct[5]= 1;
4133
        }else{
4134
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4135
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4136
        }
4137
    }else{
4138
        op_pixels_func (*op_pix)[4];
4139
        qpel_mc_func (*op_qpix)[16];
4140
        uint8_t *dest_y, *dest_cb, *dest_cr;
4141

    
4142
        dest_y  = s->dest[0];
4143
        dest_cb = s->dest[1];
4144
        dest_cr = s->dest[2];
4145

    
4146
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4147
            op_pix = s->dsp.put_pixels_tab;
4148
            op_qpix= s->dsp.put_qpel_pixels_tab;
4149
        }else{
4150
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4151
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4152
        }
4153

    
4154
        if (s->mv_dir & MV_DIR_FORWARD) {
4155
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4156
            op_pix = s->dsp.avg_pixels_tab;
4157
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4158
        }
4159
        if (s->mv_dir & MV_DIR_BACKWARD) {
4160
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4161
        }
4162

    
4163
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4164
            int progressive_score, interlaced_score;
4165

    
4166
            s->interlaced_dct=0;
4167
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
4168
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4169
            
4170
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4171

    
4172
            if(progressive_score>0){
4173
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
4174
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4175
            
4176
                if(progressive_score > interlaced_score){
4177
                    s->interlaced_dct=1;
4178
            
4179
                    dct_offset= wrap_y;
4180
                    wrap_y<<=1;
4181
                }
4182
            }
4183
        }
4184
        
4185
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4186
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4187
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4188
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4189
        
4190
        if(s->flags&CODEC_FLAG_GRAY){
4191
            skip_dct[4]= 1;
4192
            skip_dct[5]= 1;
4193
        }else{
4194
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4195
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4196
        }
4197
        /* pre quantization */         
4198
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4199
            //FIXME optimize
4200
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4201
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4202
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4203
            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;
4204
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4205
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4206
        }
4207
    }
4208

    
4209
    if(s->avctx->quantizer_noise_shaping){
4210
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4211
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4212
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4213
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4214
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4215
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4216
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4217
    }
4218
            
4219
    /* DCT & quantize */
4220
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4221
    {
4222
        for(i=0;i<6;i++) {
4223
            if(!skip_dct[i]){
4224
                int overflow;
4225
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4226
            // FIXME we could decide to change to quantizer instead of clipping
4227
            // JS: I don't think that would be a good idea it could lower quality instead
4228
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4229
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4230
            }else
4231
                s->block_last_index[i]= -1;
4232
        }
4233
        if(s->avctx->quantizer_noise_shaping){
4234
            for(i=0;i<6;i++) {
4235
                if(!skip_dct[i]){
4236
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4237
                }
4238
            }
4239
        }
4240
        
4241
        if(s->luma_elim_threshold && !s->mb_intra)
4242
            for(i=0; i<4; i++)
4243
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4244
        if(s->chroma_elim_threshold && !s->mb_intra)
4245
            for(i=4; i<6; i++)
4246
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4247

    
4248
        if(s->flags & CODEC_FLAG_CBP_RD){
4249
            for(i=0;i<6;i++) {
4250
                if(s->block_last_index[i] == -1)
4251
                    s->coded_score[i]= INT_MAX/256;
4252
            }
4253
        }
4254
    }
4255

    
4256
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4257
        s->block_last_index[4]=
4258
        s->block_last_index[5]= 0;
4259
        s->block[4][0]=
4260
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4261
    }
4262

    
4263
    //non c quantize code returns incorrect block_last_index FIXME
4264
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4265
        for(i=0; i<6; i++){
4266
            int j;
4267
            if(s->block_last_index[i]>0){
4268
                for(j=63; j>0; j--){
4269
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4270
                }
4271
                s->block_last_index[i]= j;
4272
            }
4273
        }
4274
    }
4275

    
4276
    /* huffman encode */
4277
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4278
    case CODEC_ID_MPEG1VIDEO:
4279
    case CODEC_ID_MPEG2VIDEO:
4280
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4281
    case CODEC_ID_MPEG4:
4282
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4283
    case CODEC_ID_MSMPEG4V2:
4284
    case CODEC_ID_MSMPEG4V3:
4285
    case CODEC_ID_WMV1:
4286
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4287
    case CODEC_ID_WMV2:
4288
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4289
    case CODEC_ID_H261:
4290
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4291
    case CODEC_ID_H263:
4292
    case CODEC_ID_H263P:
4293
    case CODEC_ID_FLV1:
4294
    case CODEC_ID_RV10:
4295
    case CODEC_ID_RV20:
4296
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4297
    case CODEC_ID_MJPEG:
4298
        mjpeg_encode_mb(s, s->block); break;
4299
    default:
4300
        assert(0);
4301
    }
4302
}
4303

    
4304
#endif //CONFIG_ENCODERS
4305

    
4306
void ff_mpeg_flush(AVCodecContext *avctx){
4307
    int i;
4308
    MpegEncContext *s = avctx->priv_data;
4309
    
4310
    if(s==NULL || s->picture==NULL) 
4311
        return;
4312
    
4313
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4314
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4315
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4316
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4317
    }
4318
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4319
    
4320
    s->mb_x= s->mb_y= 0;
4321
    
4322
    s->parse_context.state= -1;
4323
    s->parse_context.frame_start_found= 0;
4324
    s->parse_context.overread= 0;
4325
    s->parse_context.overread_index= 0;
4326
    s->parse_context.index= 0;
4327
    s->parse_context.last_index= 0;
4328
    s->bitstream_buffer_size=0;
4329
}
4330

    
4331
#ifdef CONFIG_ENCODERS
4332
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4333
{
4334
    const uint16_t *srcw= (uint16_t*)src;
4335
    int words= length>>4;
4336
    int bits= length&15;
4337
    int i;
4338

    
4339
    if(length==0) return;
4340
    
4341
    if(words < 16){
4342
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4343
    }else if(put_bits_count(pb)&7){
4344
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4345
    }else{
4346
        for(i=0; put_bits_count(pb)&31; i++)
4347
            put_bits(pb, 8, src[i]);
4348
        flush_put_bits(pb);
4349
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4350
        skip_put_bytes(pb, 2*words-i);
4351
    }
4352
        
4353
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4354
}
4355

    
4356
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4357
    int i;
4358

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

    
4361
    /* mpeg1 */
4362
    d->mb_skip_run= s->mb_skip_run;
4363
    for(i=0; i<3; i++)
4364
        d->last_dc[i]= s->last_dc[i];
4365
    
4366
    /* statistics */
4367
    d->mv_bits= s->mv_bits;
4368
    d->i_tex_bits= s->i_tex_bits;
4369
    d->p_tex_bits= s->p_tex_bits;
4370
    d->i_count= s->i_count;
4371
    d->f_count= s->f_count;
4372
    d->b_count= s->b_count;
4373
    d->skip_count= s->skip_count;
4374
    d->misc_bits= s->misc_bits;
4375
    d->last_bits= 0;
4376

    
4377
    d->mb_skiped= 0;
4378
    d->qscale= s->qscale;
4379
    d->dquant= s->dquant;
4380
}
4381

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

    
4385
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
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

    
4403
    d->mb_intra= s->mb_intra;
4404
    d->mb_skiped= s->mb_skiped;
4405
    d->mv_type= s->mv_type;
4406
    d->mv_dir= s->mv_dir;
4407
    d->pb= s->pb;
4408
    if(s->data_partitioning){
4409
        d->pb2= s->pb2;
4410
        d->tex_pb= s->tex_pb;
4411
    }
4412
    d->block= s->block;
4413
    for(i=0; i<6; i++)
4414
        d->block_last_index[i]= s->block_last_index[i];
4415
    d->interlaced_dct= s->interlaced_dct;
4416
    d->qscale= s->qscale;
4417
}
4418

    
4419
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4420
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4421
                           int *dmin, int *next_block, int motion_x, int motion_y)
4422
{
4423
    int score;
4424
    uint8_t *dest_backup[3];
4425
    
4426
    copy_context_before_encode(s, backup, type);
4427

    
4428
    s->block= s->blocks[*next_block];
4429
    s->pb= pb[*next_block];
4430
    if(s->data_partitioning){
4431
        s->pb2   = pb2   [*next_block];
4432
        s->tex_pb= tex_pb[*next_block];
4433
    }
4434
    
4435
    if(*next_block){
4436
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4437
        s->dest[0] = s->rd_scratchpad;
4438
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4439
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4440
        assert(s->linesize >= 32); //FIXME
4441
    }
4442

    
4443
    encode_mb(s, motion_x, motion_y);
4444
    
4445
    score= put_bits_count(&s->pb);
4446
    if(s->data_partitioning){
4447
        score+= put_bits_count(&s->pb2);
4448
        score+= put_bits_count(&s->tex_pb);
4449
    }
4450
   
4451
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4452
        MPV_decode_mb(s, s->block);
4453

    
4454
        score *= s->lambda2;
4455
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4456
    }
4457
    
4458
    if(*next_block){
4459
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4460
    }
4461

    
4462
    if(score<*dmin){
4463
        *dmin= score;
4464
        *next_block^=1;
4465

    
4466
        copy_context_after_encode(best, s, type);
4467
    }
4468
}
4469
                
4470
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4471
    uint32_t *sq = squareTbl + 256;
4472
    int acc=0;
4473
    int x,y;
4474
    
4475
    if(w==16 && h==16) 
4476
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4477
    else if(w==8 && h==8)
4478
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4479
    
4480
    for(y=0; y<h; y++){
4481
        for(x=0; x<w; x++){
4482
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4483
        } 
4484
    }
4485
    
4486
    assert(acc>=0);
4487
    
4488
    return acc;
4489
}
4490

    
4491
static int sse_mb(MpegEncContext *s){
4492
    int w= 16;
4493
    int h= 16;
4494

    
4495
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4496
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4497

    
4498
    if(w==16 && h==16)
4499
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4500
        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)
4501
               +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)
4502
               +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);
4503
      }else{
4504
        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)
4505
               +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)
4506
               +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);
4507
      }
4508
    else
4509
        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)
4510
               +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)
4511
               +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);
4512
}
4513

    
4514
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4515
    MpegEncContext *s= arg;
4516

    
4517
    
4518
    s->me.pre_pass=1;
4519
    s->me.dia_size= s->avctx->pre_dia_size;
4520
    s->first_slice_line=1;
4521
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4522
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4523
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4524
        }
4525
        s->first_slice_line=0;
4526
    }
4527
    
4528
    s->me.pre_pass=0;
4529
    
4530
    return 0;
4531
}
4532

    
4533
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4534
    MpegEncContext *s= arg;
4535

    
4536
    s->me.dia_size= s->avctx->dia_size;
4537
    s->first_slice_line=1;
4538
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4539
        s->mb_x=0; //for block init below
4540
        ff_init_block_index(s);
4541
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4542
            s->block_index[0]+=2;
4543
            s->block_index[1]+=2;
4544
            s->block_index[2]+=2;
4545
            s->block_index[3]+=2;
4546
            
4547
            /* compute motion vector & mb_type and store in context */
4548
            if(s->pict_type==B_TYPE)
4549
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4550
            else
4551
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4552
        }
4553
        s->first_slice_line=0;
4554
    }
4555
    return 0;
4556
}
4557

    
4558
static int mb_var_thread(AVCodecContext *c, void *arg){
4559
    MpegEncContext *s= arg;
4560
    int mb_x, mb_y;
4561

    
4562
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4563
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4564
            int xx = mb_x * 16;
4565
            int yy = mb_y * 16;
4566
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4567
            int varc;
4568
            int sum = s->dsp.pix_sum(pix, s->linesize);
4569
    
4570
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4571

    
4572
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4573
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4574
            s->me.mb_var_sum_temp    += varc;
4575
        }
4576
    }
4577
    return 0;
4578
}
4579

    
4580
static void write_slice_end(MpegEncContext *s){
4581
    if(s->codec_id==CODEC_ID_MPEG4){
4582
        if(s->partitioned_frame){
4583
            ff_mpeg4_merge_partitions(s);
4584
        }
4585
    
4586
        ff_mpeg4_stuffing(&s->pb);
4587
    }else if(s->out_format == FMT_MJPEG){
4588
        ff_mjpeg_stuffing(&s->pb);
4589
    }
4590

    
4591
    align_put_bits(&s->pb);
4592
    flush_put_bits(&s->pb);
4593
    
4594
    if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4595
        s->misc_bits+= get_bits_diff(s);
4596
}
4597

    
4598
static int encode_thread(AVCodecContext *c, void *arg){
4599
    MpegEncContext *s= arg;
4600
    int mb_x, mb_y, pdif = 0;
4601
    int i, j;
4602
    MpegEncContext best_s, backup_s;
4603
    uint8_t bit_buf[2][MAX_MB_BYTES];
4604
    uint8_t bit_buf2[2][MAX_MB_BYTES];
4605
    uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4606
    PutBitContext pb[2], pb2[2], tex_pb[2];
4607
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4608

    
4609
    for(i=0; i<2; i++){
4610
        init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
4611
        init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
4612
        init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4613
    }
4614

    
4615
    s->last_bits= put_bits_count(&s->pb);
4616
    s->mv_bits=0;
4617
    s->misc_bits=0;
4618
    s->i_tex_bits=0;
4619
    s->p_tex_bits=0;
4620
    s->i_count=0;
4621
    s->f_count=0;
4622
    s->b_count=0;
4623
    s->skip_count=0;
4624

    
4625
    for(i=0; i<3; i++){
4626
        /* init last dc values */
4627
        /* note: quant matrix value (8) is implied here */
4628
        s->last_dc[i] = 128 << s->intra_dc_precision;
4629
        
4630
        s->current_picture_ptr->error[i] = 0;
4631
    }
4632
    s->mb_skip_run = 0;
4633
    memset(s->last_mv, 0, sizeof(s->last_mv));
4634
     
4635
    s->last_mv_dir = 0;
4636

    
4637
    switch(s->codec_id){
4638
    case CODEC_ID_H263:
4639
    case CODEC_ID_H263P:
4640
    case CODEC_ID_FLV1:
4641
        s->gob_index = ff_h263_get_gob_height(s);
4642
        break;
4643
    case CODEC_ID_MPEG4:
4644
        if(s->partitioned_frame)
4645
            ff_mpeg4_init_partitions(s);
4646
        break;
4647
    }
4648

    
4649
    s->resync_mb_x=0;
4650
    s->resync_mb_y=0; 
4651
    s->first_slice_line = 1;
4652
    s->ptr_lastgob = s->pb.buf;
4653
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4654
//    printf("row %d at %X\n", s->mb_y, (int)s);
4655
        s->mb_x=0;
4656
        s->mb_y= mb_y;
4657

    
4658
        ff_set_qscale(s, s->qscale);
4659
        ff_init_block_index(s);
4660
        
4661
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4662
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4663
            int mb_type= s->mb_type[xy];