Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 40c5fa26

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_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
718
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719
    
720
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721
        /* interlaced direct mode decoding tables */
722
            for(i=0; i<2; i++){
723
                int j, k;
724
                for(j=0; j<2; j++){
725
                    for(k=0; k<2; k++){
726
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
727
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
728
                    }
729
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
730
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
731
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
732
                }
733
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
734
            }
735
    }
736
    if (s->out_format == FMT_H263) {
737
        /* ac values */
738
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741
        s->ac_val[2] = s->ac_val[1] + c_size;
742
        
743
        /* cbp values */
744
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
745
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
746
        
747
        /* cbp, ac_pred, pred_dir */
748
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
749
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750
    }
751
    
752
    if (s->h263_pred || s->h263_plus || !s->encoding) {
753
        /* dc values */
754
        //MN: we need these for error resilience of intra-frames
755
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758
        s->dc_val[2] = s->dc_val[1] + c_size;
759
        for(i=0;i<yc_size;i++)
760
            s->dc_val_base[i] = 1024;
761
    }
762

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

    
779
    s->context_initialized = 1;
780

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

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

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

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

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

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

    
815
    av_freep(&s->mb_type);
816
    av_freep(&s->p_mv_table_base);
817
    av_freep(&s->b_forw_mv_table_base);
818
    av_freep(&s->b_back_mv_table_base);
819
    av_freep(&s->b_bidir_forw_mv_table_base);
820
    av_freep(&s->b_bidir_back_mv_table_base);
821
    av_freep(&s->b_direct_mv_table_base);
822
    s->p_mv_table= NULL;
823
    s->b_forw_mv_table= NULL;
824
    s->b_back_mv_table= NULL;
825
    s->b_bidir_forw_mv_table= NULL;
826
    s->b_bidir_back_mv_table= NULL;
827
    s->b_direct_mv_table= NULL;
828
    for(i=0; i<2; i++){
829
        for(j=0; j<2; j++){
830
            for(k=0; k<2; k++){
831
                av_freep(&s->b_field_mv_table_base[i][j][k]);
832
                s->b_field_mv_table[i][j][k]=NULL;
833
            }
834
            av_freep(&s->b_field_select_table[i][j]);
835
            av_freep(&s->p_field_mv_table_base[i][j]);
836
            s->p_field_mv_table[i][j]=NULL;
837
        }
838
        av_freep(&s->p_field_select_table[i]);
839
    }
840
    
841
    av_freep(&s->dc_val_base);
842
    av_freep(&s->ac_val_base);
843
    av_freep(&s->coded_block_base);
844
    av_freep(&s->mbintra_table);
845
    av_freep(&s->cbp_table);
846
    av_freep(&s->pred_dir_table);
847
    
848
    av_freep(&s->mbskip_table);
849
    av_freep(&s->prev_pict_types);
850
    av_freep(&s->bitstream_buffer);
851
    s->allocated_bitstream_buffer_size=0;
852

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

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

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

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

    
884
#ifdef CONFIG_ENCODERS
885

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

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

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

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

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

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

    
944
    /* Fixed QSCALE */
945
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946
    
947
    s->adaptive_quant= (   s->avctx->lumi_masking
948
                        || s->avctx->dark_masking
949
                        || s->avctx->temporal_cplx_masking 
950
                        || s->avctx->spatial_cplx_masking
951
                        || s->avctx->p_masking
952
                        || s->avctx->border_masking
953
                        || (s->flags&CODEC_FLAG_QP_RD))
954
                       && !s->fixed_qscale;
955
    
956
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959

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

    
965
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
967
    }
968
    
969
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971
        return -1;
972
    }
973
    
974
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976
        return -1;
977
    }
978
        
979
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
980
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982
        
983
        av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
984
    }
985
       
986
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
987
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989
        return -1;
990
    }
991
        
992
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
994
        return -1;
995
    }
996
    
997
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999
        return -1;
1000
    }
1001
    
1002
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004
        return -1;
1005
    }
1006

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

    
1017
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
1018
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020
        return -1;
1021
    }
1022
        
1023
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1025
        return -1;
1026
    }
1027
        
1028
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030
        return -1;
1031
    }
1032

    
1033
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035
        return -1;
1036
    }
1037
    
1038
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040
        return -1;
1041
    }
1042
    
1043
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
1044
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
1045
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047
        return -1;
1048
    }
1049
    
1050
    if(s->avctx->thread_count > 1)
1051
        s->rtp_mode= 1;
1052

    
1053
    if(!avctx->frame_rate || !avctx->frame_rate_base){
1054
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055
        return -1;
1056
    }
1057
        
1058
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1059
    if(i > 1){
1060
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1061
        avctx->frame_rate /= i;
1062
        avctx->frame_rate_base /= i;
1063
//        return -1;
1064
    }
1065
    
1066
    if(s->codec_id==CODEC_ID_MJPEG){
1067
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1068
        s->inter_quant_bias= 0;
1069
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1070
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1071
        s->inter_quant_bias= 0;
1072
    }else{
1073
        s->intra_quant_bias=0;
1074
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1075
    }
1076
    
1077
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1078
        s->intra_quant_bias= avctx->intra_quant_bias;
1079
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1080
        s->inter_quant_bias= avctx->inter_quant_bias;
1081
        
1082
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1083

    
1084
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1085
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1086

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

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

    
1233
    s->encoding = 1;
1234

    
1235
    /* init */
1236
    if (MPV_common_init(s) < 0)
1237
        return -1;
1238

    
1239
    if(s->modified_quant)
1240
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1241
    s->progressive_frame= 
1242
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1243
    s->quant_precision=5;
1244
    
1245
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1246
    ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1247
    
1248
#ifdef CONFIG_ENCODERS
1249
    if (s->out_format == FMT_H261)
1250
        ff_h261_encode_init(s);
1251
    if (s->out_format == FMT_H263)
1252
        h263_encode_init(s);
1253
    if(s->msmpeg4_version)
1254
        ff_msmpeg4_encode_init(s);
1255
    if (s->out_format == FMT_MPEG1)
1256
        ff_mpeg1_encode_init(s);
1257
#endif
1258

    
1259
    /* init q matrix */
1260
    for(i=0;i<64;i++) {
1261
        int j= s->dsp.idct_permutation[i];
1262
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1263
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1264
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1265
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1266
            s->intra_matrix[j] =
1267
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1268
        }else
1269
        { /* mpeg1/2 */
1270
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1271
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1272
        }
1273
        if(s->avctx->intra_matrix)
1274
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1275
        if(s->avctx->inter_matrix)
1276
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1277
    }
1278

    
1279
    /* precompute matrix */
1280
    /* for mjpeg, we do include qscale in the matrix */
1281
    if (s->out_format != FMT_MJPEG) {
1282
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1283
                       s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1284
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1285
                       s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1286
    }
1287

    
1288
    if(ff_rate_control_init(s) < 0)
1289
        return -1;
1290
    
1291
    return 0;
1292
}
1293

    
1294
int MPV_encode_end(AVCodecContext *avctx)
1295
{
1296
    MpegEncContext *s = avctx->priv_data;
1297

    
1298
#ifdef STATS
1299
    print_stats();
1300
#endif
1301

    
1302
    ff_rate_control_uninit(s);
1303

    
1304
    MPV_common_end(s);
1305
    if (s->out_format == FMT_MJPEG)
1306
        mjpeg_close(s);
1307

    
1308
    av_freep(&avctx->extradata);
1309
      
1310
    return 0;
1311
}
1312

    
1313
#endif //CONFIG_ENCODERS
1314

    
1315
void init_rl(RLTable *rl, int use_static)
1316
{
1317
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1318
    uint8_t index_run[MAX_RUN+1];
1319
    int last, run, level, start, end, i;
1320

    
1321
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1322
    if(use_static && rl->max_level[0])
1323
        return;
1324

    
1325
    /* compute max_level[], max_run[] and index_run[] */
1326
    for(last=0;last<2;last++) {
1327
        if (last == 0) {
1328
            start = 0;
1329
            end = rl->last;
1330
        } else {
1331
            start = rl->last;
1332
            end = rl->n;
1333
        }
1334

    
1335
        memset(max_level, 0, MAX_RUN + 1);
1336
        memset(max_run, 0, MAX_LEVEL + 1);
1337
        memset(index_run, rl->n, MAX_RUN + 1);
1338
        for(i=start;i<end;i++) {
1339
            run = rl->table_run[i];
1340
            level = rl->table_level[i];
1341
            if (index_run[run] == rl->n)
1342
                index_run[run] = i;
1343
            if (level > max_level[run])
1344
                max_level[run] = level;
1345
            if (run > max_run[level])
1346
                max_run[level] = run;
1347
        }
1348
        if(use_static)
1349
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1350
        else
1351
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1352
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1353
        if(use_static)
1354
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1355
        else
1356
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1357
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1358
        if(use_static)
1359
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1360
        else
1361
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1362
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1363
    }
1364
}
1365

    
1366
/* draw the edges of width 'w' of an image of size width, height */
1367
//FIXME check that this is ok for mpeg4 interlaced
1368
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1369
{
1370
    uint8_t *ptr, *last_line;
1371
    int i;
1372

    
1373
    last_line = buf + (height - 1) * wrap;
1374
    for(i=0;i<w;i++) {
1375
        /* top and bottom */
1376
        memcpy(buf - (i + 1) * wrap, buf, width);
1377
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1378
    }
1379
    /* left and right */
1380
    ptr = buf;
1381
    for(i=0;i<height;i++) {
1382
        memset(ptr - w, ptr[0], w);
1383
        memset(ptr + width, ptr[width-1], w);
1384
        ptr += wrap;
1385
    }
1386
    /* corners */
1387
    for(i=0;i<w;i++) {
1388
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1389
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1390
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1391
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1392
    }
1393
}
1394

    
1395
int ff_find_unused_picture(MpegEncContext *s, int shared){
1396
    int i;
1397
    
1398
    if(shared){
1399
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1400
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1401
        }
1402
    }else{
1403
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1404
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1405
        }
