Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ d0271e8a

History | View | Annotate | Download (234 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_RV20:
1124
        s->out_format = FMT_H263;
1125
        avctx->delay=0;
1126
        s->low_delay=1;
1127
        s->modified_quant=1;
1128
        s->h263_aic=1;
1129
        s->h263_plus=1;
1130
        s->loop_filter=1;
1131
        s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1132
        break;
1133
    case CODEC_ID_MPEG4:
1134
        s->out_format = FMT_H263;
1135
        s->h263_pred = 1;
1136
        s->unrestricted_mv = 1;
1137
        s->low_delay= s->max_b_frames ? 0 : 1;
1138
        avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1139
        break;
1140
    case CODEC_ID_MSMPEG4V1:
1141
        s->out_format = FMT_H263;
1142
        s->h263_msmpeg4 = 1;
1143
        s->h263_pred = 1;
1144
        s->unrestricted_mv = 1;
1145
        s->msmpeg4_version= 1;
1146
        avctx->delay=0;
1147
        s->low_delay=1;
1148
        break;
1149
    case CODEC_ID_MSMPEG4V2:
1150
        s->out_format = FMT_H263;
1151
        s->h263_msmpeg4 = 1;
1152
        s->h263_pred = 1;
1153
        s->unrestricted_mv = 1;
1154
        s->msmpeg4_version= 2;
1155
        avctx->delay=0;
1156
        s->low_delay=1;
1157
        break;
1158
    case CODEC_ID_MSMPEG4V3:
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= 3;
1164
        s->flipflop_rounding=1;
1165
        avctx->delay=0;
1166
        s->low_delay=1;
1167
        break;
1168
    case CODEC_ID_WMV1:
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= 4;
1174
        s->flipflop_rounding=1;
1175
        avctx->delay=0;
1176
        s->low_delay=1;
1177
        break;
1178
    case CODEC_ID_WMV2:
1179
        s->out_format = FMT_H263;
1180
        s->h263_msmpeg4 = 1;
1181
        s->h263_pred = 1;
1182
        s->unrestricted_mv = 1;
1183
        s->msmpeg4_version= 5;
1184
        s->flipflop_rounding=1;
1185
        avctx->delay=0;
1186
        s->low_delay=1;
1187
        break;
1188
#endif
1189
    default:
1190
        return -1;
1191
    }
1192
    
1193
    avctx->has_b_frames= !s->low_delay;
1194

    
1195
    s->encoding = 1;
1196

    
1197
    /* init */
1198
    if (MPV_common_init(s) < 0)
1199
        return -1;
1200

    
1201
    if(s->modified_quant)
1202
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1203
    s->progressive_frame= 
1204
    s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1205
    s->quant_precision=5;
1206
    
1207
    ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1208
    
1209
#ifdef CONFIG_ENCODERS
1210
#ifdef CONFIG_RISKY
1211
    if (s->out_format == FMT_H261)
1212
        ff_h261_encode_init(s);
1213
    if (s->out_format == FMT_H263)
1214
        h263_encode_init(s);
1215
    if(s->msmpeg4_version)
1216
        ff_msmpeg4_encode_init(s);
1217
#endif
1218
    if (s->out_format == FMT_MPEG1)
1219
        ff_mpeg1_encode_init(s);
1220
#endif
1221

    
1222
    /* init q matrix */
1223
    for(i=0;i<64;i++) {
1224
        int j= s->dsp.idct_permutation[i];
1225
#ifdef CONFIG_RISKY
1226
        if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1227
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1228
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1229
        }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1230
            s->intra_matrix[j] =
1231
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1232
        }else
1233
#endif
1234
        { /* mpeg1/2 */
1235
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1236
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1237
        }
1238
        if(s->avctx->intra_matrix)
1239
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1240
        if(s->avctx->inter_matrix)
1241
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1242
    }
1243

    
1244
    /* precompute matrix */
1245
    /* for mjpeg, we do include qscale in the matrix */
1246
    if (s->out_format != FMT_MJPEG) {
1247
        convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 
1248
                       s->intra_matrix, s->intra_quant_bias, 1, 31);
1249
        convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 
1250
                       s->inter_matrix, s->inter_quant_bias, 1, 31);
1251
    }
1252

    
1253
    if(ff_rate_control_init(s) < 0)
1254
        return -1;
1255
    
1256
    return 0;
1257
}
1258

    
1259
int MPV_encode_end(AVCodecContext *avctx)
1260
{
1261
    MpegEncContext *s = avctx->priv_data;
1262

    
1263
#ifdef STATS
1264
    print_stats();
1265
#endif
1266

    
1267
    ff_rate_control_uninit(s);
1268

    
1269
    MPV_common_end(s);
1270
    if (s->out_format == FMT_MJPEG)
1271
        mjpeg_close(s);
1272

    
1273
    av_freep(&avctx->extradata);
1274
      
1275
    return 0;
1276
}
1277

    
1278
#endif //CONFIG_ENCODERS
1279

    
1280
void init_rl(RLTable *rl, int use_static)
1281
{
1282
    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1283
    uint8_t index_run[MAX_RUN+1];
1284
    int last, run, level, start, end, i;
1285

    
1286
    /* If table is static, we can quit if rl->max_level[0] is not NULL */
1287
    if(use_static && rl->max_level[0])
1288
        return;
1289

    
1290
    /* compute max_level[], max_run[] and index_run[] */
1291
    for(last=0;last<2;last++) {
1292
        if (last == 0) {
1293
            start = 0;
1294
            end = rl->last;
1295
        } else {
1296
            start = rl->last;
1297
            end = rl->n;
1298
        }
1299

    
1300
        memset(max_level, 0, MAX_RUN + 1);
1301
        memset(max_run, 0, MAX_LEVEL + 1);
1302
        memset(index_run, rl->n, MAX_RUN + 1);
1303
        for(i=start;i<end;i++) {
1304
            run = rl->table_run[i];
1305
            level = rl->table_level[i];
1306
            if (index_run[run] == rl->n)
1307
                index_run[run] = i;
1308
            if (level > max_level[run])
1309
                max_level[run] = level;
1310
            if (run > max_run[level])
1311
                max_run[level] = run;
1312
        }
1313
        if(use_static)
1314
            rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1315
        else
1316
            rl->max_level[last] = av_malloc(MAX_RUN + 1);
1317
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1318
        if(use_static)
1319
            rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1320
        else
1321
            rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1322
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1323
        if(use_static)
1324
            rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1325
        else
1326
            rl->index_run[last] = av_malloc(MAX_RUN + 1);
1327
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1328
    }
1329
}
1330

    
1331
/* draw the edges of width 'w' of an image of size width, height */
1332
//FIXME check that this is ok for mpeg4 interlaced
1333
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1334
{
1335
    uint8_t *ptr, *last_line;
1336
    int i;
1337

    
1338
    last_line = buf + (height - 1) * wrap;
1339
    for(i=0;i<w;i++) {
1340
        /* top and bottom */
1341
        memcpy(buf - (i + 1) * wrap, buf, width);
1342
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1343
    }
1344
    /* left and right */
1345
    ptr = buf;
1346
    for(i=0;i<height;i++) {
1347
        memset(ptr - w, ptr[0], w);
1348
        memset(ptr + width, ptr[width-1], w);
1349
        ptr += wrap;
1350
    }
1351
    /* corners */
1352
    for(i=0;i<w;i++) {
1353
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1354
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1355
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1356
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1357
    }
1358
}
1359

    
1360
int ff_find_unused_picture(MpegEncContext *s, int shared){
1361
    int i;
1362
    
1363
    if(shared){
1364
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1365
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1366
        }
1367
    }else{
1368
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1369
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1370
        }
1371
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1372
            if(s->picture[i].data[0]==NULL) return i;
1373
        }
1374
    }
1375

    
1376
    assert(0);
1377
    return -1;
1378
}
1379

    
1380
static void update_noise_reduction(MpegEncContext *s){
1381
    int intra, i;
1382

    
1383
    for(intra=0; intra<2; intra++){
1384
        if(s->dct_count[intra] > (1<<16)){
1385
            for(i=0; i<64; i++){
1386
                s->dct_error_sum[intra][i] >>=1;
1387
            }
1388
            s->dct_count[intra] >>= 1;
1389
        }
1390
        
1391
        for(i=0; i<64; i++){
1392
            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);
1393
        }
1394
    }
1395
}
1396

    
1397
/**
1398
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1399
 */
1400
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1401
{
1402
    int i;
1403
    AVFrame *pic;
1404
    s->mb_skiped = 0;
1405

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

    
1408
    /* mark&release old frames */
1409
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1410
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1411

    
1412
        /* release forgotten pictures */
1413
        /* if(mpeg124/h263) */
1414
        if(!s->encoding){
1415
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1416
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1417
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1418
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1419
                }
1420
            }
1421
        }
1422
    }
1423
alloc:
1424
    if(!s->encoding){
1425
        /* release non refernce frames */
1426
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1427
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1428
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1429
            }
1430
        }
1431

    
1432
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1433
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1434
        else{
1435
            i= ff_find_unused_picture(s, 0);
1436
            pic= (AVFrame*)&s->picture[i];
1437
        }
1438

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

    
1441
        pic->coded_picture_number= s->coded_picture_number++;
1442
        
1443
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1444
            return -1;
1445

    
1446
        s->current_picture_ptr= (Picture*)pic;
1447
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1448
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1449
    }
1450

    
1451
    s->current_picture_ptr->pict_type= s->pict_type;
1452
//    if(s->flags && CODEC_FLAG_QSCALE) 
1453
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1454
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1455

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

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

    
1481
    if(s->picture_structure!=PICT_FRAME){
1482
        int i;
1483
        for(i=0; i<4; i++){
1484
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1485
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1486
            } 
1487
            s->current_picture.linesize[i] *= 2;
1488
            s->last_picture.linesize[i] *=2;
1489
            s->next_picture.linesize[i] *=2;
1490
        }
1491
    }
1492
  }
1493
   
1494
    s->hurry_up= s->avctx->hurry_up;
1495
    s->error_resilience= avctx->error_resilience;
1496

    
1497
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1498
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1499
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1500
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1501
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1502
    }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1503
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1504
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1505
    }else{
1506
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1507
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1508
    }
1509

    
1510
    if(s->dct_error_sum){
1511
        assert(s->avctx->noise_reduction && s->encoding);
1512

    
1513
        update_noise_reduction(s);
1514
    }
1515
        
1516
#ifdef HAVE_XVMC
1517
    if(s->avctx->xvmc_acceleration)
