Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 650cec0c

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
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 differnt 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 doesnt 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+2)  * sizeof(int16_t))
389
                pic->motion_val[i]= pic->motion_val_base[i]+2;
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+2) * sizeof(int16_t))
396
                pic->motion_val[i]= pic->motion_val_base[i]+2;
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_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
598
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
599

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

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

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

    
622
    dsputil_init(&s->dsp, s->avctx);
623
    DCT_common_init(s);
624

    
625
    s->flags= s->avctx->flags;
626
    s->flags2= s->avctx->flags2;
627

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

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

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

    
644
    s->mb_num = s->mb_width * s->mb_height;
645
    
646
    s->block_wrap[0]=
647
    s->block_wrap[1]=
648
    s->block_wrap[2]=
649
    s->block_wrap[3]= s->b8_stride;
650
    s->block_wrap[4]=
651
    s->block_wrap[5]= s->mb_stride;
652
 
653
    y_size = s->b8_stride * (2 * s->mb_height + 1);
654
    c_size = s->mb_stride * (s->mb_height + 1);
655
    yc_size = y_size + 2 * c_size;
656
    
657
    /* convert fourcc to upper case */
658
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
659
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
660
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
661
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
662

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

    
668
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
669

    
670
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
671
    for(y=0; y<s->mb_height; y++){
672
        for(x=0; x<s->mb_width; x++){
673
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
674
        }
675
    }
676
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
677
    
678
    if (s->encoding) {
679
        /* Allocate MV tables */
680
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
681
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
682
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
683
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
684
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
685
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
686
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
687
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
688
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
689
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
690
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
691
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
692

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

    
698
        /* Allocate MB type table */
699
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
700
        
701
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
702
        
703
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
704
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
705
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
706
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
707
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
708
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
709
        
710
        if(s->avctx->noise_reduction){
711
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
712
        }
713
    }
714
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
715

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

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

    
764
    /* which mb is a intra block */
765
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
766
    memset(s->mbintra_table, 1, mb_array_size);
767
    
768
    /* init macroblock skip table */
769
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
770
    //Note the +1 is for a quicker mpeg4 slice_end detection
771
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
772
    
773
    s->parse_context.state= -1;
774
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
775
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
776
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
778
    }
779

    
780
    s->context_initialized = 1;
781

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

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

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

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

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

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

    
816
    av_freep(&s->mb_type);
817
    av_freep(&s->p_mv_table_base);
818
    av_freep(&s->b_forw_mv_table_base);
819
    av_freep(&s->b_back_mv_table_base);
820
    av_freep(&s->b_bidir_forw_mv_table_base);
821
    av_freep(&s->b_bidir_back_mv_table_base);
822
    av_freep(&s->b_direct_mv_table_base);
823
    s->p_mv_table= NULL;
824
    s->b_forw_mv_table= NULL;
825
    s->b_back_mv_table= NULL;
826
    s->b_bidir_forw_mv_table= NULL;
827
    s->b_bidir_back_mv_table= NULL;
828
    s->b_direct_mv_table= NULL;
829
    for(i=0; i<2; i++){
830
        for(j=0; j<2; j++){
831
            for(k=0; k<2; k++){
832
                av_freep(&s->b_field_mv_table_base[i][j][k]);
833
                s->b_field_mv_table[i][j][k]=NULL;
834
            }
835
            av_freep(&s->b_field_select_table[i][j]);
836
            av_freep(&s->p_field_mv_table_base[i][j]);
837
            s->p_field_mv_table[i][j]=NULL;
838
        }
839
        av_freep(&s->p_field_select_table[i]);
840
    }
841
    
842
    av_freep(&s->dc_val_base);
843
    av_freep(&s->ac_val_base);
844
    av_freep(&s->coded_block_base);
845
    av_freep(&s->mbintra_table);
846
    av_freep(&s->cbp_table);
847
    av_freep(&s->pred_dir_table);
848
    
849
    av_freep(&s->mbskip_table);
850
    av_freep(&s->prev_pict_types);
851
    av_freep(&s->bitstream_buffer);
852
    av_freep(&s->avctx->stats_out);
853
    av_freep(&s->ac_stats);
854
    av_freep(&s->error_status_table);
855
    av_freep(&s->mb_index2xy);
856
    av_freep(&s->lambda_table);
857
    av_freep(&s->q_intra_matrix);
858
    av_freep(&s->q_inter_matrix);
859
    av_freep(&s->q_intra_matrix16);
860
    av_freep(&s->q_inter_matrix16);
861
    av_freep(&s->input_picture);
862
    av_freep(&s->reordered_input_picture);
863
    av_freep(&s->dct_offset);
864

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

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

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

    
883
#ifdef CONFIG_ENCODERS
884

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

    
894
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
895

    
896
    s->bit_rate = avctx->bit_rate;
897
    s->width = avctx->width;
898
    s->height = avctx->height;
899
    if(avctx->gop_size > 600){
900
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
901
        avctx->gop_size=600;
902
    }
903
    s->gop_size = avctx->gop_size;
904
    s->avctx = avctx;
905
    s->flags= avctx->flags;
906
    s->flags2= avctx->flags2;
907
    s->max_b_frames= avctx->max_b_frames;
908
    s->codec_id= avctx->codec->id;
909
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
910
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
911
    s->strict_std_compliance= avctx->strict_std_compliance;
912
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
913
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
914
    s->mpeg_quant= avctx->mpeg_quant;
915
    s->rtp_mode= !!avctx->rtp_payload_size;
916
    s->intra_dc_precision= avctx->intra_dc_precision;
917
    s->user_specified_pts = AV_NOPTS_VALUE;
918

    
919
    if (s->gop_size <= 1) {
920
        s->intra_only = 1;
921
        s->gop_size = 12;
922
    } else {
923
        s->intra_only = 0;
924
    }
925

    
926
    s->me_method = avctx->me_method;
927

    
928
    /* Fixed QSCALE */
929
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
930
    
931
    s->adaptive_quant= (   s->avctx->lumi_masking
932
                        || s->avctx->dark_masking
933
                        || s->avctx->temporal_cplx_masking 
934
                        || s->avctx->spatial_cplx_masking
935
                        || s->avctx->p_masking
936
                        || (s->flags&CODEC_FLAG_QP_RD))
937
                       && !s->fixed_qscale;
938
    
939
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
940
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
941
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
942

    
943
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
944
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
945
        return -1;
946
    }    
947

    
948
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
949
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
950
    }
951
    
952
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
953
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
954
        return -1;
955
    }
956
    
957
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
958
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
959
        return -1;
960
    }
961
        
962
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
963
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
964
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
965
        
966
        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");
967
    }
968
       
969
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
970
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
971
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
972
        return -1;
973
    }
974
        
975
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
976
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
977
        return -1;
978
    }
979
    
980
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
981
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
982
        return -1;
983
    }
984
    
985
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
986
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
987
        return -1;
988
    }
989

    
990
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
991
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
992
        return -1;
993
    }
994
    
995
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
996
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
997
        return -1;
998
    }
999

    
1000
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
1001
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1002
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1003
        return -1;
1004
    }
1005
        
1006
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1007
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1008
        return -1;
1009
    }
1010
        
1011
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1012
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1013
        return -1;
1014
    }
1015

    
1016
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1017
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1018
        return -1;
1019
    }
1020
    
1021
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1022
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1023
        return -1;
1024
    }
1025
    
1026
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
1027
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
1028
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1029
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1030
        return -1;
1031
    }
1032
    
1033
    if(s->avctx->thread_count > 1)
1034
        s->rtp_mode= 1;
1035

    
1036
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1037
    if(i > 1){
1038
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1039
        avctx->frame_rate /= i;
1040
        avctx->frame_rate_base /= i;
1041
//        return -1;
1042
    }
1043
    
1044
    if(s->codec_id==CODEC_ID_MJPEG){
1045
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1046
        s->inter_quant_bias= 0;
1047
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1048
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1049
        s->inter_quant_bias= 0;
1050
    }else{
1051
        s->intra_quant_bias=0;
1052
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1053
    }
1054
    
1055
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1056
        s->intra_quant_bias= avctx->intra_quant_bias;
1057
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1058
        s->inter_quant_bias= avctx->inter_quant_bias;
1059
        
1060
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1061

    
1062
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1063
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1064

    
1065
    switch(avctx->codec->id) {
1066
    case CODEC_ID_MPEG1VIDEO:
1067
        s->out_format = FMT_MPEG1;
1068
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1069
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1070
        break;
1071
    case CODEC_ID_MPEG2VIDEO:
1072
        s->out_format = FMT_MPEG1;
1073
        s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1074
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1075
        s->rtp_mode= 1;
1076
        break;
1077
    case CODEC_ID_LJPEG:
1078
    case CODEC_ID_MJPEG:
1079
        s->out_format = FMT_MJPEG;
1080
        s->intra_only = 1; /* force intra only for jpeg */
1081
        s->mjpeg_write_tables = 1; /* write all tables */
1082
        s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1083
        s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1084
        s->mjpeg_vsample[1] = 1;
1085
        s->mjpeg_vsample[2] = 1; 
1086
        s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1087
        s->mjpeg_hsample[1] = 1; 
1088
        s->mjpeg_hsample[2] = 1; 
1089
        if (mjpeg_init(s) < 0)
1090
            return -1;
1091
        avctx->delay=0;
1092
        s->low_delay=1;
1093
        break;
1094
#ifdef CONFIG_RISKY
1095
    case CODEC_ID_H261:
1096
        s->out_format = FMT_H261;
1097
        avctx->delay=0;
1098
        s->low_delay=1;
1099
        break;
1100
    case CODEC_ID_H263:
1101
        if (h263_get_picture_format(s->width, s->height) == 7) {
1102
            av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1103
            return -1;
1104
        }
1105
        s->out_format = FMT_H263;
1106
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1107
        avctx->delay=0;
1108
        s->low_delay=1;
1109
        break;
1110
    case CODEC_ID_H263P:
1111
        s->out_format = FMT_H263;
1112
        s->h263_plus = 1;
1113
        /* Fx */
1114
        s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1115
        s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1116
        s->modified_quant= s->h263_aic;
1117
        s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1118
        s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1119
        s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1120
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1121
        s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1122

    
1123
        /* /Fx */
1124
        /* These are just to be sure */
1125
        avctx->delay=0;
1126
        s->low_delay=1;
1127
        break;
1128
    case CODEC_ID_FLV1:
1129
        s->out_format = FMT_H263;
1130
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1131
        s->unrestricted_mv = 1;
1132
        s->rtp_mode=0; /* don't allow GOB */
1133
        avctx->delay=0;
1134
        s->low_delay=1;
1135
        break;
1136
    case CODEC_ID_RV10:
1137
        s->out_format = FMT_H263;
1138
        avctx->delay=0;
1139
        s->low_delay=1;
1140
        break;
1141
    case CODEC_ID_RV20:
1142
        s->out_format = FMT_H263;
1143
        avctx->delay=0;
1144
        s->low_delay=1;
1145
        s->modified_quant=1;
1146
        s->h263_aic=1;
1147
        s->h263_plus=1;
1148
        s->loop_filter=1;
1149
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1150
        break;
1151
    case CODEC_ID_MPEG4:
1152
        s->out_format = FMT_H263;
1153
        s->h263_pred = 1;
1154
        s->unrestricted_mv = 1;
1155
        s->low_delay= s->max_b_frames ? 0 : 1;
1156
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1157
        break;
1158
    case CODEC_ID_MSMPEG4V1:
1159
        s->out_format = FMT_H263;
1160
        s->h263_msmpeg4 = 1;
1161
        s->h263_pred = 1;
1162
        s->unrestricted_mv = 1;
1163
        s->msmpeg4_version= 1;
1164
        avctx->delay=0;
1165
        s->low_delay=1;
1166
        break;
1167
    case CODEC_ID_MSMPEG4V2:
1168
        s->out_format = FMT_H263;
1169
        s->h263_msmpeg4 = 1;
1170
        s->h263_pred = 1;
1171
        s->unrestricted_mv = 1;
1172
        s->msmpeg4_version= 2;
1173
        avctx->delay=0;
1174
        s->low_delay=1;
1175
        break;
1176
    case CODEC_ID_MSMPEG4V3:
1177
        s->out_format = FMT_H263;
1178
        s->h263_msmpeg4 = 1;
1179
        s->h263_pred = 1;
1180
        s->unrestricted_mv = 1;
1181
        s->msmpeg4_version= 3;
1182
        s->flipflop_rounding=1;
1183
        avctx->delay=0;
1184
        s->low_delay=1;
1185
        break;
1186
    case CODEC_ID_WMV1:
1187
        s->out_format = FMT_H263;
1188
        s->h263_msmpeg4 = 1;
1189
        s->h263_pred = 1;
1190
        s->unrestricted_mv = 1;
1191
        s->msmpeg4_version= 4;
1192
        s->flipflop_rounding=1;
1193
        avctx->delay=0;
1194
        s->low_delay=1;
1195
        break;
1196
    case CODEC_ID_WMV2:
1197
        s->out_format = FMT_H263;
1198
        s->h263_msmpeg4 = 1;
1199
        s->h263_pred = 1;
1200
        s->unrestricted_mv = 1;
1201
        s->msmpeg4_version= 5;
1202
        s->flipflop_rounding=1;
1203
        avctx->delay=0;
1204
        s->low_delay=1;
1205
        break;
1206
#endif
1207
    default:
1208
        return -1;
1209
    }
1210
    
1211
    avctx->has_b_frames= !s->low_delay;
1212

    
1213
    s->encoding = 1;
1214

    
1215
    /* init */
1216
    if (MPV_common_init(s) < 0)
1217
        return -1;
1218

    
1219
    if(s->modified_quant)
1220
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1221
    s->progressive_frame= 
1222
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1223
    s->quant_precision=5;
1224
    
1225
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1226
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1227
    
1228
#ifdef CONFIG_ENCODERS
1229
#ifdef CONFIG_RISKY
1230
    if (s->out_format == FMT_H261)
1231
        ff_h261_encode_init(s);