1406
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1407
            if(s->picture[i].data[0]==NULL) return i;
1408
        }
1409
    }
1410

    
1411
    assert(0);
1412
    return -1;
1413
}
1414

    
1415
static void update_noise_reduction(MpegEncContext *s){
1416
    int intra, i;
1417

    
1418
    for(intra=0; intra<2; intra++){
1419
        if(s->dct_count[intra] > (1<<16)){
1420
            for(i=0; i<64; i++){
1421
                s->dct_error_sum[intra][i] >>=1;
1422
            }
1423
            s->dct_count[intra] >>= 1;
1424
        }
1425
        
1426
        for(i=0; i<64; i++){
1427
            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);
1428
        }
1429
    }
1430
}
1431

    
1432
/**
1433
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1434
 */
1435
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1436
{
1437
    int i;
1438
    AVFrame *pic;
1439
    s->mb_skiped = 0;
1440

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

    
1443
    /* mark&release old frames */
1444
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1445
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1446

    
1447
        /* release forgotten pictures */
1448
        /* if(mpeg124/h263) */
1449
        if(!s->encoding){
1450
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1451
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1452
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1453
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1454
                }
1455
            }
1456
        }
1457
    }
1458
alloc:
1459
    if(!s->encoding){
1460
        /* release non refernce frames */
1461
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1462
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1463
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1464
            }
1465
        }
1466

    
1467
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1468
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1469
        else{
1470
            i= ff_find_unused_picture(s, 0);
1471
            pic= (AVFrame*)&s->picture[i];
1472
        }
1473

    
1474
        pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1475
                        && !s->dropable ? 3 : 0;
1476

    
1477
        pic->coded_picture_number= s->coded_picture_number++;
1478
        
1479
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1480
            return -1;
1481

    
1482
        s->current_picture_ptr= (Picture*)pic;
1483
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1484
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1485
    }
1486

    
1487
    s->current_picture_ptr->pict_type= s->pict_type;
1488
//    if(s->flags && CODEC_FLAG_QSCALE) 
1489
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1490
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1491

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

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

    
1517
    if(s->picture_structure!=PICT_FRAME){
1518
        int i;
1519
        for(i=0; i<4; i++){
1520
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1521
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1522
            } 
1523
            s->current_picture.linesize[i] *= 2;
1524
            s->last_picture.linesize[i] *=2;
1525
            s->next_picture.linesize[i] *=2;
1526
        }
1527
    }
1528
  }
1529
   
1530
    s->hurry_up= s->avctx->hurry_up;
1531
    s->error_resilience= avctx->error_resilience;
1532

    
1533
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1534
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1535
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1536
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1537
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1538
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1539
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1540
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1541
    }else{
1542
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1543
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1544
    }
1545

    
1546
    if(s->dct_error_sum){
1547
        assert(s->avctx->noise_reduction && s->encoding);
1548

    
1549
        update_noise_reduction(s);
1550
    }
1551
        
1552
#ifdef HAVE_XVMC
1553
    if(s->avctx->xvmc_acceleration)
1554
        return XVMC_field_start(s, avctx);
1555
#endif
1556
    return 0;
1557
}
1558

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

    
1592
    if(s->encoding){
1593
        /* release non refernce frames */
1594
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1595
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1596
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1597
            }
1598
        }
1599
    }
1600
    // clear copies, to avoid confusion
1601
#if 0
1602
    memset(&s->last_picture, 0, sizeof(Picture));
1603
    memset(&s->next_picture, 0, sizeof(Picture));
1604
    memset(&s->current_picture, 0, sizeof(Picture));
1605
#endif
1606
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1607
}
1608

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

    
1658
/**
1659
 * draws an arrow from (ex, ey) -> (sx, sy).
1660
 * @param w width of the image
1661
 * @param h height of the image
1662
 * @param stride stride/linesize of the image
1663
 * @param color color of the arrow
1664
 */
1665
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1666
    int dx,dy;
1667

    
1668
    sx= clip(sx, -100, w+100);
1669
    sy= clip(sy, -100, h+100);
1670
    ex= clip(ex, -100, w+100);
1671
    ey= clip(ey, -100, h+100);
1672
    
1673
    dx= ex - sx;
1674
    dy= ey - sy;
1675
    
1676
    if(dx*dx + dy*dy > 3*3){
1677
        int rx=  dx + dy;
1678
        int ry= -dx + dy;
1679
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1680
        
1681
        //FIXME subpixel accuracy
1682
        rx= ROUNDED_DIV(rx*3<<4, length);
1683
        ry= ROUNDED_DIV(ry*3<<4, length);
1684
        
1685
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1686
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1687
    }
1688
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1689
}
1690

    
1691
/**
1692
 * prints debuging info for the given picture.
1693
 */
1694
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1695

    
1696
    if(!pict || !pict->mb_type) return;
1697

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

    
1774
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1775
        const int shift= 1 + s->quarter_sample;
1776
        int mb_y;
1777
        uint8_t *ptr;
1778
        int i;
1779
        int h_chroma_shift, v_chroma_shift;
1780
        const int width = s->avctx->width;
1781
        const int height= s->avctx->height;
1782
        const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1783
        const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1784
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1785

    
1786
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1787
        for(i=0; i<3; i++){
1788
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1789
            pict->data[i]= s->visualization_buffer[i];
1790
        }
1791
        pict->type= FF_BUFFER_TYPE_COPY;
1792
        ptr= pict->data[0];
1793

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

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

    
1883
                    
1884
                    u=v=128;
1885
                    if(IS_PCM(mb_type)){
1886
                        COLOR(120,48)
1887
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1888
                        COLOR(30,48)
1889
                    }else if(IS_INTRA4x4(mb_type)){
1890
                        COLOR(90,48)
1891
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1892
//                        COLOR(120,48)
1893
                    }else if(IS_DIRECT(mb_type)){
1894
                        COLOR(150,48)
1895
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1896
                        COLOR(170,48)
1897
                    }else if(IS_GMC(mb_type)){
1898
                        COLOR(190,48)
1899
                    }else if(IS_SKIP(mb_type)){
1900
//                        COLOR(180,48)
1901
                    }else if(!USES_LIST(mb_type, 1)){
1902
                        COLOR(240,48)
1903
                    }else if(!USES_LIST(mb_type, 0)){
1904
                        COLOR(0,48)
1905
                    }else{
1906
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1907
                        COLOR(300,48)
1908
                    }
1909

    
1910
                    u*= 0x0101010101010101ULL;
1911
                    v*= 0x0101010101010101ULL;
1912
                    for(y=0; y<8; y++){
1913
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1914
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1915
                    }
1916

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

    
1952
#ifdef CONFIG_ENCODERS
1953

    
1954
static int get_sae(uint8_t *src, int ref, int stride){
1955
    int x,y;
1956
    int acc=0;
1957
    
1958
    for(y=0; y<16; y++){
1959
        for(x=0; x<16; x++){
1960
            acc+= ABS(src[x+y*stride] - ref);
1961
        }
1962
    }
1963
    
1964
    return acc;
1965
}
1966

    
1967
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1968
    int x, y, w, h;
1969
    int acc=0;
1970
    
1971
    w= s->width &~15;
1972
    h= s->height&~15;
1973
    