1518
        return XVMC_field_start(s, avctx);
1519
#endif
1520
    return 0;
1521
}
1522

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

    
1556
    if(s->encoding){
1557
        /* release non refernce frames */
1558
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1559
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1560
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1561
            }
1562
        }
1563
    }
1564
    // clear copies, to avoid confusion
1565
#if 0
1566
    memset(&s->last_picture, 0, sizeof(Picture));
1567
    memset(&s->next_picture, 0, sizeof(Picture));
1568
    memset(&s->current_picture, 0, sizeof(Picture));
1569
#endif
1570
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1571
}
1572

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

    
1622
/**
1623
 * draws an arrow from (ex, ey) -> (sx, sy).
1624
 * @param w width of the image
1625
 * @param h height of the image
1626
 * @param stride stride/linesize of the image
1627
 * @param color color of the arrow
1628
 */
1629
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1630
    int dx,dy;
1631

    
1632
    sx= clip(sx, -100, w+100);
1633
    sy= clip(sy, -100, h+100);
1634
    ex= clip(ex, -100, w+100);
1635
    ey= clip(ey, -100, h+100);
1636
    
1637
    dx= ex - sx;
1638
    dy= ey - sy;
1639
    
1640
    if(dx*dx + dy*dy > 3*3){
1641
        int rx=  dx + dy;
1642
        int ry= -dx + dy;
1643
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1644
        
1645
        //FIXME subpixel accuracy
1646
        rx= ROUNDED_DIV(rx*3<<4, length);
1647
        ry= ROUNDED_DIV(ry*3<<4, length);
1648
        
1649
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1650
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1651
    }
1652
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1653
}
1654

    
1655
/**
1656
 * prints debuging info for the given picture.
1657
 */
1658
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1659

    
1660
    if(!pict || !pict->mb_type) return;
1661

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

    
1738
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1739
        const int shift= 1 + s->quarter_sample;
1740
        int mb_y;
1741
        uint8_t *ptr;
1742
        int i;
1743
        int h_chroma_shift, v_chroma_shift;
1744
        const int width = s->avctx->width;
1745
        const int height= s->avctx->height;
1746
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1747

    
1748
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1749
        for(i=0; i<3; i++){
1750
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1751
            pict->data[i]= s->visualization_buffer[i];
1752
        }
1753
        pict->type= FF_BUFFER_TYPE_COPY;
1754
        ptr= pict->data[0];
1755

    
1756
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1757
            int mb_x;
1758
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1759
                const int mb_index= mb_x + mb_y*s->mb_stride;
1760
                if((s->avctx->debug_mv) && pict->motion_val){
1761
                  int type;
1762
                  for(type=0; type<3; type++){
1763
                    int direction = 0;
1764
                    switch (type) {
1765
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1766
                                continue;
1767
                              direction = 0;
1768
                              break;
1769
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1770
                                continue;
1771
                              direction = 0;
1772
                              break;
1773
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1774
                                continue;
1775
                              direction = 1;
1776
                              break;
1777
                    }
1778
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1779
                        continue;
1780

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

    
1832
                    
1833
                    u=v=128;
1834
                    if(IS_PCM(mb_type)){
1835
                        COLOR(120,48)
1836
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1837
                        COLOR(30,48)
1838
                    }else if(IS_INTRA4x4(mb_type)){
1839
                        COLOR(90,48)
1840
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1841
//                        COLOR(120,48)
1842
                    }else if(IS_DIRECT(mb_type)){
1843
                        COLOR(150,48)
1844
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1845
                        COLOR(170,48)
1846
                    }else if(IS_GMC(mb_type)){
1847
                        COLOR(190,48)
1848
                    }else if(IS_SKIP(mb_type)){
1849
//                        COLOR(180,48)
1850
                    }else if(!USES_LIST(mb_type, 1)){
1851
                        COLOR(240,48)
1852
                    }else if(!USES_LIST(mb_type, 0)){
1853
                        COLOR(0,48)
1854
                    }else{
1855
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1856
                        COLOR(300,48)
1857
                    }
1858

    
1859
                    u*= 0x0101010101010101ULL;
1860
                    v*= 0x0101010101010101ULL;
1861
                    for(y=0; y<8; y++){
1862
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1863
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1864
                    }
1865

    
1866
                    //segmentation
1867
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1868
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1869
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1870
                    }
1871
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1872
                        for(y=0; y<16; y++)
1873
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1874
                    }
1875
                        
1876
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1877
                        // hmm
1878
                    }
1879
                }
1880
                s->mbskip_table[mb_index]=0;
1881
            }
1882
        }
1883
    }
1884
}
1885

    
1886
#ifdef CONFIG_ENCODERS
1887

    
1888
static int get_sae(uint8_t *src, int ref, int stride){
1889
    int x,y;
1890
    int acc=0;
1891
    
1892
    for(y=0; y<16; y++){
1893
        for(x=0; x<16; x++){
1894
            acc+= ABS(src[x+y*stride] - ref);
1895
        }
1896
    }
1897
    
1898
    return acc;
1899
}
1900

    
1901
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1902
    int x, y, w, h;
1903
    int acc=0;
1904
    
1905
    w= s->width &~15;
1906
    h= s->height&~15;
1907
    
1908
    for(y=0; y<h; y+=16){
1909
        for(x=0; x<w; x+=16){
1910
            int offset= x + y*stride;
1911
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1912
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1913
            int sae = get_sae(src + offset, mean, stride);
1914
            
1915
            acc+= sae + 500 < sad;
1916
        }
1917
    }
1918
    return acc;
1919
}
1920

    
1921

    
1922
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1923
    AVFrame *pic=NULL;
1924
    int i;
1925
    const int encoding_delay= s->max_b_frames;
1926
    int direct=1;
1927
    
1928
  if(pic_arg){
1929
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1930
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1931
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1932
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1933
  
1934
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1935
    
1936
    if(direct){
1937
        i= ff_find_unused_picture(s, 1);
1938

    
1939
        pic= (AVFrame*)&s->picture[i];
1940
        pic->reference= 3;
1941
    
1942
        for(i=0; i<4; i++){
1943
            pic->data[i]= pic_arg->data[i];
1944
            pic->linesize[i]= pic_arg->linesize[i];
1945
        }
1946
        alloc_picture(s, (Picture*)pic, 1);
1947
    }else{
1948
        int offset= 16;
1949
        i= ff_find_unused_picture(s, 0);
1950

    
1951
        pic= (AVFrame*)&s->picture[i];
1952
        pic->reference= 3;
1953

    
1954
        alloc_picture(s, (Picture*)pic, 0);
1955

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

    
2018
    return 0;
2019
}
2020

    
2021
static void select_input_picture(MpegEncContext *s){
2022
    int i;
2023

    
2024
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2025
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2026
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2027

    
2028
    /* set next picture types & ordering */
2029
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2030
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2031
            s->reordered_input_picture[0]= s->input_picture[0];
2032
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2033
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2034
        }else{
2035
            int b_frames;
2036
            
2037
            if(s->flags&CODEC_FLAG_PASS2){
2038
                for(i=0; i<s->max_b_frames+1; i++){
2039
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2040

    
2041
                    if(pict_num >= s->rc_context.num_entries) 
2042
                        break;
2043
                    if(!s->input_picture[i]){
2044
                        s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2045
                        break;
2046
                    }
2047

    
2048
                    s->input_picture[i]->pict_type= 
2049
                        s->rc_context.entry[pict_num].new_pict_type;
2050
                }
2051
            }
2052

    
2053
            if(s->avctx->b_frame_strategy==0){
2054
                b_frames= s->max_b_frames;
2055
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2056
            }else if(s->avctx->b_frame_strategy==1){
2057
                for(i=1; i<s->max_b_frames+1; i++){
2058
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2059
                        s->input_picture[i]->b_frame_score= 
2060
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2061
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2062
                    }
2063
                }
2064
                for(i=0; i<s->max_b_frames; i++){
2065
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2066
                }
2067
                                
2068
                b_frames= FFMAX(0, i-1);
2069
                
2070
                /* reset scores */
2071
                for(i=0; i<b_frames+1; i++){
2072
                    s->input_picture[i]->b_frame_score=0;
2073
                }
2074
            }else{
2075
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2076
                b_frames=0;
2077
            }
2078

    
2079
            emms_c();
2080
//static int b_count=0;
2081
//b_count+= b_frames;
2082
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2083

    
2084
            for(i= b_frames - 1; i>=0; i--){
2085
                int type= s->input_picture[i]->pict_type;
2086
                if(type && type != B_TYPE)
2087
                    b_frames= i;
2088
            }
2089
            if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2090
                av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2091
            }
2092

    
2093
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2094
              if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2095
                    b_frames= s->gop_size - s->picture_in_gop_number - 1;
2096
              }else{
2097
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2098
                    b_frames=0;
2099
                s->input_picture[b_frames]->pict_type= I_TYPE;
2100
              }
2101
            }
2102
            
2103
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2104
               && b_frames
2105
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2106
                b_frames--;
2107

    
2108
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2109
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2110
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2111
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2112
            for(i=0; i<b_frames; i++){
2113
                s->reordered_input_picture[i+1]= s->input_picture[i];
2114
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2115
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2116
            }
2117
        }
2118
    }
2119
    
2120
    if(s->reordered_input_picture[0]){
2121
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2122

    
2123
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2124

    
2125
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2126
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2127
        
2128
            int i= ff_find_unused_picture(s, 0);
2129
            Picture *pic= &s->picture[i];
2130

    
2131
            /* mark us unused / free shared pic */
2132
            for(i=0; i<4; i++)
2133
                s->reordered_input_picture[0]->data[i]= NULL;
2134
            s->reordered_input_picture[0]->type= 0;
2135
            
2136
            pic->reference              = s->reordered_input_picture[0]->reference;
2137
            
2138
            alloc_picture(s, pic, 0);
2139

    
2140
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2141

    
2142
            s->current_picture_ptr= pic;
2143
        }else{
2144
            // input is not a shared pix -> reuse buffer for current_pix
2145

    
2146
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2147
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2148
            
2149
            s->current_picture_ptr= s->reordered_input_picture[0];
2150
            for(i=0; i<4; i++){
2151
                s->new_picture.data[i]+=16;
2152
            }
2153
        }
2154
        copy_picture(&s->current_picture, s->current_picture_ptr);
2155
    
2156
        s->picture_number= s->new_picture.display_picture_number;
2157
//printf("dpn:%d\n", s->picture_number);
2158
    }else{
2159
       memset(&s->new_picture, 0, sizeof(Picture));
2160
    }
