Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 6989963c

History | View | Annotate | Download (233 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)
113
{
114
    int qscale;
115

    
116
    for(qscale=qmin; qscale<=qmax; qscale++){
117
        int i;
118
        if (dsp->fdct == ff_jpeg_fdct_islow 
119
#ifdef FAAN_POSTSCALE
120
            || dsp->fdct == ff_faandct
121
#endif
122
            ) {
123
            for(i=0;i<64;i++) {
124
                const int j= dsp->idct_permutation[i];
125
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
126
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
127
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
128
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
129
                
130
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
131
                                (qscale * quant_matrix[j]));
132
            }
133
        } else if (dsp->fdct == fdct_ifast
134
#ifndef FAAN_POSTSCALE
135
                   || dsp->fdct == ff_faandct
136
#endif
137
                   ) {
138
            for(i=0;i<64;i++) {
139
                const int j= dsp->idct_permutation[i];
140
                /* 16 <= qscale * quant_matrix[i] <= 7905 */
141
                /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
142
                /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
143
                /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
144
                
145
                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
146
                                (aanscales[i] * qscale * quant_matrix[j]));
147
            }
148
        } else {
149
            for(i=0;i<64;i++) {
150
                const int j= dsp->idct_permutation[i];
151
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
152
                   So 16           <= qscale * quant_matrix[i]             <= 7905
153
                   so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
154
                   so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
155
                */
156
                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
157
//                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
158
                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
159

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

    
167
static inline void update_qscale(MpegEncContext *s){
168
    s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
169
    s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
170
    
171
    s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
172
}
173
#endif //CONFIG_ENCODERS
174

    
175
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
176
    int i;
177
    int end;
178
    
179
    st->scantable= src_scantable;
180

    
181
    for(i=0; i<64; i++){
182
        int j;
183
        j = src_scantable[i];
184
        st->permutated[i] = permutation[j];
185
#ifdef ARCH_POWERPC
186
        st->inverse[j] = i;
187
#endif
188
    }
189
    
190
    end=-1;
191
    for(i=0; i<64; i++){
192
        int j;
193
        j = st->permutated[i];
194
        if(j>end) end=j;
195
        st->raster_end[i]= end;
196
    }
197
}
198

    
199
#ifdef CONFIG_ENCODERS
200
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
201
    int i;
202

    
203
    if(matrix){
204
        put_bits(pb, 1, 1);
205
        for(i=0;i<64;i++) {
206
            put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
207
        }
208
    }else
209
        put_bits(pb, 1, 0);
210
}
211
#endif //CONFIG_ENCODERS
212

    
213
/* init common dct for both encoder and decoder */
214
int DCT_common_init(MpegEncContext *s)
215
{
216
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
217
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
218
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
219
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
220
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
221
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
222

    
223
#ifdef CONFIG_ENCODERS
224
    s->dct_quantize= dct_quantize_c;
225
    s->denoise_dct= denoise_dct_c;
226
#endif
227
        
228
#ifdef HAVE_MMX
229
    MPV_common_init_mmx(s);
230
#endif
231
#ifdef ARCH_ALPHA
232
    MPV_common_init_axp(s);
233
#endif
234
#ifdef HAVE_MLIB
235
    MPV_common_init_mlib(s);
236
#endif
237
#ifdef HAVE_MMI
238
    MPV_common_init_mmi(s);
239
#endif
240
#ifdef ARCH_ARMV4L
241
    MPV_common_init_armv4l(s);
242
#endif
243
#ifdef ARCH_POWERPC
244
    MPV_common_init_ppc(s);
245
#endif
246

    
247
#ifdef CONFIG_ENCODERS
248
    s->fast_dct_quantize= s->dct_quantize;
249

    
250
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
251
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
252
    }
253

    
254
#endif //CONFIG_ENCODERS
255

    
256
    /* load & permutate scantables
257
       note: only wmv uses differnt ones 
258
    */
259
    if(s->alternate_scan){
260
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
261
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
262
    }else{
263
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
264
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
265
    }
266
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
267
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
268

    
269
    return 0;
270
}
271

    
272
static void copy_picture(Picture *dst, Picture *src){
273
    *dst = *src;
274
    dst->type= FF_BUFFER_TYPE_COPY;
275
}
276

    
277
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
278
    int i;
279

    
280
    dst->pict_type              = src->pict_type;
281
    dst->quality                = src->quality;
282
    dst->coded_picture_number   = src->coded_picture_number;
283
    dst->display_picture_number = src->display_picture_number;
284
//    dst->reference              = src->reference;
285
    dst->pts                    = src->pts;
286
    dst->interlaced_frame       = src->interlaced_frame;
287
    dst->top_field_first        = src->top_field_first;
288

    
289
    if(s->avctx->me_threshold){
290
        if(!src->motion_val[0])
291
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
292
        if(!src->mb_type)
293
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
294
        if(!src->ref_index[0])
295
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
296
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
297
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
298
            src->motion_subsample_log2, dst->motion_subsample_log2);
299

    
300
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
301
        
302
        for(i=0; i<2; i++){
303
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
304
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
305

    
306
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
307
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
308
            }
309
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
310
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
311
            }
312
        }
313
    }
314
}
315

    
316
/**
317
 * allocates a Picture
318
 * The pixels are allocated/set by calling get_buffer() if shared=0
319
 */
320
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
321
    const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
322
    const int mb_array_size= s->mb_stride*s->mb_height;
323
    const int b8_array_size= s->b8_stride*s->mb_height*2;
324
    const int b4_array_size= s->b4_stride*s->mb_height*4;
325
    int i;
326
    
327
    if(shared){
328
        assert(pic->data[0]);
329
        assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
330
        pic->type= FF_BUFFER_TYPE_SHARED;
331
    }else{
332
        int r;
333
        
334
        assert(!pic->data[0]);
335
        
336
        r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
337
        
338
        if(r<0 || !pic->age || !pic->type || !pic->data[0]){
339
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
340
            return -1;
341
        }
342

    
343
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
344
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
345
            return -1;
346
        }
347

    
348
        if(pic->linesize[1] != pic->linesize[2]){
349
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
350
            return -1;
351
        }
352

    
353
        s->linesize  = pic->linesize[0];
354
        s->uvlinesize= pic->linesize[1];
355
    }
356
    
357
    if(pic->qscale_table==NULL){
358
        if (s->encoding) {        
359
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
360
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
361
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
362
        }
363

    
364
        CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
365
        CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
366
        CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num    * sizeof(uint32_t))
367
        pic->mb_type= pic->mb_type_base + s->mb_stride+1;
368
        if(s->out_format == FMT_H264){
369
            for(i=0; i<2; i++){
370
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2)  * sizeof(int16_t))
371
                pic->motion_val[i]= pic->motion_val_base[i]+2;
372
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
373
            }
374
            pic->motion_subsample_log2= 2;
375
        }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
376
            for(i=0; i<2; i++){
377
                CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
378
                pic->motion_val[i]= pic->motion_val_base[i]+2;
379
                CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
380
            }
381
            pic->motion_subsample_log2= 3;
382
        }
383
        if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
384
            CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
385
        }
386
        pic->qstride= s->mb_stride;
387
        CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
388
    }
389

    
390
    //it might be nicer if the application would keep track of these but it would require a API change
391
    memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
392
    s->prev_pict_types[0]= s->pict_type;
393
    if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
394
        pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
395
    
396
    return 0;
397
fail: //for the CHECKED_ALLOCZ macro
398
    return -1;
399
}
400

    
401
/**
402
 * deallocates a picture
403
 */
404
static void free_picture(MpegEncContext *s, Picture *pic){
405
    int i;
406

    
407
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
408
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
409
    }
410

    
411
    av_freep(&pic->mb_var);
412
    av_freep(&pic->mc_mb_var);
413
    av_freep(&pic->mb_mean);
414
    av_freep(&pic->mbskip_table);
415
    av_freep(&pic->qscale_table);
416
    av_freep(&pic->mb_type_base);
417
    av_freep(&pic->dct_coeff);
418
    av_freep(&pic->pan_scan);
419
    pic->mb_type= NULL;
420
    for(i=0; i<2; i++){
421
        av_freep(&pic->motion_val_base[i]);
422
        av_freep(&pic->ref_index[i]);
423
    }
424
    
425
    if(pic->type == FF_BUFFER_TYPE_SHARED){
426
        for(i=0; i<4; i++){
427
            pic->base[i]=
428
            pic->data[i]= NULL;
429
        }
430
        pic->type= 0;        
431
    }
432
}
433

    
434
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
435
    int i;
436

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

    
441
     //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
442
    CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t)) 
443
    s->rd_scratchpad=   s->me.scratchpad;
444
    s->b_scratchpad=    s->me.scratchpad;
445
    s->obmc_scratchpad= s->me.scratchpad + 16;
446
    if (s->encoding) {
447
        CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
448
        CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
449
        if(s->avctx->noise_reduction){
450
            CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
451
        }
452
    }   
453
    CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
454
    s->block= s->blocks[0];
455

    
456
    for(i=0;i<12;i++){
457
        s->pblocks[i] = (short *)(&s->block[i]);
458
    }
459
    return 0;
460
fail:
461
    return -1; //free() through MPV_common_end()
462
}
463

    
464
static void free_duplicate_context(MpegEncContext *s){
465
    if(s==NULL) return;
466

    
467
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
468
    av_freep(&s->me.scratchpad);
469
    s->rd_scratchpad=   
470
    s->b_scratchpad=    
471
    s->obmc_scratchpad= NULL;
472
    
473
    av_freep(&s->dct_error_sum);
474
    av_freep(&s->me.map);
475
    av_freep(&s->me.score_map);
476
    av_freep(&s->blocks);
477
    s->block= NULL;
478
}
479

    
480
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
481
#define COPY(a) bak->a= src->a
482
    COPY(allocated_edge_emu_buffer);
483
    COPY(edge_emu_buffer);
484
    COPY(me.scratchpad);
485
    COPY(rd_scratchpad);
486
    COPY(b_scratchpad);
487
    COPY(obmc_scratchpad);
488
    COPY(me.map);
489
    COPY(me.score_map);
490
    COPY(blocks);
491
    COPY(block);
492
    COPY(start_mb_y);
493
    COPY(end_mb_y);
494
    COPY(me.map_generation);
495
    COPY(pb);
496
    COPY(dct_error_sum);
497
    COPY(dct_count[0]);
498
    COPY(dct_count[1]);
499
#undef COPY
500
}
501

    
502
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
503
    MpegEncContext bak;
504
    int i;
505
    //FIXME copy only needed parts
506
//START_TIMER
507
    backup_duplicate_context(&bak, dst);
508
    memcpy(dst, src, sizeof(MpegEncContext));
509
    backup_duplicate_context(dst, &bak);
510
    for(i=0;i<12;i++){
511
        dst->pblocks[i] = (short *)(&dst->block[i]);
512
    }
513
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
514
}
515

    
516
static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
517
#define COPY(a) dst->a= src->a
518
    COPY(pict_type);
519
    COPY(current_picture);
520
    COPY(f_code);
521
    COPY(b_code);
522
    COPY(qscale);
523
    COPY(lambda);
524
    COPY(lambda2);
525
    COPY(picture_in_gop_number);
526
    COPY(gop_picture_number);
527
    COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
528
    COPY(progressive_frame); //FIXME dont set in encode_header
529
    COPY(partitioned_frame); //FIXME dont set in encode_header
530
#undef COPY
531
}
532

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

    
545
    s->coded_picture_number = 0;
546
    s->picture_number = 0;
547
    s->input_picture_number = 0;
548

    
549
    s->picture_in_gop_number = 0;
550

    
551
    s->f_code = 1;
552
    s->b_code = 1;
553
}
554

    
555
/**
556
 * sets the given MpegEncContext to defaults for decoding.
557
 * the changed fields will not depend upon the prior state of the MpegEncContext.
558
 */
559
void MPV_decode_defaults(MpegEncContext *s){
560
    MPV_common_defaults(s);
561
}
562

    
563
/**
564
 * sets the given MpegEncContext to defaults for encoding.
565
 * the changed fields will not depend upon the prior state of the MpegEncContext.
566
 */
567

    
568
#ifdef CONFIG_ENCODERS
569
static void MPV_encode_defaults(MpegEncContext *s){
570
    static int done=0;
571
    
572
    MPV_common_defaults(s);
573
    
574
    if(!done){
575
        int i;
576
        done=1;
577

    
578
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
579
        memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
580
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
581

    
582
        for(i=-16; i<16; i++){
583
            default_fcode_tab[i + MAX_MV]= 1;
584
        }
585
    }
586
    s->me.mv_penalty= default_mv_penalty;
587
    s->fcode_tab= default_fcode_tab;
588
}
589
#endif //CONFIG_ENCODERS
590

    
591
/** 
592
 * init common structure for both encoder and decoder.
593
 * this assumes that some variables like width/height are already set
594
 */
595
int MPV_common_init(MpegEncContext *s)
596
{
597
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
598

    
599
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
600
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
601
        return -1;
602
    }
603

    
604
    dsputil_init(&s->dsp, s->avctx);
605
    DCT_common_init(s);
606

    
607
    s->flags= s->avctx->flags;
608
    s->flags2= s->avctx->flags2;
609

    
610
    s->mb_width  = (s->width  + 15) / 16;
611
    s->mb_height = (s->height + 15) / 16;
612
    s->mb_stride = s->mb_width + 1;
613
    s->b8_stride = s->mb_width*2 + 1;
614
    s->b4_stride = s->mb_width*4 + 1;
615
    mb_array_size= s->mb_height * s->mb_stride;
616
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
617

    
618
    /* set chroma shifts */
619
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
620
                                                    &(s->chroma_y_shift) );
621

    
622
    /* set default edge pos, will be overriden in decode_header if needed */
623
    s->h_edge_pos= s->mb_width*16;
624
    s->v_edge_pos= s->mb_height*16;
625

    
626
    s->mb_num = s->mb_width * s->mb_height;
627
    
628
    s->block_wrap[0]=
629
    s->block_wrap[1]=
630
    s->block_wrap[2]=
631
    s->block_wrap[3]= s->b8_stride;
632
    s->block_wrap[4]=
633
    s->block_wrap[5]= s->mb_stride;
634
 
635
    y_size = s->b8_stride * (2 * s->mb_height + 1);
636
    c_size = s->mb_stride * (s->mb_height + 1);
637
    yc_size = y_size + 2 * c_size;
638
    
639
    /* convert fourcc to upper case */
640
    s->avctx->codec_tag=   toupper( s->avctx->codec_tag     &0xFF)          
641
                        + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
642
                        + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 
643
                        + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
644

    
645
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
646
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
647
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
648
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
649

    
650
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
651

    
652
    CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
653
    for(y=0; y<s->mb_height; y++){
654
        for(x=0; x<s->mb_width; x++){
655
            s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
656
        }
657
    }
658
    s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
659
    
660
    if (s->encoding) {
661
        /* Allocate MV tables */
662
        CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
663
        CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
664
        CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
665
        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
666
        CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
667
        CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
668
        s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
669
        s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
670
        s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
671
        s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
672
        s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
673
        s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
674

    
675
        if(s->msmpeg4_version){
676
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
677
        }
678
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
679

    
680
        /* Allocate MB type table */
681
        CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
682
        
683
        CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
684
        
685
        CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
686
        CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
687
        CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
688
        CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
689
        CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
690
        CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
691
        
692
        if(s->avctx->noise_reduction){
693
            CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
694
        }
695
    }
696
    CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
697

    
698
    CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
699
    
700
    if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
701
        /* interlaced direct mode decoding tables */
702
            for(i=0; i<2; i++){
703
                int j, k;
704
                for(j=0; j<2; j++){
705
                    for(k=0; k<2; k++){
706
                        CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
707
                        s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
708
                    }
709
                    CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
710
                    CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
711
                    s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
712
                }
713
                CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
714
            }
715
    }
716
    if (s->out_format == FMT_H263) {
717
        /* ac values */
718
        CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
719
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
720
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
721
        s->ac_val[2] = s->ac_val[1] + c_size;
722
        
723
        /* cbp values */
724
        CHECKED_ALLOCZ(s->coded_block_base, y_size);
725
        s->coded_block= s->coded_block_base + s->b8_stride + 1;
726
        
727
        /* divx501 bitstream reorder buffer */
728
        CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
729

    
730
        /* cbp, ac_pred, pred_dir */
731
        CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
732
        CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
733
    }