1974
    for(y=0; y<h; y+=16){
1975
        for(x=0; x<w; x+=16){
1976
            int offset= x + y*stride;
1977
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1978
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1979
            int sae = get_sae(src + offset, mean, stride);
1980
            
1981
            acc+= sae + 500 < sad;
1982
        }
1983
    }
1984
    return acc;
1985
}
1986

    
1987

    
1988
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1989
    AVFrame *pic=NULL;
1990
    int64_t pts;
1991
    int i;
1992
    const int encoding_delay= s->max_b_frames;
1993
    int direct=1;
1994
    
1995
    if(pic_arg){
1996
        pts= pic_arg->pts;
1997
        pic_arg->display_picture_number= s->input_picture_number++;
1998

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

    
2021
  if(pic_arg){
2022
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2023
    if(pic_arg->linesize[0] != s->linesize) direct=0;
2024
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2025
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2026
  
2027
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2028
    
2029
    if(direct){
2030
        i= ff_find_unused_picture(s, 1);
2031

    
2032
        pic= (AVFrame*)&s->picture[i];
2033
        pic->reference= 3;
2034
    
2035
        for(i=0; i<4; i++){
2036
            pic->data[i]= pic_arg->data[i];
2037
            pic->linesize[i]= pic_arg->linesize[i];
2038
        }
2039
        alloc_picture(s, (Picture*)pic, 1);
2040
    }else{
2041
        int offset= 16;
2042
        i= ff_find_unused_picture(s, 0);
2043

    
2044
        pic= (AVFrame*)&s->picture[i];
2045
        pic->reference= 3;
2046

    
2047
        alloc_picture(s, (Picture*)pic, 0);
2048

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

    
2089
    return 0;
2090
}
2091

    
2092
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2093
    int x, y, plane;
2094
    int score=0;
2095
    int64_t score64=0;
2096

    
2097
    for(plane=0; plane<3; plane++){
2098
        const int stride= p->linesize[plane];
2099
        const int bw= plane ? 1 : 2;
2100
        for(y=0; y<s->mb_height*bw; y++){
2101
            for(x=0; x<s->mb_width*bw; x++){
2102
                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);
2103
                
2104
                switch(s->avctx->frame_skip_exp){
2105
                    case 0: score= FFMAX(score, v); break;
2106
                    case 1: score+= ABS(v);break;
2107
                    case 2: score+= v*v;break;
2108
                    case 3: score64+= ABS(v*v*(int64_t)v);break;
2109
                    case 4: score64+= v*v*(int64_t)(v*v);break;
2110
                }
2111
            }
2112
        }
2113
    }
2114
    
2115
    if(score) score64= score;
2116

    
2117
    if(score64 < s->avctx->frame_skip_threshold)
2118
        return 1;
2119
    if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2120
        return 1;
2121
    return 0;
2122
}
2123

    
2124
static void select_input_picture(MpegEncContext *s){
2125
    int i;
2126

    
2127
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2128
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2129
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2130

    
2131
    /* set next picture types & ordering */
2132
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2133
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2134
            s->reordered_input_picture[0]= s->input_picture[0];
2135
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2136
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2137
        }else{
2138
            int b_frames;
2139

    
2140
            if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2141
                if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2142
//av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2143
                
2144
                    if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2145
                        for(i=0; i<4; i++)
2146
                            s->input_picture[0]->data[i]= NULL;
2147
                        s->input_picture[0]->type= 0;            
2148
                    }else{
2149
                        assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER 
2150
                               || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2151
            
2152
                        s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2153
                    }
2154

    
2155
                    goto no_output_pic;
2156
                }
2157
            }
2158

    
2159
            if(s->flags&CODEC_FLAG_PASS2){
2160
                for(i=0; i<s->max_b_frames+1; i++){
2161
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2162

    
2163
                    if(pict_num >= s->rc_context.num_entries) 
2164
                        break;
2165
                    if(!s->input_picture[i]){
2166
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2167
                        break;
2168
                    }
2169

    
2170
                    s->input_picture[i]->pict_type= 
2171
                        s->rc_context.entry[pict_num].new_pict_type;
2172
                }
2173
            }
2174

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

    
2201
            emms_c();
2202
//static int b_count=0;
2203
//b_count+= b_frames;
2204
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2205

    
2206
            for(i= b_frames - 1; i>=0; i--){
2207
                int type= s->input_picture[i]->pict_type;
2208
                if(type && type != B_TYPE)
2209
                    b_frames= i;
2210
            }
2211
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2212
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2213
            }
2214

    
2215
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2216
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2217
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2218
              }else{
2219
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2220
                    b_frames=0;
2221
                s->input_picture[b_frames]->pict_type= I_TYPE;
2222
              }
2223
            }
2224
            
2225
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2226
               && b_frames
2227
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2228
                b_frames--;
2229

    
2230
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2231
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2232
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2233
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2234
            for(i=0; i<b_frames; i++){
2235
                s->reordered_input_picture[i+1]= s->input_picture[i];
2236
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2237
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2238
            }
2239
        }
2240
    }
2241
no_output_pic:
2242
    if(s->reordered_input_picture[0]){
2243
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2244

    
2245
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2246

    
2247
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2248
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2249
        
2250
            int i= ff_find_unused_picture(s, 0);
2251
            Picture *pic= &s->picture[i];
2252

    
2253
            /* mark us unused / free shared pic */
2254
            for(i=0; i<4; i++)
2255
                s->reordered_input_picture[0]->data[i]= NULL;
2256
            s->reordered_input_picture[0]->type= 0;
2257
            
2258
            pic->reference              = s->reordered_input_picture[0]->reference;
2259
            
2260
            alloc_picture(s, pic, 0);
2261

    
2262
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2263

    
2264
            s->current_picture_ptr= pic;
2265
        }else{
2266
            // input is not a shared pix -> reuse buffer for current_pix
2267

    
2268
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2269
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2270
            
2271
            s->current_picture_ptr= s->reordered_input_picture[0];
2272
            for(i=0; i<4; i++){
2273
                s->new_picture.data[i]+=16;
2274
            }
2275
        }
2276
        copy_picture(&s->current_picture, s->current_picture_ptr);
2277
    
2278
        s->picture_number= s->new_picture.display_picture_number;
2279
//printf("dpn:%d\n", s->picture_number);
2280
    }else{
2281
       memset(&s->new_picture, 0, sizeof(Picture));
2282
    }
2283
}
2284

    
2285
int MPV_encode_picture(AVCodecContext *avctx,
2286
                       unsigned char *buf, int buf_size, void *data)
2287
{
2288
    MpegEncContext *s = avctx->priv_data;
2289
    AVFrame *pic_arg = data;
2290
    int i, stuffing_count;
2291

    
2292
    if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2293
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2294
        return -1;
2295
    }
2296
    
2297
    for(i=0; i<avctx->thread_count; i++){
2298
        int start_y= s->thread_context[i]->start_mb_y;
2299
        int   end_y= s->thread_context[i]->  end_mb_y;
2300
        int h= s->mb_height;
2301
        uint8_t *start= buf + buf_size*start_y/h;
2302
        uint8_t *end  = buf + buf_size*  end_y/h;
2303

    
2304
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2305
    }
2306

    
2307
    s->picture_in_gop_number++;
2308

    
2309
    if(load_input_picture(s, pic_arg) < 0)
2310
        return -1;
2311
    
2312
    select_input_picture(s);
2313
    
2314
    /* output? */
2315
    if(s->new_picture.data[0]){
2316
        s->pict_type= s->new_picture.pict_type;
2317
//emms_c();
2318
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2319
        MPV_frame_start(s, avctx);
2320

    
2321
        encode_picture(s, s->picture_number);
2322
        
2323
        avctx->real_pict_num  = s->picture_number;
2324
        avctx->header_bits = s->header_bits;
2325
        avctx->mv_bits     = s->mv_bits;
2326
        avctx->misc_bits   = s->misc_bits;
2327
        avctx->i_tex_bits  = s->i_tex_bits;
2328
        avctx->p_tex_bits  = s->p_tex_bits;
2329
        avctx->i_count     = s->i_count;
2330
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2331
        avctx->skip_count  = s->skip_count;
2332

    
2333
        MPV_frame_end(s);
2334

    
2335
        if (s->out_format == FMT_MJPEG)
2336
            mjpeg_picture_trailer(s);
2337
        
2338
        if(s->flags&CODEC_FLAG_PASS1)
2339
            ff_write_pass1_stats(s);
2340

    
2341
        for(i=0; i<4; i++){
2342
            avctx->error[i] += s->current_picture_ptr->error[i];
2343
        }
2344

    
2345
        if(s->flags&CODEC_FLAG_PASS1)
2346
            assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2347
        flush_put_bits(&s->pb);
2348
        s->frame_bits  = put_bits_count(&s->pb);
2349

    
2350
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2351
        if(stuffing_count){
2352
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2353
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2354
                return -1;
2355
            }
2356

    
2357
            switch(s->codec_id){
2358
            case CODEC_ID_MPEG1VIDEO:
2359
            case CODEC_ID_MPEG2VIDEO:
2360
                while(stuffing_count--){
2361
                    put_bits(&s->pb, 8, 0);
2362
                }
2363
            break;
2364
            case CODEC_ID_MPEG4:
2365
                put_bits(&s->pb, 16, 0);
2366
                put_bits(&s->pb, 16, 0x1C3);
2367
                stuffing_count -= 4;
2368
                while(stuffing_count--){
2369
                    put_bits(&s->pb, 8, 0xFF);
2370
                }
2371
            break;
2372
            default:
2373
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2374
            }
2375
            flush_put_bits(&s->pb);
2376
            s->frame_bits  = put_bits_count(&s->pb);
2377
        }