2161
}
2162

    
2163
int MPV_encode_picture(AVCodecContext *avctx,
2164
                       unsigned char *buf, int buf_size, void *data)
2165
{
2166
    MpegEncContext *s = avctx->priv_data;
2167
    AVFrame *pic_arg = data;
2168
    int i, stuffing_count;
2169

    
2170
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2171
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2172
        return -1;
2173
    }
2174
    
2175
    for(i=0; i<avctx->thread_count; i++){
2176
        int start_y= s->thread_context[i]->start_mb_y;
2177
        int   end_y= s->thread_context[i]->  end_mb_y;
2178
        int h= s->mb_height;
2179
        uint8_t *start= buf + buf_size*start_y/h;
2180
        uint8_t *end  = buf + buf_size*  end_y/h;
2181

    
2182
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2183
    }
2184

    
2185
    s->picture_in_gop_number++;
2186

    
2187
    if(load_input_picture(s, pic_arg) < 0)
2188
        return -1;
2189
    
2190
    select_input_picture(s);
2191
    
2192
    /* output? */
2193
    if(s->new_picture.data[0]){
2194
        s->pict_type= s->new_picture.pict_type;
2195
//emms_c();
2196
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2197
        MPV_frame_start(s, avctx);
2198

    
2199
        encode_picture(s, s->picture_number);
2200
        
2201
        avctx->real_pict_num  = s->picture_number;
2202
        avctx->header_bits = s->header_bits;
2203
        avctx->mv_bits     = s->mv_bits;
2204
        avctx->misc_bits   = s->misc_bits;
2205
        avctx->i_tex_bits  = s->i_tex_bits;
2206
        avctx->p_tex_bits  = s->p_tex_bits;
2207
        avctx->i_count     = s->i_count;
2208
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2209
        avctx->skip_count  = s->skip_count;
2210

    
2211
        MPV_frame_end(s);
2212

    
2213
        if (s->out_format == FMT_MJPEG)
2214
            mjpeg_picture_trailer(s);
2215
        
2216
        if(s->flags&CODEC_FLAG_PASS1)
2217
            ff_write_pass1_stats(s);
2218

    
2219
        for(i=0; i<4; i++){
2220
            avctx->error[i] += s->current_picture_ptr->error[i];
2221
        }
2222

    
2223
        flush_put_bits(&s->pb);
2224
        s->frame_bits  = put_bits_count(&s->pb);
2225

    
2226
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2227
        if(stuffing_count){
2228
            switch(s->codec_id){
2229
            case CODEC_ID_MPEG1VIDEO:
2230
            case CODEC_ID_MPEG2VIDEO:
2231
                while(stuffing_count--){
2232
                    put_bits(&s->pb, 8, 0);
2233
                }
2234
            break;
2235
            case CODEC_ID_MPEG4:
2236
                put_bits(&s->pb, 16, 0);
2237
                put_bits(&s->pb, 16, 0x1C3);
2238
                stuffing_count -= 4;
2239
                while(stuffing_count--){
2240
                    put_bits(&s->pb, 8, 0xFF);
2241
                }
2242
            break;
2243
            default:
2244
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2245
            }
2246
            flush_put_bits(&s->pb);
2247
            s->frame_bits  = put_bits_count(&s->pb);
2248
        }
2249

    
2250
        /* update mpeg1/2 vbv_delay for CBR */    
2251
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2252
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2253
            int vbv_delay;
2254

    
2255
            assert(s->repeat_first_field==0);
2256
            
2257
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2258
            assert(vbv_delay < 0xFFFF);
2259

    
2260
            s->vbv_delay_ptr[0] &= 0xF8;
2261
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2262
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2263
            s->vbv_delay_ptr[2] &= 0x07;
2264
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2265
        }
2266
        s->total_bits += s->frame_bits;
2267
        avctx->frame_bits  = s->frame_bits;
2268
    }else{
2269
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2270
        s->frame_bits=0;
2271
    }
2272
    assert((s->frame_bits&7)==0);
2273
    
2274
    return s->frame_bits/8;
2275
}
2276

    
2277
#endif //CONFIG_ENCODERS
2278

    
2279
static inline void gmc1_motion(MpegEncContext *s,
2280
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2281
                               uint8_t **ref_picture)
2282
{
2283
    uint8_t *ptr;
2284
    int offset, src_x, src_y, linesize, uvlinesize;
2285
    int motion_x, motion_y;
2286
    int emu=0;
2287

    
2288
    motion_x= s->sprite_offset[0][0];
2289
    motion_y= s->sprite_offset[0][1];
2290
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2291
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2292
    motion_x<<=(3-s->sprite_warping_accuracy);
2293
    motion_y<<=(3-s->sprite_warping_accuracy);
2294
    src_x = clip(src_x, -16, s->width);
2295
    if (src_x == s->width)
2296
        motion_x =0;
2297
    src_y = clip(src_y, -16, s->height);
2298
    if (src_y == s->height)
2299
        motion_y =0;
2300

    
2301
    linesize = s->linesize;
2302
    uvlinesize = s->uvlinesize;
2303
    
2304
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2305

    
2306
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2307
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2308
           || (unsigned)src_y >= s->v_edge_pos - 17){
2309
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2310
            ptr= s->edge_emu_buffer;
2311
        }
2312
    }
2313
    
2314
    if((motion_x|motion_y)&7){
2315
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2316
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2317
    }else{
2318
        int dxy;
2319
        
2320
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2321
        if (s->no_rounding){
2322
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2323
        }else{
2324
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2325
        }
2326
    }
2327
    
2328
    if(s->flags&CODEC_FLAG_GRAY) return;
2329

    
2330
    motion_x= s->sprite_offset[1][0];
2331
    motion_y= s->sprite_offset[1][1];
2332
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2333
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2334
    motion_x<<=(3-s->sprite_warping_accuracy);
2335
    motion_y<<=(3-s->sprite_warping_accuracy);
2336
    src_x = clip(src_x, -8, s->width>>1);
2337
    if (src_x == s->width>>1)
2338
        motion_x =0;
2339
    src_y = clip(src_y, -8, s->height>>1);
2340
    if (src_y == s->height>>1)
2341
        motion_y =0;
2342

    
2343
    offset = (src_y * uvlinesize) + src_x;
2344
    ptr = ref_picture[1] + offset;
2345
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2346
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2347
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2348
            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);
2349
            ptr= s->edge_emu_buffer;
2350
            emu=1;
2351
        }
2352
    }
2353
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2354
    
2355
    ptr = ref_picture[2] + offset;
2356
    if(emu){
2357
        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);
2358
        ptr= s->edge_emu_buffer;
2359
    }
2360
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2361
    
2362
    return;
2363
}
2364

    
2365
static inline void gmc_motion(MpegEncContext *s,
2366
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2367
                               uint8_t **ref_picture)
2368
{
2369
    uint8_t *ptr;
2370
    int linesize, uvlinesize;
2371
    const int a= s->sprite_warping_accuracy;
2372
    int ox, oy;
2373

    
2374
    linesize = s->linesize;
2375
    uvlinesize = s->uvlinesize;
2376

    
2377
    ptr = ref_picture[0];
2378

    
2379
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2380
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2381

    
2382
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2383
           ox, 
2384
           oy, 
2385
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2386
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2387
           a+1, (1<<(2*a+1)) - s->no_rounding,
2388
           s->h_edge_pos, s->v_edge_pos);
2389
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2390
           ox + s->sprite_delta[0][0]*8, 
2391
           oy + s->sprite_delta[1][0]*8, 
2392
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2393
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2394
           a+1, (1<<(2*a+1)) - s->no_rounding,
2395
           s->h_edge_pos, s->v_edge_pos);
2396

    
2397
    if(s->flags&CODEC_FLAG_GRAY) return;
2398

    
2399
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2400
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2401

    
2402
    ptr = ref_picture[1];
2403
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2404
           ox, 
2405
           oy, 
2406
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2407
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2408
           a+1, (1<<(2*a+1)) - s->no_rounding,
2409
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2410
    
2411
    ptr = ref_picture[2];
2412
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2413
           ox, 
2414
           oy, 
2415
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2416
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2417
           a+1, (1<<(2*a+1)) - s->no_rounding,
2418
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2419
}
2420

    
2421
/**
2422
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2423
 * @param buf destination buffer
2424
 * @param src source buffer
2425
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2426
 * @param block_w width of block
2427
 * @param block_h height of block
2428
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2429
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2430
 * @param w width of the source buffer
2431
 * @param h height of the source buffer
2432
 */
2433
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2434
                                    int src_x, int src_y, int w, int h){
2435
    int x, y;
2436
    int start_y, start_x, end_y, end_x;
2437

    
2438
    if(src_y>= h){
2439
        src+= (h-1-src_y)*linesize;
2440
        src_y=h-1;
2441
    }else if(src_y<=-block_h){
2442
        src+= (1-block_h-src_y)*linesize;
2443
        src_y=1-block_h;
2444
    }
2445
    if(src_x>= w){
2446
        src+= (w-1-src_x);
2447
        src_x=w-1;
2448
    }else if(src_x<=-block_w){
2449
        src+= (1-block_w-src_x);
2450
        src_x=1-block_w;
2451
    }
2452

    
2453
    start_y= FFMAX(0, -src_y);
2454
    start_x= FFMAX(0, -src_x);
2455
    end_y= FFMIN(block_h, h-src_y);
2456
    end_x= FFMIN(block_w, w-src_x);
2457

    
2458
    // copy existing part
2459
    for(y=start_y; y<end_y; y++){
2460
        for(x=start_x; x<end_x; x++){
2461
            buf[x + y*linesize]= src[x + y*linesize];
2462
        }
2463
    }
2464

    
2465
    //top
2466
    for(y=0; y<start_y; y++){
2467
        for(x=start_x; x<end_x; x++){
2468
            buf[x + y*linesize]= buf[x + start_y*linesize];
2469
        }
2470
    }
2471

    
2472
    //bottom
2473
    for(y=end_y; y<block_h; y++){
2474
        for(x=start_x; x<end_x; x++){
2475
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2476
        }
2477
    }
2478
                                    
2479
    for(y=0; y<block_h; y++){
2480
       //left
2481
        for(x=0; x<start_x; x++){
2482
            buf[x + y*linesize]= buf[start_x + y*linesize];
2483
        }
2484
       
2485
       //right
2486
        for(x=end_x; x<block_w; x++){
2487
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2488
        }
2489
    }
2490
}
2491

    
2492
static inline int hpel_motion(MpegEncContext *s, 
2493
                                  uint8_t *dest, uint8_t *src,
2494
                                  int field_based, int field_select,
2495
                                  int src_x, int src_y,
2496
                                  int width, int height, int stride,
2497
                                  int h_edge_pos, int v_edge_pos,
2498
                                  int w, int h, op_pixels_func *pix_op,
2499
                                  int motion_x, int motion_y)