1232
    if (s->out_format == FMT_H263)
1233
        h263_encode_init(s);
1234
    if(s->msmpeg4_version)
1235
        ff_msmpeg4_encode_init(s);
1236
#endif
1237
    if (s->out_format == FMT_MPEG1)
1238
        ff_mpeg1_encode_init(s);
1239
#endif
1240

    
1241
    /* init q matrix */
1242
    for(i=0;i<64;i++) {
1243
        int j= s->dsp.idct_permutation[i];
1244
#ifdef CONFIG_RISKY
1245
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1246
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1247
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1248
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1249
            s->intra_matrix[j] =
1250
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1251
        }else
1252
#endif
1253
        { /* mpeg1/2 */
1254
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1255
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1256
        }
1257
        if(s->avctx->intra_matrix)
1258
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1259
        if(s->avctx->inter_matrix)
1260
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1261
    }
1262

    
1263
    /* precompute matrix */
1264
    /* for mjpeg, we do include qscale in the matrix */
1265
    if (s->out_format != FMT_MJPEG) {
1266
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1267
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1268
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1269
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1270
    }
1271

    
1272
    if(ff_rate_control_init(s) < 0)
1273
        return -1;
1274
    
1275
    return 0;
1276
}
1277

    
1278
int MPV_encode_end(AVCodecContext *avctx)
1279
{
1280
    MpegEncContext *s = avctx->priv_data;
1281

    
1282
#ifdef STATS
1283
    print_stats();
1284
#endif
1285

    
1286
    ff_rate_control_uninit(s);
1287

    
1288
    MPV_common_end(s);
1289
    if (s->out_format == FMT_MJPEG)
1290
        mjpeg_close(s);
1291

    
1292
    av_freep(&avctx->extradata);
1293
      
1294
    return 0;
1295
}
1296

    
1297
#endif //CONFIG_ENCODERS
1298

    
1299
void init_rl(RLTable *rl, int use_static)
1300
{
1301
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1302
    uint8_t index_run[MAX_RUN+1];
1303
    int last, run, level, start, end, i;
1304

    
1305
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1306
    if(use_static && rl->max_level[0])
1307
        return;
1308

    
1309
    /* compute max_level[], max_run[] and index_run[] */
1310
    for(last=0;last<2;last++) {
1311
        if (last == 0) {
1312
            start = 0;
1313
            end = rl->last;
1314
        } else {
1315
            start = rl->last;
1316
            end = rl->n;
1317
        }
1318

    
1319
        memset(max_level, 0, MAX_RUN + 1);
1320
        memset(max_run, 0, MAX_LEVEL + 1);
1321
        memset(index_run, rl->n, MAX_RUN + 1);
1322
        for(i=start;i<end;i++) {
1323
            run = rl->table_run[i];
1324
            level = rl->table_level[i];
1325
            if (index_run[run] == rl->n)
1326
                index_run[run] = i;
1327
            if (level > max_level[run])
1328
                max_level[run] = level;
1329
            if (run > max_run[level])
1330
                max_run[level] = run;
1331
        }
1332
        if(use_static)
1333
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1334
        else
1335
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1336
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1337
        if(use_static)
1338
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1339
        else
1340
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1341
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1342
        if(use_static)
1343
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1344
        else
1345
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1346
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1347
    }
1348
}
1349

    
1350
/* draw the edges of width 'w' of an image of size width, height */
1351
//FIXME check that this is ok for mpeg4 interlaced
1352
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1353
{
1354
    uint8_t *ptr, *last_line;
1355
    int i;
1356

    
1357
    last_line = buf + (height - 1) * wrap;
1358
    for(i=0;i<w;i++) {
1359
        /* top and bottom */
1360
        memcpy(buf - (i + 1) * wrap, buf, width);
1361
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1362
    }
1363
    /* left and right */
1364
    ptr = buf;
1365
    for(i=0;i<height;i++) {
1366
        memset(ptr - w, ptr[0], w);
1367
        memset(ptr + width, ptr[width-1], w);
1368
        ptr += wrap;
1369
    }
1370
    /* corners */
1371
    for(i=0;i<w;i++) {
1372
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1373
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1374
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1375
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1376
    }
1377
}
1378

    
1379
int ff_find_unused_picture(MpegEncContext *s, int shared){
1380
    int i;
1381
    
1382
    if(shared){
1383
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1384
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1385
        }
1386
    }else{
1387
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1388
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1389
        }
1390
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1391
            if(s->picture[i].data[0]==NULL) return i;
1392
        }
1393
    }
1394

    
1395
    assert(0);
1396
    return -1;
1397
}
1398

    
1399
static void update_noise_reduction(MpegEncContext *s){
1400
    int intra, i;
1401

    
1402
    for(intra=0; intra<2; intra++){
1403
        if(s->dct_count[intra] > (1<<16)){
1404
            for(i=0; i<64; i++){
1405
                s->dct_error_sum[intra][i] >>=1;
1406
            }
1407
            s->dct_count[intra] >>= 1;
1408
        }
1409
        
1410
        for(i=0; i<64; i++){
1411
            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);
1412
        }
1413
    }
1414
}
1415

    
1416
/**
1417
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1418
 */
1419
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1420
{
1421
    int i;
1422
    AVFrame *pic;
1423
    s->mb_skiped = 0;
1424

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

    
1427
    /* mark&release old frames */
1428
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1429
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1430

    
1431
        /* release forgotten pictures */
1432
        /* if(mpeg124/h263) */
1433
        if(!s->encoding){
1434
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1435
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1436
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1437
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1438
                }
1439
            }
1440
        }
1441
    }
1442
alloc:
1443
    if(!s->encoding){
1444
        /* release non refernce frames */
1445
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1446
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1447
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1448
            }
1449
        }
1450

    
1451
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1452
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1453
        else{
1454
            i= ff_find_unused_picture(s, 0);
1455
            pic= (AVFrame*)&s->picture[i];
1456
        }
1457

    
1458
        pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1459

    
1460
        pic->coded_picture_number= s->coded_picture_number++;
1461
        
1462
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1463
            return -1;
1464

    
1465
        s->current_picture_ptr= (Picture*)pic;
1466
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1467
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1468
    }
1469

    
1470
    s->current_picture_ptr->pict_type= s->pict_type;
1471
//    if(s->flags && CODEC_FLAG_QSCALE) 
1472
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1473
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1474

    
1475
    copy_picture(&s->current_picture, s->current_picture_ptr);
1476
  
1477
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1478
    if (s->pict_type != B_TYPE) {
1479
        s->last_picture_ptr= s->next_picture_ptr;
1480
        if(!s->dropable)
1481
            s->next_picture_ptr= s->current_picture_ptr;
1482
    }
1483
/*    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,
1484
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1485
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1486
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1487
        s->pict_type, s->dropable);*/
1488
    
1489
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1490
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1491
    
1492
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1493
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1494
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1495
        goto alloc;
1496
    }
1497

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

    
1500
    if(s->picture_structure!=PICT_FRAME){
1501
        int i;
1502
        for(i=0; i<4; i++){
1503
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1504
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1505
            } 
1506
            s->current_picture.linesize[i] *= 2;
1507
            s->last_picture.linesize[i] *=2;
1508
            s->next_picture.linesize[i] *=2;
1509
        }
1510
    }
1511
  }
1512
   
1513
    s->hurry_up= s->avctx->hurry_up;
1514
    s->error_resilience= avctx->error_resilience;
1515

    
1516
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1517
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1518
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1519
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1520
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1521
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1522
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1523
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1524
    }else{
1525
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1526
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1527
    }
1528

    
1529
    if(s->dct_error_sum){
1530
        assert(s->avctx->noise_reduction && s->encoding);
1531

    
1532
        update_noise_reduction(s);
1533
    }
1534
        
1535
#ifdef HAVE_XVMC
1536
    if(s->avctx->xvmc_acceleration)
1537
        return XVMC_field_start(s, avctx);
1538
#endif
1539
    return 0;
1540
}
1541

    
1542
/* generic function for encode/decode called after a frame has been coded/decoded */
1543
void MPV_frame_end(MpegEncContext *s)
1544
{
1545
    int i;
1546
    /* draw edge for correct motion prediction if outside */
1547
#ifdef HAVE_XVMC
1548
//just to make sure that all data is rendered.
1549
    if(s->avctx->xvmc_acceleration){
1550
        XVMC_field_end(s);
1551
    }else
1552
#endif
1553
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1554
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1555
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1556
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1557
    }
1558
    emms_c();
1559
    
1560
    s->last_pict_type    = s->pict_type;
1561
    if(s->pict_type!=B_TYPE){
1562
        s->last_non_b_pict_type= s->pict_type;
1563
    }
1564
#if 0
1565
        /* copy back current_picture variables */
1566
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1567
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1568
            s->picture[i]= s->current_picture;
1569
            break;
1570
        }    
1571
    }
1572
    assert(i<MAX_PICTURE_COUNT);
1573
#endif    
1574

    
1575
    if(s->encoding){
1576
        /* release non refernce frames */
1577
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1578
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1579
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1580
            }
1581
        }
1582
    }
1583
    // clear copies, to avoid confusion
1584
#if 0
1585
    memset(&s->last_picture, 0, sizeof(Picture));
1586
    memset(&s->next_picture, 0, sizeof(Picture));
1587
    memset(&s->current_picture, 0, sizeof(Picture));
1588
#endif
1589
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1590
}
1591

    
1592
/**
1593
 * draws an line from (ex, ey) -> (sx, sy).
1594
 * @param w width of the image
1595
 * @param h height of the image
1596
 * @param stride stride/linesize of the image
1597
 * @param color color of the arrow
1598
 */
1599
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1600
    int t, x, y, fr, f;
1601
    
1602
    sx= clip(sx, 0, w-1);
1603
    sy= clip(sy, 0, h-1);
1604
    ex= clip(ex, 0, w-1);
1605
    ey= clip(ey, 0, h-1);
1606
    
1607
    buf[sy*stride + sx]+= color;
1608
    
1609
    if(ABS(ex - sx) > ABS(ey - sy)){
1610
        if(sx > ex){
1611
            t=sx; sx=ex; ex=t;
1612
            t=sy; sy=ey; ey=t;
1613
        }
1614
        buf+= sx + sy*stride;
1615
        ex-= sx;
1616
        f= ((ey-sy)<<16)/ex;
1617
        for(x= 0; x <= ex; x++){
1618
            y = (x*f)>>16;
1619
            fr= (x*f)&0xFFFF;
1620
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1621
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1622
        }
1623
    }else{
1624
        if(sy > ey){
1625
            t=sx; sx=ex; ex=t;
1626
            t=sy; sy=ey; ey=t;
1627
        }
1628
        buf+= sx + sy*stride;
1629
        ey-= sy;
1630
        if(ey) f= ((ex-sx)<<16)/ey;
1631
        else   f= 0;
1632
        for(y= 0; y <= ey; y++){
1633
            x = (y*f)>>16;
1634
            fr= (y*f)&0xFFFF;
1635
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1636
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1637
        }
1638
    }
1639
}
1640

    
1641
/**
1642
 * draws an arrow from (ex, ey) -> (sx, sy).
1643
 * @param w width of the image
1644
 * @param h height of the image
1645
 * @param stride stride/linesize of the image
1646
 * @param color color of the arrow
1647
 */
1648
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1649
    int dx,dy;
1650

    
1651
    sx= clip(sx, -100, w+100);
1652
    sy= clip(sy, -100, h+100);
1653
    ex= clip(ex, -100, w+100);
1654
    ey= clip(ey, -100, h+100);
1655
    
1656
    dx= ex - sx;
1657
    dy= ey - sy;
1658
    
1659
    if(dx*dx + dy*dy > 3*3){
1660
        int rx=  dx + dy;
1661
        int ry= -dx + dy;
1662
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1663
        
1664
        //FIXME subpixel accuracy
1665
        rx= ROUNDED_DIV(rx*3<<4, length);
1666
        ry= ROUNDED_DIV(ry*3<<4, length);
1667
        
1668
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1669
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1670
    }
1671
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1672
}
1673

    
1674
/**
1675
 * prints debuging info for the given picture.
1676
 */
1677
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1678

    
1679
    if(!pict || !pict->mb_type) return;
1680

    
1681
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1682
        int x,y;
1683
        
1684
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1685
        switch (pict->pict_type) {
1686
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1687
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1688
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1689
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1690
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1691
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1692
        }
1693
        for(y=0; y<s->mb_height; y++){
1694
            for(x=0; x<s->mb_width; x++){
1695
                if(s->avctx->debug&FF_DEBUG_SKIP){
1696
                    int count= s->mbskip_table[x + y*s->mb_stride];
1697
                    if(count>9) count=9;
1698
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1699
                }
1700
                if(s->avctx->debug&FF_DEBUG_QP){
1701
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1702
                }
1703
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1704
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1705
                    //Type & MV direction
1706
                    if(IS_PCM(mb_type))
1707
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1708
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1709
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1710
                    else if(IS_INTRA4x4(mb_type))
1711
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1712
                    else if(IS_INTRA16x16(mb_type))
1713
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1714
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1715
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1716
                    else if(IS_DIRECT(mb_type))
1717
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1718
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1719
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1720
                    else if(IS_GMC(mb_type))
1721
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1722
                    else if(IS_SKIP(mb_type))
1723
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1724
                    else if(!USES_LIST(mb_type, 1))
1725
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1726
                    else if(!USES_LIST(mb_type, 0))
1727
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1728
                    else{
1729
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1730
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1731
                    }
1732
                    
1733
                    //segmentation
1734
                    if(IS_8X8(mb_type))
1735
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1736
                    else if(IS_16X8(mb_type))
1737
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1738
                    else if(IS_8X16(mb_type))
1739
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1740
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1741
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1742
                    else
1743
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1744
                    
1745
                        
1746
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1747
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1748
                    else
1749
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1750
                }
1751
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1752
            }
1753
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1754
        }
1755
    }
1756

    
1757
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1758
        const int shift= 1 + s->quarter_sample;
1759
        int mb_y;