2378

    
2379
        /* update mpeg1/2 vbv_delay for CBR */    
2380
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2381
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2382
            int vbv_delay;
2383

    
2384
            assert(s->repeat_first_field==0);
2385
            
2386
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2387
            assert(vbv_delay < 0xFFFF);
2388

    
2389
            s->vbv_delay_ptr[0] &= 0xF8;
2390
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2391
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2392
            s->vbv_delay_ptr[2] &= 0x07;
2393
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2394
        }
2395
        s->total_bits += s->frame_bits;
2396
        avctx->frame_bits  = s->frame_bits;
2397
    }else{
2398
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2399
        s->frame_bits=0;
2400
    }
2401
    assert((s->frame_bits&7)==0);
2402
    
2403
    return s->frame_bits/8;
2404
}
2405

    
2406
#endif //CONFIG_ENCODERS
2407

    
2408
static inline void gmc1_motion(MpegEncContext *s,
2409
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2410
                               uint8_t **ref_picture)
2411
{
2412
    uint8_t *ptr;
2413
    int offset, src_x, src_y, linesize, uvlinesize;
2414
    int motion_x, motion_y;
2415
    int emu=0;
2416

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

    
2430
    linesize = s->linesize;
2431
    uvlinesize = s->uvlinesize;
2432
    
2433
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2434

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

    
2459
    motion_x= s->sprite_offset[1][0];
2460
    motion_y= s->sprite_offset[1][1];
2461
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2462
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2463
    motion_x<<=(3-s->sprite_warping_accuracy);
2464
    motion_y<<=(3-s->sprite_warping_accuracy);
2465
    src_x = clip(src_x, -8, s->width>>1);
2466
    if (src_x == s->width>>1)
2467
        motion_x =0;
2468
    src_y = clip(src_y, -8, s->height>>1);
2469
    if (src_y == s->height>>1)
2470
        motion_y =0;
2471

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

    
2494
static inline void gmc_motion(MpegEncContext *s,
2495
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2496
                               uint8_t **ref_picture)
2497
{
2498
    uint8_t *ptr;
2499
    int linesize, uvlinesize;
2500
    const int a= s->sprite_warping_accuracy;
2501
    int ox, oy;
2502

    
2503
    linesize = s->linesize;
2504
    uvlinesize = s->uvlinesize;
2505

    
2506
    ptr = ref_picture[0];
2507

    
2508
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2509
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2510

    
2511
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2512
           ox, 
2513
           oy, 
2514
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2515
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2516
           a+1, (1<<(2*a+1)) - s->no_rounding,
2517
           s->h_edge_pos, s->v_edge_pos);
2518
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2519
           ox + s->sprite_delta[0][0]*8, 
2520
           oy + s->sprite_delta[1][0]*8, 
2521
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2522
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2523
           a+1, (1<<(2*a+1)) - s->no_rounding,
2524
           s->h_edge_pos, s->v_edge_pos);
2525

    
2526
    if(s->flags&CODEC_FLAG_GRAY) return;
2527

    
2528
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2529
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2530

    
2531
    ptr = ref_picture[1];
2532
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2533
           ox, 
2534
           oy, 
2535
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2536
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2537
           a+1, (1<<(2*a+1)) - s->no_rounding,
2538
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2539
    
2540
    ptr = ref_picture[2];
2541
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2542
           ox, 
2543
           oy, 
2544
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2545
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2546
           a+1, (1<<(2*a+1)) - s->no_rounding,
2547
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2548
}
2549

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

    
2567
    if(src_y>= h){
2568
        src+= (h-1-src_y)*linesize;
2569
        src_y=h-1;
2570
    }else if(src_y<=-block_h){
2571
        src+= (1-block_h-src_y)*linesize;
2572
        src_y=1-block_h;
2573
    }
2574
    if(src_x>= w){
2575
        src+= (w-1-src_x);
2576
        src_x=w-1;
2577
    }else if(src_x<=-block_w){
2578
        src+= (1-block_w-src_x);
2579
        src_x=1-block_w;
2580
    }
2581

    
2582
    start_y= FFMAX(0, -src_y);
2583
    start_x= FFMAX(0, -src_x);
2584
    end_y= FFMIN(block_h, h-src_y);
2585
    end_x= FFMIN(block_w, w-src_x);
2586

    
2587
    // copy existing part
2588
    for(y=start_y; y<end_y; y++){
2589
        for(x=start_x; x<end_x; x++){
2590
            buf[x + y*linesize]= src[x + y*linesize];
2591
        }
2592
    }
2593

    
2594
    //top
2595
    for(y=0; y<start_y; y++){
2596
        for(x=start_x; x<end_x; x++){
2597
            buf[x + y*linesize]= buf[x + start_y*linesize];
2598
        }
2599
    }
2600

    
2601
    //bottom
2602
    for(y=end_y; y<block_h; y++){
2603
        for(x=start_x; x<end_x; x++){
2604
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2605
        }
2606
    }
2607
                                    
2608
    for(y=0; y<block_h; y++){
2609
       //left
2610
        for(x=0; x<start_x; x++){
2611
            buf[x + y*linesize]= buf[start_x + y*linesize];
2612
        }
2613
       
2614
       //right
2615
        for(x=end_x; x<block_w; x++){
2616
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2617
        }
2618
    }
2619
}
2620

    
2621
static inline int hpel_motion(MpegEncContext *s, 
2622
                                  uint8_t *dest, uint8_t *src,
2623
                                  int field_based, int field_select,
2624
                                  int src_x, int src_y,
2625
                                  int width, int height, int stride,
2626
                                  int h_edge_pos, int v_edge_pos,
2627
                                  int w, int h, op_pixels_func *pix_op,
2628
                                  int motion_x, int motion_y)
2629
{
2630
    int dxy;
2631
    int emu=0;
2632

    
2633
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2634
    src_x += motion_x >> 1;
2635
    src_y += motion_y >> 1;
2636
                
2637
    /* WARNING: do no forget half pels */
2638
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2639
    if (src_x == width)
2640
        dxy &= ~1;
2641
    src_y = clip(src_y, -16, height);
2642
    if (src_y == height)
2643
        dxy &= ~2;
2644
    src += src_y * stride + src_x;
2645

    
2646
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2647
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2648
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2649
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2650
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2651
            src= s->edge_emu_buffer;
2652
            emu=1;
2653
        }
2654
    }
2655
    if(field_select)
2656
        src += s->linesize;
2657
    pix_op[dxy](dest, src, stride, h);
2658
    return emu;
2659
}
2660

    
2661
static inline int hpel_motion_lowres(MpegEncContext *s, 
2662
                                  uint8_t *dest, uint8_t *src,
2663
                                  int field_based, int field_select,
2664
                                  int src_x, int src_y,
2665
                                  int width, int height, int stride,
2666
                                  int h_edge_pos, int v_edge_pos,
2667
                                  int w, int h, h264_chroma_mc_func *pix_op,
2668
                                  int motion_x, int motion_y)
2669
{
2670
    const int lowres= s->avctx->lowres;
2671
    const int s_mask= (2<<lowres)-1;
2672
    int emu=0;
2673
    int sx, sy;
2674

    
2675
    if(s->quarter_sample){
2676
        motion_x/=2;
2677
        motion_y/=2;
2678
    }
2679

    
2680
    sx= motion_x & s_mask;
2681
    sy= motion_y & s_mask;
2682
    src_x += motion_x >> (lowres+1);
2683
    src_y += motion_y >> (lowres+1);
2684
                
2685
    src += src_y * stride + src_x;
2686

    
2687
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2688
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2689
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2690
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2691
        src= s->edge_emu_buffer;
2692
        emu=1;
2693
    }