2500
{
2501
    int dxy;
2502
    int emu=0;
2503

    
2504
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2505
    src_x += motion_x >> 1;
2506
    src_y += motion_y >> 1;
2507
                
2508
    /* WARNING: do no forget half pels */
2509
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2510
    if (src_x == width)
2511
        dxy &= ~1;
2512
    src_y = clip(src_y, -16, height);
2513
    if (src_y == height)
2514
        dxy &= ~2;
2515
    src += src_y * stride + src_x;
2516

    
2517
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2518
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2519
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2520
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2521
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2522
            src= s->edge_emu_buffer;
2523
            emu=1;
2524
        }
2525
    }
2526
    if(field_select)
2527
        src += s->linesize;
2528
    pix_op[dxy](dest, src, stride, h);
2529
    return emu;
2530
}
2531

    
2532
static inline int hpel_motion_lowres(MpegEncContext *s, 
2533
                                  uint8_t *dest, uint8_t *src,
2534
                                  int field_based, int field_select,
2535
                                  int src_x, int src_y,
2536
                                  int width, int height, int stride,
2537
                                  int h_edge_pos, int v_edge_pos,
2538
                                  int w, int h, h264_chroma_mc_func *pix_op,
2539
                                  int motion_x, int motion_y)
2540
{
2541
    const int lowres= s->avctx->lowres;
2542
    const int s_mask= (2<<lowres)-1;
2543
    int emu=0;
2544
    int sx, sy;
2545

    
2546
    if(s->quarter_sample){
2547
        motion_x/=2;
2548
        motion_y/=2;
2549
    }
2550

    
2551
    sx= motion_x & s_mask;
2552
    sy= motion_y & s_mask;
2553
    src_x += motion_x >> (lowres+1);
2554
    src_y += motion_y >> (lowres+1);
2555
                
2556
    src += src_y * stride + src_x;
2557

    
2558
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
2559
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2560
        ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2561
                            src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2562
        src= s->edge_emu_buffer;
2563
        emu=1;
2564
    }
2565

    
2566
    sx <<= 2 - lowres;
2567
    sy <<= 2 - lowres;
2568
    if(field_select)
2569
        src += s->linesize;
2570
    pix_op[lowres](dest, src, stride, h, sx, sy);
2571
    return emu;
2572
}
2573

    
2574
/* apply one mpeg motion vector to the three components */
2575
static always_inline void mpeg_motion(MpegEncContext *s,
2576
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2577
                               int field_based, int bottom_field, int field_select,
2578
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2579
                               int motion_x, int motion_y, int h)
2580
{
2581
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2582
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2583
    
2584
#if 0    
2585
if(s->quarter_sample)
2586
{
2587
    motion_x>>=1;
2588
    motion_y>>=1;
2589
}
2590
#endif
2591

    
2592
    v_edge_pos = s->v_edge_pos >> field_based;
2593
    linesize   = s->current_picture.linesize[0] << field_based;
2594
    uvlinesize = s->current_picture.linesize[1] << field_based;
2595

    
2596
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2597
    src_x = s->mb_x* 16               + (motion_x >> 1);
2598
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2599

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

    
2641
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2642
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2643
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2644

    
2645
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2646
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2647
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2648
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2649
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2650
                return ;
2651
            }
2652
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2653
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2654
            ptr_y = s->edge_emu_buffer;
2655
            if(!(s->flags&CODEC_FLAG_GRAY)){
2656
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2657
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2658
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2659
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2660
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2661
                ptr_cb= uvbuf;
2662
                ptr_cr= uvbuf+16;
2663
            }
2664
    }
2665

    
2666
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2667
        dest_y += s->linesize;
2668
        dest_cb+= s->uvlinesize;
2669
        dest_cr+= s->uvlinesize;
2670
    }
2671

    
2672
    if(field_select){
2673
        ptr_y += s->linesize;
2674
        ptr_cb+= s->uvlinesize;
2675
        ptr_cr+= s->uvlinesize;
2676
    }
2677

    
2678
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2679
    
2680
    if(!(s->flags&CODEC_FLAG_GRAY)){
2681
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2682
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2683
    }
2684
    if(s->out_format == FMT_H261){
2685
        ff_h261_loop_filter(s);
2686
    }
2687
}
2688

    
2689
/* apply one mpeg motion vector to the three components */
2690
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2691
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2692
                               int field_based, int bottom_field, int field_select,
2693
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2694
                               int motion_x, int motion_y, int h)
2695
{
2696
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2697
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2698
    const int lowres= s->avctx->lowres;
2699
    const int block_s= 8>>lowres;
2700
    const int s_mask= (2<<lowres)-1;
2701
    const int h_edge_pos = s->h_edge_pos >> lowres;
2702
    const int v_edge_pos = s->v_edge_pos >> lowres;
2703
    linesize   = s->current_picture.linesize[0] << field_based;
2704
    uvlinesize = s->current_picture.linesize[1] << field_based;
2705

    
2706
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2707
        motion_x/=2;
2708
        motion_y/=2;
2709
    }
2710
    
2711
    if(field_based){
2712
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2713
    }
2714

    
2715
    sx= motion_x & s_mask;
2716
    sy= motion_y & s_mask;
2717
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2718
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2719
    
2720
    if (s->out_format == FMT_H263) {
2721
        uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2722
        uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2723
        uvsrc_x = src_x>>1;
2724
        uvsrc_y = src_y>>1;
2725
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2726
        mx = motion_x / 4;
2727
        my = motion_y / 4;
2728
        uvsx = (2*mx) & s_mask;
2729
        uvsy = (2*my) & s_mask;
2730
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2731
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2732
    } else {
2733
        mx = motion_x / 2;
2734
        my = motion_y / 2;
2735
        uvsx = mx & s_mask;
2736
        uvsy = my & s_mask;
2737
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2738
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2739
    }
2740

    
2741
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2742
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2743
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2744

    
2745
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2746
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2747
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2748
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2749
            ptr_y = s->edge_emu_buffer;
2750
            if(!(s->flags&CODEC_FLAG_GRAY)){
2751
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2752
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2753
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2754
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2755
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2756
                ptr_cb= uvbuf;
2757
                ptr_cr= uvbuf+16;
2758
            }
2759
    }
2760

    
2761
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2762
        dest_y += s->linesize;
2763
        dest_cb+= s->uvlinesize;
2764
        dest_cr+= s->uvlinesize;
2765
    }
2766

    
2767
    if(field_select){
2768
        ptr_y += s->linesize;
2769
        ptr_cb+= s->uvlinesize;
2770
        ptr_cr+= s->uvlinesize;
2771
    }
2772

    
2773
    sx <<= 2 - lowres;
2774
    sy <<= 2 - lowres;
2775
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2776
    
2777
    if(!(s->flags&CODEC_FLAG_GRAY)){
2778
        uvsx <<= 2 - lowres;
2779
        uvsy <<= 2 - lowres;
2780
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2781
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2782
    }
2783
    //FIXME h261 lowres loop filter
2784
}
2785

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

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

    
2865
    put_obmc(dest, ptr, s->linesize);                
2866
}
2867

    
2868
static inline void qpel_motion(MpegEncContext *s,
2869
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2870
                               int field_based, int bottom_field, int field_select,
2871
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2872
                               qpel_mc_func (*qpix_op)[16],
2873
                               int motion_x, int motion_y, int h)
2874
{
2875
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2876
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2877

    
2878
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2879
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2880
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2881

    
2882
    v_edge_pos = s->v_edge_pos >> field_based;
2883
    linesize = s->linesize << field_based;
2884
    uvlinesize = s->uvlinesize << field_based;
2885
    
2886
    if(field_based){
2887
        mx= motion_x/2;
2888
        my= motion_y>>1;
2889
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2890
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2891
        mx= (motion_x>>1) + rtab[motion_x&7];
2892
        my= (motion_y>>1) + rtab[motion_y&7];
2893
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2894
        mx= (motion_x>>1)|(motion_x&1);
2895
        my= (motion_y>>1)|(motion_y&1);
2896
    }else{
2897
        mx= motion_x/2;
2898
        my= motion_y/2;
2899
    }
2900
    mx= (mx>>1)|(mx&1);
2901
    my= (my>>1)|(my&1);
2902

    
2903
    uvdxy= (mx&1) | ((my&1)<<1);
2904
    mx>>=1;
2905
    my>>=1;
2906

    
2907
    uvsrc_x = s->mb_x *  8                 + mx;
2908
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2909

    
2910
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2911
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2912
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2913

    
2914
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2915
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2916
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2917
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2918
        ptr_y= s->edge_emu_buffer;
2919
        if(!(s->flags&CODEC_FLAG_GRAY)){
2920
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2921
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2922
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2923
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2924
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2925
            ptr_cb= uvbuf;
2926
            ptr_cr= uvbuf + 16;
2927
        }
2928
    }
2929

    
2930
    if(!field_based)
2931
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2932
    else{
2933
        if(bottom_field){
2934
            dest_y += s->linesize;
2935
            dest_cb+= s->uvlinesize;
2936
            dest_cr+= s->uvlinesize;
2937
        }
2938

    
2939
        if(field_select){
2940
            ptr_y  += s->linesize;
2941
            ptr_cb += s->uvlinesize;
2942
            ptr_cr += s->uvlinesize;
2943
        }
2944
        //damn interlaced mode
2945
        //FIXME boundary mirroring is not exactly correct here
2946
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2947
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2948
    }
2949
    if(!(s->flags&CODEC_FLAG_GRAY)){
2950
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2951
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2952
    }
2953
}
2954

    
2955
inline int ff_h263_round_chroma(int x){
2956
    if (x >= 0)
2957
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2958
    else {
2959
        x = -x;
2960
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2961
    }
2962
}
2963

    
2964
/**
2965
 * h263 chorma 4mv motion compensation.
2966
 */