1760
        uint8_t *ptr;
1761
        int i;
1762
        int h_chroma_shift, v_chroma_shift;
1763
        const int width = s->avctx->width;
1764
        const int height= s->avctx->height;
1765
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1766
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1767
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1768

    
1769
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1770
        for(i=0; i<3; i++){
1771
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1772
            pict->data[i]= s->visualization_buffer[i];
1773
        }
1774
        pict->type= FF_BUFFER_TYPE_COPY;
1775
        ptr= pict->data[0];
1776

    
1777
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1778
            int mb_x;
1779
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1780
                const int mb_index= mb_x + mb_y*s->mb_stride;
1781
                if((s->avctx->debug_mv) && pict->motion_val){
1782
                  int type;
1783
                  for(type=0; type<3; type++){
1784
                    int direction = 0;
1785
                    switch (type) {
1786
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1787
                                continue;
1788
                              direction = 0;
1789
                              break;
1790
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1791
                                continue;
1792
                              direction = 0;
1793
                              break;
1794
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1795
                                continue;
1796
                              direction = 1;
1797
                              break;
1798
                    }
1799
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1800
                        continue;
1801

    
1802
                    if(IS_8X8(pict->mb_type[mb_index])){
1803
                      int i;
1804
                      for(i=0; i<4; i++){
1805
                        int sx= mb_x*16 + 4 + 8*(i&1);
1806
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1807
                        int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << mv_sample_log2-1;
1808
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1809
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1810
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1811
                      }
1812
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1813
                      int i;
1814
                      for(i=0; i<2; i++){
1815
                        int sx=mb_x*16 + 8;
1816
                        int sy=mb_y*16 + 4 + 8*i;
1817
                        int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << mv_sample_log2-1;
1818
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1819
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1820
                        
1821
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1822
                            my*=2;
1823
                        
1824
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1825
                      }
1826
                    }else if(IS_8X16(pict->mb_type[mb_index])){
1827
                      int i;
1828
                      for(i=0; i<2; i++){
1829
                        int sx=mb_x*16 + 4 + 8*i;
1830
                        int sy=mb_y*16 + 8;
1831
                        int xy= (mb_x*2 + i + mb_y*2*mv_stride) << mv_sample_log2-1;
1832
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1833
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1834
                        
1835
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1836
                            my*=2;
1837
                        
1838
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1839
                      }
1840
                    }else{
1841
                      int sx= mb_x*16 + 8;
1842
                      int sy= mb_y*16 + 8;
1843
                      int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1844
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1845
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1846
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1847
                    }
1848
                  }                  
1849
                }
1850
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1851
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1852
                    int y;
1853
                    for(y=0; y<8; y++){
1854
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1855
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1856
                    }
1857
                }
1858
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1859
                    int mb_type= pict->mb_type[mb_index];
1860
                    uint64_t u,v;
1861
                    int y;
1862
#define COLOR(theta, r)\
1863
u= (int)(128 + r*cos(theta*3.141592/180));\
1864
v= (int)(128 + r*sin(theta*3.141592/180));
1865

    
1866
                    
1867
                    u=v=128;
1868
                    if(IS_PCM(mb_type)){
1869
                        COLOR(120,48)
1870
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1871
                        COLOR(30,48)
1872
                    }else if(IS_INTRA4x4(mb_type)){
1873
                        COLOR(90,48)
1874
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1875
//                        COLOR(120,48)
1876
                    }else if(IS_DIRECT(mb_type)){
1877
                        COLOR(150,48)
1878
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1879
                        COLOR(170,48)
1880
                    }else if(IS_GMC(mb_type)){
1881
                        COLOR(190,48)
1882
                    }else if(IS_SKIP(mb_type)){
1883
//                        COLOR(180,48)
1884
                    }else if(!USES_LIST(mb_type, 1)){
1885
                        COLOR(240,48)
1886
                    }else if(!USES_LIST(mb_type, 0)){
1887
                        COLOR(0,48)
1888
                    }else{
1889
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1890
                        COLOR(300,48)
1891
                    }
1892

    
1893
                    u*= 0x0101010101010101ULL;
1894
                    v*= 0x0101010101010101ULL;
1895
                    for(y=0; y<8; y++){
1896
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1897
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1898
                    }
1899

    
1900
                    //segmentation
1901
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1902
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1903
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1904
                    }
1905
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1906
                        for(y=0; y<16; y++)
1907
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1908
                    }
1909
                        
1910
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1911
                        // hmm
1912
                    }
1913
                }
1914
                s->mbskip_table[mb_index]=0;
1915
            }
1916
        }
1917
    }
1918
}
1919

    
1920
#ifdef CONFIG_ENCODERS
1921

    
1922
static int get_sae(uint8_t *src, int ref, int stride){
1923
    int x,y;
1924
    int acc=0;
1925
    
1926
    for(y=0; y<16; y++){
1927
        for(x=0; x<16; x++){
1928
            acc+= ABS(src[x+y*stride] - ref);
1929
        }
1930
    }
1931
    
1932
    return acc;
1933
}
1934

    
1935
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1936
    int x, y, w, h;
1937
    int acc=0;
1938
    
1939
    w= s->width &~15;
1940
    h= s->height&~15;
1941
    
1942
    for(y=0; y<h; y+=16){
1943
        for(x=0; x<w; x+=16){
1944
            int offset= x + y*stride;
1945
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1946
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1947
            int sae = get_sae(src + offset, mean, stride);
1948
            
1949
            acc+= sae + 500 < sad;
1950
        }
1951
    }
1952
    return acc;
1953
}
1954

    
1955

    
1956
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1957
    AVFrame *pic=NULL;
1958
    int i;
1959
    const int encoding_delay= s->max_b_frames;
1960
    int direct=1;
1961
    
1962
  if(pic_arg){
1963
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1964
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1965
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1966
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1967
  
1968
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1969
    
1970
    if(direct){
1971
        i= ff_find_unused_picture(s, 1);
1972

    
1973
        pic= (AVFrame*)&s->picture[i];
1974
        pic->reference= 3;
1975
    
1976
        for(i=0; i<4; i++){
1977
            pic->data[i]= pic_arg->data[i];
1978
            pic->linesize[i]= pic_arg->linesize[i];
1979
        }
1980
        alloc_picture(s, (Picture*)pic, 1);
1981
    }else{
1982
        int offset= 16;
1983
        i= ff_find_unused_picture(s, 0);
1984

    
1985
        pic= (AVFrame*)&s->picture[i];
1986
        pic->reference= 3;
1987

    
1988
        alloc_picture(s, (Picture*)pic, 0);
1989

    
1990
        if(   pic->data[0] + offset == pic_arg->data[0] 
1991
           && pic->data[1] + offset == pic_arg->data[1]
1992
           && pic->data[2] + offset == pic_arg->data[2]){
1993
       // empty
1994
        }else{
1995
            int h_chroma_shift, v_chroma_shift;
1996
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1997
        
1998
            for(i=0; i<3; i++){
1999
                int src_stride= pic_arg->linesize[i];
2000
                int dst_stride= i ? s->uvlinesize : s->linesize;
2001
                int h_shift= i ? h_chroma_shift : 0;
2002
                int v_shift= i ? v_chroma_shift : 0;
2003
                int w= s->width >>h_shift;
2004
                int h= s->height>>v_shift;
2005
                uint8_t *src= pic_arg->data[i];
2006
                uint8_t *dst= pic->data[i] + offset;
2007
            
2008
                if(src_stride==dst_stride)
2009
                    memcpy(dst, src, src_stride*h);
2010
                else{
2011
                    while(h--){
2012
                        memcpy(dst, src, w);
2013
                        dst += dst_stride;
2014
                        src += src_stride;
2015
                    }
2016
                }
2017
            }
2018
        }
2019
    }
2020
    copy_picture_attributes(s, pic, pic_arg);
2021
    
2022
    pic->display_picture_number= s->input_picture_number++;
2023
 
2024
    if(pic->pts != AV_NOPTS_VALUE){ 
2025
        if(s->user_specified_pts != AV_NOPTS_VALUE){
2026
            int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2027
            int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2028
        
2029
            if(time <= last){            
2030
                av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
2031
                return -1;
2032
            }
2033
        }
2034
        s->user_specified_pts= pic->pts;
2035
    }else{
2036
        if(s->user_specified_pts != AV_NOPTS_VALUE){
2037
            s->user_specified_pts= 
2038
            pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2039
            av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
2040
        }else{
2041
            pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2042
        }
2043
    }
2044
  }
2045
  
2046
    /* shift buffer entries */
2047
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2048
        s->input_picture[i-1]= s->input_picture[i];
2049
        
2050
    s->input_picture[encoding_delay]= (Picture*)pic;
2051

    
2052
    return 0;
2053
}
2054

    
2055
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2056
    int x, y, plane;
2057
    int score=0;
2058
    int64_t score64=0;
2059
    int64_t threshold;
2060

    
2061
    for(plane=0; plane<3; plane++){
2062
        const int stride= p->linesize[plane];
2063
        const int bw= plane ? 1 : 2;
2064
        for(y=0; y<s->mb_height*bw; y++){
2065
            for(x=0; x<s->mb_width*bw; x++){
2066
                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);
2067
                
2068
                switch(s->avctx->frame_skip_exp){
2069
                    case 0: score= FFMAX(score, v); break;
2070
                    case 1: score+= ABS(v);break;
2071
                    case 2: score+= v*v;break;
2072
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2073
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2074
                }
2075
            }
2076
        }
2077
    }
2078
    
2079
    if(score) score64= score;
2080

    
2081
    if(score64 < s->avctx->frame_skip_threshold)
2082
        return 1;
2083
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2084
        return 1;
2085
    return 0;
2086
}
2087

    
2088
static void select_input_picture(MpegEncContext *s){
2089
    int i;
2090

    
2091
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2092
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2093
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2094

    
2095
    /* set next picture types & ordering */
2096
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2097
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2098
            s->reordered_input_picture[0]= s->input_picture[0];
2099
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2100
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2101
        }else{
2102
            int b_frames;
2103

    
2104
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2105
                if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2106
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2107
                
2108
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2109
                        for(i=0; i<4; i++)
2110
                            s->input_picture[0]->data[i]= NULL;
2111
                        s->input_picture[0]->type= 0;            
2112
                    }else{
2113
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2114
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2115
            
2116
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2117
                    }
2118

    
2119
                    goto no_output_pic;
2120
                }
2121
            }
2122

    
2123
            if(s->flags&CODEC_FLAG_PASS2){
2124
                for(i=0; i<s->max_b_frames+1; i++){
2125
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2126

    
2127
                    if(pict_num >= s->rc_context.num_entries) 
2128
                        break;
2129
                    if(!s->input_picture[i]){
2130
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2131
                        break;
2132
                    }
2133

    
2134
                    s->input_picture[i]->pict_type= 
2135
                        s->rc_context.entry[pict_num].new_pict_type;
2136
                }
2137
            }
2138

    
2139
            if(s->avctx->b_frame_strategy==0){
2140
                b_frames= s->max_b_frames;
2141
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2142
            }else if(s->avctx->b_frame_strategy==1){
2143
                for(i=1; i<s->max_b_frames+1; i++){
2144
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2145
                        s->input_picture[i]->b_frame_score= 
2146
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2147
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2148
                    }
2149
                }
2150
                for(i=0; i<s->max_b_frames; i++){
2151
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2152
                }
2153
                                
2154
                b_frames= FFMAX(0, i-1);
2155
                
2156
                /* reset scores */
2157
                for(i=0; i<b_frames+1; i++){
2158
                    s->input_picture[i]->b_frame_score=0;
2159
                }
2160
            }else{
2161
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2162
                b_frames=0;
2163
            }
2164

    
2165
            emms_c();
2166
//static int b_count=0;
2167
//b_count+= b_frames;
2168
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2169

    
2170
            for(i= b_frames - 1; i>=0; i--){
2171
                int type= s->input_picture[i]->pict_type;
2172
                if(type && type != B_TYPE)
2173
                    b_frames= i;
2174
            }
2175
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2176
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2177
            }
2178

    
2179
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2180
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2181
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2182
              }else{
2183
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2184
                    b_frames=0;
2185
                s->input_picture[b_frames]->pict_type= I_TYPE;
2186
              }
2187
            }
2188
            
2189
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2190
               && b_frames
2191
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2192
                b_frames--;
2193

    
2194
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2195
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2196
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2197
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2198
            for(i=0; i<b_frames; i++){
2199
                s->reordered_input_picture[i+1]= s->input_picture[i];
2200
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2201
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2202
            }
2203
        }
2204
    }
2205
no_output_pic:
2206
    if(s->reordered_input_picture[0]){
2207
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2208

    
2209
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2210

    
2211
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2212
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2213
        
2214
            int i= ff_find_unused_picture(s, 0);
2215
            Picture *pic= &s->picture[i];
2216

    
2217
            /* mark us unused / free shared pic */
2218
            for(i=0; i<4; i++)
2219
                s->reordered_input_picture[0]->data[i]= NULL;
2220
            s->reordered_input_picture[0]->type= 0;
2221
            
2222
            pic->reference              = s->reordered_input_picture[0]->reference;
2223
            
2224
            alloc_picture(s, pic, 0);
2225

    
2226
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2227

    
2228
            s->current_picture_ptr= pic;
2229
        }else{
2230
            // input is not a shared pix -> reuse buffer for current_pix
2231

    
2232
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2233
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2234
            
2235
            s->current_picture_ptr= s->reordered_input_picture[0];
2236
            for(i=0; i<4; i++){
2237
                s->new_picture.data[i]+=16;
2238
            }
2239
        }
2240
        copy_picture(&s->current_picture, s->current_picture_ptr);
2241
    
2242
        s->picture_number= s->new_picture.display_picture_number;
2243
//printf("dpn:%d\n", s->picture_number);
2244
    }else{
2245
       memset(&s->new_picture, 0, sizeof(Picture));
2246
    }
2247
}
2248

    
2249
int MPV_encode_picture(AVCodecContext *avctx,
2250
                       unsigned char *buf, int buf_size, void *data)