2694

    
2695
    sx <<= 2 - lowres;
2696
    sy <<= 2 - lowres;
2697
    if(field_select)
2698
        src += s->linesize;
2699
    pix_op[lowres](dest, src, stride, h, sx, sy);
2700
    return emu;
2701
}
2702

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

    
2721
    v_edge_pos = s->v_edge_pos >> field_based;
2722
    linesize   = s->current_picture.linesize[0] << field_based;
2723
    uvlinesize = s->current_picture.linesize[1] << field_based;
2724

    
2725
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2726
    src_x = s->mb_x* 16               + (motion_x >> 1);
2727
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2728

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

    
2770
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2771
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2772
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2773

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

    
2795
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2796
        dest_y += s->linesize;
2797
        dest_cb+= s->uvlinesize;
2798
        dest_cr+= s->uvlinesize;
2799
    }
2800

    
2801
    if(field_select){
2802
        ptr_y += s->linesize;
2803
        ptr_cb+= s->uvlinesize;
2804
        ptr_cr+= s->uvlinesize;
2805
    }
2806

    
2807
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2808
    
2809
    if(!(s->flags&CODEC_FLAG_GRAY)){
2810
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2811
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2812
    }
2813
    if(s->out_format == FMT_H261){
2814
        ff_h261_loop_filter(s);
2815
    }
2816
}
2817

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

    
2835
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2836
        motion_x/=2;
2837
        motion_y/=2;
2838
    }
2839
    
2840
    if(field_based){
2841
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2842
    }
2843

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

    
2870
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2871
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2872
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2873

    
2874
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2875
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2876
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2877
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2878
            ptr_y = s->edge_emu_buffer;
2879
            if(!(s->flags&CODEC_FLAG_GRAY)){
2880
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2881
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2882
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2883
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2884
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2885
                ptr_cb= uvbuf;
2886
                ptr_cr= uvbuf+16;
2887
            }
2888
    }
2889

    
2890
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2891
        dest_y += s->linesize;
2892
        dest_cb+= s->uvlinesize;
2893
        dest_cr+= s->uvlinesize;
2894
    }
2895

    
2896
    if(field_select){
2897
        ptr_y += s->linesize;
2898
        ptr_cb+= s->uvlinesize;
2899
        ptr_cr+= s->uvlinesize;
2900
    }
2901

    
2902
    sx <<= 2 - lowres;
2903
    sy <<= 2 - lowres;
2904
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2905
    
2906
    if(!(s->flags&CODEC_FLAG_GRAY)){
2907
        uvsx <<= 2 - lowres;
2908
        uvsy <<= 2 - lowres;
2909
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2910
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2911
    }
2912
    //FIXME h261 lowres loop filter
2913
}
2914

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

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

    
2994
    put_obmc(dest, ptr, s->linesize);                
2995
}
2996

    
2997
static inline void qpel_motion(MpegEncContext *s,
2998
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2999
                               int field_based, int bottom_field, int field_select,
3000
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3001
                               qpel_mc_func (*qpix_op)[16],
3002
                               int motion_x, int motion_y, int h)
3003
{
3004
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3005
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3006

    
3007
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3008
    src_x = s->mb_x *  16                 + (motion_x >> 2);
3009
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3010

    
3011
    v_edge_pos = s->v_edge_pos >> field_based;
3012
    linesize = s->linesize << field_based;
3013
    uvlinesize = s->uvlinesize << field_based;
3014
    
3015
    if(field_based){
3016
        mx= motion_x/2;
3017
        my= motion_y>>1;
3018
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3019
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
3020
        mx= (motion_x>>1) + rtab[motion_x&7];
3021
        my= (motion_y>>1) + rtab[motion_y&7];
3022
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3023
        mx= (motion_x>>1)|(motion_x&1);
3024
        my= (motion_y>>1)|(motion_y&1);
3025
    }else{
3026
        mx= motion_x/2;
3027
        my= motion_y/2;
3028
    }
3029
    mx= (mx>>1)|(mx&1);
3030
    my= (my>>1)|(my&1);
3031

    
3032
    uvdxy= (mx&1) | ((my&1)<<1);
3033
    mx>>=1;
3034
    my>>=1;
3035

    
3036
    uvsrc_x = s->mb_x *  8                 + mx;
3037
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
3038

    
3039
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
3040
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3041
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3042

    
3043
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
3044
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
3045
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
3046
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3047
        ptr_y= s->edge_emu_buffer;
3048
        if(!(s->flags&CODEC_FLAG_GRAY)){
3049
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3050
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
3051
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3052
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
3053
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3054
            ptr_cb= uvbuf;
3055
            ptr_cr= uvbuf + 16;
3056
        }
3057
    }
3058

    
3059
    if(!field_based)
3060
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
3061
    else{
3062
        if(bottom_field){
3063
            dest_y += s->linesize;
3064
            dest_cb+= s->uvlinesize;
3065
            dest_cr+= s->uvlinesize;
3066
        }
3067

    
3068
        if(field_select){
3069
            ptr_y  += s->linesize;
3070
            ptr_cb += s->uvlinesize;
3071
            ptr_cr += s->uvlinesize;
3072
        }
3073
        //damn interlaced mode
3074
        //FIXME boundary mirroring is not exactly correct here
3075
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
3076
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3077
    }
3078
    if(!(s->flags&CODEC_FLAG_GRAY)){
3079
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3080
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3081
    }
3082
}
3083

    
3084
inline int ff_h263_round_chroma(int x){
3085
    if (x >= 0)
3086
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3087
    else {
3088
        x = -x;
3089
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3090
    }
3091
}
3092

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

    
3113
    src_x = s->mb_x * 8 + mx;
3114
    src_y = s->mb_y * 8 + my;
3115
    src_x = clip(src_x, -8, s->width/2);
3116
    if (src_x == s->width/2)
3117
        dxy &= ~1;
3118
    src_y = clip(src_y, -8, s->height/2);
3119
    if (src_y == s->height/2)
3120
        dxy &= ~2;
3121
    
3122
    offset = (src_y * (s->uvlinesize)) + src_x;
3123
    ptr = ref_picture[1] + offset;
3124
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3125
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3126
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3127
            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);
3128
            ptr= s->edge_emu_buffer;
3129
            emu=1;
3130
        }
3131
    }
3132
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3133

    
3134
    ptr = ref_picture[2] + offset;
3135
    if(emu){
3136
        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);
3137
        ptr= s->edge_emu_buffer;
3138
    }
3139
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3140
}
3141

    
3142
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3143
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3144
                                     uint8_t **ref_picture,
3145
                                     h264_chroma_mc_func *pix_op,
3146
                                     int mx, int my){
3147
    const int lowres= s->avctx->lowres;
3148
    const int block_s= 8>>lowres;
3149
    const int s_mask= (2<<lowres)-1;
3150
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3151
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3152
    int emu=0, src_x, src_y, offset, sx, sy;
3153
    uint8_t *ptr;
3154
    
3155
    if(s->quarter_sample){
3156
        mx/=2;
3157
        my/=2;
3158
    }
3159

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

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

    
3213
    mb_x = s->mb_x;
3214
    mb_y = s->mb_y;
3215

    
3216
    if(s->obmc && s->pict_type != B_TYPE){
3217
        int16_t mv_cache[4][4][2];
3218
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3219
        const int mot_stride= s->b8_stride;
3220
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3221

    
3222
        assert(!s->mb_skiped);
3223
                
3224
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3225
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3226
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3227

    
3228
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3229
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3230
        }else{
3231
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3232
        }
3233

    
3234
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3235
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3236
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3237
        }else{
3238
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3239
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3240
        }
3241

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

    
3268
            mx += mv[0][0];
3269
            my += mv[0][1];
3270
        }
3271
        if(!(s->flags&CODEC_FLAG_GRAY))
3272
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3273

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

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

    
3335
                mx += s->mv[dir][i][0]/2;
3336
                my += s->mv[dir][i][1]/2;
3337
            }
3338
        }else{
3339
            for(i=0;i<4;i++) {
3340
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3341
                            ref_picture[0], 0, 0,
3342
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3343
                            s->width, s->height, s->linesize,
3344
                            s->h_edge_pos, s->v_edge_pos,
3345
                            8, 8, pix_op[1],
3346
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3347

    
3348
                mx += s->mv[dir][i][0];
3349
                my += s->mv[dir][i][1];
3350
            }
3351
        }
3352

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

    
3382
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3383
                        0, 0, s->field_select[dir][0],
3384
                        ref_picture, pix_op,
3385
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3386
        }