2967
static inline void chroma_4mv_motion(MpegEncContext *s,
2968
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2969
                                     uint8_t **ref_picture,
2970
                                     op_pixels_func *pix_op,
2971
                                     int mx, int my){
2972
    int dxy, emu=0, src_x, src_y, offset;
2973
    uint8_t *ptr;
2974
    
2975
    /* In case of 8X8, we construct a single chroma motion vector
2976
       with a special rounding */
2977
    mx= ff_h263_round_chroma(mx);
2978
    my= ff_h263_round_chroma(my);
2979
    
2980
    dxy = ((my & 1) << 1) | (mx & 1);
2981
    mx >>= 1;
2982
    my >>= 1;
2983

    
2984
    src_x = s->mb_x * 8 + mx;
2985
    src_y = s->mb_y * 8 + my;
2986
    src_x = clip(src_x, -8, s->width/2);
2987
    if (src_x == s->width/2)
2988
        dxy &= ~1;
2989
    src_y = clip(src_y, -8, s->height/2);
2990
    if (src_y == s->height/2)
2991
        dxy &= ~2;
2992
    
2993
    offset = (src_y * (s->uvlinesize)) + src_x;
2994
    ptr = ref_picture[1] + offset;
2995
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2996
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2997
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2998
            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);
2999
            ptr= s->edge_emu_buffer;
3000
            emu=1;
3001
        }
3002
    }
3003
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3004

    
3005
    ptr = ref_picture[2] + offset;
3006
    if(emu){
3007
        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);
3008
        ptr= s->edge_emu_buffer;
3009
    }
3010
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3011
}
3012

    
3013
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3014
                                     uint8_t *dest_cb, uint8_t *dest_cr,
3015
                                     uint8_t **ref_picture,
3016
                                     h264_chroma_mc_func *pix_op,
3017
                                     int mx, int my){
3018
    const int lowres= s->avctx->lowres;
3019
    const int block_s= 8>>lowres;
3020
    const int s_mask= (2<<lowres)-1;
3021
    const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3022
    const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3023
    int emu=0, src_x, src_y, offset, sx, sy;
3024
    uint8_t *ptr;
3025
    
3026
    if(s->quarter_sample){
3027
        mx/=2;
3028
        my/=2;
3029
    }
3030

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

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

    
3084
    mb_x = s->mb_x;
3085
    mb_y = s->mb_y;
3086

    
3087
    if(s->obmc && s->pict_type != B_TYPE){
3088
        int16_t mv_cache[4][4][2];
3089
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
3090
        const int mot_stride= s->b8_stride;
3091
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3092

    
3093
        assert(!s->mb_skiped);
3094
                
3095
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
3096
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3097
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3098

    
3099
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3100
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3101
        }else{
3102
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3103
        }
3104

    
3105
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3106
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3107
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3108
        }else{
3109
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3110
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3111
        }
3112

    
3113
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3114
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3115
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3116
        }else{
3117
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3118
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3119
        }
3120
        
3121
        mx = 0;
3122
        my = 0;
3123
        for(i=0;i<4;i++) {
3124
            const int x= (i&1)+1;
3125
            const int y= (i>>1)+1;
3126
            int16_t mv[5][2]= {
3127
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
3128
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3129
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3130
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3131
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3132
            //FIXME cleanup
3133
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3134
                        ref_picture[0],
3135
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3136
                        pix_op[1],
3137
                        mv);
3138

    
3139
            mx += mv[0][0];
3140
            my += mv[0][1];
3141
        }
3142
        if(!(s->flags&CODEC_FLAG_GRAY))
3143
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3144

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

    
3185
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3186
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3187
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3188
                    
3189
                /* WARNING: do no forget half pels */
3190
                src_x = clip(src_x, -16, s->width);
3191
                if (src_x == s->width)
3192
                    dxy &= ~3;
3193
                src_y = clip(src_y, -16, s->height);
3194
                if (src_y == s->height)
3195
                    dxy &= ~12;
3196
                    
3197
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3198
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3199
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3200
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3201
                        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);
3202
                        ptr= s->edge_emu_buffer;
3203
                    }
3204
                }
3205
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3206
                qpix_op[1][dxy](dest, ptr, s->linesize);
3207

    
3208
                mx += s->mv[dir][i][0]/2;
3209
                my += s->mv[dir][i][1]/2;
3210
            }
3211
        }else{
3212
            for(i=0;i<4;i++) {
3213
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3214
                            ref_picture[0], 0, 0,
3215
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3216
                            s->width, s->height, s->linesize,
3217
                            s->h_edge_pos, s->v_edge_pos,
3218
                            8, 8, pix_op[1],
3219
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3220

    
3221
                mx += s->mv[dir][i][0];
3222
                my += s->mv[dir][i][1];
3223
            }
3224
        }
3225

    
3226
        if(!(s->flags&CODEC_FLAG_GRAY))
3227
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3228
        break;
3229
    case MV_TYPE_FIELD:
3230
        if (s->picture_structure == PICT_FRAME) {
3231
            if(s->quarter_sample){
3232
                for(i=0; i<2; i++){
3233
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3234
                                1, i, s->field_select[dir][i],
3235
                                ref_picture, pix_op, qpix_op,
3236
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3237
                }
3238
            }else{
3239
                /* top field */       
3240
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3241
                            1, 0, s->field_select[dir][0],
3242
                            ref_picture, pix_op,
3243
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3244
                /* bottom field */
3245
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3246
                            1, 1, s->field_select[dir][1],
3247
                            ref_picture, pix_op,
3248
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3249
            }
3250
        } else {
3251
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3252
                ref_picture= s->current_picture_ptr->data;
3253
            } 
3254

    
3255
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3256
                        0, 0, s->field_select[dir][0],
3257
                        ref_picture, pix_op,
3258
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3259
        }
3260
        break;
3261
    case MV_TYPE_16X8:
3262
        for(i=0; i<2; i++){
3263
            uint8_t ** ref2picture;
3264

    
3265
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3266
                ref2picture= ref_picture;
3267
            }else{
3268
                ref2picture= s->current_picture_ptr->data;
3269
            } 
3270

    
3271
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3272
                        0, 0, s->field_select[dir][i],
3273
                        ref2picture, pix_op,
3274
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3275
                
3276
            dest_y += 16*s->linesize;
3277
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3278
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3279
        }        
3280
        break;
3281
    case MV_TYPE_DMV:
3282
        if(s->picture_structure == PICT_FRAME){
3283
            for(i=0; i<2; i++){
3284
                int j;
3285
                for(j=0; j<2; j++){
3286
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3287
                                1, j, j^i,
3288
                                ref_picture, pix_op,
3289
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3290
                }
3291
                pix_op = s->dsp.avg_pixels_tab; 
3292
            }
3293
        }else{
3294
            for(i=0; i<2; i++){
3295
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3296
                            0, 0, s->picture_structure != i+1,
3297
                            ref_picture, pix_op,
3298
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3299

    
3300
                // after put we make avg of the same block
3301
                pix_op=s->dsp.avg_pixels_tab; 
3302

    
3303
                //opposite parity is always in the same frame if this is second field
3304
                if(!s->first_field){
3305
                    ref_picture = s->current_picture_ptr->data;    
3306
                }
3307
            }
3308
        }
3309
    break;
3310
    default: assert(0);
3311
    }
3312
}
3313

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

    
3335
    mb_x = s->mb_x;
3336
    mb_y = s->mb_y;