2251
{
2252
    MpegEncContext *s = avctx->priv_data;
2253
    AVFrame *pic_arg = data;
2254
    int i, stuffing_count;
2255

    
2256
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2257
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2258
        return -1;
2259
    }
2260
    
2261
    for(i=0; i<avctx->thread_count; i++){
2262
        int start_y= s->thread_context[i]->start_mb_y;
2263
        int   end_y= s->thread_context[i]->  end_mb_y;
2264
        int h= s->mb_height;
2265
        uint8_t *start= buf + buf_size*start_y/h;
2266
        uint8_t *end  = buf + buf_size*  end_y/h;
2267

    
2268
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2269
    }
2270

    
2271
    s->picture_in_gop_number++;
2272

    
2273
    if(load_input_picture(s, pic_arg) < 0)
2274
        return -1;
2275
    
2276
    select_input_picture(s);
2277
    
2278
    /* output? */
2279
    if(s->new_picture.data[0]){
2280
        s->pict_type= s->new_picture.pict_type;
2281
//emms_c();
2282
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2283
        MPV_frame_start(s, avctx);
2284

    
2285
        encode_picture(s, s->picture_number);
2286
        
2287
        avctx->real_pict_num  = s->picture_number;
2288
        avctx->header_bits = s->header_bits;
2289
        avctx->mv_bits     = s->mv_bits;
2290
        avctx->misc_bits   = s->misc_bits;
2291
        avctx->i_tex_bits  = s->i_tex_bits;
2292
        avctx->p_tex_bits  = s->p_tex_bits;
2293
        avctx->i_count     = s->i_count;
2294
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2295
        avctx->skip_count  = s->skip_count;
2296

    
2297
        MPV_frame_end(s);
2298

    
2299
        if (s->out_format == FMT_MJPEG)
2300
            mjpeg_picture_trailer(s);
2301
        
2302
        if(s->flags&CODEC_FLAG_PASS1)
2303
            ff_write_pass1_stats(s);
2304

    
2305
        for(i=0; i<4; i++){
2306
            avctx->error[i] += s->current_picture_ptr->error[i];
2307
        }
2308

    
2309
        flush_put_bits(&s->pb);
2310
        s->frame_bits  = put_bits_count(&s->pb);
2311

    
2312
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2313
        if(stuffing_count){
2314
            switch(s->codec_id){
2315
            case CODEC_ID_MPEG1VIDEO:
2316
            case CODEC_ID_MPEG2VIDEO:
2317
                while(stuffing_count--){
2318
                    put_bits(&s->pb, 8, 0);
2319
                }
2320
            break;
2321
            case CODEC_ID_MPEG4:
2322
                put_bits(&s->pb, 16, 0);
2323
                put_bits(&s->pb, 16, 0x1C3);
2324
                stuffing_count -= 4;
2325
                while(stuffing_count--){
2326
                    put_bits(&s->pb, 8, 0xFF);
2327
                }
2328
            break;
2329
            default:
2330
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2331
            }
2332
            flush_put_bits(&s->pb);
2333
            s->frame_bits  = put_bits_count(&s->pb);
2334
        }
2335

    
2336
        /* update mpeg1/2 vbv_delay for CBR */    
2337
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2338
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2339
            int vbv_delay;
2340

    
2341
            assert(s->repeat_first_field==0);
2342
            
2343
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2344
            assert(vbv_delay < 0xFFFF);
2345

    
2346
            s->vbv_delay_ptr[0] &= 0xF8;
2347
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2348
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2349
            s->vbv_delay_ptr[2] &= 0x07;
2350
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2351
        }
2352
        s->total_bits += s->frame_bits;
2353
        avctx->frame_bits  = s->frame_bits;
2354
    }else{
2355
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2356
        s->frame_bits=0;
2357
    }
2358
    assert((s->frame_bits&7)==0);
2359
    
2360
    return s->frame_bits/8;
2361
}
2362

    
2363
#endif //CONFIG_ENCODERS
2364

    
2365
static inline void gmc1_motion(MpegEncContext *s,
2366
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2367
                               uint8_t **ref_picture)
2368
{
2369
    uint8_t *ptr;
2370
    int offset, src_x, src_y, linesize, uvlinesize;
2371
    int motion_x, motion_y;
2372
    int emu=0;
2373

    
2374
    motion_x= s->sprite_offset[0][0];
2375
    motion_y= s->sprite_offset[0][1];
2376
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2377
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2378
    motion_x<<=(3-s->sprite_warping_accuracy);
2379
    motion_y<<=(3-s->sprite_warping_accuracy);
2380
    src_x = clip(src_x, -16, s->width);
2381
    if (src_x == s->width)
2382
        motion_x =0;
2383
    src_y = clip(src_y, -16, s->height);
2384
    if (src_y == s->height)
2385
        motion_y =0;
2386

    
2387
    linesize = s->linesize;
2388
    uvlinesize = s->uvlinesize;
2389
    
2390
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2391

    
2392
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2393
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2394
           || (unsigned)src_y >= s->v_edge_pos - 17){
2395
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2396
            ptr= s->edge_emu_buffer;
2397
        }
2398
    }
2399
    
2400
    if((motion_x|motion_y)&7){
2401
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2402
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2403
    }else{
2404
        int dxy;
2405
        
2406
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2407
        if (s->no_rounding){
2408
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2409
        }else{
2410
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2411
        }
2412
    }
2413
    
2414
    if(s->flags&CODEC_FLAG_GRAY) return;
2415

    
2416
    motion_x= s->sprite_offset[1][0];
2417
    motion_y= s->sprite_offset[1][1];
2418
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2419
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2420
    motion_x<<=(3-s->sprite_warping_accuracy);
2421
    motion_y<<=(3-s->sprite_warping_accuracy);
2422
    src_x = clip(src_x, -8, s->width>>1);
2423
    if (src_x == s->width>>1)
2424
        motion_x =0;
2425
    src_y = clip(src_y, -8, s->height>>1);
2426
    if (src_y == s->height>>1)
2427
        motion_y =0;
2428

    
2429
    offset = (src_y * uvlinesize) + src_x;
2430
    ptr = ref_picture[1] + offset;
2431
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2432
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2433
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2434
            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);
2435
            ptr= s->edge_emu_buffer;
2436
            emu=1;
2437
        }
2438
    }
2439
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2440
    
2441
    ptr = ref_picture[2] + offset;
2442
    if(emu){
2443
        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);
2444
        ptr= s->edge_emu_buffer;
2445
    }
2446
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2447
    
2448
    return;
2449
}
2450

    
2451
static inline void gmc_motion(MpegEncContext *s,
2452
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2453
                               uint8_t **ref_picture)
2454
{
2455
    uint8_t *ptr;
2456
    int linesize, uvlinesize;
2457
    const int a= s->sprite_warping_accuracy;
2458
    int ox, oy;
2459

    
2460
    linesize = s->linesize;
2461
    uvlinesize = s->uvlinesize;
2462

    
2463
    ptr = ref_picture[0];
2464

    
2465
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2466
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2467

    
2468
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2469
           ox, 
2470
           oy, 
2471
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2472
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2473
           a+1, (1<<(2*a+1)) - s->no_rounding,
2474
           s->h_edge_pos, s->v_edge_pos);
2475
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2476
           ox + s->sprite_delta[0][0]*8, 
2477
           oy + s->sprite_delta[1][0]*8, 
2478
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2479
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2480
           a+1, (1<<(2*a+1)) - s->no_rounding,
2481
           s->h_edge_pos, s->v_edge_pos);
2482

    
2483
    if(s->flags&CODEC_FLAG_GRAY) return;
2484

    
2485
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2486
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2487

    
2488
    ptr = ref_picture[1];
2489
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2490
           ox, 
2491
           oy, 
2492
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2493
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2494
           a+1, (1<<(2*a+1)) - s->no_rounding,
2495
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2496
    
2497
    ptr = ref_picture[2];
2498
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2499
           ox, 
2500
           oy, 
2501
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2502
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2503
           a+1, (1<<(2*a+1)) - s->no_rounding,
2504
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2505
}
2506

    
2507
/**
2508
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2509
 * @param buf destination buffer
2510
 * @param src source buffer
2511
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2512
 * @param block_w width of block
2513
 * @param block_h height of block
2514
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2515
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2516
 * @param w width of the source buffer
2517
 * @param h height of the source buffer
2518
 */
2519
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2520
                                    int src_x, int src_y, int w, int h){
2521
    int x, y;
2522
    int start_y, start_x, end_y, end_x;
2523

    
2524
    if(src_y>= h){
2525
        src+= (h-1-src_y)*linesize;
2526
        src_y=h-1;
2527
    }else if(src_y<=-block_h){
2528
        src+= (1-block_h-src_y)*linesize;
2529
        src_y=1-block_h;
2530
    }
2531
    if(src_x>= w){
2532
        src+= (w-1-src_x);
2533
        src_x=w-1;
2534
    }else if(src_x<=-block_w){
2535
        src+= (1-block_w-src_x);
2536
        src_x=1-block_w;
2537
    }
2538

    
2539
    start_y= FFMAX(0, -src_y);
2540
    start_x= FFMAX(0, -src_x);
2541
    end_y= FFMIN(block_h, h-src_y);
2542
    end_x= FFMIN(block_w, w-src_x);
2543

    
2544
    // copy existing part
2545
    for(y=start_y; y<end_y; y++){
2546
        for(x=start_x; x<end_x; x++){
2547
            buf[x + y*linesize]= src[x + y*linesize];
2548
        }
2549
    }
2550

    
2551
    //top
2552
    for(y=0; y<start_y; y++){
2553
        for(x=start_x; x<end_x; x++){
2554
            buf[x + y*linesize]= buf[x + start_y*linesize];
2555
        }
2556
    }
2557

    
2558
    //bottom
2559
    for(y=end_y; y<block_h; y++){
2560
        for(x=start_x; x<end_x; x++){
2561
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2562
        }
2563
    }
2564
                                    
2565
    for(y=0; y<block_h; y++){
2566
       //left
2567
        for(x=0; x<start_x; x++){
2568
            buf[x + y*linesize]= buf[start_x + y*linesize];
2569
        }
2570
       
2571
       //right
2572
        for(x=end_x; x<block_w; x++){
2573
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2574
        }
2575
    }
2576
}
2577

    
2578
static inline int hpel_motion(MpegEncContext *s, 
2579
                                  uint8_t *dest, uint8_t *src,
2580
                                  int field_based, int field_select,
2581
                                  int src_x, int src_y,
2582
                                  int width, int height, int stride,
2583
                                  int h_edge_pos, int v_edge_pos,
2584
                                  int w, int h, op_pixels_func *pix_op,
2585
                                  int motion_x, int motion_y)
2586
{
2587
    int dxy;
2588
    int emu=0;
2589

    
2590
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2591
    src_x += motion_x >> 1;
2592
    src_y += motion_y >> 1;
2593
                
2594
    /* WARNING: do no forget half pels */
2595
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2596
    if (src_x == width)
2597
        dxy &= ~1;
2598
    src_y = clip(src_y, -16, height);
2599
    if (src_y == height)
2600
        dxy &= ~2;
2601
    src += src_y * stride + src_x;
2602

    
2603
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2604
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2605
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2606
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2607
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2608
            src= s->edge_emu_buffer;
2609
            emu=1;
2610
        }
2611
    }
2612
    if(field_select)
2613
        src += s->linesize;
2614
    pix_op[dxy](dest, src, stride, h);
2615
    return emu;
2616
}
2617

    
2618
static inline int hpel_motion_lowres(MpegEncContext *s, 
2619
                                  uint8_t *dest, uint8_t *src,
2620
                                  int field_based, int field_select,
2621
                                  int src_x, int src_y,
2622
                                  int width, int height, int stride,
2623
                                  int h_edge_pos, int v_edge_pos,
2624
                                  int w, int h, h264_chroma_mc_func *pix_op,
2625
                                  int motion_x, int motion_y)
2626
{
2627
    const int lowres= s->avctx->lowres;
2628
    const int s_mask= (2<<lowres)-1;
2629
    int emu=0;
2630
    int sx, sy;
2631

    
2632
    if(s->quarter_sample){
2633
        motion_x/=2;
2634
        motion_y/=2;
2635
    }
2636

    
2637
    sx= motion_x & s_mask;
2638
    sy= motion_y & s_mask;
2639
    src_x += motion_x >> (lowres+1);
2640
    src_y += motion_y >> (lowres+1);
2641
                
2642
    src += src_y * stride + src_x;
2643

    
2644
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2645
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2646
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2647
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2648
        src= s->edge_emu_buffer;
2649
        emu=1;
2650
    }
2651

    
2652
    sx <<= 2 - lowres;
2653
    sy <<= 2 - lowres;
2654
    if(field_select)
2655
        src += s->linesize;
2656
    pix_op[lowres](dest, src, stride, h, sx, sy);
2657
    return emu;
2658
}
2659

    
2660
/* apply one mpeg motion vector to the three components */
2661
static always_inline void mpeg_motion(MpegEncContext *s,
2662
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2663
                               int field_based, int bottom_field, int field_select,
2664
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2665
                               int motion_x, int motion_y, int h)