3387
        break;
3388
    case MV_TYPE_16X8:
3389
        for(i=0; i<2; i++){
3390
            uint8_t ** ref2picture;
3391

    
3392
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3393
                ref2picture= ref_picture;
3394
            }else{
3395
                ref2picture= s->current_picture_ptr->data;
3396
            } 
3397

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

    
3427
                // after put we make avg of the same block
3428
                pix_op=s->dsp.avg_pixels_tab; 
3429

    
3430
                //opposite parity is always in the same frame if this is second field
3431
                if(!s->first_field){
3432
                    ref_picture = s->current_picture_ptr->data;    
3433
                }
3434
            }
3435
        }
3436
    break;
3437
    default: assert(0);
3438
    }
3439
}
3440

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

    
3462
    mb_x = s->mb_x;
3463
    mb_y = s->mb_y;
3464

    
3465
    switch(s->mv_type) {
3466
    case MV_TYPE_16X16:
3467
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3468
                    0, 0, 0,
3469
                    ref_picture, pix_op,
3470
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3471
        break;
3472
    case MV_TYPE_8X8:
3473
        mx = 0;
3474
        my = 0;
3475
            for(i=0;i<4;i++) {
3476
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3477
                            ref_picture[0], 0, 0,
3478
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3479
                            s->width, s->height, s->linesize,
3480
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3481
                            block_s, block_s, pix_op,
3482
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3483

    
3484
                mx += s->mv[dir][i][0];
3485
                my += s->mv[dir][i][1];
3486
            }
3487

    
3488
        if(!(s->flags&CODEC_FLAG_GRAY))
3489
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3490
        break;
3491
    case MV_TYPE_FIELD:
3492
        if (s->picture_structure == PICT_FRAME) {
3493
            /* top field */       
3494
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3495
                        1, 0, s->field_select[dir][0],
3496
                        ref_picture, pix_op,
3497
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3498
            /* bottom field */
3499
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3500
                        1, 1, s->field_select[dir][1],
3501
                        ref_picture, pix_op,
3502
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3503
        } else {
3504
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3505
                ref_picture= s->current_picture_ptr->data;
3506
            } 
3507

    
3508
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3509
                        0, 0, s->field_select[dir][0],
3510
                        ref_picture, pix_op,
3511
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3512
        }
3513
        break;
3514
    case MV_TYPE_16X8:
3515
        for(i=0; i<2; i++){
3516
            uint8_t ** ref2picture;
3517

    
3518
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3519
                ref2picture= ref_picture;
3520
            }else{
3521
                ref2picture= s->current_picture_ptr->data;
3522
            } 
3523

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

    
3553
                // after put we make avg of the same block
3554
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3555

    
3556
                //opposite parity is always in the same frame if this is second field
3557
                if(!s->first_field){
3558
                    ref_picture = s->current_picture_ptr->data;    
3559
                }
3560
            }
3561
        }
3562
    break;
3563
    default: assert(0);
3564
    }
3565
}
3566

    
3567
/* put block[] to dest[] */
3568
static inline void put_dct(MpegEncContext *s, 
3569
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3570
{
3571
    s->dct_unquantize_intra(s, block, i, qscale);
3572
    s->dsp.idct_put (dest, line_size, block);
3573
}
3574

    
3575
/* add block[] to dest[] */
3576
static inline void add_dct(MpegEncContext *s, 
3577
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3578
{
3579
    if (s->block_last_index[i] >= 0) {
3580
        s->dsp.idct_add (dest, line_size, block);
3581
    }
3582
}
3583

    
3584
static inline void add_dequant_dct(MpegEncContext *s, 
3585
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3586
{
3587
    if (s->block_last_index[i] >= 0) {
3588
        s->dct_unquantize_inter(s, block, i, qscale);
3589

    
3590
        s->dsp.idct_add (dest, line_size, block);
3591
    }
3592
}
3593

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

    
3627
/* generic function called after a macroblock has been parsed by the
3628
   decoder or after it has been encoded by the encoder.
3629

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

    
3648
    mb_x = s->mb_x;
3649
    mb_y = s->mb_y;
3650

    
3651
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3652
       /* save DCT coefficients */
3653
       int i,j;
3654
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3655
       for(i=0; i<6; i++)
3656
           for(j=0; j<64; j++)
3657
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3658
    }
3659

    
3660
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3661

    
3662
    /* update DC predictors for P macroblocks */
3663
    if (!s->mb_intra) {
3664
        if (s->h263_pred || s->h263_aic) {
3665
            if(s->mbintra_table[mb_xy])
3666
                ff_clean_intra_table_entries(s);
3667
        } else {
3668
            s->last_dc[0] =
3669
            s->last_dc[1] =
3670
            s->last_dc[2] = 128 << s->intra_dc_precision;
3671
        }
3672
    }
3673
    else if (s->h263_pred || s->h263_aic)
3674
        s->mbintra_table[mb_xy]=1;
3675

    
3676
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3677
        uint8_t *dest_y, *dest_cb, *dest_cr;
3678
        int dct_linesize, dct_offset;
3679
        op_pixels_func (*op_pix)[4];
3680
        qpel_mc_func (*op_qpix)[16];
3681
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3682
        const int uvlinesize= s->current_picture.linesize[1];
3683
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3684
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3685

    
3686
        /* avoid copy if macroblock skipped in last frame too */
3687
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3688
        if(!s->encoding){
3689
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3690
            const int age= s->current_picture.age;
3691

    
3692
            assert(age);
3693

    
3694
            if (s->mb_skiped) {
3695
                s->mb_skiped= 0;
3696
                assert(s->pict_type!=I_TYPE);
3697
 
3698
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3699
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3700

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

    
3726
        if (!s->mb_intra) {
3727
            /* motion handling */
3728
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3729
            if(!s->encoding){
3730
                if(lowres_flag){
3731
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3732

    
3733
                    if (s->mv_dir & MV_DIR_FORWARD) {
3734
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3735
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3736
                    }
3737
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3738
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3739
                    }
3740
                }else{
3741
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3742
                        op_pix = s->dsp.put_pixels_tab;
3743
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3744
                    }else{
3745
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3746
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3747
                    }
3748
                    if (s->mv_dir & MV_DIR_FORWARD) {
3749
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3750
                        op_pix = s->dsp.avg_pixels_tab;
3751
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3752
                    }
3753
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3754
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3755
                    }
3756
                }
3757
            }
3758

    
3759
            /* skip dequant / idct if we are really late ;) */
3760
            if(s->hurry_up>1) return;
3761

    
3762
            /* add dct residue */
3763
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3764
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3765
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3766
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3767
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3768
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3769

    
3770
                if(!(s->flags&CODEC_FLAG_GRAY)){
3771
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3772
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3773
                }
3774
            } else if(s->codec_id != CODEC_ID_WMV2){
3775
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3776
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3777
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3778
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3779

    
3780
                if(!(s->flags&CODEC_FLAG_GRAY)){
3781
                    if(s->chroma_y_shift){//Chroma420
3782
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3783
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3784
                    }else{
3785
                        //chroma422
3786
                        dct_linesize = uvlinesize << s->interlaced_dct;
3787
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3788

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

    
3813
                if(!(s->flags&CODEC_FLAG_GRAY)){
3814
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3815
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3816
                }
3817
            }else{
3818
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3819
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3820
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3821
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3822

    
3823
                if(!(s->flags&CODEC_FLAG_GRAY)){
3824
                    if(s->chroma_y_shift){
3825
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3826
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3827
                    }else{
3828

    
3829
                        dct_linesize = uvlinesize << s->interlaced_dct;
3830
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3831

    
3832
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3833
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3834
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3835
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3836
                        if(!s->chroma_x_shift){//Chroma444
3837
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3838
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3839
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3840
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3841
                        }
3842
                    }
3843
                }//gray
3844
            }
3845
        }
3846
        if(!readable){
3847
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3848
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3849
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3850
        }
3851
    }
3852
}
3853

    
3854
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3855
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3856
    else                  MPV_decode_mb_internal(s, block, 0);