734
    
735
    if (s->h263_pred || s->h263_plus || !s->encoding) {
736
        /* dc values */
737
        //MN: we need these for error resilience of intra-frames
738
        CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
739
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
740
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
741
        s->dc_val[2] = s->dc_val[1] + c_size;
742
        for(i=0;i<yc_size;i++)
743
            s->dc_val_base[i] = 1024;
744
    }
745

    
746
    /* which mb is a intra block */
747
    CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
748
    memset(s->mbintra_table, 1, mb_array_size);
749
    
750
    /* init macroblock skip table */
751
    CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
752
    //Note the +1 is for a quicker mpeg4 slice_end detection
753
    CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
754
    
755
    s->parse_context.state= -1;
756
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
757
       s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
758
       s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
759
       s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
760
    }
761

    
762
    s->context_initialized = 1;
763

    
764
    s->thread_context[0]= s;
765
    for(i=1; i<s->avctx->thread_count; i++){
766
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
767
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
768
    }
769

    
770
    for(i=0; i<s->avctx->thread_count; i++){
771
        if(init_duplicate_context(s->thread_context[i], s) < 0)
772
           goto fail;
773
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
774
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
775
    }
776

    
777
    return 0;
778
 fail:
779
    MPV_common_end(s);
780
    return -1;
781
}
782

    
783
/* init common structure for both encoder and decoder */
784
void MPV_common_end(MpegEncContext *s)
785
{
786
    int i, j, k;
787

    
788
    for(i=0; i<s->avctx->thread_count; i++){
789
        free_duplicate_context(s->thread_context[i]);
790
    }
791
    for(i=1; i<s->avctx->thread_count; i++){
792
        av_freep(&s->thread_context[i]);
793
    }
794

    
795
    av_freep(&s->parse_context.buffer);
796
    s->parse_context.buffer_size=0;
797

    
798
    av_freep(&s->mb_type);
799
    av_freep(&s->p_mv_table_base);
800
    av_freep(&s->b_forw_mv_table_base);
801
    av_freep(&s->b_back_mv_table_base);
802
    av_freep(&s->b_bidir_forw_mv_table_base);
803
    av_freep(&s->b_bidir_back_mv_table_base);
804
    av_freep(&s->b_direct_mv_table_base);
805
    s->p_mv_table= NULL;
806
    s->b_forw_mv_table= NULL;
807
    s->b_back_mv_table= NULL;
808
    s->b_bidir_forw_mv_table= NULL;
809
    s->b_bidir_back_mv_table= NULL;
810
    s->b_direct_mv_table= NULL;
811
    for(i=0; i<2; i++){
812
        for(j=0; j<2; j++){
813
            for(k=0; k<2; k++){
814
                av_freep(&s->b_field_mv_table_base[i][j][k]);
815
                s->b_field_mv_table[i][j][k]=NULL;
816
            }
817
            av_freep(&s->b_field_select_table[i][j]);
818
            av_freep(&s->p_field_mv_table_base[i][j]);
819
            s->p_field_mv_table[i][j]=NULL;
820
        }
821
        av_freep(&s->p_field_select_table[i]);
822
    }
823
    
824
    av_freep(&s->dc_val_base);
825
    av_freep(&s->ac_val_base);
826
    av_freep(&s->coded_block_base);
827
    av_freep(&s->mbintra_table);
828
    av_freep(&s->cbp_table);
829
    av_freep(&s->pred_dir_table);
830
    
831
    av_freep(&s->mbskip_table);
832
    av_freep(&s->prev_pict_types);
833
    av_freep(&s->bitstream_buffer);
834
    av_freep(&s->avctx->stats_out);
835
    av_freep(&s->ac_stats);
836
    av_freep(&s->error_status_table);
837
    av_freep(&s->mb_index2xy);
838
    av_freep(&s->lambda_table);
839
    av_freep(&s->q_intra_matrix);
840
    av_freep(&s->q_inter_matrix);
841
    av_freep(&s->q_intra_matrix16);
842
    av_freep(&s->q_inter_matrix16);
843
    av_freep(&s->input_picture);
844
    av_freep(&s->reordered_input_picture);
845
    av_freep(&s->dct_offset);
846

    
847
    if(s->picture){
848
        for(i=0; i<MAX_PICTURE_COUNT; i++){
849
            free_picture(s, &s->picture[i]);
850
        }
851
    }
852
    av_freep(&s->picture);
853
    s->context_initialized = 0;
854
    s->last_picture_ptr=
855
    s->next_picture_ptr=
856
    s->current_picture_ptr= NULL;
857
    s->linesize= s->uvlinesize= 0;
858

    
859
    for(i=0; i<3; i++)
860
        av_freep(&s->visualization_buffer[i]);
861

    
862
    avcodec_default_free_buffers(s->avctx);
863
}
864

    
865
#ifdef CONFIG_ENCODERS
866

    
867
/* init video encoder */
868
int MPV_encode_init(AVCodecContext *avctx)
869
{
870
    MpegEncContext *s = avctx->priv_data;
871
    int i, dummy;
872
    int chroma_h_shift, chroma_v_shift;
873
    
874
    MPV_encode_defaults(s);
875

    
876
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
877

    
878
    s->bit_rate = avctx->bit_rate;
879
    s->width = avctx->width;
880
    s->height = avctx->height;
881
    if(avctx->gop_size > 600){
882
        av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
883
        avctx->gop_size=600;
884
    }
885
    s->gop_size = avctx->gop_size;
886
    s->avctx = avctx;
887
    s->flags= avctx->flags;
888
    s->flags2= avctx->flags2;
889
    s->max_b_frames= avctx->max_b_frames;
890
    s->codec_id= avctx->codec->id;
891
    s->luma_elim_threshold  = avctx->luma_elim_threshold;
892
    s->chroma_elim_threshold= avctx->chroma_elim_threshold;
893
    s->strict_std_compliance= avctx->strict_std_compliance;
894
    s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
895
    s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
896
    s->mpeg_quant= avctx->mpeg_quant;
897
    s->rtp_mode= !!avctx->rtp_payload_size;
898
    s->intra_dc_precision= avctx->intra_dc_precision;
899
    s->user_specified_pts = AV_NOPTS_VALUE;
900

    
901
    if (s->gop_size <= 1) {
902
        s->intra_only = 1;
903
        s->gop_size = 12;
904
    } else {
905
        s->intra_only = 0;
906
    }
907

    
908
    s->me_method = avctx->me_method;
909

    
910
    /* Fixed QSCALE */
911
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
912
    
913
    s->adaptive_quant= (   s->avctx->lumi_masking
914
                        || s->avctx->dark_masking
915
                        || s->avctx->temporal_cplx_masking 
916
                        || s->avctx->spatial_cplx_masking
917
                        || s->avctx->p_masking
918
                        || (s->flags&CODEC_FLAG_QP_RD))
919
                       && !s->fixed_qscale;
920
    
921
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
922
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
923
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
924

    
925
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
926
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
927
        return -1;
928
    }    
929

    
930
    if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
931
        av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
932
    }
933
    
934
    if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
935
        av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
936
        return -1;
937
    }
938
    
939
    if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
940
        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
941
        return -1;
942
    }
943
        
944
    if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 
945
       && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
946
       && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
947
        
948
        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");
949
    }
950
       
951
    if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 
952
       && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
953
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
954
        return -1;
955
    }
956
        
957
    if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
958
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
959
        return -1;
960
    }
961
    
962
    if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
963
        av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
964
        return -1;
965
    }
966
    
967
    if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
968
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
969
        return -1;
970
    }
971

    
972
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
973
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
974
        return -1;
975
    }
976
    
977
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
978
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
979
        return -1;
980
    }
981

    
982
    if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 
983
       && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
984
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
985
        return -1;
986
    }
987
        
988
    if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
989
        av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
990
        return -1;
991
    }
992
        
993
    if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
994
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
995
        return -1;
996
    }
997

    
998
    if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
999
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1000
        return -1;
1001
    }
1002
    
1003
    if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1004
        av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1005
        return -1;
1006
    }
1007
    
1008
    if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 
1009
       && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 
1010
       && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1011
        av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1012
        return -1;
1013
    }
1014
    
1015
    if(s->avctx->thread_count > 1)
1016
        s->rtp_mode= 1;
1017

    
1018
    i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1019
    if(i > 1){
1020
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1021
        avctx->frame_rate /= i;
1022
        avctx->frame_rate_base /= i;
1023
//        return -1;
1024
    }
1025
    
1026
    if(s->codec_id==CODEC_ID_MJPEG){
1027
        s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1028
        s->inter_quant_bias= 0;
1029
    }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1030
        s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1031
        s->inter_quant_bias= 0;
1032
    }else{
1033
        s->intra_quant_bias=0;
1034
        s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1035
    }
1036
    
1037
    if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1038
        s->intra_quant_bias= avctx->intra_quant_bias;
1039
    if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1040
        s->inter_quant_bias= avctx->inter_quant_bias;
1041
        
1042
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1043

    
1044
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1045
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1046

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

    
1105
        /* /Fx */
1106
        /* These are just to be sure */
1107
        avctx->delay=0;
1108
        s->low_delay=1;
1109
        break;
1110
    case CODEC_ID_FLV1:
1111
        s->out_format = FMT_H263;
1112
        s->h263_flv = 2; /* format = 1; 11-bit codes */
1113
        s->unrestricted_mv = 1;
1114
        s->rtp_mode=0; /* don't allow GOB */
1115
        avctx->delay=0;
1116
        s->low_delay=1;
1117
        break;
1118
    case CODEC_ID_RV10:
1119
        s->out_format = FMT_H263;
1120
        avctx->delay=0;
1121
        s->low_delay=1;
1122
        break;
1123
    case CODEC_ID_MPEG4:
1124
        s->out_format = FMT_H263;
1125
        s->h263_pred = 1;
1126
        s->unrestricted_mv = 1;
1127
        s->low_delay= s->max_b_frames ? 0 : 1;
1128
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1129
        break;
1130
    case CODEC_ID_MSMPEG4V1:
1131
        s->out_format = FMT_H263;
1132
        s->h263_msmpeg4 = 1;
1133
        s->h263_pred = 1;
1134
        s->unrestricted_mv = 1;
1135
        s->msmpeg4_version= 1;
1136
        avctx->delay=0;
1137
        s->low_delay=1;
1138
        break;
1139
    case CODEC_ID_MSMPEG4V2:
1140
        s->out_format = FMT_H263;
1141
        s->h263_msmpeg4 = 1;
1142
        s->h263_pred = 1;
1143
        s->unrestricted_mv = 1;
1144
        s->msmpeg4_version= 2;
1145
        avctx->delay=0;
1146
        s->low_delay=1;
1147
        break;
1148
    case CODEC_ID_MSMPEG4V3:
1149
        s->out_format = FMT_H263;
1150
        s->h263_msmpeg4 = 1;
1151
        s->h263_pred = 1;
1152
        s->unrestricted_mv = 1;
1153
        s->msmpeg4_version= 3;
1154
        s->flipflop_rounding=1;
1155
        avctx->delay=0;
1156
        s->low_delay=1;
1157
        break;
1158
    case CODEC_ID_WMV1:
1159
        s->out_format = FMT_H263;
1160
        s->h263_msmpeg4 = 1;
1161
        s->h263_pred = 1;
1162
        s->unrestricted_mv = 1;
1163
        s->msmpeg4_version= 4;
1164
        s->flipflop_rounding=1;
1165
        avctx->delay=0;
1166
        s->low_delay=1;
1167
        break;
1168
    case CODEC_ID_WMV2:
1169
        s->out_format = FMT_H263;
1170
        s->h263_msmpeg4 = 1;
1171
        s->h263_pred = 1;
1172
        s->unrestricted_mv = 1;
1173
        s->msmpeg4_version= 5;
1174
        s->flipflop_rounding=1;
1175
        avctx->delay=0;
1176
        s->low_delay=1;
1177
        break;
1178
#endif
1179
    default:
1180
        return -1;
1181
    }
1182
    
1183
    avctx->has_b_frames= !s->low_delay;
1184

    
1185
    s->encoding = 1;
1186

    
1187
    /* init */
1188
    if (MPV_common_init(s) < 0)
1189
        return -1;
1190

    
1191
    if(s->modified_quant)
1192
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1193
    s->progressive_frame= 
1194
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1195
    s->quant_precision=5;
1196
    
1197
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1198
    
1199
#ifdef CONFIG_ENCODERS
1200
#ifdef CONFIG_RISKY
1201
    if (s->out_format == FMT_H261)
1202
        ff_h261_encode_init(s);
1203
    if (s->out_format == FMT_H263)
1204
        h263_encode_init(s);
1205
    if(s->msmpeg4_version)
1206
        ff_msmpeg4_encode_init(s);
1207
#endif
1208
    if (s->out_format == FMT_MPEG1)
1209
        ff_mpeg1_encode_init(s);
1210
#endif
1211

    
1212
    /* init q matrix */
1213
    for(i=0;i<64;i++) {
1214
        int j= s->dsp.idct_permutation[i];
1215
#ifdef CONFIG_RISKY
1216
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1217
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1218
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1219
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1220
            s->intra_matrix[j] =
1221
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1222
        }else
1223
#endif
1224
        { /* mpeg1/2 */
1225
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1226
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1227
        }
1228
        if(s->avctx->intra_matrix)
1229
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1230
        if(s->avctx->inter_matrix)
1231
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1232
    }
1233

    
1234
    /* precompute matrix */
1235
    /* for mjpeg, we do include qscale in the matrix */
1236
    if (s->out_format != FMT_MJPEG) {
1237
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1238
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1239
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1240
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1241
    }
1242

    
1243
    if(ff_rate_control_init(s) < 0)
1244
        return -1;
1245
    
1246
    return 0;
1247
}
1248

    
1249
int MPV_encode_end(AVCodecContext *avctx)
1250
{
1251
    MpegEncContext *s = avctx->priv_data;
1252

    
1253
#ifdef STATS
1254
    print_stats();
1255
#endif
1256

    
1257
    ff_rate_control_uninit(s);
1258

    
1259
    MPV_common_end(s);
1260
    if (s->out_format == FMT_MJPEG)
1261
        mjpeg_close(s);
1262

    
1263
    av_freep(&avctx->extradata);
1264
      
1265
    return 0;
1266
}
1267

    
1268
#endif //CONFIG_ENCODERS
1269

    
1270
void init_rl(RLTable *rl, int use_static)
1271
{
1272
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1273
    uint8_t index_run[MAX_RUN+1];
1274
    int last, run, level, start, end, i;
1275

    
1276
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1277
    if(use_static && rl->max_level[0])
1278
        return;
1279

    
1280
    /* compute max_level[], max_run[] and index_run[] */
1281
    for(last=0;last<2;last++) {
1282
        if (last == 0) {
1283
            start = 0;
1284
            end = rl->last;
1285
        } else {
1286
            start = rl->last;
1287
            end = rl->n;
1288
        }
1289

    
1290
        memset(max_level, 0, MAX_RUN + 1);
1291
        memset(max_run, 0, MAX_LEVEL + 1);
1292
        memset(index_run, rl->n, MAX_RUN + 1);
1293
        for(i=start;i<end;i++) {
1294
            run = rl->table_run[i];
1295
            level = rl->table_level[i];
1296
            if (index_run[run] == rl->n)
1297
                index_run[run] = i;
1298
            if (level > max_level[run])
1299
                max_level[run] = level;
1300
            if (run > max_run[level])
1301
                max_run[level] = run;
1302
        }
1303
        if(use_static)
1304
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1305
        else
1306
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1307
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1308
        if(use_static)
1309
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1310
        else
1311
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1312
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1313
        if(use_static)
1314
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1315
        else
1316
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1317
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1318
    }
1319
}
1320

    
1321
/* draw the edges of width 'w' of an image of size width, height */
1322
//FIXME check that this is ok for mpeg4 interlaced
1323
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1324
{
1325
    uint8_t *ptr, *last_line;
1326
    int i;
1327

    
1328
    last_line = buf + (height - 1) * wrap;
1329
    for(i=0;i<w;i++) {
1330
        /* top and bottom */
1331
        memcpy(buf - (i + 1) * wrap, buf, width);
1332
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1333
    }
1334
    /* left and right */
1335
    ptr = buf;
1336
    for(i=0;i<height;i++) {
1337
        memset(ptr - w, ptr[0], w);
1338
        memset(ptr + width, ptr[width-1], w);
1339
        ptr += wrap;
1340
    }
1341
    /* corners */
1342
    for(i=0;i<w;i++) {
1343
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1344
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1345
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1346
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1347
    }
1348
}
1349

    
1350
int ff_find_unused_picture(MpegEncContext *s, int shared){
1351
    int i;
1352
    
1353
    if(shared){
1354
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1355
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1356
        }
1357
    }else{
1358
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1359
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1360
        }