2666
{
2667
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2668
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2669
    
2670
#if 0    
2671
if(s->quarter_sample)
2672
{
2673
    motion_x>>=1;
2674
    motion_y>>=1;
2675
}
2676
#endif
2677

    
2678
    v_edge_pos = s->v_edge_pos >> field_based;
2679
    linesize   = s->current_picture.linesize[0] << field_based;
2680
    uvlinesize = s->current_picture.linesize[1] << field_based;
2681

    
2682
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2683
    src_x = s->mb_x* 16               + (motion_x >> 1);
2684
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2685

    
2686
    if (s->out_format == FMT_H263) {
2687
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2688
            mx = (motion_x>>1)|(motion_x&1);
2689
            my = motion_y >>1;
2690
            uvdxy = ((my & 1) << 1) | (mx & 1);
2691
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2692
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2693
        }else{
2694
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2695
            uvsrc_x = src_x>>1;
2696
            uvsrc_y = src_y>>1;
2697
        }
2698
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2699
        mx = motion_x / 4;
2700
        my = motion_y / 4;
2701
        uvdxy = 0;
2702
        uvsrc_x = s->mb_x*8 + mx;
2703
        uvsrc_y = s->mb_y*8 + my;
2704
    } else {
2705
        if(s->chroma_y_shift){
2706
            mx = motion_x / 2;
2707
            my = motion_y / 2;
2708
            uvdxy = ((my & 1) << 1) | (mx & 1);
2709
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2710
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2711
        } else {
2712
            if(s->chroma_x_shift){
2713
            //Chroma422
2714
                mx = motion_x / 2;
2715
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2716
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2717
                uvsrc_y = src_y;
2718
            } else {
2719
            //Chroma444
2720
                uvdxy = dxy;
2721
                uvsrc_x = src_x;
2722
                uvsrc_y = src_y;
2723
            }
2724
        }
2725
    }
2726

    
2727
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2728
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2729
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2730

    
2731
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2732
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2733
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2734
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2735
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2736
                return ;
2737
            }
2738
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2739
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2740
            ptr_y = s->edge_emu_buffer;
2741
            if(!(s->flags&CODEC_FLAG_GRAY)){
2742
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2743
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2744
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2745
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2746
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2747
                ptr_cb= uvbuf;
2748
                ptr_cr= uvbuf+16;
2749
            }
2750
    }
2751

    
2752
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2753
        dest_y += s->linesize;
2754
        dest_cb+= s->uvlinesize;
2755
        dest_cr+= s->uvlinesize;
2756
    }
2757

    
2758
    if(field_select){
2759
        ptr_y += s->linesize;
2760
        ptr_cb+= s->uvlinesize;
2761
        ptr_cr+= s->uvlinesize;
2762
    }
2763

    
2764
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2765
    
2766
    if(!(s->flags&CODEC_FLAG_GRAY)){
2767
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2768
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2769
    }
2770
    if(s->out_format == FMT_H261){
2771
        ff_h261_loop_filter(s);
2772
    }
2773
}
2774

    
2775
/* apply one mpeg motion vector to the three components */
2776
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2777
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2778
                               int field_based, int bottom_field, int field_select,
2779
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2780
                               int motion_x, int motion_y, int h)
2781
{
2782
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2783
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2784
    const int lowres= s->avctx->lowres;
2785
    const int block_s= 8>>lowres;
2786
    const int s_mask= (2<<lowres)-1;
2787
    const int h_edge_pos = s->h_edge_pos >> lowres;
2788
    const int v_edge_pos = s->v_edge_pos >> lowres;
2789
    linesize   = s->current_picture.linesize[0] << field_based;
2790
    uvlinesize = s->current_picture.linesize[1] << field_based;
2791

    
2792
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2793
        motion_x/=2;
2794
        motion_y/=2;
2795
    }
2796
    
2797
    if(field_based){
2798
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2799
    }
2800

    
2801
    sx= motion_x & s_mask;
2802
    sy= motion_y & s_mask;
2803
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2804
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2805
    
2806
    if (s->out_format == FMT_H263) {
2807
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2808
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2809
        uvsrc_x = src_x>>1;
2810
        uvsrc_y = src_y>>1;
2811
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2812
        mx = motion_x / 4;
2813
        my = motion_y / 4;
2814
        uvsx = (2*mx) & s_mask;
2815
        uvsy = (2*my) & s_mask;
2816
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2817
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2818
    } else {
2819
        mx = motion_x / 2;
2820
        my = motion_y / 2;
2821
        uvsx = mx & s_mask;
2822
        uvsy = my & s_mask;
2823
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2824
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2825
    }
2826

    
2827
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2828
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2829
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2830

    
2831
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2832
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2833
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2834
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2835
            ptr_y = s->edge_emu_buffer;
2836
            if(!(s->flags&CODEC_FLAG_GRAY)){
2837
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2838
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2839
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2840
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2841
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2842
                ptr_cb= uvbuf;
2843
                ptr_cr= uvbuf+16;
2844
            }
2845
    }
2846

    
2847
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2848
        dest_y += s->linesize;
2849
        dest_cb+= s->uvlinesize;
2850
        dest_cr+= s->uvlinesize;
2851
    }
2852

    
2853
    if(field_select){
2854
        ptr_y += s->linesize;
2855
        ptr_cb+= s->uvlinesize;
2856
        ptr_cr+= s->uvlinesize;
2857
    }
2858

    
2859
    sx <<= 2 - lowres;
2860
    sy <<= 2 - lowres;
2861
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2862
    
2863
    if(!(s->flags&CODEC_FLAG_GRAY)){
2864
        uvsx <<= 2 - lowres;
2865
        uvsy <<= 2 - lowres;
2866
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2867
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2868
    }
2869
    //FIXME h261 lowres loop filter
2870
}
2871

    
2872
//FIXME move to dsputil, avg variant, 16x16 version
2873
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2874
    int x;
2875
    uint8_t * const top   = src[1];
2876
    uint8_t * const left  = src[2];
2877
    uint8_t * const mid   = src[0];
2878
    uint8_t * const right = src[3];
2879
    uint8_t * const bottom= src[4];
2880
#define OBMC_FILTER(x, t, l, m, r, b)\
2881
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2882
#define OBMC_FILTER4(x, t, l, m, r, b)\
2883
    OBMC_FILTER(x         , t, l, m, r, b);\
2884
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2885
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2886
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2887
    
2888
    x=0;
2889
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2890
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2891
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2892
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2893
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2894
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2895
    x+= stride;
2896
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2897
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2898
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2899
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2900
    x+= stride;
2901
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2902
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2903
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2904
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2905
    x+= 2*stride;
2906
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2907
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2908
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2909
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2910
    x+= 2*stride;
2911
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2912
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2913
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2914
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2915
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2916
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2917
    x+= stride;
2918
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2919
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2920
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2921
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2922
}
2923

    
2924
/* obmc for 1 8x8 luma block */
2925
static inline void obmc_motion(MpegEncContext *s,
2926
                               uint8_t *dest, uint8_t *src,
2927
                               int src_x, int src_y,
2928
                               op_pixels_func *pix_op,
2929
                               int16_t mv[5][2]/* mid top left right bottom*/)
2930
#define MID    0
2931
{
2932
    int i;
2933
    uint8_t *ptr[5];
2934
    
2935
    assert(s->quarter_sample==0);
2936
    
2937
    for(i=0; i<5; i++){
2938
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2939
            ptr[i]= ptr[MID];
2940
        }else{
2941
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2942
            hpel_motion(s, ptr[i], src, 0, 0,
2943
                        src_x, src_y,
2944
                        s->width, s->height, s->linesize,
2945
                        s->h_edge_pos, s->v_edge_pos,
2946
                        8, 8, pix_op,
2947
                        mv[i][0], mv[i][1]);
2948
        }
2949
    }
2950

    
2951
    put_obmc(dest, ptr, s->linesize);                
2952
}
2953

    
2954
static inline void qpel_motion(MpegEncContext *s,
2955
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2956
                               int field_based, int bottom_field, int field_select,
2957
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2958
                               qpel_mc_func (*qpix_op)[16],
2959
                               int motion_x, int motion_y, int h)
2960
{
2961
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2962
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2963

    
2964
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2965
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2966
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2967

    
2968
    v_edge_pos = s->v_edge_pos >> field_based;
2969
    linesize = s->linesize << field_based;
2970
    uvlinesize = s->uvlinesize << field_based;
2971
    
2972
    if(field_based){
2973
        mx= motion_x/2;
2974
        my= motion_y>>1;
2975
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2976
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2977
        mx= (motion_x>>1) + rtab[motion_x&7];
2978
        my= (motion_y>>1) + rtab[motion_y&7];
2979
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2980
        mx= (motion_x>>1)|(motion_x&1);
2981
        my= (motion_y>>1)|(motion_y&1);
2982
    }else{
2983
        mx= motion_x/2;
2984
        my= motion_y/2;
2985
    }
2986
    mx= (mx>>1)|(mx&1);
2987
    my= (my>>1)|(my&1);
2988

    
2989
    uvdxy= (mx&1) | ((my&1)<<1);
2990
    mx>>=1;
2991
    my>>=1;
2992

    
2993
    uvsrc_x = s->mb_x *  8                 + mx;
2994
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2995

    
2996
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2997
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2998
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2999

    
3000
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
3001
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3002
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
3003
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3004
        ptr_y= s->edge_emu_buffer;
3005
        if(!(s->flags&CODEC_FLAG_GRAY)){
3006
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3007
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
3008
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3009
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
3010
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3011
            ptr_cb= uvbuf;
3012
            ptr_cr= uvbuf + 16;
3013
        }
3014
    }
3015

    
3016
    if(!field_based)
3017
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3018
    else{
3019
        if(bottom_field){
3020
            dest_y += s->linesize;
3021
            dest_cb+= s->uvlinesize;
3022
            dest_cr+= s->uvlinesize;
3023
        }
3024

    
3025
        if(field_select){
3026
            ptr_y  += s->linesize;
3027
            ptr_cb += s->uvlinesize;
3028
            ptr_cr += s->uvlinesize;
3029
        }
3030
        //damn interlaced mode
3031
        //FIXME boundary mirroring is not exactly correct here
3032
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3033
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3034
    }
3035
    if(!(s->flags&CODEC_FLAG_GRAY)){
3036
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3037
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3038
    }
3039
}
3040

    
3041
inline int ff_h263_round_chroma(int x){
3042
    if (x >= 0)
3043
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3044
    else {
3045
        x = -x;
3046
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3047
    }
3048
}
3049

    
3050
/**
3051
 * h263 chorma 4mv motion compensation.
3052
 */
3053
static inline void chroma_4mv_motion(MpegEncContext *s,
3054
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3055
                                     uint8_t **ref_picture,
3056
                                     op_pixels_func *pix_op,
3057
                                     int mx, int my){
3058
    int dxy, emu=0, src_x, src_y, offset;
3059
    uint8_t *ptr;
3060
    
3061
    /* In case of 8X8, we construct a single chroma motion vector
3062
       with a special rounding */
3063
    mx= ff_h263_round_chroma(mx);
3064
    my= ff_h263_round_chroma(my);
3065
    
3066
    dxy = ((my & 1) << 1) | (mx & 1);
3067
    mx >>= 1;
3068
    my >>= 1;
3069

    
3070
    src_x = s->mb_x * 8 + mx;
3071
    src_y = s->mb_y * 8 + my;
3072
    src_x = clip(src_x, -8, s->width/2);
3073
    if (src_x == s->width/2)
3074
        dxy &= ~1;
3075
    src_y = clip(src_y, -8, s->height/2);
3076
    if (src_y == s->height/2)
3077
        dxy &= ~2;
3078
    
3079
    offset = (src_y * (s->uvlinesize)) + src_x;
3080
    ptr = ref_picture[1] + offset;
3081
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3082
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3083
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3084
            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);
3085
            ptr= s->edge_emu_buffer;
3086
            emu=1;
3087
        }
3088
    }
3089
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3090

    
3091
    ptr = ref_picture[2] + offset;
3092
    if(emu){
3093
        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);
3094
        ptr= s->edge_emu_buffer;
3095
    }
3096
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3097
}
3098

    
3099
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3100
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3101
                                     uint8_t **ref_picture,
3102
                                     h264_chroma_mc_func *pix_op,
3103
                                     int mx, int my){
3104
    const int lowres= s->avctx->lowres;
3105
    const int block_s= 8>>lowres;
3106
    const int s_mask= (2<<lowres)-1;
3107
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3108
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3109
    int emu=0, src_x, src_y, offset, sx, sy;
3110
    uint8_t *ptr;
3111
    
3112
    if(s->quarter_sample){
3113
        mx/=2;
3114
        my/=2;
3115
    }
3116

    
3117
    /* In case of 8X8, we construct a single chroma motion vector
3118
       with a special rounding */
3119
    mx= ff_h263_round_chroma(mx);
3120
    my= ff_h263_round_chroma(my);
3121
    
3122
    sx= mx & s_mask;
3123
    sy= my & s_mask;
3124
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3125
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3126
    
3127
    offset = src_y * s->uvlinesize + src_x;
3128
    ptr = ref_picture[1] + offset;
3129
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3130
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3131
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3132
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3133
            ptr= s->edge_emu_buffer;
3134
            emu=1;
3135
        }
3136
    }     
3137
    sx <<= 2 - lowres;
3138
    sy <<= 2 - lowres;
3139
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3140
          
3141
    ptr = ref_picture[2] + offset;
3142
    if(emu){
3143
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3144
        ptr= s->edge_emu_buffer;
3145
    }
3146
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3147
}
3148

    
3149
/**
3150
 * motion compesation of a single macroblock
3151
 * @param s context
3152
 * @param dest_y luma destination pointer
3153
 * @param dest_cb chroma cb/u destination pointer
3154
 * @param dest_cr chroma cr/v destination pointer
3155
 * @param dir direction (0->forward, 1->backward)
3156
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3157
 * @param pic_op halfpel motion compensation function (average or put normally)
3158
 * @param pic_op qpel motion compensation function (average or put normally)
3159
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3160
 */
3161
static inline void MPV_motion(MpegEncContext *s, 
3162
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3163
                              int dir, uint8_t **ref_picture, 
3164
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3165
{
3166
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3167
    int mb_x, mb_y, i;
3168
    uint8_t *ptr, *dest;
3169

    
3170
    mb_x = s->mb_x;
3171
    mb_y = s->mb_y;
3172

    
3173
    if(s->obmc && s->pict_type != B_TYPE){
3174
        int16_t mv_cache[4][4][2];
3175
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3176
        const int mot_stride= s->b8_stride;
3177
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3178

    
3179
        assert(!s->mb_skiped);
3180
                
3181
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3182
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3183
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3184

    
3185
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3186
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3187
        }else{
3188
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3189
        }
3190

    
3191
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3192
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3193
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3194
        }else{
3195
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3196
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3197
        }
3198

    
3199
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3200
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3201
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3202
        }else{
3203
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3204
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3205
        }