3857
}
3858

    
3859
#ifdef CONFIG_ENCODERS
3860

    
3861
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3862
{
3863
    static const char tab[64]=
3864
        {3,2,2,1,1,1,1,1,
3865
         1,1,1,1,1,1,1,1,
3866
         1,1,1,1,1,1,1,1,
3867
         0,0,0,0,0,0,0,0,
3868
         0,0,0,0,0,0,0,0,
3869
         0,0,0,0,0,0,0,0,
3870
         0,0,0,0,0,0,0,0,
3871
         0,0,0,0,0,0,0,0};
3872
    int score=0;
3873
    int run=0;
3874
    int i;
3875
    DCTELEM *block= s->block[n];
3876
    const int last_index= s->block_last_index[n];
3877
    int skip_dc;
3878

    
3879
    if(threshold<0){
3880
        skip_dc=0;
3881
        threshold= -threshold;
3882
    }else
3883
        skip_dc=1;
3884

    
3885
    /* are all which we could set to zero are allready zero? */
3886
    if(last_index<=skip_dc - 1) return;
3887

    
3888
    for(i=0; i<=last_index; i++){
3889
        const int j = s->intra_scantable.permutated[i];
3890
        const int level = ABS(block[j]);
3891
        if(level==1){
3892
            if(skip_dc && i==0) continue;
3893
            score+= tab[run];
3894
            run=0;
3895
        }else if(level>1){
3896
            return;
3897
        }else{
3898
            run++;
3899
        }
3900
    }
3901
    if(score >= threshold) return;
3902
    for(i=skip_dc; i<=last_index; i++){
3903
        const int j = s->intra_scantable.permutated[i];
3904
        block[j]=0;
3905
    }
3906
    if(block[0]) s->block_last_index[n]= 0;
3907
    else         s->block_last_index[n]= -1;
3908
}
3909

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

    
3941
#endif //CONFIG_ENCODERS
3942

    
3943
/**
3944
 *
3945
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3946
 */
3947
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3948
    if (s->avctx->draw_horiz_band) {
3949
        AVFrame *src;
3950
        int offset[4];
3951
        
3952
        if(s->picture_structure != PICT_FRAME){
3953
            h <<= 1;
3954
            y <<= 1;
3955
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3956
        }
3957

    
3958
        h= FFMIN(h, s->avctx->height - y);
3959

    
3960
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3961
            src= (AVFrame*)s->current_picture_ptr;
3962
        else if(s->last_picture_ptr)
3963
            src= (AVFrame*)s->last_picture_ptr;
3964
        else
3965
            return;
3966
            
3967
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3968
            offset[0]=
3969
            offset[1]=
3970
            offset[2]=
3971
            offset[3]= 0;
3972
        }else{
3973
            offset[0]= y * s->linesize;;
3974
            offset[1]= 
3975
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3976
            offset[3]= 0;
3977
        }
3978

    
3979
        emms_c();
3980

    
3981
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3982
                                  y, s->picture_structure, h);
3983
    }
3984
}
3985

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

    
3999
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4000
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4001
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4002

    
4003
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4004
    {
4005
        s->dest[0] += s->mb_y *   linesize << mb_size;
4006
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4007
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4008
    }
4009
}
4010

    
4011
#ifdef CONFIG_ENCODERS
4012

    
4013
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4014
    int x, y;
4015
//FIXME optimize
4016
    for(y=0; y<8; y++){
4017
        for(x=0; x<8; x++){
4018
            int x2, y2;
4019
            int sum=0;
4020
            int sqr=0;
4021
            int count=0;
4022

    
4023
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4024
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4025
                    int v= ptr[x2 + y2*stride];
4026
                    sum += v;
4027
                    sqr += v*v;
4028
                    count++;
4029
                }
4030
            }
4031
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4032
        }
4033
    }
4034
}
4035

    
4036
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4037
{
4038
    int16_t weight[6][64];
4039
    DCTELEM orig[6][64];
4040
    const int mb_x= s->mb_x;
4041
    const int mb_y= s->mb_y;
4042
    int i;
4043
    int skip_dct[6];
4044
    int dct_offset   = s->linesize*8; //default for progressive frames
4045
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4046
    int wrap_y, wrap_c;
4047
    
4048
    for(i=0; i<6; i++) skip_dct[i]=0;
4049
    
4050
    if(s->adaptive_quant){
4051
        const int last_qp= s->qscale;
4052
        const int mb_xy= mb_x + mb_y*s->mb_stride;
4053

    
4054
        s->lambda= s->lambda_table[mb_xy];
4055
        update_qscale(s);
4056
    
4057
        if(!(s->flags&CODEC_FLAG_QP_RD)){
4058
            s->dquant= s->qscale - last_qp;
4059

    
4060
            if(s->out_format==FMT_H263){
4061
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4062
            
4063
                if(s->codec_id==CODEC_ID_MPEG4){        
4064
                    if(!s->mb_intra){
4065
                        if(s->pict_type == B_TYPE){
4066
                            if(s->dquant&1) 
4067
                                s->dquant= (s->dquant/2)*2;
4068
                            if(s->mv_dir&MV_DIRECT)
4069
                                s->dquant= 0;
4070
                        }
4071
                        if(s->mv_type==MV_TYPE_8X8)
4072
                            s->dquant=0;
4073
                    }
4074
                }
4075
            }
4076
        }
4077
        ff_set_qscale(s, last_qp + s->dquant);
4078
    }else if(s->flags&CODEC_FLAG_QP_RD)
4079
        ff_set_qscale(s, s->qscale + s->dquant);
4080

    
4081
    wrap_y = s->linesize;
4082
    wrap_c = s->uvlinesize;
4083
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4084
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
4085
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
4086

    
4087
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4088
        uint8_t *ebuf= s->edge_emu_buffer + 32;
4089
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
4090
        ptr_y= ebuf;
4091
        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);
4092
        ptr_cb= ebuf+18*wrap_y;
4093
        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);
4094
        ptr_cr= ebuf+18*wrap_y+8;
4095
    }
4096

    
4097
    if (s->mb_intra) {
4098
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4099
            int progressive_score, interlaced_score;
4100

    
4101
            s->interlaced_dct=0;
4102
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
4103
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4104

    
4105
            if(progressive_score > 0){
4106
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
4107
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
4108
                if(progressive_score > interlaced_score){
4109
                    s->interlaced_dct=1;
4110
            
4111
                    dct_offset= wrap_y;
4112
                    wrap_y<<=1;
4113
                }
4114
            }
4115
        }
4116
        
4117
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
4118
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
4119
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
4120
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4121

    
4122
        if(s->flags&CODEC_FLAG_GRAY){
4123
            skip_dct[4]= 1;
4124
            skip_dct[5]= 1;
4125
        }else{
4126
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4127
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4128
        }
4129
    }else{
4130
        op_pixels_func (*op_pix)[4];
4131
        qpel_mc_func (*op_qpix)[16];
4132
        uint8_t *dest_y, *dest_cb, *dest_cr;
4133

    
4134
        dest_y  = s->dest[0];
4135
        dest_cb = s->dest[1];
4136
        dest_cr = s->dest[2];
4137

    
4138
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4139
            op_pix = s->dsp.put_pixels_tab;
4140
            op_qpix= s->dsp.put_qpel_pixels_tab;
4141
        }else{
4142
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4143
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4144
        }
4145

    
4146
        if (s->mv_dir & MV_DIR_FORWARD) {
4147
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4148
            op_pix = s->dsp.avg_pixels_tab;
4149
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4150
        }
4151
        if (s->mv_dir & MV_DIR_BACKWARD) {
4152
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4153
        }
4154

    
4155
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4156
            int progressive_score, interlaced_score;
4157

    
4158
            s->interlaced_dct=0;
4159
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
4160
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4161
            
4162
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4163

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

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

    
4240
        if(s->flags & CODEC_FLAG_CBP_RD){
4241
            for(i=0;i<6;i++) {
4242
                if(s->block_last_index[i] == -1)
4243
                    s->coded_score[i]= INT_MAX/256;
4244
            }
4245
        }
4246
    }
4247

    
4248
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4249
        s->block_last_index[4]=
4250
        s->block_last_index[5]= 0;
4251
        s->block[4][0]=
4252
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4253
    }
4254

    
4255
    //non c quantize code returns incorrect block_last_index FIXME
4256
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4257
        for(i=0; i<6; i++){
4258
            int j;
4259
            if(s->block_last_index[i]>0){
4260
                for(j=63; j>0; j--){
4261
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4262
                }
4263
                s->block_last_index[i]= j;
4264
            }
4265
        }
4266
    }
4267

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

    
4296
#endif //CONFIG_ENCODERS
4297

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

    
4323
#ifdef CONFIG_ENCODERS
4324
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4325
{
4326
    const uint16_t *srcw= (uint16_t*)src;
4327
    int words= length>>4;
4328
    int bits= length&15;
4329
    int i;
4330

    
4331
    if(length==0) return;
4332
    
4333
    if(words < 16){
4334
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4335
    }else if(put_bits_count(pb)&7){
4336
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4337
    }else{
4338
        for(i=0; put_bits_count(pb)&31; i++)
4339
            put_bits(pb, 8, src[i]);
4340
        flush_put_bits(pb);
4341
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4342
        skip_put_bytes(pb, 2*words-i);
4343
    }
4344
        
4345
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4346
}
4347

    
4348
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4349
    int i;