3337

    
3338
    switch(s->mv_type) {
3339
    case MV_TYPE_16X16:
3340
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3341
                    0, 0, 0,
3342
                    ref_picture, pix_op,
3343
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3344
        break;
3345
    case MV_TYPE_8X8:
3346
        mx = 0;
3347
        my = 0;
3348
            for(i=0;i<4;i++) {
3349
                hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3350
                            ref_picture[0], 0, 0,
3351
                            (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3352
                            s->width, s->height, s->linesize,
3353
                            s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3354
                            block_s, block_s, pix_op,
3355
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3356

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

    
3361
        if(!(s->flags&CODEC_FLAG_GRAY))
3362
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3363
        break;
3364
    case MV_TYPE_FIELD:
3365
        if (s->picture_structure == PICT_FRAME) {
3366
            /* top field */       
3367
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3368
                        1, 0, s->field_select[dir][0],
3369
                        ref_picture, pix_op,
3370
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3371
            /* bottom field */
3372
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3373
                        1, 1, s->field_select[dir][1],
3374
                        ref_picture, pix_op,
3375
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3376
        } else {
3377
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3378
                ref_picture= s->current_picture_ptr->data;
3379
            } 
3380

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

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

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

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

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

    
3440
/* put block[] to dest[] */
3441
static inline void put_dct(MpegEncContext *s, 
3442
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3443
{
3444
    s->dct_unquantize_intra(s, block, i, qscale);
3445
    s->dsp.idct_put (dest, line_size, block);
3446
}
3447

    
3448
/* add block[] to dest[] */
3449
static inline void add_dct(MpegEncContext *s, 
3450
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3451
{
3452
    if (s->block_last_index[i] >= 0) {
3453
        s->dsp.idct_add (dest, line_size, block);
3454
    }
3455
}
3456

    
3457
static inline void add_dequant_dct(MpegEncContext *s, 
3458
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3459
{
3460
    if (s->block_last_index[i] >= 0) {
3461
        s->dct_unquantize_inter(s, block, i, qscale);
3462

    
3463
        s->dsp.idct_add (dest, line_size, block);
3464
    }
3465
}
3466

    
3467
/**
3468
 * cleans dc, ac, coded_block for the current non intra MB
3469
 */
3470
void ff_clean_intra_table_entries(MpegEncContext *s)
3471
{
3472
    int wrap = s->b8_stride;
3473
    int xy = s->block_index[0];
3474
    
3475
    s->dc_val[0][xy           ] = 
3476
    s->dc_val[0][xy + 1       ] = 
3477
    s->dc_val[0][xy     + wrap] =
3478
    s->dc_val[0][xy + 1 + wrap] = 1024;
3479
    /* ac pred */
3480
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3481
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3482
    if (s->msmpeg4_version>=3) {
3483
        s->coded_block[xy           ] =
3484
        s->coded_block[xy + 1       ] =
3485
        s->coded_block[xy     + wrap] =
3486
        s->coded_block[xy + 1 + wrap] = 0;
3487
    }
3488
    /* chroma */
3489
    wrap = s->mb_stride;
3490
    xy = s->mb_x + s->mb_y * wrap;
3491
    s->dc_val[1][xy] =
3492
    s->dc_val[2][xy] = 1024;
3493
    /* ac pred */
3494
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3495
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3496
    
3497
    s->mbintra_table[xy]= 0;
3498
}
3499

    
3500
/* generic function called after a macroblock has been parsed by the
3501
   decoder or after it has been encoded by the encoder.
3502

3503
   Important variables used:
3504
   s->mb_intra : true if intra macroblock
3505
   s->mv_dir   : motion vector direction
3506
   s->mv_type  : motion vector type
3507
   s->mv       : motion vector
3508
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3509
 */
3510
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3511
{
3512
    int mb_x, mb_y;
3513
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3514
#ifdef HAVE_XVMC
3515
    if(s->avctx->xvmc_acceleration){
3516
        XVMC_decode_mb(s);//xvmc uses pblocks
3517
        return;
3518
    }
3519
#endif
3520

    
3521
    mb_x = s->mb_x;
3522
    mb_y = s->mb_y;
3523

    
3524
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3525
       /* save DCT coefficients */
3526
       int i,j;
3527
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3528
       for(i=0; i<6; i++)
3529
           for(j=0; j<64; j++)
3530
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3531
    }
3532

    
3533
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3534

    
3535
    /* update DC predictors for P macroblocks */
3536
    if (!s->mb_intra) {
3537
        if (s->h263_pred || s->h263_aic) {
3538
            if(s->mbintra_table[mb_xy])
3539
                ff_clean_intra_table_entries(s);
3540
        } else {
3541
            s->last_dc[0] =
3542
            s->last_dc[1] =
3543
            s->last_dc[2] = 128 << s->intra_dc_precision;
3544
        }
3545
    }
3546
    else if (s->h263_pred || s->h263_aic)
3547
        s->mbintra_table[mb_xy]=1;
3548

    
3549
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3550
        uint8_t *dest_y, *dest_cb, *dest_cr;
3551
        int dct_linesize, dct_offset;
3552
        op_pixels_func (*op_pix)[4];
3553
        qpel_mc_func (*op_qpix)[16];
3554
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3555
        const int uvlinesize= s->current_picture.linesize[1];
3556
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3557
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3558

    
3559
        /* avoid copy if macroblock skipped in last frame too */
3560
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3561
        if(!s->encoding){
3562
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3563
            const int age= s->current_picture.age;
3564

    
3565
            assert(age);
3566

    
3567
            if (s->mb_skiped) {
3568
                s->mb_skiped= 0;
3569
                assert(s->pict_type!=I_TYPE);
3570
 
3571
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3572
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3573

    
3574
                /* if previous was skipped too, then nothing to do !  */
3575
                if (*mbskip_ptr >= age && s->current_picture.reference){
3576
                    return;
3577
                }
3578
            } else if(!s->current_picture.reference){
3579
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3580
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3581
            } else{
3582
                *mbskip_ptr = 0; /* not skipped */
3583
            }
3584
        }
3585
        
3586
        dct_linesize = linesize << s->interlaced_dct;
3587
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3588
        
3589
        if(readable){
3590
            dest_y=  s->dest[0];
3591
            dest_cb= s->dest[1];
3592
            dest_cr= s->dest[2];
3593
        }else{
3594
            dest_y = s->b_scratchpad;
3595
            dest_cb= s->b_scratchpad+16*linesize;
3596
            dest_cr= s->b_scratchpad+32*linesize;
3597
        }
3598

    
3599
        if (!s->mb_intra) {
3600
            /* motion handling */
3601
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3602
            if(!s->encoding){
3603
                if(lowres_flag){
3604
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3605

    
3606
                    if (s->mv_dir & MV_DIR_FORWARD) {
3607
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3608
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3609
                    }
3610
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3611
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3612
                    }
3613
                }else{
3614
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3615
                        op_pix = s->dsp.put_pixels_tab;
3616
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3617
                    }else{
3618
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3619
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3620
                    }
3621
                    if (s->mv_dir & MV_DIR_FORWARD) {
3622
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3623
                        op_pix = s->dsp.avg_pixels_tab;
3624
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3625
                    }
3626
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3627
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3628
                    }
3629
                }
3630
            }
3631

    
3632
            /* skip dequant / idct if we are really late ;) */
3633
            if(s->hurry_up>1) return;
3634

    
3635
            /* add dct residue */
3636
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3637
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3638
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3639
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3640
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3641
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3642

    
3643
                if(!(s->flags&CODEC_FLAG_GRAY)){
3644
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3645
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3646
                }
3647
            } else if(s->codec_id != CODEC_ID_WMV2){
3648
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3649
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3650
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3651
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3652

    
3653
                if(!(s->flags&CODEC_FLAG_GRAY)){
3654
                    if(s->chroma_y_shift){//Chroma420
3655
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3656
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3657
                    }else{
3658
                        //chroma422
3659
                        dct_linesize = uvlinesize << s->interlaced_dct;
3660
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3661

    
3662
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3663
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3664
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3665
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3666
                        if(!s->chroma_x_shift){//Chroma444
3667
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3668
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3669
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3670
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3671
                        }
3672
                    }
3673
                }//fi gray
3674
            }
3675
#ifdef CONFIG_RISKY
3676
            else{
3677
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3678
            }
3679
#endif
3680
        } else {
3681
            /* dct only in intra block */
3682
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3683
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3684
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3685
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3686
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3687

    
3688
                if(!(s->flags&CODEC_FLAG_GRAY)){
3689
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3690
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3691
                }
3692
            }else{
3693
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3694
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3695
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3696
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3697

    
3698
                if(!(s->flags&CODEC_FLAG_GRAY)){
3699
                    if(s->chroma_y_shift){
3700
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3701
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3702
                    }else{
3703

    
3704
                        dct_linesize = uvlinesize << s->interlaced_dct;
3705
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3706

    
3707
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3708
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3709
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3710
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3711
                        if(!s->chroma_x_shift){//Chroma444
3712
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3713
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3714
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3715
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3716
                        }
3717
                    }
3718
                }//gray
3719
            }
3720
        }
3721
        if(!readable){
3722
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3723
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3724
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3725
        }
3726
    }
3727
}
3728

    
3729
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3730
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3731
    else                  MPV_decode_mb_internal(s, block, 0);
3732
}
3733

    
3734
#ifdef CONFIG_ENCODERS
3735

    
3736
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3737
{
3738
    static const char tab[64]=
3739
        {3,2,2,1,1,1,1,1,
3740
         1,1,1,1,1,1,1,1,
3741
         1,1,1,1,1,1,1,1,
3742
         0,0,0,0,0,0,0,0,
3743
         0,0,0,0,0,0,0,0,
3744
         0,0,0,0,0,0,0,0,
3745
         0,0,0,0,0,0,0,0,
3746
         0,0,0,0,0,0,0,0};
3747
    int score=0;
3748
    int run=0;
3749
    int i;
3750
    DCTELEM *block= s->block[n];
3751
    const int last_index= s->block_last_index[n];
3752
    int skip_dc;
3753

    
3754
    if(threshold<0){
3755
        skip_dc=0;
3756
        threshold= -threshold;
3757
    }else
3758
        skip_dc=1;
3759

    
3760
    /* are all which we could set to zero are allready zero? */
3761
    if(last_index<=skip_dc - 1) return;
3762

    
3763
    for(i=0; i<=last_index; i++){
3764
        const int j = s->intra_scantable.permutated[i];
3765
        const int level = ABS(block[j]);
3766
        if(level==1){
3767
            if(skip_dc && i==0) continue;
3768
            score+= tab[run];
3769
            run=0;
3770
        }else if(level>1){
3771
            return;
3772
        }else{
3773
            run++;
3774
        }
3775
    }
3776
    if(score >= threshold) return;
3777
    for(i=skip_dc; i<=last_index; i++){
3778
        const int j = s->intra_scantable.permutated[i];
3779
        block[j]=0;
3780
    }
3781
    if(block[0]) s->block_last_index[n]= 0;
3782
    else         s->block_last_index[n]= -1;
3783
}
3784

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

    
3816
#endif //CONFIG_ENCODERS
3817

    
3818
/**
3819
 *
3820
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3821
 */
3822
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3823
    if (s->avctx->draw_horiz_band) {
3824
        AVFrame *src;
3825
        int offset[4];
3826
        
3827
        if(s->picture_structure != PICT_FRAME){
3828
            h <<= 1;
3829
            y <<= 1;
3830
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3831
        }
3832

    
3833
        h= FFMIN(h, s->avctx->height - y);
3834

    
3835
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3836
            src= (AVFrame*)s->current_picture_ptr;
3837
        else if(s->last_picture_ptr)
3838
            src= (AVFrame*)s->last_picture_ptr;
3839
        else
3840
            return;
3841
            
3842
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3843
            offset[0]=
3844
            offset[1]=
3845
            offset[2]=
3846
            offset[3]= 0;
3847
        }else{
3848
            offset[0]= y * s->linesize;;
3849
            offset[1]= 
3850
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3851
            offset[3]= 0;
3852
        }
3853

    
3854
        emms_c();
3855

    
3856
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3857
                                  y, s->picture_structure, h);
3858
    }
3859
}
3860

    
3861
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3862
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3863
    const int uvlinesize= s->current_picture.linesize[1];
3864
    const int mb_size= 4 - s->avctx->lowres;
3865
        
3866
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3867
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3868
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3869
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3870
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3871
    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;
3872
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3873

    
3874
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3875
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3876
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3877

    
3878
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3879
    {
3880
        s->dest[0] += s->mb_y *   linesize << mb_size;
3881
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3882
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3883
    }
3884
}
3885

    
3886
#ifdef CONFIG_ENCODERS
3887

    
3888
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3889
    int x, y;
3890
//FIXME optimize
3891
    for(y=0; y<8; y++){
3892
        for(x=0; x<8; x++){
3893
            int x2, y2;
3894
            int sum=0;
3895
            int sqr=0;
3896
            int count=0;
3897

    
3898
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3899
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3900
                    int v= ptr[x2 + y2*stride];
3901
                    sum += v;
3902
                    sqr += v*v;
3903
                    count++;
3904
                }
3905
            }
3906
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3907
        }
3908
    }