3206
        
3207
        mx = 0;
3208
        my = 0;
3209
        for(i=0;i<4;i++) {
3210
            const int x= (i&1)+1;
3211
            const int y= (i>>1)+1;
3212
            int16_t mv[5][2]= {
3213
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3214
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3215
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3216
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3217
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3218
            //FIXME cleanup
3219
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3220
                        ref_picture[0],
3221
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3222
                        pix_op[1],
3223
                        mv);
3224

    
3225
            mx += mv[0][0];
3226
            my += mv[0][1];
3227
        }
3228
        if(!(s->flags&CODEC_FLAG_GRAY))
3229
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3230

    
3231
        return;
3232
    }
3233
   
3234
    switch(s->mv_type) {
3235
    case MV_TYPE_16X16:
3236
#ifdef CONFIG_RISKY
3237
        if(s->mcsel){
3238
            if(s->real_sprite_warping_points==1){
3239
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3240
                            ref_picture);
3241
            }else{
3242
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3243
                            ref_picture);
3244
            }
3245
        }else if(s->quarter_sample){
3246
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
3247
                        0, 0, 0,
3248
                        ref_picture, pix_op, qpix_op,
3249
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3250
        }else if(s->mspel){
3251
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3252
                        ref_picture, pix_op,
3253
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3254
        }else
3255
#endif
3256
        {
3257
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3258
                        0, 0, 0,
3259
                        ref_picture, pix_op,
3260
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3261
        }           
3262
        break;
3263
    case MV_TYPE_8X8:
3264
        mx = 0;
3265
        my = 0;
3266
        if(s->quarter_sample){
3267
            for(i=0;i<4;i++) {
3268
                motion_x = s->mv[dir][i][0];
3269
                motion_y = s->mv[dir][i][1];
3270

    
3271
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3272
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3273
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3274
                    
3275
                /* WARNING: do no forget half pels */
3276
                src_x = clip(src_x, -16, s->width);
3277
                if (src_x == s->width)
3278
                    dxy &= ~3;
3279
                src_y = clip(src_y, -16, s->height);
3280
                if (src_y == s->height)
3281
                    dxy &= ~12;
3282
                    
3283
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3284
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3285
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3286
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3287
                        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);
3288
                        ptr= s->edge_emu_buffer;
3289
                    }
3290
                }
3291
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3292
                qpix_op[1][dxy](dest, ptr, s->linesize);
3293

    
3294
                mx += s->mv[dir][i][0]/2;
3295
                my += s->mv[dir][i][1]/2;
3296
            }
3297
        }else{
3298
            for(i=0;i<4;i++) {
3299
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3300
                            ref_picture[0], 0, 0,
3301
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3302
                            s->width, s->height, s->linesize,
3303
                            s->h_edge_pos, s->v_edge_pos,
3304
                            8, 8, pix_op[1],
3305
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3306

    
3307
                mx += s->mv[dir][i][0];
3308
                my += s->mv[dir][i][1];
3309
            }
3310
        }
3311

    
3312
        if(!(s->flags&CODEC_FLAG_GRAY))
3313
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3314
        break;
3315
    case MV_TYPE_FIELD:
3316
        if (s->picture_structure == PICT_FRAME) {
3317
            if(s->quarter_sample){
3318
                for(i=0; i<2; i++){
3319
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3320
                                1, i, s->field_select[dir][i],
3321
                                ref_picture, pix_op, qpix_op,
3322
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3323
                }
3324
            }else{
3325
                /* top field */       
3326
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3327
                            1, 0, s->field_select[dir][0],
3328
                            ref_picture, pix_op,
3329
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3330
                /* bottom field */
3331
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3332
                            1, 1, s->field_select[dir][1],
3333
                            ref_picture, pix_op,
3334
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3335
            }
3336
        } else {
3337
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3338
                ref_picture= s->current_picture_ptr->data;
3339
            } 
3340

    
3341
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3342
                        0, 0, s->field_select[dir][0],
3343
                        ref_picture, pix_op,
3344
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3345
        }
3346
        break;
3347
    case MV_TYPE_16X8:
3348
        for(i=0; i<2; i++){
3349
            uint8_t ** ref2picture;
3350

    
3351
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3352
                ref2picture= ref_picture;
3353
            }else{
3354
                ref2picture= s->current_picture_ptr->data;
3355
            } 
3356

    
3357
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3358
                        0, 0, s->field_select[dir][i],
3359
                        ref2picture, pix_op,
3360
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3361
                
3362
            dest_y += 16*s->linesize;
3363
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3364
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3365
        }        
3366
        break;
3367
    case MV_TYPE_DMV:
3368
        if(s->picture_structure == PICT_FRAME){
3369
            for(i=0; i<2; i++){
3370
                int j;
3371
                for(j=0; j<2; j++){
3372
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3373
                                1, j, j^i,
3374
                                ref_picture, pix_op,
3375
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3376
                }
3377
                pix_op = s->dsp.avg_pixels_tab; 
3378
            }
3379
        }else{
3380
            for(i=0; i<2; i++){
3381
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3382
                            0, 0, s->picture_structure != i+1,
3383
                            ref_picture, pix_op,
3384
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3385

    
3386
                // after put we make avg of the same block
3387
                pix_op=s->dsp.avg_pixels_tab; 
3388

    
3389
                //opposite parity is always in the same frame if this is second field
3390
                if(!s->first_field){
3391
                    ref_picture = s->current_picture_ptr->data;    
3392
                }
3393
            }
3394
        }
3395
    break;
3396
    default: assert(0);
3397
    }
3398
}
3399

    
3400
/**
3401
 * motion compesation of a single macroblock
3402
 * @param s context
3403
 * @param dest_y luma destination pointer
3404
 * @param dest_cb chroma cb/u destination pointer
3405
 * @param dest_cr chroma cr/v destination pointer
3406
 * @param dir direction (0->forward, 1->backward)
3407
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3408
 * @param pic_op halfpel motion compensation function (average or put normally)
3409
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3410
 */
3411
static inline void MPV_motion_lowres(MpegEncContext *s, 
3412
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3413
                              int dir, uint8_t **ref_picture, 
3414
                              h264_chroma_mc_func *pix_op)
3415
{
3416
    int mx, my;
3417
    int mb_x, mb_y, i;
3418
    const int lowres= s->avctx->lowres;
3419
    const int block_s= 8>>lowres;    
3420

    
3421
    mb_x = s->mb_x;
3422
    mb_y = s->mb_y;
3423

    
3424
    switch(s->mv_type) {
3425
    case MV_TYPE_16X16:
3426
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3427
                    0, 0, 0,
3428
                    ref_picture, pix_op,
3429
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3430
        break;
3431
    case MV_TYPE_8X8:
3432
        mx = 0;
3433
        my = 0;
3434
            for(i=0;i<4;i++) {
3435
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3436
                            ref_picture[0], 0, 0,
3437
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3438
                            s->width, s->height, s->linesize,
3439
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3440
                            block_s, block_s, pix_op,
3441
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3442

    
3443
                mx += s->mv[dir][i][0];
3444
                my += s->mv[dir][i][1];
3445
            }
3446

    
3447
        if(!(s->flags&CODEC_FLAG_GRAY))
3448
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3449
        break;
3450
    case MV_TYPE_FIELD:
3451
        if (s->picture_structure == PICT_FRAME) {
3452
            /* top field */       
3453
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3454
                        1, 0, s->field_select[dir][0],
3455
                        ref_picture, pix_op,
3456
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3457
            /* bottom field */
3458
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3459
                        1, 1, s->field_select[dir][1],
3460
                        ref_picture, pix_op,
3461
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3462
        } else {
3463
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3464
                ref_picture= s->current_picture_ptr->data;
3465
            } 
3466

    
3467
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3468
                        0, 0, s->field_select[dir][0],
3469
                        ref_picture, pix_op,
3470
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3471
        }
3472
        break;
3473
    case MV_TYPE_16X8:
3474
        for(i=0; i<2; i++){
3475
            uint8_t ** ref2picture;
3476

    
3477
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3478
                ref2picture= ref_picture;
3479
            }else{
3480
                ref2picture= s->current_picture_ptr->data;
3481
            } 
3482

    
3483
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3484
                        0, 0, s->field_select[dir][i],
3485
                        ref2picture, pix_op,
3486
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3487
                
3488
            dest_y += 2*block_s*s->linesize;
3489
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3490
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3491
        }        
3492
        break;
3493
    case MV_TYPE_DMV:
3494
        if(s->picture_structure == PICT_FRAME){
3495
            for(i=0; i<2; i++){
3496
                int j;
3497
                for(j=0; j<2; j++){
3498
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3499
                                1, j, j^i,
3500
                                ref_picture, pix_op,
3501
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3502
                }
3503
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3504
            }
3505
        }else{
3506
            for(i=0; i<2; i++){
3507
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3508
                            0, 0, s->picture_structure != i+1,
3509
                            ref_picture, pix_op,
3510
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3511

    
3512
                // after put we make avg of the same block
3513
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3514

    
3515
                //opposite parity is always in the same frame if this is second field
3516
                if(!s->first_field){
3517
                    ref_picture = s->current_picture_ptr->data;    
3518
                }
3519
            }
3520
        }
3521
    break;
3522
    default: assert(0);
3523
    }
3524
}
3525

    
3526
/* put block[] to dest[] */
3527
static inline void put_dct(MpegEncContext *s, 
3528
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3529
{
3530
    s->dct_unquantize_intra(s, block, i, qscale);
3531
    s->dsp.idct_put (dest, line_size, block);
3532
}
3533

    
3534
/* add block[] to dest[] */
3535
static inline void add_dct(MpegEncContext *s, 
3536
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3537
{
3538
    if (s->block_last_index[i] >= 0) {
3539
        s->dsp.idct_add (dest, line_size, block);
3540
    }
3541
}
3542

    
3543
static inline void add_dequant_dct(MpegEncContext *s, 
3544
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3545
{
3546
    if (s->block_last_index[i] >= 0) {
3547
        s->dct_unquantize_inter(s, block, i, qscale);
3548

    
3549
        s->dsp.idct_add (dest, line_size, block);
3550
    }
3551
}
3552

    
3553
/**
3554
 * cleans dc, ac, coded_block for the current non intra MB
3555
 */
3556
void ff_clean_intra_table_entries(MpegEncContext *s)
3557
{
3558
    int wrap = s->b8_stride;
3559
    int xy = s->block_index[0];
3560
    
3561
    s->dc_val[0][xy           ] = 
3562
    s->dc_val[0][xy + 1       ] = 
3563
    s->dc_val[0][xy     + wrap] =
3564
    s->dc_val[0][xy + 1 + wrap] = 1024;
3565
    /* ac pred */
3566
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3567
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3568
    if (s->msmpeg4_version>=3) {
3569
        s->coded_block[xy           ] =
3570
        s->coded_block[xy + 1       ] =
3571
        s->coded_block[xy     + wrap] =
3572
        s->coded_block[xy + 1 + wrap] = 0;
3573
    }
3574
    /* chroma */
3575
    wrap = s->mb_stride;
3576
    xy = s->mb_x + s->mb_y * wrap;
3577
    s->dc_val[1][xy] =
3578
    s->dc_val[2][xy] = 1024;
3579
    /* ac pred */
3580
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3581
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3582
    
3583
    s->mbintra_table[xy]= 0;
3584
}
3585

    
3586
/* generic function called after a macroblock has been parsed by the
3587
   decoder or after it has been encoded by the encoder.
3588

3589
   Important variables used:
3590
   s->mb_intra : true if intra macroblock
3591
   s->mv_dir   : motion vector direction
3592
   s->mv_type  : motion vector type
3593
   s->mv       : motion vector
3594
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3595
 */
3596
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3597
{
3598
    int mb_x, mb_y;
3599
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3600
#ifdef HAVE_XVMC
3601
    if(s->avctx->xvmc_acceleration){
3602
        XVMC_decode_mb(s);//xvmc uses pblocks
3603
        return;
3604
    }
3605
#endif
3606

    
3607
    mb_x = s->mb_x;
3608
    mb_y = s->mb_y;
3609

    
3610
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3611
       /* save DCT coefficients */
3612
       int i,j;
3613
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3614
       for(i=0; i<6; i++)
3615
           for(j=0; j<64; j++)
3616
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3617
    }
3618

    
3619
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3620

    
3621
    /* update DC predictors for P macroblocks */
3622
    if (!s->mb_intra) {
3623
        if (s->h263_pred || s->h263_aic) {
3624
            if(s->mbintra_table[mb_xy])
3625
                ff_clean_intra_table_entries(s);
3626
        } else {
3627
            s->last_dc[0] =
3628
            s->last_dc[1] =
3629
            s->last_dc[2] = 128 << s->intra_dc_precision;
3630
        }
3631
    }
3632
    else if (s->h263_pred || s->h263_aic)
3633
        s->mbintra_table[mb_xy]=1;
3634

    
3635
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3636
        uint8_t *dest_y, *dest_cb, *dest_cr;
3637
        int dct_linesize, dct_offset;
3638
        op_pixels_func (*op_pix)[4];
3639
        qpel_mc_func (*op_qpix)[16];
3640
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3641
        const int uvlinesize= s->current_picture.linesize[1];
3642
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3643
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3644

    
3645
        /* avoid copy if macroblock skipped in last frame too */
3646
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3647
        if(!s->encoding){
3648
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3649
            const int age= s->current_picture.age;
3650

    
3651
            assert(age);
3652

    
3653
            if (s->mb_skiped) {
3654
                s->mb_skiped= 0;
3655
                assert(s->pict_type!=I_TYPE);
3656
 
3657
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3658
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3659

    
3660
                /* if previous was skipped too, then nothing to do !  */
3661
                if (*mbskip_ptr >= age && s->current_picture.reference){
3662
                    return;
3663
                }
3664
            } else if(!s->current_picture.reference){
3665
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3666
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3667
            } else{
3668
                *mbskip_ptr = 0; /* not skipped */
3669
            }
3670
        }
3671
        
3672
        dct_linesize = linesize << s->interlaced_dct;
3673
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3674
        
3675
        if(readable){
3676
            dest_y=  s->dest[0];
3677
            dest_cb= s->dest[1];
3678
            dest_cr= s->dest[2];
3679
        }else{
3680
            dest_y = s->b_scratchpad;
3681
            dest_cb= s->b_scratchpad+16*linesize;
3682
            dest_cr= s->b_scratchpad+32*linesize;
3683
        }
3684

    
3685
        if (!s->mb_intra) {
3686
            /* motion handling */
3687
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3688
            if(!s->encoding){
3689
                if(lowres_flag){
3690
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3691

    
3692
                    if (s->mv_dir & MV_DIR_FORWARD) {
3693
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3694
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3695
                    }
3696
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3697
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3698
                    }
3699
                }else{
3700
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3701
                        op_pix = s->dsp.put_pixels_tab;
3702
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3703
                    }else{
3704
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3705
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3706
                    }
3707
                    if (s->mv_dir & MV_DIR_FORWARD) {
3708
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3709
                        op_pix = s->dsp.avg_pixels_tab;
3710
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3711
                    }
3712
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3713
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3714
                    }
3715
                }
3716
            }
3717

    
3718
            /* skip dequant / idct if we are really late ;) */
3719
            if(s->hurry_up>1) return;
3720

    
3721
            /* add dct residue */
3722
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3723
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3724
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3725
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3726
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3727
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3728

    
3729
                if(!(s->flags&CODEC_FLAG_GRAY)){
3730
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3731
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3732
                }
3733
            } else if(s->codec_id != CODEC_ID_WMV2){
3734
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3735
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3736
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3737
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3738

    
3739
                if(!(s->flags&CODEC_FLAG_GRAY)){
3740
                    if(s->chroma_y_shift){//Chroma420
3741
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3742
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3743
                    }else{
3744
                        //chroma422
3745
                        dct_linesize = uvlinesize << s->interlaced_dct;
3746
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3747

    
3748
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3749
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3750
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3751
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3752
                        if(!s->chroma_x_shift){//Chroma444
3753
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3754
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3755
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3756
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3757
                        }
3758
                    }
3759
                }//fi gray
3760
            }