4350

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

    
4353
    /* mpeg1 */
4354
    d->mb_skip_run= s->mb_skip_run;
4355
    for(i=0; i<3; i++)
4356
        d->last_dc[i]= s->last_dc[i];
4357
    
4358
    /* statistics */
4359
    d->mv_bits= s->mv_bits;
4360
    d->i_tex_bits= s->i_tex_bits;
4361
    d->p_tex_bits= s->p_tex_bits;
4362
    d->i_count= s->i_count;
4363
    d->f_count= s->f_count;
4364
    d->b_count= s->b_count;
4365
    d->skip_count= s->skip_count;
4366
    d->misc_bits= s->misc_bits;
4367
    d->last_bits= 0;
4368

    
4369
    d->mb_skiped= 0;
4370
    d->qscale= s->qscale;
4371
    d->dquant= s->dquant;
4372
}
4373

    
4374
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4375
    int i;
4376

    
4377
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
4378
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4379
    
4380
    /* mpeg1 */
4381
    d->mb_skip_run= s->mb_skip_run;
4382
    for(i=0; i<3; i++)
4383
        d->last_dc[i]= s->last_dc[i];
4384
    
4385
    /* statistics */
4386
    d->mv_bits= s->mv_bits;
4387
    d->i_tex_bits= s->i_tex_bits;
4388
    d->p_tex_bits= s->p_tex_bits;
4389
    d->i_count= s->i_count;
4390
    d->f_count= s->f_count;
4391
    d->b_count= s->b_count;
4392
    d->skip_count= s->skip_count;
4393
    d->misc_bits= s->misc_bits;
4394

    
4395
    d->mb_intra= s->mb_intra;
4396
    d->mb_skiped= s->mb_skiped;
4397
    d->mv_type= s->mv_type;
4398
    d->mv_dir= s->mv_dir;
4399
    d->pb= s->pb;
4400
    if(s->data_partitioning){
4401
        d->pb2= s->pb2;
4402
        d->tex_pb= s->tex_pb;
4403
    }
4404
    d->block= s->block;
4405
    for(i=0; i<6; i++)
4406
        d->block_last_index[i]= s->block_last_index[i];
4407
    d->interlaced_dct= s->interlaced_dct;
4408
    d->qscale= s->qscale;
4409
}
4410

    
4411
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4412
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4413
                           int *dmin, int *next_block, int motion_x, int motion_y)
4414
{
4415
    int score;
4416
    uint8_t *dest_backup[3];
4417
    
4418
    copy_context_before_encode(s, backup, type);
4419

    
4420
    s->block= s->blocks[*next_block];
4421
    s->pb= pb[*next_block];
4422
    if(s->data_partitioning){
4423
        s->pb2   = pb2   [*next_block];
4424
        s->tex_pb= tex_pb[*next_block];
4425
    }
4426
    
4427
    if(*next_block){
4428
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4429
        s->dest[0] = s->rd_scratchpad;
4430
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4431
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4432
        assert(s->linesize >= 32); //FIXME
4433
    }
4434

    
4435
    encode_mb(s, motion_x, motion_y);
4436
    
4437
    score= put_bits_count(&s->pb);
4438
    if(s->data_partitioning){
4439
        score+= put_bits_count(&s->pb2);
4440
        score+= put_bits_count(&s->tex_pb);
4441
    }
4442
   
4443
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4444
        MPV_decode_mb(s, s->block);
4445

    
4446
        score *= s->lambda2;
4447
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4448
    }
4449
    
4450
    if(*next_block){
4451
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4452
    }
4453

    
4454
    if(score<*dmin){
4455
        *dmin= score;
4456
        *next_block^=1;
4457

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

    
4483
static int sse_mb(MpegEncContext *s){
4484
    int w= 16;
4485
    int h= 16;
4486

    
4487
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4488
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4489

    
4490
    if(w==16 && h==16)
4491
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4492
        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)
4493
               +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)
4494
               +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);
4495
      }else{
4496
        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)
4497
               +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)
4498
               +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);
4499
      }
4500
    else
4501
        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)
4502
               +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)
4503
               +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);
4504
}
4505

    
4506
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4507
    MpegEncContext *s= arg;
4508

    
4509
    
4510
    s->me.pre_pass=1;
4511
    s->me.dia_size= s->avctx->pre_dia_size;
4512
    s->first_slice_line=1;
4513
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4514
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4515
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4516
        }
4517
        s->first_slice_line=0;
4518
    }
4519
    
4520
    s->me.pre_pass=0;
4521
    
4522
    return 0;
4523
}
4524

    
4525
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4526
    MpegEncContext *s= arg;
4527

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

    
4550
static int mb_var_thread(AVCodecContext *c, void *arg){
4551
    MpegEncContext *s= arg;
4552
    int mb_x, mb_y;
4553

    
4554
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4555
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4556
            int xx = mb_x * 16;
4557
            int yy = mb_y * 16;
4558
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4559
            int varc;
4560
            int sum = s->dsp.pix_sum(pix, s->linesize);
4561
    
4562
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4563

    
4564
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4565
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4566
            s->me.mb_var_sum_temp    += varc;
4567
        }
4568
    }
4569
    return 0;
4570
}
4571

    
4572
static void write_slice_end(MpegEncContext *s){
4573
    if(s->codec_id==CODEC_ID_MPEG4){
4574
        if(s->partitioned_frame){
4575
            ff_mpeg4_merge_partitions(s);
4576
        }
4577
    
4578
        ff_mpeg4_stuffing(&s->pb);
4579
    }else if(s->out_format == FMT_MJPEG){
4580
        ff_mjpeg_stuffing(&s->pb);
4581
    }
4582

    
4583
    align_put_bits(&s->pb);
4584
    flush_put_bits(&s->pb);
4585
    
4586
    if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4587
        s->misc_bits+= get_bits_diff(s);
4588
}
4589

    
4590
static int encode_thread(AVCodecContext *c, void *arg){
4591
    MpegEncContext *s= arg;
4592
    int mb_x, mb_y, pdif = 0;
4593
    int i, j;
4594
    MpegEncContext best_s, backup_s;
4595
    uint8_t bit_buf[2][MAX_MB_BYTES];
4596
    uint8_t bit_buf2[2][MAX_MB_BYTES];
4597
    uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4598
    PutBitContext pb[2], pb2[2], tex_pb[2];
4599
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4600

    
4601
    for(i=0; i<2; i++){
4602
        init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
4603
        init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
4604
        init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4605
    }
4606

    
4607
    s->last_bits= put_bits_count(&s->pb);
4608
    s->mv_bits=0;
4609
    s->misc_bits=0;
4610
    s->i_tex_bits=0;
4611
    s->p_tex_bits=0;
4612
    s->i_count=0;
4613
    s->f_count=0;
4614
    s->b_count=0;
4615
    s->skip_count=0;
4616

    
4617
    for(i=0; i<3; i++){
4618
        /* init last dc values */
4619
        /* note: quant matrix value (8) is implied here */
4620
        s->last_dc[i] = 128 << s->intra_dc_precision;
4621
        
4622
        s->current_picture_ptr->error[i] = 0;
4623
    }
4624
    s->mb_skip_run = 0;
4625
    memset(s->last_mv, 0, sizeof(s->last_mv));
4626
     
4627
    s->last_mv_dir = 0;
4628

    
4629
    switch(s->codec_id){
4630
    case CODEC_ID_H263:
4631
    case CODEC_ID_H263P:
4632
    case CODEC_ID_FLV1:
4633
        s->gob_index = ff_h263_get_gob_height(s);
4634
        break;
4635
    case CODEC_ID_MPEG4:
4636
        if(s->partitioned_frame)
4637
            ff_mpeg4_init_partitions(s);
4638
        break;
4639
    }
4640

    
4641
    s->resync_mb_x=0;
4642
    s->resync_mb_y=0; 
4643
    s->first_slice_line = 1;
4644
    s->ptr_lastgob = s->pb.buf;
4645
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4646
//    printf("row %d at %X\n", s->mb_y, (int)s);
4647
        s->mb_x=0;
4648
        s->mb_y= mb_y;
4649

    
4650
        ff_set_qscale(s, s->qscale);
4651
        ff_init_block_index(s);
4652
        
4653
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4654
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4655
            int mb_type= s->mb_type[xy];
4656
//            int d;
4657
            int dmin= INT_MAX;
4658
            int dir;
4659

    
4660
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4661
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4662
                return -1;
4663
            }
4664
            if(s->data_partitioning){