3909
}
3910

    
3911
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3912
{
3913
    int16_t weight[6][64];
3914
    DCTELEM orig[6][64];
3915
    const int mb_x= s->mb_x;
3916
    const int mb_y= s->mb_y;
3917
    int i;
3918
    int skip_dct[6];
3919
    int dct_offset   = s->linesize*8; //default for progressive frames
3920
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3921
    int wrap_y, wrap_c;
3922
    
3923
    for(i=0; i<6; i++) skip_dct[i]=0;
3924
    
3925
    if(s->adaptive_quant){
3926
        const int last_qp= s->qscale;
3927
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3928

    
3929
        s->lambda= s->lambda_table[mb_xy];
3930
        update_qscale(s);
3931
    
3932
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3933
            s->dquant= s->qscale - last_qp;
3934

    
3935
            if(s->out_format==FMT_H263){
3936
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3937
            
3938
                if(s->codec_id==CODEC_ID_MPEG4){        
3939
                    if(!s->mb_intra){
3940
                        if(s->pict_type == B_TYPE){
3941
                            if(s->dquant&1) 
3942
                                s->dquant= (s->dquant/2)*2;
3943
                            if(s->mv_dir&MV_DIRECT)
3944
                                s->dquant= 0;
3945
                        }
3946
                        if(s->mv_type==MV_TYPE_8X8)
3947
                            s->dquant=0;
3948
                    }
3949
                }
3950
            }
3951
        }
3952
        ff_set_qscale(s, last_qp + s->dquant);
3953
    }else if(s->flags&CODEC_FLAG_QP_RD)
3954
        ff_set_qscale(s, s->qscale + s->dquant);
3955

    
3956
    wrap_y = s->linesize;
3957
    wrap_c = s->uvlinesize;
3958
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3959
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3960
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3961

    
3962
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3963
        uint8_t *ebuf= s->edge_emu_buffer + 32;
3964
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3965
        ptr_y= ebuf;
3966
        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);
3967
        ptr_cb= ebuf+18*wrap_y;
3968
        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);
3969
        ptr_cr= ebuf+18*wrap_y+8;
3970
    }
3971

    
3972
    if (s->mb_intra) {
3973
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3974
            int progressive_score, interlaced_score;
3975

    
3976
            s->interlaced_dct=0;
3977
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3978
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3979

    
3980
            if(progressive_score > 0){
3981
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3982
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3983
                if(progressive_score > interlaced_score){
3984
                    s->interlaced_dct=1;
3985
            
3986
                    dct_offset= wrap_y;
3987
                    wrap_y<<=1;
3988
                }
3989
            }
3990
        }
3991
        
3992
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3993
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3994
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3995
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3996

    
3997
        if(s->flags&CODEC_FLAG_GRAY){
3998
            skip_dct[4]= 1;
3999
            skip_dct[5]= 1;
4000
        }else{
4001
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4002
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4003
        }
4004
    }else{
4005
        op_pixels_func (*op_pix)[4];
4006
        qpel_mc_func (*op_qpix)[16];
4007
        uint8_t *dest_y, *dest_cb, *dest_cr;
4008

    
4009
        dest_y  = s->dest[0];
4010
        dest_cb = s->dest[1];
4011
        dest_cr = s->dest[2];
4012

    
4013
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
4014
            op_pix = s->dsp.put_pixels_tab;
4015
            op_qpix= s->dsp.put_qpel_pixels_tab;
4016
        }else{
4017
            op_pix = s->dsp.put_no_rnd_pixels_tab;
4018
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4019
        }
4020

    
4021
        if (s->mv_dir & MV_DIR_FORWARD) {
4022
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4023
            op_pix = s->dsp.avg_pixels_tab;
4024
            op_qpix= s->dsp.avg_qpel_pixels_tab;
4025
        }
4026
        if (s->mv_dir & MV_DIR_BACKWARD) {
4027
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4028
        }
4029

    
4030
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4031
            int progressive_score, interlaced_score;
4032

    
4033
            s->interlaced_dct=0;
4034
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
4035
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4036
            
4037
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4038

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

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

    
4115
        if(s->flags & CODEC_FLAG_CBP_RD){
4116
            for(i=0;i<6;i++) {
4117
                if(s->block_last_index[i] == -1)
4118
                    s->coded_score[i]= INT_MAX/256;
4119
            }
4120
        }
4121
    }
4122

    
4123
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4124
        s->block_last_index[4]=
4125
        s->block_last_index[5]= 0;
4126
        s->block[4][0]=
4127
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4128
    }
4129

    
4130
    //non c quantize code returns incorrect block_last_index FIXME
4131
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4132
        for(i=0; i<6; i++){
4133
            int j;
4134
            if(s->block_last_index[i]>0){
4135
                for(j=63; j>0; j--){
4136
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4137
                }
4138
                s->block_last_index[i]= j;
4139
            }
4140
        }
4141
    }
4142

    
4143
    /* huffman encode */
4144
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4145
    case CODEC_ID_MPEG1VIDEO:
4146
    case CODEC_ID_MPEG2VIDEO:
4147
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4148
#ifdef CONFIG_RISKY
4149
    case CODEC_ID_MPEG4:
4150
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4151
    case CODEC_ID_MSMPEG4V2:
4152
    case CODEC_ID_MSMPEG4V3:
4153
    case CODEC_ID_WMV1:
4154
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4155
    case CODEC_ID_WMV2:
4156
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4157
    case CODEC_ID_H261:
4158
        ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4159
    case CODEC_ID_H263:
4160
    case CODEC_ID_H263P:
4161
    case CODEC_ID_FLV1:
4162
    case CODEC_ID_RV10:
4163
    case CODEC_ID_RV20:
4164
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4165
#endif
4166
    case CODEC_ID_MJPEG:
4167
        mjpeg_encode_mb(s, s->block); break;
4168
    default:
4169
        assert(0);
4170
    }
4171
}
4172

    
4173
#endif //CONFIG_ENCODERS
4174

    
4175
void ff_mpeg_flush(AVCodecContext *avctx){
4176
    int i;
4177
    MpegEncContext *s = avctx->priv_data;
4178
    
4179
    if(s==NULL || s->picture==NULL) 
4180
        return;
4181
    
4182
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4183
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4184
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4185
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4186
    }
4187
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4188
    
4189
    s->mb_x= s->mb_y= 0;
4190
    
4191
    s->parse_context.state= -1;
4192
    s->parse_context.frame_start_found= 0;
4193
    s->parse_context.overread= 0;
4194
    s->parse_context.overread_index= 0;
4195
    s->parse_context.index= 0;
4196
    s->parse_context.last_index= 0;
4197
    s->bitstream_buffer_size=0;
4198
}
4199

    
4200
#ifdef CONFIG_ENCODERS
4201
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4202
{
4203
    const uint16_t *srcw= (uint16_t*)src;
4204
    int words= length>>4;
4205
    int bits= length&15;
4206
    int i;
4207

    
4208
    if(length==0) return;
4209
    
4210
    if(words < 16){
4211
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4212
    }else if(put_bits_count(pb)&7){
4213
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4214
    }else{
4215
        for(i=0; put_bits_count(pb)&31; i++)
4216
            put_bits(pb, 8, src[i]);
4217
        flush_put_bits(pb);
4218
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4219
        skip_put_bytes(pb, 2*words-i);
4220
    }
4221
        
4222
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4223
}
4224

    
4225
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4226
    int i;
4227

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

    
4230
    /* mpeg1 */
4231
    d->mb_skip_run= s->mb_skip_run;
4232
    for(i=0; i<3; i++)
4233
        d->last_dc[i]= s->last_dc[i];
4234
    
4235
    /* statistics */
4236
    d->mv_bits= s->mv_bits;
4237
    d->i_tex_bits= s->i_tex_bits;
4238
    d->p_tex_bits= s->p_tex_bits;
4239
    d->i_count= s->i_count;
4240
    d->f_count= s->f_count;
4241
    d->b_count= s->b_count;
4242
    d->skip_count= s->skip_count;
4243
    d->misc_bits= s->misc_bits;
4244
    d->last_bits= 0;
4245

    
4246
    d->mb_skiped= 0;
4247
    d->qscale= s->qscale;
4248
    d->dquant= s->dquant;
4249
}
4250

    
4251
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4252
    int i;
4253

    
4254
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
4255
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4256
    
4257
    /* mpeg1 */
4258
    d->mb_skip_run= s->mb_skip_run;
4259
    for(i=0; i<3; i++)
4260
        d->last_dc[i]= s->last_dc[i];
4261
    
4262
    /* statistics */
4263
    d->mv_bits= s->mv_bits;
4264
    d->i_tex_bits= s->i_tex_bits;
4265
    d->p_tex_bits= s->p_tex_bits;
4266
    d->i_count= s->i_count;
4267
    d->f_count= s->f_count;
4268
    d->b_count= s->b_count;
4269
    d->skip_count= s->skip_count;
4270
    d->misc_bits= s->misc_bits;
4271

    
4272
    d->mb_intra= s->mb_intra;
4273
    d->mb_skiped= s->mb_skiped;
4274
    d->mv_type= s->mv_type;
4275
    d->mv_dir= s->mv_dir;
4276
    d->pb= s->pb;
4277
    if(s->data_partitioning){
4278
        d->pb2= s->pb2;
4279
        d->tex_pb= s->tex_pb;
4280
    }
4281
    d->block= s->block;
4282
    for(i=0; i<6; i++)
4283
        d->block_last_index[i]= s->block_last_index[i];
4284
    d->interlaced_dct= s->interlaced_dct;
4285
    d->qscale= s->qscale;
4286
}
4287

    
4288
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4289
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4290
                           int *dmin, int *next_block, int motion_x, int motion_y)
4291
{
4292
    int score;
4293
    uint8_t *dest_backup[3];
4294
    
4295
    copy_context_before_encode(s, backup, type);
4296

    
4297
    s->block= s->blocks[*next_block];
4298
    s->pb= pb[*next_block];
4299
    if(s->data_partitioning){
4300
        s->pb2   = pb2   [*next_block];
4301
        s->tex_pb= tex_pb[*next_block];
4302
    }
4303
    
4304
    if(*next_block){
4305
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4306
        s->dest[0] = s->rd_scratchpad;
4307
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4308
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4309
        assert(s->linesize >= 32); //FIXME
4310
    }
4311

    
4312
    encode_mb(s, motion_x, motion_y);
4313
    
4314
    score= put_bits_count(&s->pb);
4315
    if(s->data_partitioning){
4316
        score+= put_bits_count(&s->pb2);
4317
        score+= put_bits_count(&s->tex_pb);
4318
    }
4319
   
4320
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4321
        MPV_decode_mb(s, s->block);
4322

    
4323
        score *= s->lambda2;
4324
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4325
    }
4326
    
4327
    if(*next_block){
4328
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4329
    }
4330

    
4331
    if(score<*dmin){
4332
        *dmin= score;
4333
        *next_block^=1;
4334

    
4335
        copy_context_after_encode(best, s, type);
4336
    }
4337
}
4338
                
4339
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4340
    uint32_t *sq = squareTbl + 256;
4341
    int acc=0;
4342
    int x,y;
4343
    