3761
#ifdef CONFIG_RISKY
3762
            else{
3763
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3764
            }
3765
#endif
3766
        } else {
3767
            /* dct only in intra block */
3768
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3769
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3770
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3771
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3772
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3773

    
3774
                if(!(s->flags&CODEC_FLAG_GRAY)){
3775
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3776
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3777
                }
3778
            }else{
3779
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3780
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3781
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3782
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3783

    
3784
                if(!(s->flags&CODEC_FLAG_GRAY)){
3785
                    if(s->chroma_y_shift){
3786
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3787
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3788
                    }else{
3789

    
3790
                        dct_linesize = uvlinesize << s->interlaced_dct;
3791
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3792

    
3793
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3794
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3795
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3796
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3797
                        if(!s->chroma_x_shift){//Chroma444
3798
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3799
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3800
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3801
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3802
                        }
3803
                    }
3804
                }//gray
3805
            }
3806
        }
3807
        if(!readable){
3808
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3809
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3810
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3811
        }
3812
    }
3813
}
3814

    
3815
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3816
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3817
    else                  MPV_decode_mb_internal(s, block, 0);
3818
}
3819

    
3820
#ifdef CONFIG_ENCODERS
3821

    
3822
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3823
{
3824
    static const char tab[64]=
3825
        {3,2,2,1,1,1,1,1,
3826
         1,1,1,1,1,1,1,1,
3827
         1,1,1,1,1,1,1,1,
3828
         0,0,0,0,0,0,0,0,
3829
         0,0,0,0,0,0,0,0,
3830
         0,0,0,0,0,0,0,0,
3831
         0,0,0,0,0,0,0,0,
3832
         0,0,0,0,0,0,0,0};
3833
    int score=0;
3834
    int run=0;
3835
    int i;
3836
    DCTELEM *block= s->block[n];
3837
    const int last_index= s->block_last_index[n];
3838
    int skip_dc;
3839

    
3840
    if(threshold<0){
3841
        skip_dc=0;
3842
        threshold= -threshold;
3843
    }else
3844
        skip_dc=1;
3845

    
3846
    /* are all which we could set to zero are allready zero? */
3847
    if(last_index<=skip_dc - 1) return;
3848

    
3849
    for(i=0; i<=last_index; i++){
3850
        const int j = s->intra_scantable.permutated[i];
3851
        const int level = ABS(block[j]);
3852
        if(level==1){
3853
            if(skip_dc && i==0) continue;
3854
            score+= tab[run];
3855
            run=0;
3856
        }else if(level>1){
3857
            return;
3858
        }else{
3859
            run++;
3860
        }
3861
    }
3862
    if(score >= threshold) return;
3863
    for(i=skip_dc; i<=last_index; i++){
3864
        const int j = s->intra_scantable.permutated[i];
3865
        block[j]=0;
3866
    }
3867
    if(block[0]) s->block_last_index[n]= 0;
3868
    else         s->block_last_index[n]= -1;
3869
}
3870

    
3871
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3872
{
3873
    int i;
3874
    const int maxlevel= s->max_qcoeff;
3875
    const int minlevel= s->min_qcoeff;
3876
    int overflow=0;
3877
    
3878
    if(s->mb_intra){
3879
        i=1; //skip clipping of intra dc
3880
    }else
3881
        i=0;
3882
    
3883
    for(;i<=last_index; i++){
3884
        const int j= s->intra_scantable.permutated[i];
3885
        int level = block[j];
3886
       
3887
        if     (level>maxlevel){
3888
            level=maxlevel;
3889
            overflow++;
3890
        }else if(level<minlevel){
3891
            level=minlevel;
3892
            overflow++;
3893
        }
3894
        
3895
        block[j]= level;
3896
    }
3897
    
3898
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3899
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3900
}
3901

    
3902
#endif //CONFIG_ENCODERS
3903

    
3904
/**
3905
 *
3906
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3907
 */
3908
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3909
    if (s->avctx->draw_horiz_band) {
3910
        AVFrame *src;
3911
        int offset[4];
3912
        
3913
        if(s->picture_structure != PICT_FRAME){
3914
            h <<= 1;
3915
            y <<= 1;
3916
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3917
        }
3918

    
3919
        h= FFMIN(h, s->avctx->height - y);
3920

    
3921
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3922
            src= (AVFrame*)s->current_picture_ptr;
3923
        else if(s->last_picture_ptr)
3924
            src= (AVFrame*)s->last_picture_ptr;
3925
        else
3926
            return;
3927
            
3928
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3929
            offset[0]=
3930
            offset[1]=
3931
            offset[2]=
3932
            offset[3]= 0;
3933
        }else{
3934
            offset[0]= y * s->linesize;;
3935
            offset[1]= 
3936
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3937
            offset[3]= 0;
3938
        }
3939

    
3940
        emms_c();
3941

    
3942
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3943
                                  y, s->picture_structure, h);
3944
    }
3945
}
3946

    
3947
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3948
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3949
    const int uvlinesize= s->current_picture.linesize[1];
3950
    const int mb_size= 4 - s->avctx->lowres;
3951
        
3952
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3953
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3954
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3955
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3956
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3957
    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;
3958
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3959

    
3960
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3961
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3962
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3963

    
3964
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3965
    {
3966
        s->dest[0] += s->mb_y *   linesize << mb_size;
3967
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3968
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3969
    }
3970
}
3971

    
3972
#ifdef CONFIG_ENCODERS
3973

    
3974
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3975
    int x, y;
3976
//FIXME optimize
3977
    for(y=0; y<8; y++){
3978
        for(x=0; x<8; x++){
3979
            int x2, y2;
3980
            int sum=0;
3981
            int sqr=0;
3982
            int count=0;
3983

    
3984
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3985
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3986
                    int v= ptr[x2 + y2*stride];
3987
                    sum += v;
3988
                    sqr += v*v;
3989
                    count++;
3990
                }
3991
            }
3992
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3993
        }
3994
    }
3995
}
3996

    
3997
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3998
{
3999
    int16_t weight[6][64];
4000
    DCTELEM orig[6][64];
4001
    const int mb_x= s->mb_x;
4002
    const int mb_y= s->mb_y;
4003
    int i;
4004
    int skip_dct[6];
4005
    int dct_offset   = s->linesize*8; //default for progressive frames
4006
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4007
    int wrap_y, wrap_c;
4008
    
4009
    for(i=0; i<6; i++) skip_dct[i]=0;
4010
    
4011
    if(s->adaptive_quant){
4012
        const int last_qp= s->qscale;
4013
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4014

    
4015
        s->lambda= s->lambda_table[mb_xy];
4016
        update_qscale(s);
4017
    
4018
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4019
            s->dquant= s->qscale - last_qp;
4020

    
4021
            if(s->out_format==FMT_H263){
4022
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4023
            
4024
                if(s->codec_id==CODEC_ID_MPEG4){        
4025
                    if(!s->mb_intra){
4026
                        if(s->pict_type == B_TYPE){
4027
                            if(s->dquant&1) 
4028
                                s->dquant= (s->dquant/2)*2;
4029
                            if(s->mv_dir&MV_DIRECT)
4030
                                s->dquant= 0;
4031
                        }
4032
                        if(s->mv_type==MV_TYPE_8X8)
4033
                            s->dquant=0;
4034
                    }
4035
                }
4036
            }
4037
        }
4038
        ff_set_qscale(s, last_qp + s->dquant);
4039
    }else if(s->flags&CODEC_FLAG_QP_RD)
4040
        ff_set_qscale(s, s->qscale + s->dquant);
4041

    
4042
    wrap_y = s->linesize;
4043
    wrap_c = s->uvlinesize;
4044
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4045
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4046
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4047

    
4048
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4049
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4050
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4051
        ptr_y= ebuf;
4052
        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);
4053
        ptr_cb= ebuf+18*wrap_y;
4054
        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);
4055
        ptr_cr= ebuf+18*wrap_y+8;
4056
    }
4057

    
4058
    if (s->mb_intra) {
4059
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4060
            int progressive_score, interlaced_score;
4061

    
4062
            s->interlaced_dct=0;
4063
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
4064
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4065

    
4066
            if(progressive_score > 0){
4067
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
4068
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4069
                if(progressive_score > interlaced_score){
4070
                    s->interlaced_dct=1;
4071
            
4072
                    dct_offset= wrap_y;
4073
                    wrap_y<<=1;
4074
                }
4075
            }
4076
        }
4077
        
4078
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4079
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4080
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4081
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4082

    
4083
        if(s->flags&CODEC_FLAG_GRAY){
4084
            skip_dct[4]= 1;
4085
            skip_dct[5]= 1;
4086
        }else{
4087
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4088
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4089
        }
4090
    }else{
4091
        op_pixels_func (*op_pix)[4];
4092
        qpel_mc_func (*op_qpix)[16];
4093
        uint8_t *dest_y, *dest_cb, *dest_cr;
4094

    
4095
        dest_y  = s->dest[0];
4096
        dest_cb = s->dest[1];
4097
        dest_cr = s->dest[2];
4098

    
4099
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4100
            op_pix = s->dsp.put_pixels_tab;
4101
            op_qpix= s->dsp.put_qpel_pixels_tab;
4102
        }else{
4103
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4104
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4105
        }
4106

    
4107
        if (s->mv_dir & MV_DIR_FORWARD) {
4108
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4109
            op_pix = s->dsp.avg_pixels_tab;
4110
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4111
        }
4112
        if (s->mv_dir & MV_DIR_BACKWARD) {
4113
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4114
        }
4115

    
4116
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4117
            int progressive_score, interlaced_score;
4118

    
4119
            s->interlaced_dct=0;
4120
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
4121
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4122
            
4123
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4124

    
4125
            if(progressive_score>0){
4126
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
4127
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4128
            
4129
                if(progressive_score > interlaced_score){
4130
                    s->interlaced_dct=1;
4131
            
4132
                    dct_offset= wrap_y;
4133
                    wrap_y<<=1;
4134
                }
4135
            }
4136
        }
4137
        
4138
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4139
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4140
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4141
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4142
        
4143
        if(s->flags&CODEC_FLAG_GRAY){
4144
            skip_dct[4]= 1;
4145
            skip_dct[5]= 1;
4146
        }else{
4147
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4148
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4149
        }
4150
        /* pre quantization */         
4151
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4152
            //FIXME optimize
4153
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4154
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4155
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4156
            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;
4157
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4158
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4159
        }
4160
    }
4161

    
4162
    if(s->avctx->quantizer_noise_shaping){
4163
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4164
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4165
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4166
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4167
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4168
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4169
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4170
    }
4171
            
4172
    /* DCT & quantize */
4173
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4174
    {
4175
        for(i=0;i<6;i++) {
4176
            if(!skip_dct[i]){
4177
                int overflow;
4178
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4179
            // FIXME we could decide to change to quantizer instead of clipping
4180
            // JS: I don't think that would be a good idea it could lower quality instead
4181
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4182
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4183
            }else
4184
                s->block_last_index[i]= -1;
4185
        }
4186
        if(s->avctx->quantizer_noise_shaping){
4187
            for(i=0;i<6;i++) {
4188
                if(!skip_dct[i]){
4189
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4190
                }
4191
            }
4192
        }
4193
        
4194
        if(s->luma_elim_threshold && !s->mb_intra)
4195
            for(i=0; i<4; i++)
4196
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4197
        if(s->chroma_elim_threshold && !s->mb_intra)
4198
            for(i=4; i<6; i++)
4199
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4200

    
4201
        if(s->flags & CODEC_FLAG_CBP_RD){
4202
            for(i=0;i<6;i++) {
4203
                if(s->block_last_index[i] == -1)
4204
                    s->coded_score[i]= INT_MAX/256;
4205
            }
4206
        }
4207
    }
4208

    
4209
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4210
        s->block_last_index[4]=
4211
        s->block_last_index[5]= 0;
4212
        s->block[4][0]=