1361
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1362
            if(s->picture[i].data[0]==NULL) return i;
1363
        }
1364
    }
1365

    
1366
    assert(0);
1367
    return -1;
1368
}
1369

    
1370
static void update_noise_reduction(MpegEncContext *s){
1371
    int intra, i;
1372

    
1373
    for(intra=0; intra<2; intra++){
1374
        if(s->dct_count[intra] > (1<<16)){
1375
            for(i=0; i<64; i++){
1376
                s->dct_error_sum[intra][i] >>=1;
1377
            }
1378
            s->dct_count[intra] >>= 1;
1379
        }
1380
        
1381
        for(i=0; i<64; i++){
1382
            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);
1383
        }
1384
    }
1385
}
1386

    
1387
/**
1388
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1389
 */
1390
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1391
{
1392
    int i;
1393
    AVFrame *pic;
1394
    s->mb_skiped = 0;
1395

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

    
1398
    /* mark&release old frames */
1399
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1400
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1401

    
1402
        /* release forgotten pictures */
1403
        /* if(mpeg124/h263) */
1404
        if(!s->encoding){
1405
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1406
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1407
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1408
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1409
                }
1410
            }
1411
        }
1412
    }
1413
alloc:
1414
    if(!s->encoding){
1415
        /* release non refernce frames */
1416
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1417
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1418
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1419
            }
1420
        }
1421

    
1422
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1423
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1424
        else{
1425
            i= ff_find_unused_picture(s, 0);
1426
            pic= (AVFrame*)&s->picture[i];
1427
        }
1428

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

    
1431
        pic->coded_picture_number= s->coded_picture_number++;
1432
        
1433
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1434
            return -1;
1435

    
1436
        s->current_picture_ptr= (Picture*)pic;
1437
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1438
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1439
    }
1440

    
1441
    s->current_picture_ptr->pict_type= s->pict_type;
1442
//    if(s->flags && CODEC_FLAG_QSCALE) 
1443
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1444
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1445

    
1446
    copy_picture(&s->current_picture, s->current_picture_ptr);
1447
  
1448
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1449
    if (s->pict_type != B_TYPE) {
1450
        s->last_picture_ptr= s->next_picture_ptr;
1451
        if(!s->dropable)
1452
            s->next_picture_ptr= s->current_picture_ptr;
1453
    }
1454
/*    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,
1455
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1456
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1457
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1458
        s->pict_type, s->dropable);*/
1459
    
1460
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1461
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1462
    
1463
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1464
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1465
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1466
        goto alloc;
1467
    }
1468

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

    
1471
    if(s->picture_structure!=PICT_FRAME){
1472
        int i;
1473
        for(i=0; i<4; i++){
1474
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1475
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1476
            } 
1477
            s->current_picture.linesize[i] *= 2;
1478
            s->last_picture.linesize[i] *=2;
1479
            s->next_picture.linesize[i] *=2;
1480
        }
1481
    }
1482
  }
1483
   
1484
    s->hurry_up= s->avctx->hurry_up;
1485
    s->error_resilience= avctx->error_resilience;
1486

    
1487
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1488
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1489
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1490
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1491
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1492
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1493
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1494
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1495
    }else{
1496
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1497
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1498
    }
1499

    
1500
    if(s->dct_error_sum){
1501
        assert(s->avctx->noise_reduction && s->encoding);
1502

    
1503
        update_noise_reduction(s);
1504
    }
1505
        
1506
#ifdef HAVE_XVMC
1507
    if(s->avctx->xvmc_acceleration)
1508
        return XVMC_field_start(s, avctx);
1509
#endif
1510
    return 0;
1511
}
1512

    
1513
/* generic function for encode/decode called after a frame has been coded/decoded */
1514
void MPV_frame_end(MpegEncContext *s)
1515
{
1516
    int i;
1517
    /* draw edge for correct motion prediction if outside */
1518
#ifdef HAVE_XVMC
1519
//just to make sure that all data is rendered.
1520
    if(s->avctx->xvmc_acceleration){
1521
        XVMC_field_end(s);
1522
    }else
1523
#endif
1524
    if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1525
            draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1526
            draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1527
            draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1528
    }
1529
    emms_c();
1530
    
1531
    s->last_pict_type    = s->pict_type;
1532
    if(s->pict_type!=B_TYPE){
1533
        s->last_non_b_pict_type= s->pict_type;
1534
    }
1535
#if 0
1536
        /* copy back current_picture variables */
1537
    for(i=0; i<MAX_PICTURE_COUNT; i++){
1538
        if(s->picture[i].data[0] == s->current_picture.data[0]){
1539
            s->picture[i]= s->current_picture;
1540
            break;
1541
        }    
1542
    }
1543
    assert(i<MAX_PICTURE_COUNT);
1544
#endif    
1545

    
1546
    if(s->encoding){
1547
        /* release non refernce frames */
1548
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1549
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1550
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1551
            }
1552
        }
1553
    }
1554
    // clear copies, to avoid confusion
1555
#if 0
1556
    memset(&s->last_picture, 0, sizeof(Picture));
1557
    memset(&s->next_picture, 0, sizeof(Picture));
1558
    memset(&s->current_picture, 0, sizeof(Picture));
1559
#endif
1560
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1561
}
1562

    
1563
/**
1564
 * draws an line from (ex, ey) -> (sx, sy).
1565
 * @param w width of the image
1566
 * @param h height of the image
1567
 * @param stride stride/linesize of the image
1568
 * @param color color of the arrow
1569
 */
1570
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1571
    int t, x, y, fr, f;
1572
    
1573
    sx= clip(sx, 0, w-1);
1574
    sy= clip(sy, 0, h-1);
1575
    ex= clip(ex, 0, w-1);
1576
    ey= clip(ey, 0, h-1);
1577
    
1578
    buf[sy*stride + sx]+= color;
1579
    
1580
    if(ABS(ex - sx) > ABS(ey - sy)){
1581
        if(sx > ex){
1582
            t=sx; sx=ex; ex=t;
1583
            t=sy; sy=ey; ey=t;
1584
        }
1585
        buf+= sx + sy*stride;
1586
        ex-= sx;
1587
        f= ((ey-sy)<<16)/ex;
1588
        for(x= 0; x <= ex; x++){
1589
            y = (x*f)>>16;
1590
            fr= (x*f)&0xFFFF;
1591
            buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1592
            buf[(y+1)*stride + x]+= (color*         fr )>>16;
1593
        }
1594
    }else{
1595
        if(sy > ey){
1596
            t=sx; sx=ex; ex=t;
1597
            t=sy; sy=ey; ey=t;
1598
        }
1599
        buf+= sx + sy*stride;
1600
        ey-= sy;
1601
        if(ey) f= ((ex-sx)<<16)/ey;
1602
        else   f= 0;
1603
        for(y= 0; y <= ey; y++){
1604
            x = (y*f)>>16;
1605
            fr= (y*f)&0xFFFF;
1606
            buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;;
1607
            buf[y*stride + x+1]+= (color*         fr )>>16;;
1608
        }
1609
    }
1610
}
1611

    
1612
/**
1613
 * draws an arrow from (ex, ey) -> (sx, sy).
1614
 * @param w width of the image
1615
 * @param h height of the image
1616
 * @param stride stride/linesize of the image
1617
 * @param color color of the arrow
1618
 */
1619
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1620
    int dx,dy;
1621

    
1622
    sx= clip(sx, -100, w+100);
1623
    sy= clip(sy, -100, h+100);
1624
    ex= clip(ex, -100, w+100);
1625
    ey= clip(ey, -100, h+100);
1626
    
1627
    dx= ex - sx;
1628
    dy= ey - sy;
1629
    
1630
    if(dx*dx + dy*dy > 3*3){
1631
        int rx=  dx + dy;
1632
        int ry= -dx + dy;
1633
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1634
        
1635
        //FIXME subpixel accuracy
1636
        rx= ROUNDED_DIV(rx*3<<4, length);
1637
        ry= ROUNDED_DIV(ry*3<<4, length);
1638
        
1639
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1640
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1641
    }
1642
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1643
}
1644

    
1645
/**
1646
 * prints debuging info for the given picture.
1647
 */
1648
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1649

    
1650
    if(!pict || !pict->mb_type) return;
1651

    
1652
    if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1653
        int x,y;
1654
        
1655
        av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1656
        switch (pict->pict_type) {
1657
            case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1658
            case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1659
            case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1660
            case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1661
            case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1662
            case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;            
1663
        }
1664
        for(y=0; y<s->mb_height; y++){
1665
            for(x=0; x<s->mb_width; x++){
1666
                if(s->avctx->debug&FF_DEBUG_SKIP){
1667
                    int count= s->mbskip_table[x + y*s->mb_stride];
1668
                    if(count>9) count=9;
1669
                    av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1670
                }
1671
                if(s->avctx->debug&FF_DEBUG_QP){
1672
                    av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1673
                }
1674
                if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1675
                    int mb_type= pict->mb_type[x + y*s->mb_stride];
1676
                    //Type & MV direction
1677
                    if(IS_PCM(mb_type))
1678
                        av_log(s->avctx, AV_LOG_DEBUG, "P");
1679
                    else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1680
                        av_log(s->avctx, AV_LOG_DEBUG, "A");
1681
                    else if(IS_INTRA4x4(mb_type))
1682
                        av_log(s->avctx, AV_LOG_DEBUG, "i");
1683
                    else if(IS_INTRA16x16(mb_type))
1684
                        av_log(s->avctx, AV_LOG_DEBUG, "I");
1685
                    else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1686
                        av_log(s->avctx, AV_LOG_DEBUG, "d");
1687
                    else if(IS_DIRECT(mb_type))
1688
                        av_log(s->avctx, AV_LOG_DEBUG, "D");
1689
                    else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1690
                        av_log(s->avctx, AV_LOG_DEBUG, "g");
1691
                    else if(IS_GMC(mb_type))
1692
                        av_log(s->avctx, AV_LOG_DEBUG, "G");
1693
                    else if(IS_SKIP(mb_type))
1694
                        av_log(s->avctx, AV_LOG_DEBUG, "S");
1695
                    else if(!USES_LIST(mb_type, 1))
1696
                        av_log(s->avctx, AV_LOG_DEBUG, ">");
1697
                    else if(!USES_LIST(mb_type, 0))
1698
                        av_log(s->avctx, AV_LOG_DEBUG, "<");
1699
                    else{
1700
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1701
                        av_log(s->avctx, AV_LOG_DEBUG, "X");
1702
                    }
1703
                    
1704
                    //segmentation
1705
                    if(IS_8X8(mb_type))
1706
                        av_log(s->avctx, AV_LOG_DEBUG, "+");
1707
                    else if(IS_16X8(mb_type))
1708
                        av_log(s->avctx, AV_LOG_DEBUG, "-");
1709
                    else if(IS_8X16(mb_type))
1710
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1711
                    else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1712
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1713
                    else
1714
                        av_log(s->avctx, AV_LOG_DEBUG, "?");
1715
                    
1716
                        
1717
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1718
                        av_log(s->avctx, AV_LOG_DEBUG, "=");
1719
                    else
1720
                        av_log(s->avctx, AV_LOG_DEBUG, " ");
1721
                }
1722
//                av_log(s->avctx, AV_LOG_DEBUG, " ");
1723
            }
1724
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1725
        }
1726
    }
1727

    
1728
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1729
        const int shift= 1 + s->quarter_sample;
1730
        int mb_y;
1731
        uint8_t *ptr;
1732
        int i;
1733
        int h_chroma_shift, v_chroma_shift;
1734
        const int width = s->avctx->width;
1735
        const int height= s->avctx->height;
1736
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1737

    
1738
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1739
        for(i=0; i<3; i++){
1740
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1741
            pict->data[i]= s->visualization_buffer[i];
1742
        }
1743
        pict->type= FF_BUFFER_TYPE_COPY;
1744
        ptr= pict->data[0];
1745

    
1746
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1747
            int mb_x;
1748
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1749
                const int mb_index= mb_x + mb_y*s->mb_stride;
1750
                if((s->avctx->debug_mv) && pict->motion_val){
1751
                  int type;
1752
                  for(type=0; type<3; type++){
1753
                    int direction = 0;
1754
                    switch (type) {
1755
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1756
                                continue;
1757
                              direction = 0;
1758
                              break;
1759
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1760
                                continue;
1761
                              direction = 0;
1762
                              break;
1763
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1764
                                continue;
1765
                              direction = 1;
1766
                              break;
1767
                    }
1768
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1769
                        continue;
1770

    
1771
                    //FIXME for h264
1772
                    if(IS_8X8(pict->mb_type[mb_index])){
1773
                      int i;
1774
                      for(i=0; i<4; i++){
1775
                        int sx= mb_x*16 + 4 + 8*(i&1);
1776
                        int sy= mb_y*16 + 4 + 8*(i>>1);
1777
                        int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1778
                        int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1779
                        int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1780
                        draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1781
                      }
1782
                    }else if(IS_16X8(pict->mb_type[mb_index])){
1783
                      int i;
1784
                      for(i=0; i<2; i++){
1785
                        int sx=mb_x*16 + 8;
1786
                        int sy=mb_y*16 + 4 + 8*i;
1787
                        int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1788
                        int mx=(pict->motion_val[direction][xy][0]>>shift);
1789
                        int my=(pict->motion_val[direction][xy][1]>>shift);
1790
                        
1791
                        if(IS_INTERLACED(pict->mb_type[mb_index]))
1792
                            my*=2;
1793
                        
1794
                        draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1795
                      }
1796
                    }else{
1797
                      int sx= mb_x*16 + 8;
1798
                      int sy= mb_y*16 + 8;
1799
                      int xy= mb_x*2 + mb_y*2*s->b8_stride;
1800
                      int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1801
                      int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1802
                      draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1803
                    }
1804
                  }                  
1805
                }
1806
                if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1807
                    uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1808
                    int y;
1809
                    for(y=0; y<8; y++){
1810
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1811
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1812
                    }
1813
                }
1814
                if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1815
                    int mb_type= pict->mb_type[mb_index];
1816
                    uint64_t u,v;
1817
                    int y;
1818
#define COLOR(theta, r)\
1819
u= (int)(128 + r*cos(theta*3.141592/180));\
1820
v= (int)(128 + r*sin(theta*3.141592/180));
1821

    
1822
                    
1823
                    u=v=128;
1824
                    if(IS_PCM(mb_type)){
1825
                        COLOR(120,48)
1826
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1827
                        COLOR(30,48)
1828
                    }else if(IS_INTRA4x4(mb_type)){
1829
                        COLOR(90,48)
1830
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1831
//                        COLOR(120,48)
1832
                    }else if(IS_DIRECT(mb_type)){
1833
                        COLOR(150,48)
1834
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1835
                        COLOR(170,48)
1836
                    }else if(IS_GMC(mb_type)){
1837
                        COLOR(190,48)
1838
                    }else if(IS_SKIP(mb_type)){
1839
//                        COLOR(180,48)
1840
                    }else if(!USES_LIST(mb_type, 1)){
1841
                        COLOR(240,48)
1842
                    }else if(!USES_LIST(mb_type, 0)){
1843
                        COLOR(0,48)
1844
                    }else{
1845
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1846
                        COLOR(300,48)
1847
                    }
1848

    
1849
                    u*= 0x0101010101010101ULL;
1850
                    v*= 0x0101010101010101ULL;
1851
                    for(y=0; y<8; y++){
1852
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1853
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1854
                    }
1855

    
1856
                    //segmentation
1857
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1858
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1859
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1860
                    }
1861
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1862
                        for(y=0; y<16; y++)
1863
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1864
                    }
1865
                        
1866
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1867
                        // hmm