4344
    if(w==16 && h==16) 
4345
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4346
    else if(w==8 && h==8)
4347
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4348
    
4349
    for(y=0; y<h; y++){
4350
        for(x=0; x<w; x++){
4351
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4352
        } 
4353
    }
4354
    
4355
    assert(acc>=0);
4356
    
4357
    return acc;
4358
}
4359

    
4360
static int sse_mb(MpegEncContext *s){
4361
    int w= 16;
4362
    int h= 16;
4363

    
4364
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4365
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4366

    
4367
    if(w==16 && h==16)
4368
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4369
        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)
4370
               +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)
4371
               +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);
4372
      }else{
4373
        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)
4374
               +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)
4375
               +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);
4376
      }
4377
    else
4378
        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)
4379
               +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)
4380
               +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);
4381
}
4382

    
4383
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4384
    MpegEncContext *s= arg;
4385

    
4386
    
4387
    s->me.pre_pass=1;
4388
    s->me.dia_size= s->avctx->pre_dia_size;
4389
    s->first_slice_line=1;
4390
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4391
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4392
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4393
        }
4394
        s->first_slice_line=0;
4395
    }
4396
    
4397
    s->me.pre_pass=0;
4398
    
4399
    return 0;
4400
}
4401

    
4402
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4403
    MpegEncContext *s= arg;
4404

    
4405
    s->me.dia_size= s->avctx->dia_size;
4406
    s->first_slice_line=1;
4407
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4408
        s->mb_x=0; //for block init below
4409
        ff_init_block_index(s);
4410
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4411
            s->block_index[0]+=2;
4412
            s->block_index[1]+=2;
4413
            s->block_index[2]+=2;
4414
            s->block_index[3]+=2;
4415
            
4416
            /* compute motion vector & mb_type and store in context */
4417
            if(s->pict_type==B_TYPE)
4418
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4419
            else
4420
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4421
        }
4422
        s->first_slice_line=0;
4423
    }
4424
    return 0;
4425
}
4426

    
4427
static int mb_var_thread(AVCodecContext *c, void *arg){
4428
    MpegEncContext *s= arg;
4429
    int mb_x, mb_y;
4430

    
4431
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4432
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4433
            int xx = mb_x * 16;
4434
            int yy = mb_y * 16;
4435
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4436
            int varc;
4437
            int sum = s->dsp.pix_sum(pix, s->linesize);
4438
    
4439
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4440

    
4441
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4442
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4443
            s->me.mb_var_sum_temp    += varc;
4444
        }
4445
    }
4446
    return 0;
4447
}
4448

    
4449
static void write_slice_end(MpegEncContext *s){
4450
    if(s->codec_id==CODEC_ID_MPEG4){
4451
        if(s->partitioned_frame){
4452
            ff_mpeg4_merge_partitions(s);
4453
        }
4454
    
4455
        ff_mpeg4_stuffing(&s->pb);
4456
    }else if(s->out_format == FMT_MJPEG){
4457
        ff_mjpeg_stuffing(&s->pb);
4458
    }
4459

    
4460
    align_put_bits(&s->pb);
4461
    flush_put_bits(&s->pb);
4462
}
4463

    
4464
static int encode_thread(AVCodecContext *c, void *arg){
4465
    MpegEncContext *s= arg;
4466
    int mb_x, mb_y, pdif = 0;
4467
    int i, j;
4468
    MpegEncContext best_s, backup_s;
4469
    uint8_t bit_buf[2][3000];
4470
    uint8_t bit_buf2[2][3000];
4471
    uint8_t bit_buf_tex[2][3000];
4472
    PutBitContext pb[2], pb2[2], tex_pb[2];
4473
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4474

    
4475
    for(i=0; i<2; i++){
4476
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4477
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4478
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4479
    }
4480

    
4481
    s->last_bits= put_bits_count(&s->pb);
4482
    s->mv_bits=0;
4483
    s->misc_bits=0;
4484
    s->i_tex_bits=0;
4485
    s->p_tex_bits=0;
4486
    s->i_count=0;
4487
    s->f_count=0;
4488
    s->b_count=0;
4489
    s->skip_count=0;
4490

    
4491
    for(i=0; i<3; i++){
4492
        /* init last dc values */
4493
        /* note: quant matrix value (8) is implied here */
4494
        s->last_dc[i] = 128 << s->intra_dc_precision;
4495
        
4496
        s->current_picture_ptr->error[i] = 0;
4497
    }
4498
    s->mb_skip_run = 0;
4499
    memset(s->last_mv, 0, sizeof(s->last_mv));
4500
     
4501
    s->last_mv_dir = 0;
4502

    
4503
#ifdef CONFIG_RISKY
4504
    switch(s->codec_id){
4505
    case CODEC_ID_H263:
4506
    case CODEC_ID_H263P:
4507
    case CODEC_ID_FLV1:
4508
        s->gob_index = ff_h263_get_gob_height(s);
4509
        break;
4510
    case CODEC_ID_MPEG4:
4511
        if(s->partitioned_frame)
4512
            ff_mpeg4_init_partitions(s);
4513
        break;
4514
    }
4515
#endif
4516

    
4517
    s->resync_mb_x=0;
4518
    s->resync_mb_y=0; 
4519
    s->first_slice_line = 1;
4520
    s->ptr_lastgob = s->pb.buf;
4521
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4522
//    printf("row %d at %X\n", s->mb_y, (int)s);
4523
        s->mb_x=0;
4524
        s->mb_y= mb_y;
4525

    
4526
        ff_set_qscale(s, s->qscale);
4527
        ff_init_block_index(s);
4528
        
4529
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4530
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4531
            int mb_type= s->mb_type[xy];
4532
//            int d;
4533
            int dmin= INT_MAX;
4534
            int dir;
4535

    
4536
            s->mb_x = mb_x;
4537
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
4538
            ff_update_block_index(s);
4539

    
4540
            if(s->codec_id == CODEC_ID_H261){
4541
                ff_h261_reorder_mb_index(s);
4542
                xy= s->mb_y*s->mb_stride + s->mb_x;
4543
                mb_type= s->mb_type[xy];
4544
            }
4545

    
4546
            /* write gob / video packet header  */
4547
#ifdef CONFIG_RISKY
4548
            if(s->rtp_mode){
4549
                int current_packet_size, is_gob_start;
4550
                
4551
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4552
                
4553
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4554
                
4555
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4556
                
4557
                switch(s->codec_id){
4558
                case CODEC_ID_H263:
4559
                case CODEC_ID_H263P:
4560
                    if(!s->h263_slice_structured)
4561
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4562
                    break;
4563
                case CODEC_ID_MPEG2VIDEO:
4564
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4565
                case CODEC_ID_MPEG1VIDEO:
4566
                    if(s->mb_skip_run) is_gob_start=0;
4567
                    break;
4568
                }
4569

    
4570
                if(is_gob_start){
4571
                    if(s->start_mb_y != mb_y || mb_x!=0){
4572
                        write_slice_end(s);
4573

    
4574
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4575
                            ff_mpeg4_init_partitions(s);
4576
                        }
4577
                    }
4578
                
4579
                    assert((put_bits_count(&s->pb)&7) == 0);
4580
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4581
                    
4582
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4583
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4584
                        int d= 100 / s->avctx->error_rate;
4585
                        if(r % d == 0){
4586
                            current_packet_size=0;
4587
#ifndef ALT_BITSTREAM_WRITER
4588
                            s->pb.buf_ptr= s->ptr_lastgob;
4589
#endif
4590
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4591
                        }
4592
                    }
4593
        
4594
                    if (s->avctx->rtp_callback)
4595
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4596
                    
4597
                    switch(s->codec_id){
4598
                    case CODEC_ID_MPEG4:
4599
                        ff_mpeg4_encode_video_packet_header(s);
4600
                        ff_mpeg4_clean_buffers(s);
4601
                    break;
4602
                    case CODEC_ID_MPEG1VIDEO:
4603
                    case CODEC_ID_MPEG2VIDEO:
4604
                        ff_mpeg1_encode_slice_header(s);
4605
                        ff_mpeg1_clean_buffers(s);
4606
                    break;
4607
                    case CODEC_ID_H263:
4608
                    case CODEC_ID_H263P:
4609
                        h263_encode_gob_header(s, mb_y);                       
4610
                    break;
4611
                    }
4612

    
4613
                    if(s->flags&CODEC_FLAG_PASS1){
4614
                        int bits= put_bits_count(&s->pb);
4615
                        s->misc_bits+= bits - s->last_bits;
4616
                        s->last_bits= bits;
4617
                    }
4618
    
4619
                    s->ptr_lastgob += current_packet_size;
4620
                    s->first_slice_line=1;
4621
                    s->resync_mb_x=mb_x;
4622
                    s->resync_mb_y=mb_y;
4623
                }
4624
            }
4625
#endif
4626

    
4627
            if(  (s->resync_mb_x   == s->mb_x)
4628
               && s->resync_mb_y+1 == s->mb_y){
4629
                s->first_slice_line=0; 
4630
            }
4631

    
4632
            s->mb_skiped=0;
4633
            s->dquant=0; //only for QP_RD
4634

    
4635
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4636
                int next_block=0;
4637
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4638

    
4639
                copy_context_before_encode(&backup_s, s, -1);
4640
                backup_s.pb= s->pb;
4641
                best_s.data_partitioning= s->data_partitioning;
4642
                best_s.partitioned_frame= s->partitioned_frame;
4643
                if(s->data_partitioning){
4644
                    backup_s.pb2= s->pb2;
4645
                    backup_s.tex_pb= s->tex_pb;
4646
                }
4647

    
4648
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4649
                    s->mv_dir = MV_DIR_FORWARD;
4650
                    s->mv_type = MV_TYPE_16X16;
4651
                    s->mb_intra= 0;
4652
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4653
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4654
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4655
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4656
                }
4657
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4658
                    s->mv_dir = MV_DIR_FORWARD;
4659
                    s->mv_type = MV_TYPE_FIELD;
4660
                    s->mb_intra= 0;
4661
                    for(i=0; i<2; i++){
4662
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4663
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4664
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4665
                    }
4666
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4667
                                 &dmin, &next_block, 0, 0);
4668
                }
4669
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4670
                    s->mv_dir = MV_DIR_FORWARD;
4671
                    s->mv_type = MV_TYPE_16X16;
4672
                    s->mb_intra= 0;
4673
                    s->mv[0][0][0] = 0;
4674
                    s->mv[0][0][1] = 0;
4675
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4676
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4677
                }
4678
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4679