4213
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4214
    }
4215

    
4216
    //non c quantize code returns incorrect block_last_index FIXME
4217
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4218
        for(i=0; i<6; i++){
4219
            int j;
4220
            if(s->block_last_index[i]>0){
4221
                for(j=63; j>0; j--){
4222
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4223
                }
4224
                s->block_last_index[i]= j;
4225
            }
4226
        }
4227
    }
4228

    
4229
    /* huffman encode */
4230
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4231
    case CODEC_ID_MPEG1VIDEO:
4232
    case CODEC_ID_MPEG2VIDEO:
4233
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4234
#ifdef CONFIG_RISKY
4235
    case CODEC_ID_MPEG4:
4236
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4237
    case CODEC_ID_MSMPEG4V2:
4238
    case CODEC_ID_MSMPEG4V3:
4239
    case CODEC_ID_WMV1:
4240
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4241
    case CODEC_ID_WMV2:
4242
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4243
    case CODEC_ID_H261:
4244
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4245
    case CODEC_ID_H263:
4246
    case CODEC_ID_H263P:
4247
    case CODEC_ID_FLV1:
4248
    case CODEC_ID_RV10:
4249
    case CODEC_ID_RV20:
4250
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4251
#endif
4252
    case CODEC_ID_MJPEG:
4253
        mjpeg_encode_mb(s, s->block); break;
4254
    default:
4255
        assert(0);
4256
    }
4257
}
4258

    
4259
#endif //CONFIG_ENCODERS
4260

    
4261
void ff_mpeg_flush(AVCodecContext *avctx){
4262
    int i;
4263
    MpegEncContext *s = avctx->priv_data;
4264
    
4265
    if(s==NULL || s->picture==NULL) 
4266
        return;
4267
    
4268
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4269
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4270
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4271
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4272
    }
4273
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4274
    
4275
    s->mb_x= s->mb_y= 0;
4276
    
4277
    s->parse_context.state= -1;
4278
    s->parse_context.frame_start_found= 0;
4279
    s->parse_context.overread= 0;
4280
    s->parse_context.overread_index= 0;
4281
    s->parse_context.index= 0;
4282
    s->parse_context.last_index= 0;
4283
    s->bitstream_buffer_size=0;
4284
}
4285

    
4286
#ifdef CONFIG_ENCODERS
4287
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4288
{
4289
    const uint16_t *srcw= (uint16_t*)src;
4290
    int words= length>>4;
4291
    int bits= length&15;
4292
    int i;
4293

    
4294
    if(length==0) return;
4295
    
4296
    if(words < 16){
4297
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4298
    }else if(put_bits_count(pb)&7){
4299
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4300
    }else{
4301
        for(i=0; put_bits_count(pb)&31; i++)
4302
            put_bits(pb, 8, src[i]);
4303
        flush_put_bits(pb);
4304
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4305
        skip_put_bytes(pb, 2*words-i);
4306
    }
4307
        
4308
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4309
}
4310

    
4311
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4312
    int i;
4313

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

    
4316
    /* mpeg1 */
4317
    d->mb_skip_run= s->mb_skip_run;
4318
    for(i=0; i<3; i++)
4319
        d->last_dc[i]= s->last_dc[i];
4320
    
4321
    /* statistics */
4322
    d->mv_bits= s->mv_bits;
4323
    d->i_tex_bits= s->i_tex_bits;
4324
    d->p_tex_bits= s->p_tex_bits;
4325
    d->i_count= s->i_count;
4326
    d->f_count= s->f_count;
4327
    d->b_count= s->b_count;
4328
    d->skip_count= s->skip_count;
4329
    d->misc_bits= s->misc_bits;
4330
    d->last_bits= 0;
4331

    
4332
    d->mb_skiped= 0;
4333
    d->qscale= s->qscale;
4334
    d->dquant= s->dquant;
4335
}
4336

    
4337
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4338
    int i;
4339

    
4340
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
4341
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4342
    
4343
    /* mpeg1 */
4344
    d->mb_skip_run= s->mb_skip_run;
4345
    for(i=0; i<3; i++)
4346
        d->last_dc[i]= s->last_dc[i];
4347
    
4348
    /* statistics */
4349
    d->mv_bits= s->mv_bits;
4350
    d->i_tex_bits= s->i_tex_bits;
4351
    d->p_tex_bits= s->p_tex_bits;
4352
    d->i_count= s->i_count;
4353
    d->f_count= s->f_count;
4354
    d->b_count= s->b_count;
4355
    d->skip_count= s->skip_count;
4356
    d->misc_bits= s->misc_bits;
4357

    
4358
    d->mb_intra= s->mb_intra;
4359
    d->mb_skiped= s->mb_skiped;
4360
    d->mv_type= s->mv_type;
4361
    d->mv_dir= s->mv_dir;
4362
    d->pb= s->pb;
4363
    if(s->data_partitioning){
4364
        d->pb2= s->pb2;
4365
        d->tex_pb= s->tex_pb;
4366
    }
4367
    d->block= s->block;
4368
    for(i=0; i<6; i++)
4369
        d->block_last_index[i]= s->block_last_index[i];
4370
    d->interlaced_dct= s->interlaced_dct;
4371
    d->qscale= s->qscale;
4372
}
4373

    
4374
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4375
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4376
                           int *dmin, int *next_block, int motion_x, int motion_y)
4377
{
4378
    int score;
4379
    uint8_t *dest_backup[3];
4380
    
4381
    copy_context_before_encode(s, backup, type);
4382

    
4383
    s->block= s->blocks[*next_block];
4384
    s->pb= pb[*next_block];
4385
    if(s->data_partitioning){
4386
        s->pb2   = pb2   [*next_block];
4387
        s->tex_pb= tex_pb[*next_block];
4388
    }
4389
    
4390
    if(*next_block){
4391
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4392
        s->dest[0] = s->rd_scratchpad;
4393
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4394
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4395
        assert(s->linesize >= 32); //FIXME
4396
    }
4397

    
4398
    encode_mb(s, motion_x, motion_y);
4399
    
4400
    score= put_bits_count(&s->pb);
4401
    if(s->data_partitioning){
4402
        score+= put_bits_count(&s->pb2);
4403
        score+= put_bits_count(&s->tex_pb);
4404
    }
4405
   
4406
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4407
        MPV_decode_mb(s, s->block);
4408

    
4409
        score *= s->lambda2;
4410
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4411
    }
4412
    
4413
    if(*next_block){
4414
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4415
    }
4416

    
4417
    if(score<*dmin){
4418
        *dmin= score;
4419
        *next_block^=1;
4420

    
4421
        copy_context_after_encode(best, s, type);
4422
    }
4423
}
4424
                
4425
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4426
    uint32_t *sq = squareTbl + 256;
4427
    int acc=0;
4428
    int x,y;
4429
    
4430
    if(w==16 && h==16) 
4431
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4432
    else if(w==8 && h==8)
4433
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4434
    
4435
    for(y=0; y<h; y++){
4436
        for(x=0; x<w; x++){
4437
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4438
        } 
4439
    }
4440
    
4441
    assert(acc>=0);
4442
    
4443
    return acc;
4444
}
4445

    
4446
static int sse_mb(MpegEncContext *s){
4447
    int w= 16;
4448
    int h= 16;
4449

    
4450
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4451
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4452

    
4453
    if(w==16 && h==16)
4454
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4455
        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)
4456
               +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)
4457
               +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);
4458
      }else{
4459
        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)
4460
               +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)
4461
               +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);
4462
      }
4463
    else
4464
        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)
4465
               +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)
4466
               +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);
4467
}
4468

    
4469
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4470
    MpegEncContext *s= arg;
4471

    
4472
    
4473
    s->me.pre_pass=1;
4474
    s->me.dia_size= s->avctx->pre_dia_size;
4475
    s->first_slice_line=1;
4476
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4477
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4478
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4479
        }
4480
        s->first_slice_line=0;
4481
    }
4482
    
4483
    s->me.pre_pass=0;
4484
    
4485
    return 0;
4486
}
4487

    
4488
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4489
    MpegEncContext *s= arg;
4490

    
4491
    s->me.dia_size= s->avctx->dia_size;
4492
    s->first_slice_line=1;
4493
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4494
        s->mb_x=0; //for block init below
4495
        ff_init_block_index(s);
4496
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4497
            s->block_index[0]+=2;
4498
            s->block_index[1]+=2;
4499
            s->block_index[2]+=2;
4500
            s->block_index[3]+=2;
4501
            
4502
            /* compute motion vector & mb_type and store in context */
4503
            if(s->pict_type==B_TYPE)
4504
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4505
            else
4506
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4507
        }
4508
        s->first_slice_line=0;
4509
    }
4510
    return 0;
4511
}
4512

    
4513
static int mb_var_thread(AVCodecContext *c, void *arg){
4514
    MpegEncContext *s= arg;
4515
    int mb_x, mb_y;
4516

    
4517
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4518
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4519
            int xx = mb_x * 16;
4520
            int yy = mb_y * 16;
4521
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4522
            int varc;
4523
            int sum = s->dsp.pix_sum(pix, s->linesize);
4524
    
4525
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4526

    
4527
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4528
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4529
            s->me.mb_var_sum_temp    += varc;
4530
        }
4531
    }
4532
    return 0;
4533
}
4534

    
4535
static void write_slice_end(MpegEncContext *s){
4536
    if(s->codec_id==CODEC_ID_MPEG4){
4537
        if(s->partitioned_frame){
4538
            ff_mpeg4_merge_partitions(s);
4539
        }
4540
    
4541
        ff_mpeg4_stuffing(&s->pb);
4542
    }else if(s->out_format == FMT_MJPEG){
4543
        ff_mjpeg_stuffing(&s->pb);
4544
    }
4545

    
4546
    align_put_bits(&s->pb);
4547
    flush_put_bits(&s->pb);
4548
}
4549

    
4550
static int encode_thread(AVCodecContext *c, void *arg){
4551
    MpegEncContext *s= arg;
4552
    int mb_x, mb_y, pdif = 0;
4553
    int i, j;
4554
    MpegEncContext best_s, backup_s;
4555
    uint8_t bit_buf[2][3000];
4556
    uint8_t bit_buf2[2][3000];
4557
    uint8_t bit_buf_tex[2][3000];
4558
    PutBitContext pb[2], pb2[2], tex_pb[2];
4559
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4560

    
4561
    for(i=0; i<2; i++){
4562
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4563
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4564
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4565
    }
4566

    
4567
    s->last_bits= put_bits_count(&s->pb);
4568
    s->mv_bits=0;
4569
    s->misc_bits=0;
4570
    s->i_tex_bits=0;
4571
    s->p_tex_bits=0;
4572
    s->i_count=0;
4573
    s->f_count=0;
4574
    s->b_count=0;
4575
    s->skip_count=0;
4576

    
4577
    for(i=0; i<3; i++){
4578
        /* init last dc values */
4579
        /* note: quant matrix value (8) is implied here */
4580
        s->last_dc[i] = 128 << s->intra_dc_precision;
4581
        
4582
        s->current_picture_ptr->error[i] = 0;
4583
    }
4584
    s->mb_skip_run = 0;
4585
    memset(s->last_mv, 0, sizeof(s->last_mv));
4586
     
4587
    s->last_mv_dir = 0;
4588

    
4589
#ifdef CONFIG_RISKY
4590
    switch(s->codec_id){
4591
    case CODEC_ID_H263:
4592
    case CODEC_ID_H263P:
4593
    case CODEC_ID_FLV1:
4594
        s->gob_index = ff_h263_get_gob_height(s);
4595
        break;
4596
    case CODEC_ID_MPEG4:
4597
        if(s->partitioned_frame)
4598
            ff_mpeg4_init_partitions(s);
4599
        break;
4600
    }
4601
#endif
4602

    
4603
    s->resync_mb_x=0;
4604
    s->resync_mb_y=0; 
4605
    s->first_slice_line = 1;
4606
    s->ptr_lastgob = s->pb.buf;
4607
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4608
//    printf("row %d at %X\n", s->mb_y, (int)s);
4609
        s->mb_x=0;
4610
        s->mb_y= mb_y;
4611

    
4612
        ff_set_qscale(s, s->qscale);
4613
        ff_init_block_index(s);
4614
        
4615
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4616
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4617
            int mb_type= s->mb_type[xy];
4618
//            int d;
4619
            int dmin= INT_MAX;
4620
            int dir;
4621

    
4622
            s->mb_x = mb_x;
4623
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4624
            ff_update_block_index(s);
4625

    
4626
            if(s->codec_id == CODEC_ID_H261){
4627
                ff_h261_reorder_mb_index(s);
4628
                xy= s->mb_y*s->mb_stride + s->mb_x;
4629
                mb_type= s->mb_type[xy];
4630
            }
4631

    
4632
            /* write gob / video packet header  */
4633
#ifdef CONFIG_RISKY
4634
            if(s->rtp_mode){
4635
                int current_packet_size, is_gob_start;
4636
                
4637
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4638
                
4639
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4640
                
4641
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4642
                
4643
                switch(s->codec_id){
4644
                case CODEC_ID_H263:
4645
                case CODEC_ID_H263P:
4646
                    if(!s->h263_slice_structured)
4647
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4648
                    break;
4649
                case CODEC_ID_MPEG2VIDEO:
4650
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4651
                case CODEC_ID_MPEG1VIDEO:
4652
                    if(s->mb_skip_run) is_gob_start=0;
4653
                    break;
4654
                }
4655

    
4656
                if(is_gob_start){
4657
                    if(s->start_mb_y != mb_y || mb_x!=0){
4658
                        write_slice_end(s);
4659

    
4660
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4661
                            ff_mpeg4_init_partitions(s);
4662
                        }
4663
                    }
4664
                
4665
                    assert((put_bits_count(&s->pb)&7) == 0);
4666
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4667
                    
4668
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4669
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4670
                        int d= 100 / s->avctx->error_rate;
4671
                        if(r % d == 0){
4672
                            current_packet_size=0;
4673
#ifndef ALT_BITSTREAM_WRITER