1868
                    }
1869
                }
1870
                s->mbskip_table[mb_index]=0;
1871
            }
1872
        }
1873
    }
1874
}
1875

    
1876
#ifdef CONFIG_ENCODERS
1877

    
1878
static int get_sae(uint8_t *src, int ref, int stride){
1879
    int x,y;
1880
    int acc=0;
1881
    
1882
    for(y=0; y<16; y++){
1883
        for(x=0; x<16; x++){
1884
            acc+= ABS(src[x+y*stride] - ref);
1885
        }
1886
    }
1887
    
1888
    return acc;
1889
}
1890

    
1891
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1892
    int x, y, w, h;
1893
    int acc=0;
1894
    
1895
    w= s->width &~15;
1896
    h= s->height&~15;
1897
    
1898
    for(y=0; y<h; y+=16){
1899
        for(x=0; x<w; x+=16){
1900
            int offset= x + y*stride;
1901
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1902
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1903
            int sae = get_sae(src + offset, mean, stride);
1904
            
1905
            acc+= sae + 500 < sad;
1906
        }
1907
    }
1908
    return acc;
1909
}
1910

    
1911

    
1912
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1913
    AVFrame *pic=NULL;
1914
    int i;
1915
    const int encoding_delay= s->max_b_frames;
1916
    int direct=1;
1917
    
1918
  if(pic_arg){
1919
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1920
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1921
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1922
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1923
  
1924
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1925
    
1926
    if(direct){
1927
        i= ff_find_unused_picture(s, 1);
1928

    
1929
        pic= (AVFrame*)&s->picture[i];
1930
        pic->reference= 3;
1931
    
1932
        for(i=0; i<4; i++){
1933
            pic->data[i]= pic_arg->data[i];
1934
            pic->linesize[i]= pic_arg->linesize[i];
1935
        }
1936
        alloc_picture(s, (Picture*)pic, 1);
1937
    }else{
1938
        int offset= 16;
1939
        i= ff_find_unused_picture(s, 0);
1940

    
1941
        pic= (AVFrame*)&s->picture[i];
1942
        pic->reference= 3;
1943

    
1944
        alloc_picture(s, (Picture*)pic, 0);
1945

    
1946
        if(   pic->data[0] + offset == pic_arg->data[0] 
1947
           && pic->data[1] + offset == pic_arg->data[1]
1948
           && pic->data[2] + offset == pic_arg->data[2]){
1949
       // empty
1950
        }else{
1951
            int h_chroma_shift, v_chroma_shift;
1952
            avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1953
        
1954
            for(i=0; i<3; i++){
1955
                int src_stride= pic_arg->linesize[i];
1956
                int dst_stride= i ? s->uvlinesize : s->linesize;
1957
                int h_shift= i ? h_chroma_shift : 0;
1958
                int v_shift= i ? v_chroma_shift : 0;
1959
                int w= s->width >>h_shift;
1960
                int h= s->height>>v_shift;
1961
                uint8_t *src= pic_arg->data[i];
1962
                uint8_t *dst= pic->data[i] + offset;
1963
            
1964
                if(src_stride==dst_stride)
1965
                    memcpy(dst, src, src_stride*h);
1966
                else{
1967
                    while(h--){
1968
                        memcpy(dst, src, w);
1969
                        dst += dst_stride;
1970
                        src += src_stride;
1971
                    }
1972
                }
1973
            }
1974
        }
1975
    }
1976
    copy_picture_attributes(s, pic, pic_arg);
1977
    
1978
    pic->display_picture_number= s->input_picture_number++;
1979
 
1980
    if(pic->pts != AV_NOPTS_VALUE){ 
1981
        if(s->user_specified_pts != AV_NOPTS_VALUE){
1982
            int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1983
            int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1984
        
1985
            if(time <= last){            
1986
                av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1987
                return -1;
1988
            }
1989
        }
1990
        s->user_specified_pts= pic->pts;
1991
    }else{
1992
        if(s->user_specified_pts != AV_NOPTS_VALUE){
1993
            s->user_specified_pts= 
1994
            pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1995
            av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1996
        }else{
1997
            pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1998
        }
1999
    }
2000
  }
2001
  
2002
    /* shift buffer entries */
2003
    for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2004
        s->input_picture[i-1]= s->input_picture[i];
2005
        
2006
    s->input_picture[encoding_delay]= (Picture*)pic;
2007

    
2008
    return 0;
2009
}
2010

    
2011
static void select_input_picture(MpegEncContext *s){
2012
    int i;
2013

    
2014
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2015
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2016
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2017

    
2018
    /* set next picture types & ordering */
2019
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2020
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2021
            s->reordered_input_picture[0]= s->input_picture[0];
2022
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2023
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2024
        }else{
2025
            int b_frames;
2026
            
2027
            if(s->flags&CODEC_FLAG_PASS2){
2028
                for(i=0; i<s->max_b_frames+1; i++){
2029
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2030

    
2031
                    if(pict_num >= s->rc_context.num_entries) 
2032
                        break;
2033
                    if(!s->input_picture[i]){
2034
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2035
                        break;
2036
                    }
2037

    
2038
                    s->input_picture[i]->pict_type= 
2039
                        s->rc_context.entry[pict_num].new_pict_type;
2040
                }
2041
            }
2042

    
2043
            if(s->avctx->b_frame_strategy==0){
2044
                b_frames= s->max_b_frames;
2045
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2046
            }else if(s->avctx->b_frame_strategy==1){
2047
                for(i=1; i<s->max_b_frames+1; i++){
2048
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2049
                        s->input_picture[i]->b_frame_score= 
2050
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2051
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2052
                    }
2053
                }
2054
                for(i=0; i<s->max_b_frames; i++){
2055
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2056
                }
2057
                                
2058
                b_frames= FFMAX(0, i-1);
2059
                
2060
                /* reset scores */
2061
                for(i=0; i<b_frames+1; i++){
2062
                    s->input_picture[i]->b_frame_score=0;
2063
                }
2064
            }else{
2065
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2066
                b_frames=0;
2067
            }
2068

    
2069
            emms_c();
2070
//static int b_count=0;
2071
//b_count+= b_frames;
2072
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2073

    
2074
            for(i= b_frames - 1; i>=0; i--){
2075
                int type= s->input_picture[i]->pict_type;
2076
                if(type && type != B_TYPE)
2077
                    b_frames= i;
2078
            }
2079
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2080
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2081
            }
2082

    
2083
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2084
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2085
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2086
              }else{
2087
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2088
                    b_frames=0;
2089
                s->input_picture[b_frames]->pict_type= I_TYPE;
2090
              }
2091
            }
2092
            
2093
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2094
               && b_frames
2095
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2096
                b_frames--;
2097

    
2098
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2099
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2100
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2101
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2102
            for(i=0; i<b_frames; i++){
2103
                s->reordered_input_picture[i+1]= s->input_picture[i];
2104
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2105
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2106
            }
2107
        }
2108
    }
2109
    
2110
    if(s->reordered_input_picture[0]){
2111
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2112

    
2113
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2114

    
2115
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2116
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2117
        
2118
            int i= ff_find_unused_picture(s, 0);
2119
            Picture *pic= &s->picture[i];
2120

    
2121
            /* mark us unused / free shared pic */
2122
            for(i=0; i<4; i++)
2123
                s->reordered_input_picture[0]->data[i]= NULL;
2124
            s->reordered_input_picture[0]->type= 0;
2125
            
2126
            pic->reference              = s->reordered_input_picture[0]->reference;
2127
            
2128
            alloc_picture(s, pic, 0);
2129

    
2130
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2131

    
2132
            s->current_picture_ptr= pic;
2133
        }else{
2134
            // input is not a shared pix -> reuse buffer for current_pix
2135

    
2136
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2137
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2138
            
2139
            s->current_picture_ptr= s->reordered_input_picture[0];
2140
            for(i=0; i<4; i++){
2141
                s->new_picture.data[i]+=16;
2142
            }
2143
        }
2144
        copy_picture(&s->current_picture, s->current_picture_ptr);
2145
    
2146
        s->picture_number= s->new_picture.display_picture_number;
2147
//printf("dpn:%d\n", s->picture_number);
2148
    }else{
2149
       memset(&s->new_picture, 0, sizeof(Picture));
2150
    }
2151
}
2152

    
2153
int MPV_encode_picture(AVCodecContext *avctx,
2154
                       unsigned char *buf, int buf_size, void *data)
2155
{
2156
    MpegEncContext *s = avctx->priv_data;
2157
    AVFrame *pic_arg = data;
2158
    int i, stuffing_count;
2159

    
2160
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2161
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2162
        return -1;
2163
    }
2164
    
2165
    for(i=0; i<avctx->thread_count; i++){
2166
        int start_y= s->thread_context[i]->start_mb_y;
2167
        int   end_y= s->thread_context[i]->  end_mb_y;
2168
        int h= s->mb_height;
2169
        uint8_t *start= buf + buf_size*start_y/h;
2170
        uint8_t *end  = buf + buf_size*  end_y/h;
2171

    
2172
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2173
    }
2174

    
2175
    s->picture_in_gop_number++;
2176

    
2177
    if(load_input_picture(s, pic_arg) < 0)
2178
        return -1;
2179
    
2180
    select_input_picture(s);
2181
    
2182
    /* output? */
2183
    if(s->new_picture.data[0]){
2184
        s->pict_type= s->new_picture.pict_type;
2185
//emms_c();
2186
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2187
        MPV_frame_start(s, avctx);
2188

    
2189
        encode_picture(s, s->picture_number);
2190
        
2191
        avctx->real_pict_num  = s->picture_number;
2192
        avctx->header_bits = s->header_bits;
2193
        avctx->mv_bits     = s->mv_bits;
2194
        avctx->misc_bits   = s->misc_bits;
2195
        avctx->i_tex_bits  = s->i_tex_bits;
2196
        avctx->p_tex_bits  = s->p_tex_bits;
2197
        avctx->i_count     = s->i_count;
2198
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2199
        avctx->skip_count  = s->skip_count;
2200

    
2201
        MPV_frame_end(s);
2202

    
2203
        if (s->out_format == FMT_MJPEG)
2204
            mjpeg_picture_trailer(s);
2205
        
2206
        if(s->flags&CODEC_FLAG_PASS1)
2207
            ff_write_pass1_stats(s);
2208

    
2209
        for(i=0; i<4; i++){
2210
            avctx->error[i] += s->current_picture_ptr->error[i];
2211
        }
2212

    
2213
        flush_put_bits(&s->pb);
2214
        s->frame_bits  = put_bits_count(&s->pb);
2215

    
2216
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2217
        if(stuffing_count){
2218
            switch(s->codec_id){
2219
            case CODEC_ID_MPEG1VIDEO:
2220
            case CODEC_ID_MPEG2VIDEO:
2221
                while(stuffing_count--){
2222
                    put_bits(&s->pb, 8, 0);
2223
                }
2224
            break;
2225
            case CODEC_ID_MPEG4:
2226
                put_bits(&s->pb, 16, 0);
2227
                put_bits(&s->pb, 16, 0x1C3);
2228
                stuffing_count -= 4;
2229
                while(stuffing_count--){
2230
                    put_bits(&s->pb, 8, 0xFF);
2231
                }
2232
            break;
2233
            default:
2234
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2235
            }
2236
            flush_put_bits(&s->pb);
2237
            s->frame_bits  = put_bits_count(&s->pb);
2238
        }
2239

    
2240
        /* update mpeg1/2 vbv_delay for CBR */    
2241
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2242
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2243
            int vbv_delay;
2244

    
2245
            assert(s->repeat_first_field==0);
2246
            
2247
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2248
            assert(vbv_delay < 0xFFFF);
2249

    
2250
            s->vbv_delay_ptr[0] &= 0xF8;
2251
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2252
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2253
            s->vbv_delay_ptr[2] &= 0x07;
2254
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2255
        }
2256
        s->total_bits += s->frame_bits;
2257
        avctx->frame_bits  = s->frame_bits;
2258
    }else{
2259
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2260
        s->frame_bits=0;
2261
    }
2262
    assert((s->frame_bits&7)==0);
2263
    
2264
    return s->frame_bits/8;
2265
}
2266

    
2267
#endif //CONFIG_ENCODERS
2268

    
2269
static inline void gmc1_motion(MpegEncContext *s,
2270
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2271
                               uint8_t **ref_picture)
2272
{
2273
    uint8_t *ptr;
2274
    int offset, src_x, src_y, linesize, uvlinesize;
2275
    int motion_x, motion_y;
2276
    int emu=0;
2277

    
2278
    motion_x= s->sprite_offset[0][0];
2279
    motion_y= s->sprite_offset[0][1];
2280
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2281
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2282
    motion_x<<=(3-s->sprite_warping_accuracy);
2283
    motion_y<<=(3-s->sprite_warping_accuracy);
2284
    src_x = clip(src_x, -16, s->width);
2285
    if (src_x == s->width)
2286
        motion_x =0;
2287
    src_y = clip(src_y, -16, s->height);
2288
    if (src_y == s->height)
2289
        motion_y =0;
2290

    
2291
    linesize = s->linesize;
2292
    uvlinesize = s->uvlinesize;
2293
    
2294
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2295

    
2296
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2297
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2298
           || (unsigned)src_y >= s->v_edge_pos - 17){
2299
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2300
            ptr= s->edge_emu_buffer;
2301
        }
2302
    }
2303
    
2304
    if((motion_x|motion_y)&7){
2305
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2306
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2307
    }else{
2308
        int dxy;
2309
        
2310
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2311
        if (s->no_rounding){
2312
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2313
        }else{
2314
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2315
        }
2316
    }
2317
    
2318
    if(s->flags&CODEC_FLAG_GRAY) return;
2319

    
2320
    motion_x= s->sprite_offset[1][0];
2321
    motion_y= s->sprite_offset[1][1];
2322
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2323
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2324
    motion_x<<=(3-s->sprite_warping_accuracy);
2325
    motion_y<<=(3-s->sprite_warping_accuracy);
2326
    src_x = clip(src_x, -8, s->width>>1);
2327
    if (src_x == s->width>>1)
2328
        motion_x =0;
2329
    src_y = clip(src_y, -8, s->height>>1);
2330
    if (src_y == s->height>>1)
2331
        motion_y =0;
2332

    
2333
    offset = (src_y * uvlinesize) + src_x;
2334
    ptr = ref_picture[1] + offset;
2335
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2336
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2337
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2338
            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);
2339
            ptr= s->edge_emu_buffer;
2340
            emu=1;
2341
        }
2342
    }
2343
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2344
    
2345
    ptr = ref_picture[2] + offset;
2346
    if(emu){
2347
        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);
2348
        ptr= s->edge_emu_buffer;
2349
    }
2350
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2351
    
2352
    return;
2353
}
2354

    
2355
static inline void gmc_motion(MpegEncContext *s,
2356
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2357
                               uint8_t **ref_picture)
2358
{
2359
    uint8_t *ptr;
2360
    int linesize, uvlinesize;
2361
    const int a= s->sprite_warping_accuracy;
2362
    int ox, oy;
2363

    
2364
    linesize = s->linesize;
2365
    uvlinesize = s->uvlinesize;
2366

    
2367
    ptr = ref_picture[0];
2368

    
2369
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2370
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2371

    
2372
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2373
           ox, 
2374
           oy, 
2375
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2376
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2377
           a+1, (1<<(2*a+1)) - s->no_rounding,
2378
           s->h_edge_pos, s->v_edge_pos);
2379
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2380
           ox + s->sprite_delta[0][0]*8, 
2381
           oy + s->sprite_delta[1][0]*8, 
2382
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2383
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2384
           a+1, (1<<(2*a+1)) - s->no_rounding,
2385
           s->h_edge_pos, s->v_edge_pos);
2386

    
2387
    if(s->flags&CODEC_FLAG_GRAY) return;
2388

    
2389
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2390
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2391

    
2392
    ptr = ref_picture[1];
2393
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2394
           ox, 
2395
           oy, 
2396
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2397
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2398
           a+1, (1<<(2*a+1)) - s->no_rounding,
2399
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2400
    
2401
    ptr = ref_picture[2];
2402
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2403
           ox, 
2404
           oy, 
2405
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2406
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2407
           a+1, (1<<(2*a+1)) - s->no_rounding,
2408
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2409
}
2410

    
2411
/**
2412
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2413
 * @param buf destination buffer
2414
 * @param src source buffer
2415
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2416
 * @param block_w width of block
2417
 * @param block_h height of block
2418
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2419
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2420
 * @param w width of the source buffer
2421
 * @param h height of the source buffer
2422
 */
2423
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2424
                                    int src_x, int src_y, int w, int h){
2425
    int x, y;
2426
    int start_y, start_x, end_y, end_x;
2427

    
2428
    if(src_y>= h){
2429
        src+= (h-1-src_y)*linesize;
2430
        src_y=h-1;
2431
    }else if(src_y<=-block_h){
2432
        src+= (1-block_h-src_y)*linesize;
2433
        src_y=1-block_h;
2434
    }
2435
    if(src_x>= w){
2436
        src+= (w-1-src_x);
2437
        src_x=w-1;
2438
    }else if(src_x<=-block_w){
2439
        src+= (1-block_w-src_x);
2440
        src_x=1-block_w;
2441
    }
2442

    
2443
    start_y= FFMAX(0, -src_y);
2444
    start_x= FFMAX(0, -src_x);
2445
    end_y= FFMIN(block_h, h-src_y);
2446
    end_x= FFMIN(block_w, w-src_x);
2447

    
2448
    // copy existing part
2449
    for(y=start_y; y<end_y; y++){
2450
        for(x=start_x; x<end_x; x++){
2451
            buf[x + y*linesize]= src[x + y*linesize];
2452
        }
2453
    }
2454

    
2455
    //top
2456
    for(y=0; y<start_y; y++){
2457
        for(x=start_x; x<end_x; x++){
2458
            buf[x + y*linesize]= buf[x + start_y*linesize];
2459
        }
2460
    }
2461

    
2462
    //bottom
2463
    for(y=end_y; y<block_h; y++){
2464
        for(x=start_x; x<end_x; x++){
2465
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2466
        }
2467
    }
2468
                                    
2469
    for(y=0; y<block_h; y++){
2470
       //left
2471
        for(x=0; x<start_x; x++){
2472
            buf[x + y*linesize]= buf[start_x + y*linesize];
2473
        }
2474
       
2475
       //right
2476
        for(x=end_x; x<block_w; x++){
2477
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2478
        }
2479
    }
2480
}
2481

    
2482
static inline int hpel_motion(MpegEncContext *s, 
2483
                                  uint8_t *dest, uint8_t *src,
2484
                                  int field_based, int field_select,
2485
                                  int src_x, int src_y,
2486
                                  int width, int height, int stride,
2487
                                  int h_edge_pos, int v_edge_pos,
2488
                                  int w, int h, op_pixels_func *pix_op,
2489
                                  int motion_x, int motion_y)
2490
{
2491
    int dxy;
2492
    int emu=0;
2493

    
2494
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2495
    src_x += motion_x >> 1;
2496
    src_y += motion_y >> 1;
2497
                
2498
    /* WARNING: do no forget half pels */
2499
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2500
    if (src_x == width)
2501
        dxy &= ~1;
2502
    src_y = clip(src_y, -16, height);
2503
    if (src_y == height)
2504
        dxy &= ~2;
2505
    src += src_y * stride + src_x;
2506

    
2507
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2508
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2509
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2510
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2511
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2512
            src= s->edge_emu_buffer;
2513
            emu=1;
2514
        }
2515
    }
2516
    if(field_select)
2517
        src += s->linesize;
2518
    pix_op[dxy](dest, src, stride, h);
2519
    return emu;
2520
}
2521

    
2522
static inline int hpel_motion_lowres(MpegEncContext *s, 
2523
                                  uint8_t *dest, uint8_t *src,
2524
                                  int field_based, int field_select,
2525
                                  int src_x, int src_y,
2526
                                  int width, int height, int stride,
2527
                                  int h_edge_pos, int v_edge_pos,
2528
                                  int w, int h, h264_chroma_mc_func *pix_op,
2529
                                  int motion_x, int motion_y)
2530
{
2531
    const int lowres= s->avctx->lowres;
2532
    const int s_mask= (2<<lowres)-1;
2533
    int emu=0;
2534
    int sx, sy;
2535

    
2536
    if(s->quarter_sample){
2537
        motion_x/=2;
2538
        motion_y/=2;
2539
    }
2540

    
2541
    sx= motion_x & s_mask;
2542
    sy= motion_y & s_mask;
2543
    src_x += motion_x >> (lowres+1);
2544
    src_y += motion_y >> (lowres+1);
2545
                
2546
    src += src_y * stride + src_x;
2547

    
2548
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2549
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2550
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2551
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2552
        src= s->edge_emu_buffer;
2553
        emu=1;
2554
    }
2555

    
2556
    sx <<= 2 - lowres;
2557
    sy <<= 2 - lowres;
2558
    if(field_select)
2559
        src += s->linesize;
2560
    pix_op[lowres](dest, src, stride, h, sx, sy);
2561
    return emu;
2562
}
2563

    
2564
/* apply one mpeg motion vector to the three components */
2565
static always_inline void mpeg_motion(MpegEncContext *s,
2566
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2567
                               int field_based, int bottom_field, int field_select,
2568
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2569
                               int motion_x, int motion_y, int h)
2570
{
2571
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2572
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2573
    
2574
#if 0    
2575
if(s->quarter_sample)
2576
{
2577
    motion_x>>=1;
2578
    motion_y>>=1;
2579
}
2580
#endif
2581

    
2582
    v_edge_pos = s->v_edge_pos >> field_based;
2583
    linesize   = s->current_picture.linesize[0] << field_based;
2584
    uvlinesize = s->current_picture.linesize[1] << field_based;
2585

    
2586
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2587
    src_x = s->mb_x* 16               + (motion_x >> 1);
2588
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2589

    
2590
    if (s->out_format == FMT_H263) {
2591
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2592
            mx = (motion_x>>1)|(motion_x&1);
2593
            my = motion_y >>1;
2594
            uvdxy = ((my & 1) << 1) | (mx & 1);
2595
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2596
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2597
        }else{
2598
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2599
            uvsrc_x = src_x>>1;
2600
            uvsrc_y = src_y>>1;
2601
        }
2602
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2603
        mx = motion_x / 4;
2604
        my = motion_y / 4;
2605
        uvdxy = 0;
2606
        uvsrc_x = s->mb_x*8 + mx;
2607
        uvsrc_y = s->mb_y*8 + my;
2608
    } else {
2609
        if(s->chroma_y_shift){
2610
            mx = motion_x / 2;
2611
            my = motion_y / 2;
2612
            uvdxy = ((my & 1) << 1) | (mx & 1);
2613
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2614
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2615
        } else {
2616
            if(s->chroma_x_shift){
2617
            //Chroma422
2618
                mx = motion_x / 2;
2619
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2620
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2621
                uvsrc_y = src_y;
2622
            } else {
2623
            //Chroma444
2624
                uvdxy = dxy;
2625
                uvsrc_x = src_x;
2626
                uvsrc_y = src_y;
2627
            }
2628
        }
2629
    }
2630

    
2631
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2632
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2633
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2634

    
2635
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2636
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2637
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2638
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2639
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2640
                return ;
2641
            }
2642
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2643
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2644
            ptr_y = s->edge_emu_buffer;
2645
            if(!(s->flags&CODEC_FLAG_GRAY)){
2646
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2647
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2648
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2649
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2650
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2651
                ptr_cb= uvbuf;
2652
                ptr_cr= uvbuf+16;
2653
            }
2654
    }
2655

    
2656
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2657
        dest_y += s->linesize;
2658
        dest_cb+= s->uvlinesize;
2659
        dest_cr+= s->uvlinesize;
2660
    }
2661

    
2662
    if(field_select){
2663
        ptr_y += s->linesize;
2664
        ptr_cb+= s->uvlinesize;
2665
        ptr_cr+= s->uvlinesize;
2666
    }
2667

    
2668
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2669
    
2670
    if(!(s->flags&CODEC_FLAG_GRAY)){
2671
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2672
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2673
    }
2674
    if(s->out_format == FMT_H261){
2675
        ff_h261_loop_filter(s);
2676
    }
2677
}
2678

    
2679
/* apply one mpeg motion vector to the three components */
2680
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2681
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2682
                               int field_based, int bottom_field, int field_select,
2683
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2684
                               int motion_x, int motion_y, int h)
2685
{
2686
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2687
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2688
    const int lowres= s->avctx->lowres;
2689
    const int block_s= 8>>lowres;
2690
    const int s_mask= (2<<lowres)-1;
2691
    const int h_edge_pos = s->h_edge_pos >> lowres;
2692
    const int v_edge_pos = s->v_edge_pos >> lowres;
2693
    linesize   = s->current_picture.linesize[0] << field_based;
2694
    uvlinesize = s->current_picture.linesize[1] << field_based;
2695

    
2696
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2697
        motion_x/=2;
2698
        motion_y/=2;
2699
    }
2700
    
2701
    if(field_based){
2702
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2703
    }
2704

    
2705
    sx= motion_x & s_mask;
2706
    sy= motion_y & s_mask;
2707
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2708
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2709
    
2710
    if (s->out_format == FMT_H263) {
2711
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2712
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2713
        uvsrc_x = src_x>>1;
2714
        uvsrc_y = src_y>>1;
2715
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2716
        mx = motion_x / 4;
2717
        my = motion_y / 4;
2718
        uvsx = (2*mx) & s_mask;
2719
        uvsy = (2*my) & s_mask;
2720
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2721
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2722
    } else {
2723
        mx = motion_x / 2;
2724
        my = motion_y / 2;
2725
        uvsx = mx & s_mask;
2726
        uvsy = my & s_mask;
2727
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2728
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2729
    }
2730

    
2731
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2732
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2733
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2734

    
2735
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2736
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2737
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2738
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2739
            ptr_y = s->edge_emu_buffer;
2740
            if(!(s->flags&CODEC_FLAG_GRAY)){
2741
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2742
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2743
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2744
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2745
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2746
                ptr_cb= uvbuf;
2747
                ptr_cr= uvbuf+16;
2748
            }
2749
    }
2750

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

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

    
2763
    sx <<= 2 - lowres;
2764
    sy <<= 2 - lowres;
2765
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2766
    
2767
    if(!(s->flags&CODEC_FLAG_GRAY)){
2768
        uvsx <<= 2 - lowres;
2769
        uvsy <<= 2 - lowres;
2770
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2771
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2772
    }
2773
    //FIXME h261 lowres loop filter
2774
}
2775

    
2776
//FIXME move to dsputil, avg variant, 16x16 version
2777
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2778
    int x;
2779
    uint8_t * const top   = src[1];
2780
    uint8_t * const left  = src[2];
2781
    uint8_t * const mid   = src[0];
2782
    uint8_t * const right = src[3];
2783
    uint8_t * const bottom= src[4];
2784
#define OBMC_FILTER(x, t, l, m, r, b)\
2785
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2786
#define OBMC_FILTER4(x, t, l, m, r, b)\
2787
    OBMC_FILTER(x         , t, l, m, r, b);\
2788
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2789
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2790
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2791
    
2792
    x=0;
2793
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2794
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2795
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2796
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2797
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2798
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2799
    x+= stride;
2800
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2801
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2802
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2803
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2804
    x+= stride;
2805
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2806
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2807
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2808
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2809
    x+= 2*stride;
2810
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2811
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2812
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2813
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2814
    x+= 2*stride;
2815
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2816
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2817
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2818
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2819
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2820
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2821
    x+= stride;
2822
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2823
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2824
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2825
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2826
}
2827

    
2828
/* obmc for 1 8x8 luma block */
2829
static inline void obmc_motion(MpegEncContext *s,
2830
                               uint8_t *dest, uint8_t *src,
2831
                               int src_x, int src_y,
2832
                               op_pixels_func *pix_op,
2833
                               int16_t mv[5][2]/* mid top left right bottom*/)
2834
#define MID    0
2835
{
2836
    int i;
2837
    uint8_t *ptr[5];
2838
    
2839
    assert(s->quarter_sample==0);
2840
    
2841
    for(i=0; i<5; i++){
2842
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2843
            ptr[i]= ptr[MID];
2844
        }else{
2845
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2846
            hpel_motion(s, ptr[i], src, 0, 0,
2847
                        src_x, src_y,
2848
                        s->width, s->height, s->linesize,
2849
                        s->h_edge_pos, s->v_edge_pos,
2850
                        8, 8, pix_op,
2851
                        mv[i][0], mv[i][1]);
2852
        }
2853
    }
2854

    
2855
    put_obmc(dest, ptr, s->linesize);                
2856
}
2857

    
2858
static inline void qpel_motion(MpegEncContext *s,
2859
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2860
                               int field_based, int bottom_field, int field_select,
2861
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2862
                               qpel_mc_func (*qpix_op)[16],
2863
                               int motion_x, int motion_y, int h)
2864
{
2865
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2866
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2867

    
2868
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2869
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2870
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2871

    
2872
    v_edge_pos = s->v_edge_pos >> field_based;
2873
    linesize = s->linesize << field_based;
2874
    uvlinesize = s->uvlinesize << field_based;
2875
    
2876
    if(field_based){
2877
        mx= motion_x/2;
2878
        my= motion_y>>1;
2879
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2880
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2881
        mx= (motion_x>>1) + rtab[motion_x&7];
2882
        my= (motion_y>>1) + rtab[motion_y&7];
2883
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2884
        mx= (motion_x>>1)|(motion_x&1);
2885
        my= (motion_y>>1)|(motion_y&1);
2886
    }else{
2887
        mx= motion_x/2;
2888
        my= motion_y/2;
2889
    }
2890
    mx= (mx>>1)|(mx&1);
2891
    my= (my>>1)|(my&1);
2892

    
2893
    uvdxy= (mx&1) | ((my&1)<<1);
2894
    mx>>=1;
2895
    my>>=1;
2896

    
2897
    uvsrc_x = s->mb_x *  8                 + mx;
2898
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2899

    
2900
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2901
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2902
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2903

    
2904
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2905
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2906
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2907
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2908
        ptr_y= s->edge_emu_buffer;
2909
        if(!(s->flags&CODEC_FLAG_GRAY)){
2910
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2911
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2912
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2913
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2914
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2915
            ptr_cb= uvbuf;
2916
            ptr_cr= uvbuf + 16;
2917
        }
2918
    }
2919

    
2920
    if(!field_based)
2921
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2922
    else{
2923
        if(bottom_field){
2924
            dest_y += s->linesize;
2925
            dest_cb+= s->uvlinesize;
2926
            dest_cr+= s->uvlinesize;
2927
        }
2928

    
2929
        if(field_select){
2930
            ptr_y  += s->linesize;
2931
            ptr_cb += s->uvlinesize;
2932
            ptr_cr += s->uvlinesize;
2933
        }
2934
        //damn interlaced mode
2935
        //FIXME boundary mirroring is not exactly correct here
2936
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2937
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2938
    }
2939
    if(!(s->flags&CODEC_FLAG_GRAY)){
2940
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2941
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2942
    }
2943
}
2944

    
2945
inline int ff_h263_round_chroma(int x){
2946
    if (x >= 0)
2947
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2948
    else {
2949
        x = -x;
2950
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2951
    }
2952
}
2953

    
2954
/**
2955
 * h263 chorma 4mv motion compensation.
2956
 */
2957
static inline void chroma_4mv_motion(MpegEncContext *s,
2958
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2959
                                     uint8_t **ref_picture,
2960
                                     op_pixels_func *pix_op,
2961
                                     int mx, int my){
2962
    int dxy, emu=0, src_x, src_y, offset;
2963
    uint8_t *ptr;
2964
    
2965
    /* In case of 8X8, we construct a single chroma motion vector
2966
       with a special rounding */
2967
    mx= ff_h263_round_chroma(mx);
2968
    my= ff_h263_round_chroma(my);
2969
    
2970
    dxy = ((my & 1) << 1) | (mx & 1);
2971
    mx >>= 1;
2972
    my >>= 1;
2973

    
2974
    src_x = s->mb_x * 8 + mx;
2975
    src_y = s->mb_y * 8 + my;
2976
    src_x = clip(src_x, -8, s->width/2);
2977
    if (src_x == s->width/2)
2978
        dxy &= ~1;
2979
    src_y = clip(src_y, -8, s->height/2);
2980
    if (src_y == s->height/2)
2981
        dxy &= ~2;
2982
    
2983
    offset = (src_y * (s->uvlinesize)) + src_x;
2984
    ptr = ref_picture[1] + offset;
2985
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2986
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2987
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2988
            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);
2989
            ptr= s->edge_emu_buffer;
2990
            emu=1;
2991
        }
2992
    }
2993
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2994

    
2995
    ptr = ref_picture[2] + offset;
2996
    if(emu){
2997
        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);
2998
        ptr= s->edge_emu_buffer;
2999
    }
3000
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3001
}
3002

    
3003
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3004
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3005
                                     uint8_t **ref_picture,
3006
                                     h264_chroma_mc_func *pix_op,
3007
                                     int mx, int my){
3008
    const int lowres= s->avctx->lowres;
3009
    const int block_s= 8>>lowres;
3010
    const int s_mask= (2<<lowres)-1;
3011
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3012
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3013
    int emu=0, src_x, src_y, offset, sx, sy;
3014
    uint8_t *ptr;
3015
    
3016
    if(s->quarter_sample){
3017
        mx/=2;
3018
        my/=2;
3019
    }
3020

    
3021
    /* In case of 8X8, we construct a single chroma motion vector
3022
       with a special rounding */
3023
    mx= ff_h263_round_chroma(mx);
3024
    my= ff_h263_round_chroma(my);
3025
    
3026
    sx= mx & s_mask;
3027
    sy= my & s_mask;
3028
    src_x = s->mb_x*block_s + (mx >> (lowres+1));
3029
    src_y = s->mb_y*block_s + (my >> (lowres+1));
3030
    
3031
    offset = src_y * s->uvlinesize + src_x;
3032
    ptr = ref_picture[1] + offset;
3033
    if(s->flags&CODEC_FLAG_EMU_EDGE){
3034
        if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3035
           || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3036
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3037
            ptr= s->edge_emu_buffer;
3038
            emu=1;
3039
        }
3040
    }     
3041
    sx <<= 2 - lowres;
3042
    sy <<= 2 - lowres;
3043
    pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3044
          
3045
    ptr = ref_picture[2] + offset;
3046
    if(emu){
3047
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3048
        ptr= s->edge_emu_buffer;
3049
    }
3050
    pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3051
}
3052

    
3053
/**
3054
 * motion compesation of a single macroblock
3055
 * @param s context
3056
 * @param dest_y luma destination pointer
3057
 * @param dest_cb chroma cb/u destination pointer
3058
 * @param dest_cr chroma cr/v destination pointer
3059
 * @param dir direction (0->forward, 1->backward)
3060
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3061
 * @param pic_op halfpel motion compensation function (average or put normally)
3062
 * @param pic_op qpel motion compensation function (average or put normally)
3063
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3064
 */
3065
static inline void MPV_motion(MpegEncContext *s, 
3066
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3067
                              int dir, uint8_t **ref_picture, 
3068
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3069
{
3070
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3071
    int mb_x, mb_y, i;
3072
    uint8_t *ptr, *dest;
3073

    
3074
    mb_x = s->mb_x;
3075
    mb_y = s->mb_y;
3076

    
3077
    if(s->obmc && s->pict_type != B_TYPE){
3078
        int16_t mv_cache[4][4][2];
3079
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3080
        const int mot_stride= s->b8_stride;
3081
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3082

    
3083
        assert(!s->mb_skiped);
3084
                
3085
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3086
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3087
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3088

    
3089
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3090
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3091
        }else{
3092
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3093
        }
3094

    
3095
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3096
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3097
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3098
        }else{
3099
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3100
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3101
        }
3102

    
3103
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3104
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3105
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3106
        }else{
3107
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3108
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3109
        }
3110
        
3111
        mx = 0;
3112
        my = 0;
3113
        for(i=0;i<4;i++) {
3114
            const int x= (i&1)+1;
3115
            const int y= (i>>1)+1;
3116
            int16_t mv[5][2]= {
3117
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3118
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3119
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3120
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3121
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3122
            //FIXME cleanup
3123
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3124
                        ref_picture[0],
3125
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3126
                        pix_op[1],
3127
                        mv);
3128

    
3129
            mx += mv[0][0];
3130
            my += mv[0][1];
3131
        }
3132
        if(!(s->flags&CODEC_FLAG_GRAY))
3133
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3134

    
3135
        return;
3136
    }
3137
   
3138
    switch(s->mv_type) {
3139
    case MV_TYPE_16X16:
3140
#ifdef CONFIG_RISKY
3141
        if(s->mcsel){
3142
            if(s->real_sprite_warping_points==1){
3143
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3144
                            ref_picture);
3145
            }else{
3146
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3147
                            ref_picture);
3148
            }
3149
        }else if(s->quarter_sample){
3150
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
3151
                        0, 0, 0,
3152
                        ref_picture, pix_op, qpix_op,
3153
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3154
        }else if(s->mspel){
3155
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3156
                        ref_picture, pix_op,
3157
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3158
        }else
3159
#endif
3160
        {
3161
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3162
                        0, 0, 0,
3163
                        ref_picture, pix_op,
3164
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3165
        }           
3166
        break;
3167
    case MV_TYPE_8X8:
3168
        mx = 0;
3169
        my = 0;
3170
        if(s->quarter_sample){
3171
            for(i=0;i<4;i++) {
3172
                motion_x = s->mv[dir][i][0];
3173
                motion_y = s->mv[dir][i][1];
3174

    
3175
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3176
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3177
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3178
                    
3179
                /* WARNING: do no forget half pels */
3180
                src_x = clip(src_x, -16, s->width);
3181
                if (src_x == s->width)
3182
                    dxy &= ~3;
3183
                src_y = clip(src_y, -16, s->height);
3184
                if (src_y == s->height)
3185
                    dxy &= ~12;
3186
                    
3187
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3188
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3189
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3190
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3191
                        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);
3192
                        ptr= s->edge_emu_buffer;
3193
                    }
3194
                }
3195
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3196
                qpix_op[1][dxy](dest, ptr, s->linesize);
3197

    
3198
                mx += s->mv[dir][i][0]/2;
3199
                my += s->mv[dir][i][1]/2;
3200
            }
3201
        }else{
3202
            for(i=0;i<4;i++) {
3203
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3204
                            ref_picture[0], 0, 0,
3205
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3206
                            s->width, s->height, s->linesize,
3207
                            s->h_edge_pos, s->v_edge_pos,
3208
                            8, 8, pix_op[1],
3209
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3210

    
3211
                mx += s->mv[dir][i][0];
3212
                my += s->mv[dir][i][1];
3213
            }
3214
        }
3215

    
3216
        if(!(s->flags&CODEC_FLAG_GRAY))
3217
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3218
        break;
3219
    case MV_TYPE_FIELD:
3220
        if (s->picture_structure == PICT_FRAME) {
3221
            if(s->quarter_sample){
3222
                for(i=0; i<2; i++){
3223
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3224
                                1, i, s->field_select[dir][i],
3225
                                ref_picture, pix_op, qpix_op,
3226
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3227
                }
3228
            }else{
3229
                /* top field */       
3230
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3231
                            1, 0, s->field_select[dir][0],
3232
                            ref_picture, pix_op,
3233
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3234
                /* bottom field */
3235
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3236
                            1, 1, s->field_select[dir][1],
3237
                            ref_picture, pix_op,
3238
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3239
            }
3240
        } else {
3241
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3242
                ref_picture= s->current_picture_ptr->data;
3243
            } 
3244

    
3245
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3246
                        0, 0, s->field_select[dir][0],
3247
                        ref_picture, pix_op,
3248
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3249
        }
3250
        break;
3251
    case MV_TYPE_16X8:
3252
        for(i=0; i<2; i++){
3253
            uint8_t ** ref2picture;
3254

    
3255
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3256
                ref2picture= ref_picture;
3257
            }else{
3258
                ref2picture= s->current_picture_ptr->data;
3259
            } 
3260

    
3261
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3262
                        0, 0, s->field_select[dir][i],
3263
                        ref2picture, pix_op,
3264
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3265
                
3266
            dest_y += 16*s->linesize;
3267
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3268
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3269
        }        
3270
        break;
3271
    case MV_TYPE_DMV:
3272
        if(s->picture_structure == PICT_FRAME){
3273
            for(i=0; i<2; i++){
3274
                int j;
3275
                for(j=0; j<2; j++){
3276
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3277
                                1, j, j^i,
3278
                                ref_picture, pix_op,
3279
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3280
                }
3281
                pix_op = s->dsp.avg_pixels_tab; 
3282
            }
3283
        }else{
3284
            for(i=0; i<2; i++){
3285
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3286
                            0, 0, s->picture_structure != i+1,
3287
                            ref_picture, pix_op,
3288
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3289

    
3290
                // after put we make avg of the same block
3291
                pix_op=s->dsp.avg_pixels_tab; 
3292

    
3293
                //opposite parity is always in the same frame if this is second field
3294
                if(!s->first_field){
3295
                    ref_picture = s->current_picture_ptr->data;    
3296
                }
3297
            }
3298
        }
3299
    break;
3300
    default: assert(0);
3301
    }
3302
}
3303

    
3304
/**
3305
 * motion compesation of a single macroblock
3306
 * @param s context
3307
 * @param dest_y luma destination pointer
3308
 * @param dest_cb chroma cb/u destination pointer
3309
 * @param dest_cr chroma cr/v destination pointer
3310
 * @param dir direction (0->forward, 1->backward)
3311
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3312
 * @param pic_op halfpel motion compensation function (average or put normally)
3313
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3314
 */
3315
static inline void MPV_motion_lowres(MpegEncContext *s, 
3316
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3317
                              int dir, uint8_t **ref_picture, 
3318
                              h264_chroma_mc_func *pix_op)
3319
{
3320
    int mx, my;
3321
    int mb_x, mb_y, i;
3322
    const int lowres= s->avctx->lowres;
3323
    const int block_s= 8>>lowres;    
3324

    
3325
    mb_x = s->mb_x;
3326
    mb_y = s->mb_y;
3327

    
3328
    switch(s->mv_type) {
3329
    case MV_TYPE_16X16:
3330
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3331
                    0, 0, 0,
3332
                    ref_picture, pix_op,
3333
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3334
        break;
3335
    case MV_TYPE_8X8:
3336
        mx = 0;
3337
        my = 0;
3338
            for(i=0;i<4;i++) {
3339
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3340
                            ref_picture[0], 0, 0,
3341
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3342
                            s->width, s->height, s->linesize,
3343
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3344
                            block_s, block_s, pix_op,
3345
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3346

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

    
3351
        if(!(s->flags&CODEC_FLAG_GRAY))
3352
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3353
        break;
3354
    case MV_TYPE_FIELD:
3355
        if (s->picture_structure == PICT_FRAME) {
3356
            /* top field */       
3357
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3358
                        1, 0, s->field_select[dir][0],
3359
                        ref_picture, pix_op,
3360
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3361
            /* bottom field */
3362
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3363
                        1, 1, s->field_select[dir][1],
3364
                        ref_picture, pix_op,
3365
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3366
        } else {
3367
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3368
                ref_picture= s->current_picture_ptr->data;
3369
            } 
3370

    
3371
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3372
                        0, 0, s->field_select[dir][0],
3373
                        ref_picture, pix_op,
3374
                        s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3375
        }
3376
        break;
3377
    case MV_TYPE_16X8:
3378
        for(i=0; i<2; i++){
3379
            uint8_t ** ref2picture;
3380

    
3381
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3382
                ref2picture= ref_picture;
3383
            }else{
3384
                ref2picture= s->current_picture_ptr->data;
3385
            } 
3386

    
3387
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3388
                        0, 0, s->field_select[dir][i],
3389
                        ref2picture, pix_op,
3390
                        s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3391
                
3392
            dest_y += 2*block_s*s->linesize;
3393
            dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3394
            dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3395
        }        
3396
        break;
3397
    case MV_TYPE_DMV:
3398
        if(s->picture_structure == PICT_FRAME){
3399
            for(i=0; i<2; i++){
3400
                int j;
3401
                for(j=0; j<2; j++){
3402
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3403
                                1, j, j^i,
3404
                                ref_picture, pix_op,
3405
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3406
                }
3407
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3408
            }
3409
        }else{
3410
            for(i=0; i<2; i++){
3411
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3412
                            0, 0, s->picture_structure != i+1,
3413
                            ref_picture, pix_op,
3414
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3415

    
3416
                // after put we make avg of the same block
3417
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3418

    
3419
                //opposite parity is always in the same frame if this is second field
3420
                if(!s->first_field){
3421
                    ref_picture = s->current_picture_ptr->data;    
3422
                }
3423
            }
3424
        }
3425
    break;
3426
    default: assert(0);
3427
    }
3428
}
3429

    
3430
/* put block[] to dest[] */
3431
static inline void put_dct(MpegEncContext *s, 
3432
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3433
{
3434
    s->dct_unquantize_intra(s, block, i, qscale);
3435
    s->dsp.idct_put (dest, line_size, block);
3436
}
3437

    
3438
/* add block[] to dest[] */
3439
static inline void add_dct(MpegEncContext *s, 
3440
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3441
{
3442
    if (s->block_last_index[i] >= 0) {
3443
        s->dsp.idct_add (dest, line_size, block);
3444
    }
3445
}
3446

    
3447
static inline void add_dequant_dct(MpegEncContext *s, 
3448
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3449
{
3450
    if (s->block_last_index[i] >= 0) {
3451
        s->dct_unquantize_inter(s, block, i, qscale);
3452

    
3453
        s->dsp.idct_add (dest, line_size, block);
3454
    }
3455
}
3456

    
3457
/**
3458
 * cleans dc, ac, coded_block for the current non intra MB
3459
 */
3460
void ff_clean_intra_table_entries(MpegEncContext *s)
3461
{
3462
    int wrap = s->b8_stride;
3463
    int xy = s->block_index[0];
3464
    
3465
    s->dc_val[0][xy           ] = 
3466
    s->dc_val[0][xy + 1       ] = 
3467
    s->dc_val[0][xy     + wrap] =
3468
    s->dc_val[0][xy + 1 + wrap] = 1024;
3469
    /* ac pred */
3470
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3471
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3472
    if (s->msmpeg4_version>=3) {
3473
        s->coded_block[xy           ] =
3474
        s->coded_block[xy + 1       ] =
3475
        s->coded_block[xy     + wrap] =
3476
        s->coded_block[xy + 1 + wrap] = 0;
3477
    }
3478
    /* chroma */
3479
    wrap = s->mb_stride;
3480
    xy = s->mb_x + s->mb_y * wrap;
3481
    s->dc_val[1][xy] =
3482
    s->dc_val[2][xy] = 1024;
3483
    /* ac pred */
3484
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3485
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3486
    
3487
    s->mbintra_table[xy]= 0;
3488
}
3489

    
3490
/* generic function called after a macroblock has been parsed by the
3491
   decoder or after it has been encoded by the encoder.
3492

3493
   Important variables used:
3494
   s->mb_intra : true if intra macroblock
3495
   s->mv_dir   : motion vector direction
3496
   s->mv_type  : motion vector type
3497
   s->mv       : motion vector
3498
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3499
 */
3500
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3501
{
3502
    int mb_x, mb_y;
3503
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3504
#ifdef HAVE_XVMC
3505
    if(s->avctx->xvmc_acceleration){
3506
        XVMC_decode_mb(s);//xvmc uses pblocks
3507
        return;
3508
    }
3509
#endif
3510

    
3511
    mb_x = s->mb_x;
3512
    mb_y = s->mb_y;
3513

    
3514
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3515
       /* save DCT coefficients */
3516
       int i,j;
3517
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3518
       for(i=0; i<6; i++)
3519
           for(j=0; j<64; j++)
3520
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3521
    }
3522

    
3523
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3524

    
3525
    /* update DC predictors for P macroblocks */
3526
    if (!s->mb_intra) {
3527
        if (s->h263_pred || s->h263_aic) {
3528
            if(s->mbintra_table[mb_xy])
3529
                ff_clean_intra_table_entries(s);
3530
        } else {
3531
            s->last_dc[0] =
3532
            s->last_dc[1] =
3533
            s->last_dc[2] = 128 << s->intra_dc_precision;
3534
        }
3535
    }
3536
    else if (s->h263_pred || s->h263_aic)
3537
        s->mbintra_table[mb_xy]=1;
3538

    
3539
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3540
        uint8_t *dest_y, *dest_cb, *dest_cr;
3541
        int dct_linesize, dct_offset;
3542
        op_pixels_func (*op_pix)[4];
3543
        qpel_mc_func (*op_qpix)[16];
3544
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3545
        const int uvlinesize= s->current_picture.linesize[1];
3546
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3547
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3548

    
3549
        /* avoid copy if macroblock skipped in last frame too */
3550
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3551
        if(!s->encoding){
3552
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3553
            const int age= s->current_picture.age;
3554

    
3555
            assert(age);
3556

    
3557
            if (s->mb_skiped) {
3558
                s->mb_skiped= 0;
3559
                assert(s->pict_type!=I_TYPE);
3560
 
3561
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3562
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3563

    
3564
                /* if previous was skipped too, then nothing to do !  */
3565
                if (*mbskip_ptr >= age && s->current_picture.reference){
3566
                    return;
3567
                }
3568
            } else if(!s->current_picture.reference){
3569
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3570
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3571
            } else{
3572
                *mbskip_ptr = 0; /* not skipped */
3573
            }
3574
        }
3575
        
3576
        dct_linesize = linesize << s->interlaced_dct;
3577
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3578
        
3579
        if(readable){
3580
            dest_y=  s->dest[0];
3581
            dest_cb= s->dest[1];
3582
            dest_cr= s->dest[2];
3583
        }else{
3584
            dest_y = s->b_scratchpad;
3585
            dest_cb= s->b_scratchpad+16*linesize;
3586
            dest_cr= s->b_scratchpad+32*linesize;
3587
        }
3588

    
3589
        if (!s->mb_intra) {
3590
            /* motion handling */
3591
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3592
            if(!s->encoding){
3593
                if(lowres_flag){
3594
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3595

    
3596
                    if (s->mv_dir & MV_DIR_FORWARD) {
3597
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3598
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3599
                    }
3600
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3601
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3602
                    }
3603
                }else{
3604
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3605
                        op_pix = s->dsp.put_pixels_tab;
3606
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3607
                    }else{
3608
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3609
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3610
                    }
3611
                    if (s->mv_dir & MV_DIR_FORWARD) {
3612
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3613
                        op_pix = s->dsp.avg_pixels_tab;
3614
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3615
                    }
3616
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3617
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3618
                    }
3619
                }
3620
            }
3621

    
3622
            /* skip dequant / idct if we are really late ;) */
3623
            if(s->hurry_up>1) return;
3624

    
3625
            /* add dct residue */
3626
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3627
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3628
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3629
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3630
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3631
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3632

    
3633
                if(!(s->flags&CODEC_FLAG_GRAY)){
3634
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3635
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3636
                }
3637
            } else if(s->codec_id != CODEC_ID_WMV2){
3638
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3639
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3640
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3641
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3642

    
3643
                if(!(s->flags&CODEC_FLAG_GRAY)){
3644
                    if(s->chroma_y_shift){//Chroma420
3645
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3646
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3647
                    }else{
3648
                        //chroma422
3649
                        dct_linesize = uvlinesize << s->interlaced_dct;
3650
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3651

    
3652
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3653
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3654
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3655
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3656
                        if(!s->chroma_x_shift){//Chroma444
3657
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3658
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3659
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3660
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3661
                        }
3662
                    }
3663
                }//fi gray
3664
            }
3665
#ifdef CONFIG_RISKY
3666
            else{
3667
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3668
            }
3669
#endif
3670
        } else {
3671
            /* dct only in intra block */
3672
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3673
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3674
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3675
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3676
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3677

    
3678
                if(!(s->flags&CODEC_FLAG_GRAY)){
3679
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3680
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3681
                }
3682
            }else{
3683
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3684
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3685
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3686
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3687

    
3688
                if(!(s->flags&CODEC_FLAG_GRAY)){
3689
                    if(s->chroma_y_shift){
3690
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3691
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3692
                    }else{
3693

    
3694
                        dct_linesize = uvlinesize << s->interlaced_dct;
3695
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3696

    
3697
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3698
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3699
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3700
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3701
                        if(!s->chroma_x_shift){//Chroma444
3702
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3703
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3704
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3705
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3706
                        }
3707
                    }
3708
                }//gray
3709
            }
3710
        }
3711
        if(!readable){
3712
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3713
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3714
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3715
        }
3716
    }
3717
}
3718

    
3719
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3720
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3721
    else                  MPV_decode_mb_internal(s, block, 0);
3722
}
3723

    
3724
#ifdef CONFIG_ENCODERS
3725

    
3726
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3727
{
3728
    static const char tab[64]=
3729
        {3,2,2,1,1,1,1,1,
3730
         1,1,1,1,1,1,1,1,
3731
         1,1,1,1,1,1,1,1,
3732
         0,0,0,0,0,0,0,0,
3733
         0,0,0,0,0,0,0,0,
3734
         0,0,0,0,0,0,0,0,
3735
         0,0,0,0,0,0,0,0,
3736
         0,0,0,0,0,0,0,0};
3737
    int score=0;
3738
    int run=0;
3739
    int i;
3740
    DCTELEM *block= s->block[n];
3741
    const int last_index= s->block_last_index[n];
3742
    int skip_dc;
3743

    
3744
    if(threshold<0){
3745
        skip_dc=0;
3746
        threshold= -threshold;
3747
    }else
3748
        skip_dc=1;
3749

    
3750
    /* are all which we could set to zero are allready zero? */
3751
    if(last_index<=skip_dc - 1) return;
3752

    
3753
    for(i=0; i<=last_index; i++){
3754
        const int j = s->intra_scantable.permutated[i];
3755
        const int level = ABS(block[j]);
3756
        if(level==1){
3757
            if(skip_dc && i==0) continue;
3758
            score+= tab[run];
3759
            run=0;
3760
        }else if(level>1){
3761
            return;
3762
        }else{
3763
            run++;
3764
        }
3765
    }
3766
    if(score >= threshold) return;
3767
    for(i=skip_dc; i<=last_index; i++){
3768
        const int j = s->intra_scantable.permutated[i];
3769
        block[j]=0;
3770
    }
3771
    if(block[0]) s->block_last_index[n]= 0;
3772
    else         s->block_last_index[n]= -1;
3773
}
3774

    
3775
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3776
{
3777
    int i;
3778
    const int maxlevel= s->max_qcoeff;
3779
    const int minlevel= s->min_qcoeff;
3780
    int overflow=0;
3781
    
3782
    if(s->mb_intra){
3783
        i=1; //skip clipping of intra dc
3784
    }else
3785
        i=0;
3786
    
3787
    for(;i<=last_index; i++){
3788
        const int j= s->intra_scantable.permutated[i];
3789
        int level = block[j];
3790
       
3791
        if     (level>maxlevel){
3792
            level=maxlevel;
3793
            overflow++;
3794
        }else if(level<minlevel){
3795
            level=minlevel;
3796
            overflow++;
3797
        }
3798
        
3799
        block[j]= level;
3800
    }
3801
    
3802
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3803
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3804
}
3805

    
3806
#endif //CONFIG_ENCODERS
3807

    
3808
/**
3809
 *
3810
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3811
 */
3812
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3813
    if (s->avctx->draw_horiz_band) {
3814
        AVFrame *src;
3815
        int offset[4];
3816
        
3817
        if(s->picture_structure != PICT_FRAME){
3818
            h <<= 1;
3819
            y <<= 1;
3820
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3821
        }
3822

    
3823
        h= FFMIN(h, s->avctx->height - y);
3824

    
3825
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3826
            src= (AVFrame*)s->current_picture_ptr;
3827
        else if(s->last_picture_ptr)
3828
            src= (AVFrame*)s->last_picture_ptr;
3829
        else
3830
            return;
3831
            
3832
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3833
            offset[0]=
3834
            offset[1]=
3835
            offset[2]=
3836
            offset[3]= 0;
3837
        }else{
3838
            offset[0]= y * s->linesize;;
3839
            offset[1]= 
3840
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3841
            offset[3]= 0;
3842
        }
3843

    
3844
        emms_c();
3845

    
3846
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3847
                                  y, s->picture_structure, h);
3848
    }
3849
}
3850

    
3851
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3852
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3853
    const int uvlinesize= s->current_picture.linesize[1];
3854
    const int mb_size= 4 - s->avctx->lowres;
3855
        
3856
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3857
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3858
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3859
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3860
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3861
    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;
3862
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3863

    
3864
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3865
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3866
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3867

    
3868
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3869
    {
3870
        s->dest[0] += s->mb_y *   linesize << mb_size;
3871
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3872
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3873
    }
3874
}
3875

    
3876
#ifdef CONFIG_ENCODERS
3877

    
3878
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3879
    int x, y;
3880
//FIXME optimize
3881
    for(y=0; y<8; y++){
3882
        for(x=0; x<8; x++){
3883
            int x2, y2;
3884
            int sum=0;
3885
            int sqr=0;
3886
            int count=0;
3887

    
3888
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3889
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3890
                    int v= ptr[x2 + y2*stride];
3891
                    sum += v;
3892
                    sqr += v*v;
3893
                    count++;
3894
                }
3895
            }
3896
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3897
        }
3898
    }
3899
}
3900

    
3901
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3902
{
3903
    int16_t weight[6][64];
3904
    DCTELEM orig[6][64];
3905
    const int mb_x= s->mb_x;
3906
    const int mb_y= s->mb_y;
3907
    int i;
3908
    int skip_dct[6];
3909
    int dct_offset   = s->linesize*8; //default for progressive frames
3910
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3911
    int wrap_y, wrap_c;
3912
    
3913
    for(i=0; i<6; i++) skip_dct[i]=0;
3914
    
3915
    if(s->adaptive_quant){
3916
        const int last_qp= s->qscale;
3917
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3918

    
3919
        s->lambda= s->lambda_table[mb_xy];
3920
        update_qscale(s);
3921
    
3922
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3923
            s->dquant= s->qscale - last_qp;
3924

    
3925
            if(s->out_format==FMT_H263){
3926
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3927
            
3928
                if(s->codec_id==CODEC_ID_MPEG4){        
3929
                    if(!s->mb_intra){
3930
                        if(s->pict_type == B_TYPE){
3931
                            if(s->dquant&1) 
3932
                                s->dquant= (s->dquant/2)*2;
3933
                            if(s->mv_dir&MV_DIRECT)
3934
                                s->dquant= 0;
3935
                        }
3936
                        if(s->mv_type==MV_TYPE_8X8)
3937
                            s->dquant=0;
3938
                    }
3939
                }
3940
            }
3941
        }
3942
        ff_set_qscale(s, last_qp + s->dquant);
3943
    }else if(s->flags&CODEC_FLAG_QP_RD)
3944
        ff_set_qscale(s, s->qscale + s->dquant);
3945

    
3946
    wrap_y = s->linesize;
3947
    wrap_c = s->uvlinesize;
3948
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3949
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3950
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3951

    
3952
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3953
        uint8_t *ebuf= s->edge_emu_buffer + 32;
3954
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3955
        ptr_y= ebuf;
3956
        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);
3957
        ptr_cb= ebuf+18*wrap_y;
3958
        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);
3959
        ptr_cr= ebuf+18*wrap_y+8;
3960
    }
3961

    
3962
    if (s->mb_intra) {
3963
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3964
            int progressive_score, interlaced_score;
3965

    
3966
            s->interlaced_dct=0;
3967
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3968
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3969

    
3970
            if(progressive_score > 0){
3971
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3972
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3973
                if(progressive_score > interlaced_score){
3974
                    s->interlaced_dct=1;
3975
            
3976
                    dct_offset= wrap_y;
3977
                    wrap_y<<=1;
3978
                }
3979
            }
3980
        }
3981
        
3982
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3983
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3984
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3985
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3986

    
3987
        if(s->flags&CODEC_FLAG_GRAY){
3988
            skip_dct[4]= 1;
3989
            skip_dct[5]= 1;
3990
        }else{
3991
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3992
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3993
        }
3994
    }else{
3995
        op_pixels_func (*op_pix)[4];
3996
        qpel_mc_func (*op_qpix)[16];
3997
        uint8_t *dest_y, *dest_cb, *dest_cr;
3998

    
3999
        dest_y  = s->dest[0];
4000
        dest_cb = s->dest[1];
4001
        dest_cr = s->dest[2];
4002

    
4003
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4004
            op_pix = s->dsp.put_pixels_tab;
4005
            op_qpix= s->dsp.put_qpel_pixels_tab;
4006
        }else{
4007
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4008
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4009
        }
4010

    
4011
        if (s->mv_dir & MV_DIR_FORWARD) {
4012
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4013
            op_pix = s->dsp.avg_pixels_tab;
4014
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4015
        }
4016
        if (s->mv_dir & MV_DIR_BACKWARD) {
4017
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4018
        }
4019

    
4020
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4021
            int progressive_score, interlaced_score;
4022

    
4023
            s->interlaced_dct=0;
4024
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
4025
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4026
            
4027
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4028

    
4029
            if(progressive_score>0){
4030
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
4031
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
4032
            
4033
                if(progressive_score > interlaced_score){
4034
                    s->interlaced_dct=1;
4035
            
4036
                    dct_offset= wrap_y;
4037
                    wrap_y<<=1;
4038
                }
4039
            }
4040
        }
4041
        
4042
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
4043
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
4044
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
4045
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4046
        
4047
        if(s->flags&CODEC_FLAG_GRAY){
4048
            skip_dct[4]= 1;
4049
            skip_dct[5]= 1;
4050
        }else{
4051
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4052
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4053
        }
4054
        /* pre quantization */         
4055
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4056
            //FIXME optimize
4057
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4058
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4059
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4060
            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;
4061
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4062
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4063
        }
4064
    }
4065

    
4066
    if(s->avctx->quantizer_noise_shaping){
4067
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
4068
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
4069
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
4070
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4071
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
4072
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
4073
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
4074
    }
4075
            
4076
    /* DCT & quantize */
4077
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4078
    {
4079
        for(i=0;i<6;i++) {
4080
            if(!skip_dct[i]){
4081
                int overflow;
4082
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4083
            // FIXME we could decide to change to quantizer instead of clipping
4084
            // JS: I don't think that would be a good idea it could lower quality instead
4085
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
4086
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4087
            }else
4088
                s->block_last_index[i]= -1;
4089
        }
4090
        if(s->avctx->quantizer_noise_shaping){
4091
            for(i=0;i<6;i++) {
4092
                if(!skip_dct[i]){
4093
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4094
                }
4095
            }
4096
        }
4097
        
4098
        if(s->luma_elim_threshold && !s->mb_intra)
4099
            for(i=0; i<4; i++)
4100
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4101
        if(s->chroma_elim_threshold && !s->mb_intra)
4102
            for(i=4; i<6; i++)
4103
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4104

    
4105
        if(s->flags & CODEC_FLAG_CBP_RD){
4106
            for(i=0;i<6;i++) {
4107
                if(s->block_last_index[i] == -1)
4108
                    s->coded_score[i]= INT_MAX/256;
4109
            }
4110
        }
4111
    }
4112

    
4113
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4114
        s->block_last_index[4]=
4115
        s->block_last_index[5]= 0;
4116
        s->block[4][0]=
4117
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4118
    }
4119

    
4120
    //non c quantize code returns incorrect block_last_index FIXME
4121
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4122
        for(i=0; i<6; i++){
4123
            int j;
4124
            if(s->block_last_index[i]>0){
4125
                for(j=63; j>0; j--){
4126
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4127
                }
4128
                s->block_last_index[i]= j;
4129
            }
4130
        }
4131
    }
4132

    
4133
    /* huffman encode */
4134
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4135
    case CODEC_ID_MPEG1VIDEO:
4136
    case CODEC_ID_MPEG2VIDEO:
4137
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4138
#ifdef CONFIG_RISKY
4139
    case CODEC_ID_MPEG4:
4140
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4141
    case CODEC_ID_MSMPEG4V2:
4142
    case CODEC_ID_MSMPEG4V3:
4143
    case CODEC_ID_WMV1:
4144
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4145
    case CODEC_ID_WMV2:
4146
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4147
    case CODEC_ID_H261:
4148
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4149
    case CODEC_ID_H263:
4150
    case CODEC_ID_H263P:
4151
    case CODEC_ID_FLV1:
4152
    case CODEC_ID_RV10:
4153
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4154
#endif
4155
    case CODEC_ID_MJPEG:
4156
        mjpeg_encode_mb(s, s->block); break;
4157
    default:
4158
        assert(0);
4159
    }
4160
}
4161

    
4162
#endif //CONFIG_ENCODERS
4163

    
4164
void ff_mpeg_flush(AVCodecContext *avctx){
4165
    int i;
4166
    MpegEncContext *s = avctx->priv_data;
4167
    
4168
    if(s==NULL || s->picture==NULL) 
4169
        return;
4170
    
4171
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4172
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4173
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4174
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4175
    }
4176
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4177
    
4178
    s->parse_context.state= -1;
4179
    s->parse_context.frame_start_found= 0;
4180
    s->parse_context.overread= 0;
4181
    s->parse_context.overread_index= 0;
4182
    s->parse_context.index= 0;
4183
    s->parse_context.last_index= 0;
4184
    s->bitstream_buffer_size=0;
4185
}
4186

    
4187
#ifdef CONFIG_ENCODERS
4188
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4189
{
4190
    const uint16_t *srcw= (uint16_t*)src;
4191
    int words= length>>4;
4192
    int bits= length&15;
4193
    int i;
4194

    
4195
    if(length==0) return;
4196
    
4197
    if(words < 16){
4198
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4199
    }else if(put_bits_count(pb)&7){
4200
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4201
    }else{
4202
        for(i=0; put_bits_count(pb)&31; i++)
4203
            put_bits(pb, 8, src[i]);
4204
        flush_put_bits(pb);
4205
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4206
        skip_put_bytes(pb, 2*words-i);
4207
    }
4208
        
4209
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4210
}
4211

    
4212
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4213
    int i;
4214

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

    
4217
    /* mpeg1 */
4218
    d->mb_skip_run= s->mb_skip_run;
4219
    for(i=0; i<3; i++)
4220
        d->last_dc[i]= s->last_dc[i];
4221
    
4222
    /* statistics */
4223
    d->mv_bits= s->mv_bits;
4224
    d->i_tex_bits= s->i_tex_bits;
4225
    d->p_tex_bits= s->p_tex_bits;
4226
    d->i_count= s->i_count;
4227
    d->f_count= s->f_count;
4228
    d->b_count= s->b_count;
4229
    d->skip_count= s->skip_count;
4230
    d->misc_bits= s->misc_bits;
4231
    d->last_bits= 0;
4232

    
4233
    d->mb_skiped= 0;
4234
    d->qscale= s->qscale;
4235
    d->dquant= s->dquant;
4236
}
4237

    
4238
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4239
    int i;
4240

    
4241
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
4242
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4243
    
4244
    /* mpeg1 */
4245
    d->mb_skip_run= s->mb_skip_run;
4246
    for(i=0; i<3; i++)
4247
        d->last_dc[i]= s->last_dc[i];
4248
    
4249
    /* statistics */
4250
    d->mv_bits= s->mv_bits;
4251
    d->i_tex_bits= s->i_tex_bits;
4252
    d->p_tex_bits= s->p_tex_bits;
4253
    d->i_count= s->i_count;
4254
    d->f_count= s->f_count;
4255
    d->b_count= s->b_count;
4256
    d->skip_count= s->skip_count;
4257
    d->misc_bits= s->misc_bits;
4258

    
4259
    d->mb_intra= s->mb_intra;
4260
    d->mb_skiped= s->mb_skiped;
4261
    d->mv_type= s->mv_type;
4262
    d->mv_dir= s->mv_dir;
4263
    d->pb= s->pb;
4264
    if(s->data_partitioning){
4265
        d->pb2= s->pb2;
4266
        d->tex_pb= s->tex_pb;
4267
    }
4268
    d->block= s->block;
4269
    for(i=0; i<6; i++)
4270
        d->block_last_index[i]= s->block_last_index[i];
4271
    d->interlaced_dct= s->interlaced_dct;
4272
    d->qscale= s->qscale;
4273
}
4274

    
4275
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4276
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4277
                           int *dmin, int *next_block, int motion_x, int motion_y)
4278
{
4279
    int score;
4280
    uint8_t *dest_backup[3];
4281
    
4282
    copy_context_before_encode(s, backup, type);
4283

    
4284
    s->block= s->blocks[*next_block];
4285
    s->pb= pb[*next_block];
4286
    if(s->data_partitioning){
4287
        s->pb2   = pb2   [*next_block];
4288
        s->tex_pb= tex_pb[*next_block];
4289
    }
4290
    
4291
    if(*next_block){
4292
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4293
        s->dest[0] = s->rd_scratchpad;
4294
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4295
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4296
        assert(s->linesize >= 32); //FIXME
4297
    }
4298

    
4299
    encode_mb(s, motion_x, motion_y);
4300
    
4301
    score= put_bits_count(&s->pb);
4302
    if(s->data_partitioning){
4303
        score+= put_bits_count(&s->pb2);
4304
        score+= put_bits_count(&s->tex_pb);
4305
    }
4306
   
4307
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4308
        MPV_decode_mb(s, s->block);
4309

    
4310
        score *= s->lambda2;
4311
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4312
    }
4313
    
4314
    if(*next_block){
4315
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4316
    }
4317

    
4318
    if(score<*dmin){
4319
        *dmin= score;
4320
        *next_block^=1;
4321

    
4322
        copy_context_after_encode(best, s, type);
4323
    }
4324
}
4325
                
4326
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4327
    uint32_t *sq = squareTbl + 256;
4328
    int acc=0;
4329
    int x,y;
4330
    
4331
    if(w==16 && h==16) 
4332
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4333
    else if(w==8 && h==8)
4334
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4335
    
4336
    for(y=0; y<h; y++){
4337
        for(x=0; x<w; x++){
4338
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4339
        } 
4340
    }
4341
    
4342
    assert(acc>=0);
4343
    
4344
    return acc;
4345
}
4346

    
4347
static int sse_mb(MpegEncContext *s){
4348
    int w= 16;
4349
    int h= 16;
4350

    
4351
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4352
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4353

    
4354
    if(w==16 && h==16)
4355
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4356
        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)
4357
               +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)
4358
               +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);
4359
      }else{
4360
        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)
4361
               +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)
4362
               +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);
4363
      }
4364
    else
4365
        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)
4366
               +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)
4367
               +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);
4368
}
4369

    
4370
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4371
    MpegEncContext *s= arg;
4372

    
4373
    
4374
    s->me.pre_pass=1;
4375
    s->me.dia_size= s->avctx->pre_dia_size;
4376
    s->first_slice_line=1;
4377
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4378
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4379
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4380
        }
4381
        s->first_slice_line=0;
4382
    }
4383
    
4384
    s->me.pre_pass=0;
4385
    
4386
    return 0;
4387
}
4388

    
4389
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4390
    MpegEncContext *s= arg;
4391

    
4392
    s->me.dia_size= s->avctx->dia_size;
4393
    s->first_slice_line=1;
4394
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4395
        s->mb_x=0; //for block init below
4396
        ff_init_block_index(s);
4397
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4398
            s->block_index[0]+=2;
4399
            s->block_index[1]+=2;
4400
            s->block_index[2]+=2;
4401
            s->block_index[3]+=2;
4402
            
4403
            /* compute motion vector & mb_type and store in context */
4404
            if(s->pict_type==B_TYPE)
4405
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4406
            else
4407
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4408
        }
4409
        s->first_slice_line=0;
4410
    }
4411
    return 0;
4412
}
4413

    
4414
static int mb_var_thread(AVCodecContext *c, void *arg){
4415
    MpegEncContext *s= arg;
4416
    int mb_x, mb_y;
4417

    
4418
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4419
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4420
            int xx = mb_x * 16;
4421
            int yy = mb_y * 16;
4422
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4423
            int varc;
4424
            int sum = s->dsp.pix_sum(pix, s->linesize);
4425
    
4426
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4427

    
4428
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4429
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4430
            s->me.mb_var_sum_temp    += varc;
4431
        }
4432
    }
4433
    return 0;
4434
}
4435

    
4436
static void write_slice_end(MpegEncContext *s){
4437
    if(s->codec_id==CODEC_ID_MPEG4){
4438
        if(s->partitioned_frame){
4439
            ff_mpeg4_merge_partitions(s);
4440
        }
4441
    
4442
        ff_mpeg4_stuffing(&s->pb);
4443
    }else if(s->out_format == FMT_MJPEG){
4444
        ff_mjpeg_stuffing(&s->pb);
4445
    }
4446

    
4447
    align_put_bits(&s->pb);
4448
    flush_put_bits(&s->pb);
4449
}
4450

    
4451
static int encode_thread(AVCodecContext *c, void *arg){
4452
    MpegEncContext *s= arg;
4453
    int mb_x, mb_y, pdif = 0;
4454
    int i, j;
4455
    MpegEncContext best_s, backup_s;
4456
    uint8_t bit_buf[2][3000];
4457
    uint8_t bit_buf2[2][3000];
4458
    uint8_t bit_buf_tex[2][3000];
4459
    PutBitContext pb[2], pb2[2], tex_pb[2];
4460
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4461

    
4462
    for(i=0; i<2; i++){
4463
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4464
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4465
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4466
    }
4467

    
4468
    s->last_bits= put_bits_count(&s->pb);
4469
    s->mv_bits=0;
4470
    s->misc_bits=0;
4471
    s->i_tex_bits=0;
4472
    s->p_tex_bits=0;
4473
    s->i_count=0;
4474
    s->f_count=0;
4475
    s->b_count=0;
4476
    s->skip_count=0;
4477

    
4478
    for(i=0; i<3; i++){
4479
        /* init last dc values */
4480
        /* note: quant matrix value (8) is implied here */
4481
        s->last_dc[i] = 128 << s->intra_dc_precision;
4482
        
4483
        s->current_picture_ptr->error[i] = 0;
4484
    }
4485
    s->mb_skip_run = 0;
4486
    memset(s->last_mv, 0, sizeof(s->last_mv));
4487
     
4488
    s->last_mv_dir = 0;
4489

    
4490
#ifdef CONFIG_RISKY
4491
    switch(s->codec_id){
4492
    case CODEC_ID_H263:
4493
    case CODEC_ID_H263P:
4494
    case CODEC_ID_FLV1:
4495
        s->gob_index = ff_h263_get_gob_height(s);
4496
        break;
4497
    case CODEC_ID_MPEG4:
4498
        if(s->partitioned_frame)
4499
            ff_mpeg4_init_partitions(s);
4500
        break;
4501
    }
4502
#endif
4503

    
4504
    s->resync_mb_x=0;
4505
    s->resync_mb_y=0; 
4506
    s->first_slice_line = 1;
4507
    s->ptr_lastgob = s->pb.buf;
4508
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4509
//    printf("row %d at %X\n", s->mb_y, (int)s);
4510
        s->mb_x=0;
4511
        s->mb_y= mb_y;
4512

    
4513
        ff_set_qscale(s, s->qscale);
4514
        ff_init_block_index(s);
4515
        
4516
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4517
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4518
            int mb_type= s->mb_type[xy];
4519
//            int d;
4520
            int dmin= INT_MAX;
4521
            int dir;
4522

    
4523
            s->mb_x = mb_x;
4524
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4525
            ff_update_block_index(s);
4526

    
4527
            if(s->codec_id == CODEC_ID_H261){
4528
                ff_h261_reorder_mb_index(s);
4529
                xy= s->mb_y*s->mb_stride + s->mb_x;
4530
                mb_type= s->mb_type[xy];
4531
            }
4532

    
4533
            /* write gob / video packet header  */
4534
#ifdef CONFIG_RISKY
4535
            if(s->rtp_mode){
4536
                int current_packet_size, is_gob_start;
4537
                
4538
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4539
                
4540
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4541
                
4542
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4543
                
4544
                switch(s->codec_id){
4545
                case CODEC_ID_H263:
4546
                case CODEC_ID_H263P:
4547
                    if(!s->h263_slice_structured)
4548
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4549
                    break;
4550
                case CODEC_ID_MPEG2VIDEO:
4551
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4552
                case CODEC_ID_MPEG1VIDEO:
4553
                    if(s->mb_skip_run) is_gob_start=0;
4554
                    break;
4555
                }
4556

    
4557
                if(is_gob_start){
4558
                    if(s->start_mb_y != mb_y || mb_x!=0){
4559
                        write_slice_end(s);
4560

    
4561
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4562
                            ff_mpeg4_init_partitions(s);
4563
                        }
4564
                    }
4565
                
4566
                    assert((put_bits_count(&s->pb)&7) == 0);
4567
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4568
                    
4569
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4570
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4571
                        int d= 100 / s->avctx->error_rate;
4572
                        if(r % d == 0){
4573
                            current_packet_size=0;
4574
#ifndef ALT_BITSTREAM_WRITER
4575
                            s->pb.buf_ptr= s->ptr_lastgob;
4576
#endif
4577
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4578
                        }
4579
                    }
4580
        
4581
                    if (s->avctx->rtp_callback)
4582
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4583
                    
4584
                    switch(s->codec_id){
4585
                    case CODEC_ID_MPEG4:
4586
                        ff_mpeg4_encode_video_packet_header(s);
4587
                        ff_mpeg4_clean_buffers(s);
4588
                    break;
4589
                    case CODEC_ID_MPEG1VIDEO:
4590
                    case CODEC_ID_MPEG2VIDEO:
4591
                        ff_mpeg1_encode_slice_header(s);
4592
                        ff_mpeg1_clean_buffers(s);
4593
                    break;
4594
                    case CODEC_ID_H263:
4595
                    case CODEC_ID_H263P:
4596
                        h263_encode_gob_header(s, mb_y);                       
4597
                    break;
4598
                    }
4599

    
4600
                    if(s->flags&CODEC_FLAG_PASS1){
4601
                        int bits= put_bits_count(&s->pb);
4602
                        s->misc_bits+= bits - s->last_bits;
4603
                        s->last_bits= bits;
4604
                    }
4605
    
4606
                    s->ptr_lastgob += current_packet_size;
4607
                    s->first_slice_line=1;
4608
                    s->resync_mb_x=mb_x;
4609
                    s->resync_mb_y=mb_y;
4610
                }
4611
            }
4612
#endif
4613

    
4614
            if(  (s->resync_mb_x   == s->mb_x)
4615
               && s->resync_mb_y+1 == s->mb_y){
4616
                s->first_slice_line=0; 
4617
            }
4618

    
4619
            s->mb_skiped=0;
4620
            s->dquant=0; //only for QP_RD
4621

    
4622
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4623
                int next_block=0;
4624
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4625

    
4626
                copy_context_before_encode(&backup_s, s, -1);
4627
                backup_s.pb= s->pb;
4628
                best_s.data_partitioning= s->data_partitioning;
4629
                best_s.partitioned_frame= s->partitioned_frame;
4630
                if(s->data_partitioning){
4631
                    backup_s.pb2= s->pb2;
4632
                    backup_s.tex_pb= s->tex_pb;
4633
                }
4634

    
4635
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4636
                    s->mv_dir = MV_DIR_FORWARD;
4637
                    s->mv_type = MV_TYPE_16X16;
4638
                    s->mb_intra= 0;
4639
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4640
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4641
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4642
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4643
                }
4644
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4645
                    s->mv_dir = MV_DIR_FORWARD;
4646
                    s->mv_type = MV_TYPE_FIELD;
4647
                    s->mb_intra= 0;
4648
                    for(i=0; i<2; i++){
4649
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4650
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4651
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4652
                    }
4653
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4654
                                 &dmin, &next_block, 0, 0);
4655
                }
4656
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4657
                    s->mv_dir = MV_DIR_FORWARD;
4658
                    s->mv_type = MV_TYPE_16X16;
4659
                    s->mb_intra= 0;
4660
                    s->mv[0][0][0] = 0;
4661
                    s->mv[0][0][1] = 0;
4662
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4663
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4664
                }
4665
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4666
                    s->mv_dir = MV_DIR_FORWARD;
4667
                    s->mv_type = MV_TYPE_8X8;
4668
                    s->mb_intra= 0;
4669
                    for(i=0; i<4; i++){
4670
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4671
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4672
                    }
4673
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4674
                                 &dmin, &next_block, 0, 0);
4675
                }
4676
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){