Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 0f748574

History | View | Annotate | Download (230 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 dct_unquantize_h261_intra_c(MpegEncContext *s, 
57
                                  DCTELEM *block, int n, int qscale);
58
static void dct_unquantize_h261_inter_c(MpegEncContext *s, 
59
                                  DCTELEM *block, int n, int qscale);
60
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
61
#ifdef CONFIG_ENCODERS
62
static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
63
static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
64
static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
65
static int sse_mb(MpegEncContext *s);
66
static void  denoise_dct_c(MpegEncContext *s, DCTELEM *block);
67
#endif //CONFIG_ENCODERS
68

    
69
#ifdef HAVE_XVMC
70
extern int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
71
extern void XVMC_field_end(MpegEncContext *s);
72
extern void XVMC_decode_mb(MpegEncContext *s);
73
#endif
74

    
75
void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
76

    
77

    
78
/* enable all paranoid tests for rounding, overflows, etc... */
79
//#define PARANOID
80

    
81
//#define DEBUG
82

    
83

    
84
/* for jpeg fast DCT */
85
#define CONST_BITS 14
86

    
87
static const uint16_t aanscales[64] = {
88
    /* precomputed values scaled up by 14 bits */
89
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
90
    22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
91
    21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
92
    19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
93
    16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
94
    12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
95
    8867 , 12299, 11585, 10426,  8867,  6967,  4799,  2446,
96
    4520 ,  6270,  5906,  5315,  4520,  3552,  2446,  1247
97
};
98

    
99
static const uint8_t h263_chroma_roundtab[16] = {
100
//  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
101
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
102
};
103

    
104
static const uint8_t ff_default_chroma_qscale_table[32]={
105
//  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
106
    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
107
};
108

    
109
#ifdef CONFIG_ENCODERS
110
static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
111
static uint8_t default_fcode_tab[MAX_MV*2+1];
112

    
113
enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
114

    
115
static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
116
                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
117
{
118
    int qscale;
119

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

    
164
                if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
165
                qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
166
            }
167
        }
168
    }
169
}
170

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

    
179
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
180
    int i;
181
    int end;
182
    
183
    st->scantable= src_scantable;
184

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

    
203
#ifdef CONFIG_ENCODERS
204
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
205
    int i;
206

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

    
217
/* init common dct for both encoder and decoder */
218
int DCT_common_init(MpegEncContext *s)
219
{
220
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
221
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
222
    s->dct_unquantize_h261_intra = dct_unquantize_h261_intra_c;
223
    s->dct_unquantize_h261_inter = dct_unquantize_h261_inter_c;
224
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
225
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
226
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
227
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
228

    
229
#ifdef CONFIG_ENCODERS
230
    s->dct_quantize= dct_quantize_c;
231
    s->denoise_dct= denoise_dct_c;
232
#endif
233
        
234
#ifdef HAVE_MMX
235
    MPV_common_init_mmx(s);
236
#endif
237
#ifdef ARCH_ALPHA
238
    MPV_common_init_axp(s);
239
#endif
240
#ifdef HAVE_MLIB
241
    MPV_common_init_mlib(s);
242
#endif
243
#ifdef HAVE_MMI
244
    MPV_common_init_mmi(s);
245
#endif
246
#ifdef ARCH_ARMV4L
247
    MPV_common_init_armv4l(s);
248
#endif
249
#ifdef ARCH_POWERPC
250
    MPV_common_init_ppc(s);
251
#endif
252

    
253
#ifdef CONFIG_ENCODERS
254
    s->fast_dct_quantize= s->dct_quantize;
255

    
256
    if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
257
        s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
258
    }
259

    
260
#endif //CONFIG_ENCODERS
261

    
262
    /* load & permutate scantables
263
       note: only wmv uses differnt ones 
264
    */
265
    if(s->alternate_scan){
266
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
267
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
268
    }else{
269
        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
270
        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
271
    }
272
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
273
    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
274

    
275
    return 0;
276
}
277

    
278
static void copy_picture(Picture *dst, Picture *src){
279
    *dst = *src;
280
    dst->type= FF_BUFFER_TYPE_COPY;
281
}
282

    
283
static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
284
    int i;
285

    
286
    dst->pict_type              = src->pict_type;
287
    dst->quality                = src->quality;
288
    dst->coded_picture_number   = src->coded_picture_number;
289
    dst->display_picture_number = src->display_picture_number;
290
//    dst->reference              = src->reference;
291
    dst->pts                    = src->pts;
292
    dst->interlaced_frame       = src->interlaced_frame;
293
    dst->top_field_first        = src->top_field_first;
294

    
295
    if(s->avctx->me_threshold){
296
        if(!src->motion_val[0])
297
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
298
        if(!src->mb_type)
299
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
300
        if(!src->ref_index[0])
301
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
302
        if(src->motion_subsample_log2 != dst->motion_subsample_log2)
303
            av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
304
            src->motion_subsample_log2, dst->motion_subsample_log2);
305

    
306
        memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
307
        
308
        for(i=0; i<2; i++){
309
            int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
310
            int height= ((16*s->mb_height)>>src->motion_subsample_log2);
311

    
312
            if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
313
                memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
314
            }
315
            if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
316
                memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
317
            }
318
        }
319
    }
320
}
321

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

    
349
        if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
350
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
351
            return -1;
352
        }
353

    
354
        if(pic->linesize[1] != pic->linesize[2]){
355
            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
356
            return -1;
357
        }
358

    
359
        s->linesize  = pic->linesize[0];
360
        s->uvlinesize= pic->linesize[1];
361
    }
362
    
363
    if(pic->qscale_table==NULL){
364
        if (s->encoding) {        
365
            CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
366
            CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
367
            CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
368
        }
369

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

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

    
407
/**
408
 * deallocates a picture
409
 */
410
static void free_picture(MpegEncContext *s, Picture *pic){
411
    int i;
412

    
413
    if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
414
        s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
415
    }
416

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

    
440
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
441
    int i;
442

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

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

    
462
    for(i=0;i<12;i++){
463
        s->pblocks[i] = (short *)(&s->block[i]);
464
    }
465
    return 0;
466
fail:
467
    return -1; //free() through MPV_common_end()
468
}
469

    
470
static void free_duplicate_context(MpegEncContext *s){
471
    if(s==NULL) return;
472

    
473
    av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
474
    av_freep(&s->me.scratchpad);
475
    s->rd_scratchpad=   
476
    s->b_scratchpad=    
477
    s->obmc_scratchpad= NULL;
478
    
479
    av_freep(&s->dct_error_sum);
480
    av_freep(&s->me.map);
481
    av_freep(&s->me.score_map);
482
    av_freep(&s->blocks);
483
    s->block= NULL;
484
}
485

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

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

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

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

    
551
    s->coded_picture_number = 0;
552
    s->picture_number = 0;
553
    s->input_picture_number = 0;
554

    
555
    s->picture_in_gop_number = 0;
556

    
557
    s->f_code = 1;
558
    s->b_code = 1;
559
}
560

    
561
/**
562
 * sets the given MpegEncContext to defaults for decoding.
563
 * the changed fields will not depend upon the prior state of the MpegEncContext.
564
 */
565
void MPV_decode_defaults(MpegEncContext *s){
566
    MPV_common_defaults(s);
567
}
568

    
569
/**
570
 * sets the given MpegEncContext to defaults for encoding.
571
 * the changed fields will not depend upon the prior state of the MpegEncContext.
572
 */
573

    
574
#ifdef CONFIG_ENCODERS
575
static void MPV_encode_defaults(MpegEncContext *s){
576
    static int done=0;
577
    
578
    MPV_common_defaults(s);
579
    
580
    if(!done){
581
        int i;
582
        done=1;
583

    
584
        default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
585
        memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
586
        memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
587

    
588
        for(i=-16; i<16; i++){
589
            default_fcode_tab[i + MAX_MV]= 1;
590
        }
591
    }
592
    s->me.mv_penalty= default_mv_penalty;
593
    s->fcode_tab= default_fcode_tab;
594
}
595
#endif //CONFIG_ENCODERS
596

    
597
/** 
598
 * init common structure for both encoder and decoder.
599
 * this assumes that some variables like width/height are already set
600
 */
601
int MPV_common_init(MpegEncContext *s)
602
{
603
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
604

    
605
    if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
606
        av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
607
        return -1;
608
    }
609

    
610
    dsputil_init(&s->dsp, s->avctx);
611
    DCT_common_init(s);
612

    
613
    s->flags= s->avctx->flags;
614
    s->flags2= s->avctx->flags2;
615

    
616
    s->mb_width  = (s->width  + 15) / 16;
617
    s->mb_height = (s->height + 15) / 16;
618
    s->mb_stride = s->mb_width + 1;
619
    s->b8_stride = s->mb_width*2 + 1;
620
    s->b4_stride = s->mb_width*4 + 1;
621
    mb_array_size= s->mb_height * s->mb_stride;
622
    mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
623

    
624
    /* set chroma shifts */
625
    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
626
                                                    &(s->chroma_y_shift) );
627

    
628
    /* set default edge pos, will be overriden in decode_header if needed */
629
    s->h_edge_pos= s->mb_width*16;
630
    s->v_edge_pos= s->mb_height*16;
631

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

    
651
    s->avctx->stream_codec_tag=   toupper( s->avctx->stream_codec_tag     &0xFF)          
652
                               + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
653
                               + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 
654
                               + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
655

    
656
    s->avctx->coded_frame= (AVFrame*)&s->current_picture;
657

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

    
681
        if(s->msmpeg4_version){
682
            CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
683
        }
684
        CHECKED_ALLOCZ(s->avctx->stats_out, 256);
685

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

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

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

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

    
768
    s->context_initialized = 1;
769

    
770
    s->thread_context[0]= s;
771
    for(i=1; i<s->avctx->thread_count; i++){
772
        s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
773
        memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
774
    }
775

    
776
    for(i=0; i<s->avctx->thread_count; i++){
777
        if(init_duplicate_context(s->thread_context[i], s) < 0)
778
           goto fail;
779
        s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
780
        s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
781
    }
782

    
783
    return 0;
784
 fail:
785
    MPV_common_end(s);
786
    return -1;
787
}
788

    
789
/* init common structure for both encoder and decoder */
790
void MPV_common_end(MpegEncContext *s)
791
{
792
    int i, j, k;
793

    
794
    for(i=0; i<s->avctx->thread_count; i++){
795
        free_duplicate_context(s->thread_context[i]);
796
    }
797
    for(i=1; i<s->avctx->thread_count; i++){
798
        av_freep(&s->thread_context[i]);
799
    }
800

    
801
    av_freep(&s->parse_context.buffer);
802
    s->parse_context.buffer_size=0;
803

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

    
853
    if(s->picture){
854
        for(i=0; i<MAX_PICTURE_COUNT; i++){
855
            free_picture(s, &s->picture[i]);
856
        }
857
    }
858
    av_freep(&s->picture);
859
    s->context_initialized = 0;
860
    s->last_picture_ptr=
861
    s->next_picture_ptr=
862
    s->current_picture_ptr= NULL;
863
    s->linesize= s->uvlinesize= 0;
864

    
865
    for(i=0; i<3; i++)
866
        av_freep(&s->visualization_buffer[i]);
867

    
868
    avcodec_default_free_buffers(s->avctx);
869
}
870

    
871
#ifdef CONFIG_ENCODERS
872

    
873
/* init video encoder */
874
int MPV_encode_init(AVCodecContext *avctx)
875
{
876
    MpegEncContext *s = avctx->priv_data;
877
    int i, dummy;
878
    int chroma_h_shift, chroma_v_shift;
879
    
880
    MPV_encode_defaults(s);
881

    
882
    avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
883

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

    
907
    if (s->gop_size <= 1) {
908
        s->intra_only = 1;
909
        s->gop_size = 12;
910
    } else {
911
        s->intra_only = 0;
912
    }
913

    
914
    s->me_method = avctx->me_method;
915

    
916
    /* Fixed QSCALE */
917
    s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
918
    
919
    s->adaptive_quant= (   s->avctx->lumi_masking
920
                        || s->avctx->dark_masking
921
                        || s->avctx->temporal_cplx_masking 
922
                        || s->avctx->spatial_cplx_masking
923
                        || s->avctx->p_masking
924
                        || (s->flags&CODEC_FLAG_QP_RD))
925
                       && !s->fixed_qscale;
926
    
927
    s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
928
    s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
929
    s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
930

    
931
    if(avctx->rc_max_rate && !avctx->rc_buffer_size){
932
        av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
933
        return -1;
934
    }    
935

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

    
978
    if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
979
        av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
980
        return -1;
981
    }
982
    
983
    if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
984
        av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
985
        return -1;
986
    }
987

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

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

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

    
1050
    av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1051
    s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1052

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

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

    
1186
    s->encoding = 1;
1187

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

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

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

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

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

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

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

    
1256
    ff_rate_control_uninit(s);
1257

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

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

    
1267
#endif //CONFIG_ENCODERS
1268

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

    
1275
    /* compute max_level[], max_run[] and index_run[] */
1276
    for(last=0;last<2;last++) {
1277
        if (last == 0) {
1278
            start = 0;
1279
            end = rl->last;
1280
        } else {
1281
            start = rl->last;
1282
            end = rl->n;
1283
        }
1284

    
1285
        memset(max_level, 0, MAX_RUN + 1);
1286
        memset(max_run, 0, MAX_LEVEL + 1);
1287
        memset(index_run, rl->n, MAX_RUN + 1);
1288
        for(i=start;i<end;i++) {
1289
            run = rl->table_run[i];
1290
            level = rl->table_level[i];
1291
            if (index_run[run] == rl->n)
1292
                index_run[run] = i;
1293
            if (level > max_level[run])
1294
                max_level[run] = level;
1295
            if (run > max_run[level])
1296
                max_run[level] = run;
1297
        }
1298
        rl->max_level[last] = av_malloc(MAX_RUN + 1);
1299
        memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1300
        rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1301
        memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1302
        rl->index_run[last] = av_malloc(MAX_RUN + 1);
1303
        memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1304
    }
1305
}
1306

    
1307
/* draw the edges of width 'w' of an image of size width, height */
1308
//FIXME check that this is ok for mpeg4 interlaced
1309
static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1310
{
1311
    uint8_t *ptr, *last_line;
1312
    int i;
1313

    
1314
    last_line = buf + (height - 1) * wrap;
1315
    for(i=0;i<w;i++) {
1316
        /* top and bottom */
1317
        memcpy(buf - (i + 1) * wrap, buf, width);
1318
        memcpy(last_line + (i + 1) * wrap, last_line, width);
1319
    }
1320
    /* left and right */
1321
    ptr = buf;
1322
    for(i=0;i<height;i++) {
1323
        memset(ptr - w, ptr[0], w);
1324
        memset(ptr + width, ptr[width-1], w);
1325
        ptr += wrap;
1326
    }
1327
    /* corners */
1328
    for(i=0;i<w;i++) {
1329
        memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1330
        memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1331
        memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1332
        memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1333
    }
1334
}
1335

    
1336
int ff_find_unused_picture(MpegEncContext *s, int shared){
1337
    int i;
1338
    
1339
    if(shared){
1340
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1341
            if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1342
        }
1343
    }else{
1344
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1345
            if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1346
        }
1347
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1348
            if(s->picture[i].data[0]==NULL) return i;
1349
        }
1350
    }
1351

    
1352
    assert(0);
1353
    return -1;
1354
}
1355

    
1356
static void update_noise_reduction(MpegEncContext *s){
1357
    int intra, i;
1358

    
1359
    for(intra=0; intra<2; intra++){
1360
        if(s->dct_count[intra] > (1<<16)){
1361
            for(i=0; i<64; i++){
1362
                s->dct_error_sum[intra][i] >>=1;
1363
            }
1364
            s->dct_count[intra] >>= 1;
1365
        }
1366
        
1367
        for(i=0; i<64; i++){
1368
            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);
1369
        }
1370
    }
1371
}
1372

    
1373
/**
1374
 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1375
 */
1376
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1377
{
1378
    int i;
1379
    AVFrame *pic;
1380
    s->mb_skiped = 0;
1381

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

    
1384
    /* mark&release old frames */
1385
    if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1386
        avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1387

    
1388
        /* release forgotten pictures */
1389
        /* if(mpeg124/h263) */
1390
        if(!s->encoding){
1391
            for(i=0; i<MAX_PICTURE_COUNT; i++){
1392
                if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1393
                    av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1394
                    avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);                
1395
                }
1396
            }
1397
        }
1398
    }
1399
alloc:
1400
    if(!s->encoding){
1401
        /* release non refernce frames */
1402
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1403
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1404
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1405
            }
1406
        }
1407

    
1408
        if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1409
            pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1410
        else{
1411
            i= ff_find_unused_picture(s, 0);
1412
            pic= (AVFrame*)&s->picture[i];
1413
        }
1414

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

    
1417
        pic->coded_picture_number= s->coded_picture_number++;
1418
        
1419
        if( alloc_picture(s, (Picture*)pic, 0) < 0)
1420
            return -1;
1421

    
1422
        s->current_picture_ptr= (Picture*)pic;
1423
        s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1424
        s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1425
    }
1426

    
1427
    s->current_picture_ptr->pict_type= s->pict_type;
1428
//    if(s->flags && CODEC_FLAG_QSCALE) 
1429
  //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1430
    s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1431

    
1432
    copy_picture(&s->current_picture, s->current_picture_ptr);
1433
  
1434
  if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1435
    if (s->pict_type != B_TYPE) {
1436
        s->last_picture_ptr= s->next_picture_ptr;
1437
        if(!s->dropable)
1438
            s->next_picture_ptr= s->current_picture_ptr;
1439
    }
1440
/*    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,
1441
        s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL, 
1442
        s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL, 
1443
        s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1444
        s->pict_type, s->dropable);*/
1445
    
1446
    if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1447
    if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1448
    
1449
    if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1450
        av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1451
        assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1452
        goto alloc;
1453
    }
1454

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

    
1457
    if(s->picture_structure!=PICT_FRAME){
1458
        int i;
1459
        for(i=0; i<4; i++){
1460
            if(s->picture_structure == PICT_BOTTOM_FIELD){
1461
                 s->current_picture.data[i] += s->current_picture.linesize[i];
1462
            } 
1463
            s->current_picture.linesize[i] *= 2;
1464
            s->last_picture.linesize[i] *=2;
1465
            s->next_picture.linesize[i] *=2;
1466
        }
1467
    }
1468
  }
1469
   
1470
    s->hurry_up= s->avctx->hurry_up;
1471
    s->error_resilience= avctx->error_resilience;
1472

    
1473
    /* set dequantizer, we cant do it during init as it might change for mpeg4
1474
       and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1475
    if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1476
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1477
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1478
    }else if(s->out_format == FMT_H263){
1479
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1480
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1481
    }else if(s->out_format == FMT_H261){
1482
        s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1483
        s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1484
    }else{
1485
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1486
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1487
    }
1488

    
1489
    if(s->dct_error_sum){
1490
        assert(s->avctx->noise_reduction && s->encoding);
1491

    
1492
        update_noise_reduction(s);
1493
    }
1494
        
1495
#ifdef HAVE_XVMC
1496
    if(s->avctx->xvmc_acceleration)
1497
        return XVMC_field_start(s, avctx);
1498
#endif
1499
    return 0;
1500
}
1501

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

    
1535
    if(s->encoding){
1536
        /* release non refernce frames */
1537
        for(i=0; i<MAX_PICTURE_COUNT; i++){
1538
            if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1539
                s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1540
            }
1541
        }
1542
    }
1543
    // clear copies, to avoid confusion
1544
#if 0
1545
    memset(&s->last_picture, 0, sizeof(Picture));
1546
    memset(&s->next_picture, 0, sizeof(Picture));
1547
    memset(&s->current_picture, 0, sizeof(Picture));
1548
#endif
1549
    s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1550
}
1551

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

    
1601
/**
1602
 * draws an arrow from (ex, ey) -> (sx, sy).
1603
 * @param w width of the image
1604
 * @param h height of the image
1605
 * @param stride stride/linesize of the image
1606
 * @param color color of the arrow
1607
 */
1608
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
1609
    int dx,dy;
1610

    
1611
    sx= clip(sx, -100, w+100);
1612
    sy= clip(sy, -100, h+100);
1613
    ex= clip(ex, -100, w+100);
1614
    ey= clip(ey, -100, h+100);
1615
    
1616
    dx= ex - sx;
1617
    dy= ey - sy;
1618
    
1619
    if(dx*dx + dy*dy > 3*3){
1620
        int rx=  dx + dy;
1621
        int ry= -dx + dy;
1622
        int length= ff_sqrt((rx*rx + ry*ry)<<8);
1623
        
1624
        //FIXME subpixel accuracy
1625
        rx= ROUNDED_DIV(rx*3<<4, length);
1626
        ry= ROUNDED_DIV(ry*3<<4, length);
1627
        
1628
        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1629
        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1630
    }
1631
    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1632
}
1633

    
1634
/**
1635
 * prints debuging info for the given picture.
1636
 */
1637
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1638

    
1639
    if(!pict || !pict->mb_type) return;
1640

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

    
1717
    if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1718
        const int shift= 1 + s->quarter_sample;
1719
        int mb_y;
1720
        uint8_t *ptr;
1721
        int i;
1722
        int h_chroma_shift, v_chroma_shift;
1723
        s->low_delay=0; //needed to see the vectors without trashing the buffers
1724

    
1725
        avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1726
        for(i=0; i<3; i++){
1727
            memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1728
            pict->data[i]= s->visualization_buffer[i];
1729
        }
1730
        pict->type= FF_BUFFER_TYPE_COPY;
1731
        ptr= pict->data[0];
1732

    
1733
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
1734
            int mb_x;
1735
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
1736
                const int mb_index= mb_x + mb_y*s->mb_stride;
1737
                if((s->avctx->debug_mv) && pict->motion_val){
1738
                  int type;
1739
                  for(type=0; type<3; type++){
1740
                    int direction = 0;
1741
                    switch (type) {
1742
                      case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1743
                                continue;
1744
                              direction = 0;
1745
                              break;
1746
                      case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1747
                                continue;
1748
                              direction = 0;
1749
                              break;
1750
                      case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1751
                                continue;
1752
                              direction = 1;
1753
                              break;
1754
                    }
1755
                    if(!USES_LIST(pict->mb_type[mb_index], direction))
1756
                        continue;
1757

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

    
1809
                    
1810
                    u=v=128;
1811
                    if(IS_PCM(mb_type)){
1812
                        COLOR(120,48)
1813
                    }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1814
                        COLOR(30,48)
1815
                    }else if(IS_INTRA4x4(mb_type)){
1816
                        COLOR(90,48)
1817
                    }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1818
//                        COLOR(120,48)
1819
                    }else if(IS_DIRECT(mb_type)){
1820
                        COLOR(150,48)
1821
                    }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1822
                        COLOR(170,48)
1823
                    }else if(IS_GMC(mb_type)){
1824
                        COLOR(190,48)
1825
                    }else if(IS_SKIP(mb_type)){
1826
//                        COLOR(180,48)
1827
                    }else if(!USES_LIST(mb_type, 1)){
1828
                        COLOR(240,48)
1829
                    }else if(!USES_LIST(mb_type, 0)){
1830
                        COLOR(0,48)
1831
                    }else{
1832
                        assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1833
                        COLOR(300,48)
1834
                    }
1835

    
1836
                    u*= 0x0101010101010101ULL;
1837
                    v*= 0x0101010101010101ULL;
1838
                    for(y=0; y<8; y++){
1839
                        *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1840
                        *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1841
                    }
1842

    
1843
                    //segmentation
1844
                    if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1845
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1846
                        *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1847
                    }
1848
                    if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1849
                        for(y=0; y<16; y++)
1850
                            pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1851
                    }
1852
                        
1853
                    if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1854
                        // hmm
1855
                    }
1856
                }
1857
                s->mbskip_table[mb_index]=0;
1858
            }
1859
        }
1860
    }
1861
}
1862

    
1863
#ifdef CONFIG_ENCODERS
1864

    
1865
static int get_sae(uint8_t *src, int ref, int stride){
1866
    int x,y;
1867
    int acc=0;
1868
    
1869
    for(y=0; y<16; y++){
1870
        for(x=0; x<16; x++){
1871
            acc+= ABS(src[x+y*stride] - ref);
1872
        }
1873
    }
1874
    
1875
    return acc;
1876
}
1877

    
1878
static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1879
    int x, y, w, h;
1880
    int acc=0;
1881
    
1882
    w= s->width &~15;
1883
    h= s->height&~15;
1884
    
1885
    for(y=0; y<h; y+=16){
1886
        for(x=0; x<w; x+=16){
1887
            int offset= x + y*stride;
1888
            int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1889
            int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1890
            int sae = get_sae(src + offset, mean, stride);
1891
            
1892
            acc+= sae + 500 < sad;
1893
        }
1894
    }
1895
    return acc;
1896
}
1897

    
1898

    
1899
static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1900
    AVFrame *pic=NULL;
1901
    int i;
1902
    const int encoding_delay= s->max_b_frames;
1903
    int direct=1;
1904
    
1905
  if(pic_arg){
1906
    if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1907
    if(pic_arg->linesize[0] != s->linesize) direct=0;
1908
    if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1909
    if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1910
  
1911
//    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1912
    
1913
    if(direct){
1914
        i= ff_find_unused_picture(s, 1);
1915

    
1916
        pic= (AVFrame*)&s->picture[i];
1917
        pic->reference= 3;
1918
    
1919
        for(i=0; i<4; i++){
1920
            pic->data[i]= pic_arg->data[i];
1921
            pic->linesize[i]= pic_arg->linesize[i];
1922
        }
1923
        alloc_picture(s, (Picture*)pic, 1);
1924
    }else{
1925
        int offset= 16;
1926
        i= ff_find_unused_picture(s, 0);
1927

    
1928
        pic= (AVFrame*)&s->picture[i];
1929
        pic->reference= 3;
1930

    
1931
        alloc_picture(s, (Picture*)pic, 0);
1932

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

    
1995
    return 0;
1996
}
1997

    
1998
static void select_input_picture(MpegEncContext *s){
1999
    int i;
2000

    
2001
    for(i=1; i<MAX_PICTURE_COUNT; i++)
2002
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2003
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2004

    
2005
    /* set next picture types & ordering */
2006
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2007
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2008
            s->reordered_input_picture[0]= s->input_picture[0];
2009
            s->reordered_input_picture[0]->pict_type= I_TYPE;
2010
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2011
        }else{
2012
            int b_frames;
2013
            
2014
            if(s->flags&CODEC_FLAG_PASS2){
2015
                for(i=0; i<s->max_b_frames+1; i++){
2016
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2017
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
2018
                    s->input_picture[i]->pict_type= pict_type;
2019
                    
2020
                    if(i + 1 >= s->rc_context.num_entries) break;
2021
                }
2022
            }
2023

    
2024
            if(s->input_picture[0]->pict_type){
2025
                /* user selected pict_type */
2026
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
2027
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
2028
                }
2029
            
2030
                if(b_frames > s->max_b_frames){
2031
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2032
                    b_frames = s->max_b_frames;
2033
                }
2034
            }else if(s->avctx->b_frame_strategy==0){
2035
                b_frames= s->max_b_frames;
2036
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2037
            }else if(s->avctx->b_frame_strategy==1){
2038
                for(i=1; i<s->max_b_frames+1; i++){
2039
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2040
                        s->input_picture[i]->b_frame_score= 
2041
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2042
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2043
                    }
2044
                }
2045
                for(i=0; i<s->max_b_frames; i++){
2046
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2047
                }
2048
                                
2049
                b_frames= FFMAX(0, i-1);
2050
                
2051
                /* reset scores */
2052
                for(i=0; i<b_frames+1; i++){
2053
                    s->input_picture[i]->b_frame_score=0;
2054
                }
2055
            }else{
2056
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2057
                b_frames=0;
2058
            }
2059

    
2060
            emms_c();
2061
//static int b_count=0;
2062
//b_count+= b_frames;
2063
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2064
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2065
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2066
                    b_frames=0;
2067
                s->input_picture[b_frames]->pict_type= I_TYPE;
2068
            }
2069
            
2070
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2071
               && b_frames
2072
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2073
                b_frames--;
2074

    
2075
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2076
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2077
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2078
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2079
            for(i=0; i<b_frames; i++){
2080
                s->reordered_input_picture[i+1]= s->input_picture[i];
2081
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2082
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2083
            }
2084
        }
2085
    }
2086
    
2087
    if(s->reordered_input_picture[0]){
2088
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2089

    
2090
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2091

    
2092
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2093
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2094
        
2095
            int i= ff_find_unused_picture(s, 0);
2096
            Picture *pic= &s->picture[i];
2097

    
2098
            /* mark us unused / free shared pic */
2099
            for(i=0; i<4; i++)
2100
                s->reordered_input_picture[0]->data[i]= NULL;
2101
            s->reordered_input_picture[0]->type= 0;
2102
            
2103
            pic->reference              = s->reordered_input_picture[0]->reference;
2104
            
2105
            alloc_picture(s, pic, 0);
2106

    
2107
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2108

    
2109
            s->current_picture_ptr= pic;
2110
        }else{
2111
            // input is not a shared pix -> reuse buffer for current_pix
2112

    
2113
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2114
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2115
            
2116
            s->current_picture_ptr= s->reordered_input_picture[0];
2117
            for(i=0; i<4; i++){
2118
                s->new_picture.data[i]+=16;
2119
            }
2120
        }
2121
        copy_picture(&s->current_picture, s->current_picture_ptr);
2122
    
2123
        s->picture_number= s->new_picture.display_picture_number;
2124
//printf("dpn:%d\n", s->picture_number);
2125
    }else{
2126
       memset(&s->new_picture, 0, sizeof(Picture));
2127
    }
2128
}
2129

    
2130
int MPV_encode_picture(AVCodecContext *avctx,
2131
                       unsigned char *buf, int buf_size, void *data)
2132
{
2133
    MpegEncContext *s = avctx->priv_data;
2134
    AVFrame *pic_arg = data;
2135
    int i, stuffing_count;
2136

    
2137
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2138
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2139
        return -1;
2140
    }
2141
    
2142
    for(i=0; i<avctx->thread_count; i++){
2143
        int start_y= s->thread_context[i]->start_mb_y;
2144
        int   end_y= s->thread_context[i]->  end_mb_y;
2145
        int h= s->mb_height;
2146
        uint8_t *start= buf + buf_size*start_y/h;
2147
        uint8_t *end  = buf + buf_size*  end_y/h;
2148

    
2149
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2150
    }
2151

    
2152
    s->picture_in_gop_number++;
2153

    
2154
    if(load_input_picture(s, pic_arg) < 0)
2155
        return -1;
2156
    
2157
    select_input_picture(s);
2158
    
2159
    /* output? */
2160
    if(s->new_picture.data[0]){
2161
        s->pict_type= s->new_picture.pict_type;
2162
//emms_c();
2163
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2164
        MPV_frame_start(s, avctx);
2165

    
2166
        encode_picture(s, s->picture_number);
2167
        
2168
        avctx->real_pict_num  = s->picture_number;
2169
        avctx->header_bits = s->header_bits;
2170
        avctx->mv_bits     = s->mv_bits;
2171
        avctx->misc_bits   = s->misc_bits;
2172
        avctx->i_tex_bits  = s->i_tex_bits;
2173
        avctx->p_tex_bits  = s->p_tex_bits;
2174
        avctx->i_count     = s->i_count;
2175
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2176
        avctx->skip_count  = s->skip_count;
2177

    
2178
        MPV_frame_end(s);
2179

    
2180
        if (s->out_format == FMT_MJPEG)
2181
            mjpeg_picture_trailer(s);
2182
        
2183
        if(s->flags&CODEC_FLAG_PASS1)
2184
            ff_write_pass1_stats(s);
2185

    
2186
        for(i=0; i<4; i++){
2187
            avctx->error[i] += s->current_picture_ptr->error[i];
2188
        }
2189

    
2190
        flush_put_bits(&s->pb);
2191
        s->frame_bits  = put_bits_count(&s->pb);
2192

    
2193
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2194
        if(stuffing_count){
2195
            switch(s->codec_id){
2196
            case CODEC_ID_MPEG1VIDEO:
2197
            case CODEC_ID_MPEG2VIDEO:
2198
                while(stuffing_count--){
2199
                    put_bits(&s->pb, 8, 0);
2200
                }
2201
            break;
2202
            case CODEC_ID_MPEG4:
2203
                put_bits(&s->pb, 16, 0);
2204
                put_bits(&s->pb, 16, 0x1C3);
2205
                stuffing_count -= 4;
2206
                while(stuffing_count--){
2207
                    put_bits(&s->pb, 8, 0xFF);
2208
                }
2209
            break;
2210
            default:
2211
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2212
            }
2213
            flush_put_bits(&s->pb);
2214
            s->frame_bits  = put_bits_count(&s->pb);
2215
        }
2216

    
2217
        /* update mpeg1/2 vbv_delay for CBR */    
2218
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2219
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2220
            int vbv_delay;
2221

    
2222
            assert(s->repeat_first_field==0);
2223
            
2224
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2225
            assert(vbv_delay < 0xFFFF);
2226

    
2227
            s->vbv_delay_ptr[0] &= 0xF8;
2228
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2229
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2230
            s->vbv_delay_ptr[2] &= 0x07;
2231
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2232
        }
2233
        s->total_bits += s->frame_bits;
2234
        avctx->frame_bits  = s->frame_bits;
2235
    }else{
2236
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2237
        s->frame_bits=0;
2238
    }
2239
    assert((s->frame_bits&7)==0);
2240
    
2241
    return s->frame_bits/8;
2242
}
2243

    
2244
#endif //CONFIG_ENCODERS
2245

    
2246
static inline void gmc1_motion(MpegEncContext *s,
2247
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2248
                               uint8_t **ref_picture)
2249
{
2250
    uint8_t *ptr;
2251
    int offset, src_x, src_y, linesize, uvlinesize;
2252
    int motion_x, motion_y;
2253
    int emu=0;
2254

    
2255
    motion_x= s->sprite_offset[0][0];
2256
    motion_y= s->sprite_offset[0][1];
2257
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2258
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2259
    motion_x<<=(3-s->sprite_warping_accuracy);
2260
    motion_y<<=(3-s->sprite_warping_accuracy);
2261
    src_x = clip(src_x, -16, s->width);
2262
    if (src_x == s->width)
2263
        motion_x =0;
2264
    src_y = clip(src_y, -16, s->height);
2265
    if (src_y == s->height)
2266
        motion_y =0;
2267

    
2268
    linesize = s->linesize;
2269
    uvlinesize = s->uvlinesize;
2270
    
2271
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2272

    
2273
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2274
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2275
           || (unsigned)src_y >= s->v_edge_pos - 17){
2276
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2277
            ptr= s->edge_emu_buffer;
2278
        }
2279
    }
2280
    
2281
    if((motion_x|motion_y)&7){
2282
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2283
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2284
    }else{
2285
        int dxy;
2286
        
2287
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2288
        if (s->no_rounding){
2289
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2290
        }else{
2291
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2292
        }
2293
    }
2294
    
2295
    if(s->flags&CODEC_FLAG_GRAY) return;
2296

    
2297
    motion_x= s->sprite_offset[1][0];
2298
    motion_y= s->sprite_offset[1][1];
2299
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2300
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2301
    motion_x<<=(3-s->sprite_warping_accuracy);
2302
    motion_y<<=(3-s->sprite_warping_accuracy);
2303
    src_x = clip(src_x, -8, s->width>>1);
2304
    if (src_x == s->width>>1)
2305
        motion_x =0;
2306
    src_y = clip(src_y, -8, s->height>>1);
2307
    if (src_y == s->height>>1)
2308
        motion_y =0;
2309

    
2310
    offset = (src_y * uvlinesize) + src_x;
2311
    ptr = ref_picture[1] + offset;
2312
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2313
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2314
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2315
            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);
2316
            ptr= s->edge_emu_buffer;
2317
            emu=1;
2318
        }
2319
    }
2320
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2321
    
2322
    ptr = ref_picture[2] + offset;
2323
    if(emu){
2324
        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);
2325
        ptr= s->edge_emu_buffer;
2326
    }
2327
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2328
    
2329
    return;
2330
}
2331

    
2332
static inline void gmc_motion(MpegEncContext *s,
2333
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2334
                               uint8_t **ref_picture)
2335
{
2336
    uint8_t *ptr;
2337
    int linesize, uvlinesize;
2338
    const int a= s->sprite_warping_accuracy;
2339
    int ox, oy;
2340

    
2341
    linesize = s->linesize;
2342
    uvlinesize = s->uvlinesize;
2343

    
2344
    ptr = ref_picture[0];
2345

    
2346
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2347
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2348

    
2349
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2350
           ox, 
2351
           oy, 
2352
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2353
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2354
           a+1, (1<<(2*a+1)) - s->no_rounding,
2355
           s->h_edge_pos, s->v_edge_pos);
2356
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2357
           ox + s->sprite_delta[0][0]*8, 
2358
           oy + s->sprite_delta[1][0]*8, 
2359
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2360
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2361
           a+1, (1<<(2*a+1)) - s->no_rounding,
2362
           s->h_edge_pos, s->v_edge_pos);
2363

    
2364
    if(s->flags&CODEC_FLAG_GRAY) return;
2365

    
2366
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2367
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2368

    
2369
    ptr = ref_picture[1];
2370
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2371
           ox, 
2372
           oy, 
2373
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2374
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2375
           a+1, (1<<(2*a+1)) - s->no_rounding,
2376
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2377
    
2378
    ptr = ref_picture[2];
2379
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2380
           ox, 
2381
           oy, 
2382
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2383
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2384
           a+1, (1<<(2*a+1)) - s->no_rounding,
2385
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2386
}
2387

    
2388
/**
2389
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2390
 * @param buf destination buffer
2391
 * @param src source buffer
2392
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2393
 * @param block_w width of block
2394
 * @param block_h height of block
2395
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2396
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2397
 * @param w width of the source buffer
2398
 * @param h height of the source buffer
2399
 */
2400
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2401
                                    int src_x, int src_y, int w, int h){
2402
    int x, y;
2403
    int start_y, start_x, end_y, end_x;
2404

    
2405
    if(src_y>= h){
2406
        src+= (h-1-src_y)*linesize;
2407
        src_y=h-1;
2408
    }else if(src_y<=-block_h){
2409
        src+= (1-block_h-src_y)*linesize;
2410
        src_y=1-block_h;
2411
    }
2412
    if(src_x>= w){
2413
        src+= (w-1-src_x);
2414
        src_x=w-1;
2415
    }else if(src_x<=-block_w){
2416
        src+= (1-block_w-src_x);
2417
        src_x=1-block_w;
2418
    }
2419

    
2420
    start_y= FFMAX(0, -src_y);
2421
    start_x= FFMAX(0, -src_x);
2422
    end_y= FFMIN(block_h, h-src_y);
2423
    end_x= FFMIN(block_w, w-src_x);
2424

    
2425
    // copy existing part
2426
    for(y=start_y; y<end_y; y++){
2427
        for(x=start_x; x<end_x; x++){
2428
            buf[x + y*linesize]= src[x + y*linesize];
2429
        }
2430
    }
2431

    
2432
    //top
2433
    for(y=0; y<start_y; y++){
2434
        for(x=start_x; x<end_x; x++){
2435
            buf[x + y*linesize]= buf[x + start_y*linesize];
2436
        }
2437
    }
2438

    
2439
    //bottom
2440
    for(y=end_y; y<block_h; y++){
2441
        for(x=start_x; x<end_x; x++){
2442
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2443
        }
2444
    }
2445
                                    
2446
    for(y=0; y<block_h; y++){
2447
       //left
2448
        for(x=0; x<start_x; x++){
2449
            buf[x + y*linesize]= buf[start_x + y*linesize];
2450
        }
2451
       
2452
       //right
2453
        for(x=end_x; x<block_w; x++){
2454
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2455
        }
2456
    }
2457
}
2458

    
2459
static inline int hpel_motion(MpegEncContext *s, 
2460
                                  uint8_t *dest, uint8_t *src,
2461
                                  int field_based, int field_select,
2462
                                  int src_x, int src_y,
2463
                                  int width, int height, int stride,
2464
                                  int h_edge_pos, int v_edge_pos,
2465
                                  int w, int h, op_pixels_func *pix_op,
2466
                                  int motion_x, int motion_y)
2467
{
2468
    int dxy;
2469
    int emu=0;
2470

    
2471
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2472
    src_x += motion_x >> 1;
2473
    src_y += motion_y >> 1;
2474
                
2475
    /* WARNING: do no forget half pels */
2476
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2477
    if (src_x == width)
2478
        dxy &= ~1;
2479
    src_y = clip(src_y, -16, height);
2480
    if (src_y == height)
2481
        dxy &= ~2;
2482
    src += src_y * stride + src_x;
2483

    
2484
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2485
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2486
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2487
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2488
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2489
            src= s->edge_emu_buffer;
2490
            emu=1;
2491
        }
2492
    }
2493
    if(field_select)
2494
        src += s->linesize;
2495
    pix_op[dxy](dest, src, stride, h);
2496
    return emu;
2497
}
2498

    
2499
/* apply one mpeg motion vector to the three components */
2500
static always_inline void mpeg_motion(MpegEncContext *s,
2501
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2502
                               int field_based, int bottom_field, int field_select,
2503
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2504
                               int motion_x, int motion_y, int h)
2505
{
2506
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2507
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2508
    
2509
#if 0    
2510
if(s->quarter_sample)
2511
{
2512
    motion_x>>=1;
2513
    motion_y>>=1;
2514
}
2515
#endif
2516

    
2517
    v_edge_pos = s->v_edge_pos >> field_based;
2518
    linesize   = s->current_picture.linesize[0] << field_based;
2519
    uvlinesize = s->current_picture.linesize[1] << field_based;
2520

    
2521
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2522
    src_x = s->mb_x* 16               + (motion_x >> 1);
2523
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2524

    
2525
    if (s->out_format == FMT_H263) {
2526
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2527
            mx = (motion_x>>1)|(motion_x&1);
2528
            my = motion_y >>1;
2529
            uvdxy = ((my & 1) << 1) | (mx & 1);
2530
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2531
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2532
        }else{
2533
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2534
            uvsrc_x = src_x>>1;
2535
            uvsrc_y = src_y>>1;
2536
        }
2537
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2538
        mx = motion_x / 4;
2539
        my = motion_y / 4;
2540
        uvdxy = 0;
2541
        uvsrc_x = s->mb_x*8 + mx;
2542
        uvsrc_y = s->mb_y*8 + my;
2543
    } else {
2544
        if(s->chroma_y_shift){
2545
            mx = motion_x / 2;
2546
            my = motion_y / 2;
2547
            uvdxy = ((my & 1) << 1) | (mx & 1);
2548
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2549
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2550
        } else {
2551
            if(s->chroma_x_shift){
2552
            //Chroma422
2553
                mx = motion_x / 2;
2554
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2555
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2556
                uvsrc_y = src_y;
2557
            } else {
2558
            //Chroma444
2559
                uvdxy = dxy;
2560
                uvsrc_x = src_x;
2561
                uvsrc_y = src_y;
2562
            }
2563
        }
2564
    }
2565

    
2566
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2567
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2568
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2569

    
2570
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2571
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2572
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2573
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2574
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2575
                return ;
2576
            }
2577
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2578
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2579
            ptr_y = s->edge_emu_buffer;
2580
            if(!(s->flags&CODEC_FLAG_GRAY)){
2581
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2582
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2583
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2584
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2585
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2586
                ptr_cb= uvbuf;
2587
                ptr_cr= uvbuf+16;
2588
            }
2589
    }
2590

    
2591
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2592
        dest_y += s->linesize;
2593
        dest_cb+= s->uvlinesize;
2594
        dest_cr+= s->uvlinesize;
2595
    }
2596

    
2597
    if(field_select){
2598
        ptr_y += s->linesize;
2599
        ptr_cb+= s->uvlinesize;
2600
        ptr_cr+= s->uvlinesize;
2601
    }
2602

    
2603
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2604
    
2605
    if(!(s->flags&CODEC_FLAG_GRAY)){
2606
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2607
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2608
    }
2609
}
2610

    
2611
/* apply one mpeg motion vector to the three components */
2612
static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2613
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2614
                               int field_based, int bottom_field, int field_select,
2615
                               uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2616
                               int motion_x, int motion_y, int h)
2617
{
2618
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2619
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2620
    const int lowres= s->avctx->lowres;
2621
    const int block_s= 8>>lowres;
2622
    const int s_mask= (2<<lowres)-1;
2623
    const int h_edge_pos = s->h_edge_pos >> lowres;
2624
    const int v_edge_pos = s->v_edge_pos >> lowres;
2625
    linesize   = s->current_picture.linesize[0] << field_based;
2626
    uvlinesize = s->current_picture.linesize[1] << field_based;
2627

    
2628
    if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2629
        motion_x/=2;
2630
        motion_y/=2;
2631
    }
2632
    
2633
    if(field_based){
2634
        motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2635
    }
2636

    
2637
    sx= motion_x & s_mask;
2638
    sy= motion_y & s_mask;
2639
    src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
2640
    src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2641
    
2642
    if (s->out_format == FMT_H263) {
2643
        uvsx = sx | ((motion_x & 2)>>1);
2644
        uvsy = sy | ((motion_y & 2)>>1);
2645
        uvsrc_x = src_x>>1;
2646
        uvsrc_y = src_y>>1;
2647
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2648
        mx = motion_x / 4;
2649
        my = motion_y / 4;
2650
        uvsx = (2*mx) & s_mask;
2651
        uvsy = (2*my) & s_mask;
2652
        uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
2653
        uvsrc_y = s->mb_y*block_s               + (my >> lowres);
2654
    } else {
2655
        mx = motion_x / 2;
2656
        my = motion_y / 2;
2657
        uvsx = mx & s_mask;
2658
        uvsy = my & s_mask;
2659
        uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2660
        uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2661
    }
2662

    
2663
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2664
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2665
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2666

    
2667
    if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
2668
       || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2669
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2670
                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2671
            ptr_y = s->edge_emu_buffer;
2672
            if(!(s->flags&CODEC_FLAG_GRAY)){
2673
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2674
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2675
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2676
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2677
                                 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2678
                ptr_cb= uvbuf;
2679
                ptr_cr= uvbuf+16;
2680
            }
2681
    }
2682

    
2683
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2684
        dest_y += s->linesize;
2685
        dest_cb+= s->uvlinesize;
2686
        dest_cr+= s->uvlinesize;
2687
    }
2688

    
2689
    if(field_select){
2690
        ptr_y += s->linesize;
2691
        ptr_cb+= s->uvlinesize;
2692
        ptr_cr+= s->uvlinesize;
2693
    }
2694

    
2695
    sx <<= 2 - lowres;
2696
    sy <<= 2 - lowres;
2697
    pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2698
    
2699
    if(!(s->flags&CODEC_FLAG_GRAY)){
2700
        uvsx <<= 2 - lowres;
2701
        uvsy <<= 2 - lowres;
2702
        pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2703
        pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2704
    }
2705
}
2706

    
2707
//FIXME move to dsputil, avg variant, 16x16 version
2708
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2709
    int x;
2710
    uint8_t * const top   = src[1];
2711
    uint8_t * const left  = src[2];
2712
    uint8_t * const mid   = src[0];
2713
    uint8_t * const right = src[3];
2714
    uint8_t * const bottom= src[4];
2715
#define OBMC_FILTER(x, t, l, m, r, b)\
2716
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2717
#define OBMC_FILTER4(x, t, l, m, r, b)\
2718
    OBMC_FILTER(x         , t, l, m, r, b);\
2719
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2720
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2721
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2722
    
2723
    x=0;
2724
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2725
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2726
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2727
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2728
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2729
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2730
    x+= stride;
2731
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2732
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2733
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2734
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2735
    x+= stride;
2736
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2737
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2738
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2739
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2740
    x+= 2*stride;
2741
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2742
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2743
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2744
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2745
    x+= 2*stride;
2746
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2747
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2748
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2749
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2750
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2751
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2752
    x+= stride;
2753
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2754
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2755
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2756
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2757
}
2758

    
2759
/* obmc for 1 8x8 luma block */
2760
static inline void obmc_motion(MpegEncContext *s,
2761
                               uint8_t *dest, uint8_t *src,
2762
                               int src_x, int src_y,
2763
                               op_pixels_func *pix_op,
2764
                               int16_t mv[5][2]/* mid top left right bottom*/)
2765
#define MID    0
2766
{
2767
    int i;
2768
    uint8_t *ptr[5];
2769
    
2770
    assert(s->quarter_sample==0);
2771
    
2772
    for(i=0; i<5; i++){
2773
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2774
            ptr[i]= ptr[MID];
2775
        }else{
2776
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2777
            hpel_motion(s, ptr[i], src, 0, 0,
2778
                        src_x, src_y,
2779
                        s->width, s->height, s->linesize,
2780
                        s->h_edge_pos, s->v_edge_pos,
2781
                        8, 8, pix_op,
2782
                        mv[i][0], mv[i][1]);
2783
        }
2784
    }
2785

    
2786
    put_obmc(dest, ptr, s->linesize);                
2787
}
2788

    
2789
static inline void qpel_motion(MpegEncContext *s,
2790
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2791
                               int field_based, int bottom_field, int field_select,
2792
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2793
                               qpel_mc_func (*qpix_op)[16],
2794
                               int motion_x, int motion_y, int h)
2795
{
2796
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2797
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2798

    
2799
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2800
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2801
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2802

    
2803
    v_edge_pos = s->v_edge_pos >> field_based;
2804
    linesize = s->linesize << field_based;
2805
    uvlinesize = s->uvlinesize << field_based;
2806
    
2807
    if(field_based){
2808
        mx= motion_x/2;
2809
        my= motion_y>>1;
2810
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2811
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2812
        mx= (motion_x>>1) + rtab[motion_x&7];
2813
        my= (motion_y>>1) + rtab[motion_y&7];
2814
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2815
        mx= (motion_x>>1)|(motion_x&1);
2816
        my= (motion_y>>1)|(motion_y&1);
2817
    }else{
2818
        mx= motion_x/2;
2819
        my= motion_y/2;
2820
    }
2821
    mx= (mx>>1)|(mx&1);
2822
    my= (my>>1)|(my&1);
2823

    
2824
    uvdxy= (mx&1) | ((my&1)<<1);
2825
    mx>>=1;
2826
    my>>=1;
2827

    
2828
    uvsrc_x = s->mb_x *  8                 + mx;
2829
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2830

    
2831
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2832
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2833
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2834

    
2835
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2836
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2837
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2838
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2839
        ptr_y= s->edge_emu_buffer;
2840
        if(!(s->flags&CODEC_FLAG_GRAY)){
2841
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2842
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2843
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2844
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2845
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2846
            ptr_cb= uvbuf;
2847
            ptr_cr= uvbuf + 16;
2848
        }
2849
    }
2850

    
2851
    if(!field_based)
2852
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2853
    else{
2854
        if(bottom_field){
2855
            dest_y += s->linesize;
2856
            dest_cb+= s->uvlinesize;
2857
            dest_cr+= s->uvlinesize;
2858
        }
2859

    
2860
        if(field_select){
2861
            ptr_y  += s->linesize;
2862
            ptr_cb += s->uvlinesize;
2863
            ptr_cr += s->uvlinesize;
2864
        }
2865
        //damn interlaced mode
2866
        //FIXME boundary mirroring is not exactly correct here
2867
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2868
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2869
    }
2870
    if(!(s->flags&CODEC_FLAG_GRAY)){
2871
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2872
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2873
    }
2874
}
2875

    
2876
inline int ff_h263_round_chroma(int x){
2877
    if (x >= 0)
2878
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2879
    else {
2880
        x = -x;
2881
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2882
    }
2883
}
2884

    
2885
/**
2886
 * h263 chorma 4mv motion compensation.
2887
 */
2888
static inline void chroma_4mv_motion(MpegEncContext *s,
2889
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2890
                                     uint8_t **ref_picture,
2891
                                     op_pixels_func *pix_op,
2892
                                     int mx, int my){
2893
    int dxy, emu=0, src_x, src_y, offset;
2894
    uint8_t *ptr;
2895
    
2896
    /* In case of 8X8, we construct a single chroma motion vector
2897
       with a special rounding */
2898
    mx= ff_h263_round_chroma(mx);
2899
    my= ff_h263_round_chroma(my);
2900
    
2901
    dxy = ((my & 1) << 1) | (mx & 1);
2902
    mx >>= 1;
2903
    my >>= 1;
2904

    
2905
    src_x = s->mb_x * 8 + mx;
2906
    src_y = s->mb_y * 8 + my;
2907
    src_x = clip(src_x, -8, s->width/2);
2908
    if (src_x == s->width/2)
2909
        dxy &= ~1;
2910
    src_y = clip(src_y, -8, s->height/2);
2911
    if (src_y == s->height/2)
2912
        dxy &= ~2;
2913
    
2914
    offset = (src_y * (s->uvlinesize)) + src_x;
2915
    ptr = ref_picture[1] + offset;
2916
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2917
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2918
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2919
            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);
2920
            ptr= s->edge_emu_buffer;
2921
            emu=1;
2922
        }
2923
    }
2924
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2925

    
2926
    ptr = ref_picture[2] + offset;
2927
    if(emu){
2928
        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);
2929
        ptr= s->edge_emu_buffer;
2930
    }
2931
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2932
}
2933

    
2934
/**
2935
 * motion compesation of a single macroblock
2936
 * @param s context
2937
 * @param dest_y luma destination pointer
2938
 * @param dest_cb chroma cb/u destination pointer
2939
 * @param dest_cr chroma cr/v destination pointer
2940
 * @param dir direction (0->forward, 1->backward)
2941
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2942
 * @param pic_op halfpel motion compensation function (average or put normally)
2943
 * @param pic_op qpel motion compensation function (average or put normally)
2944
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2945
 */
2946
static inline void MPV_motion(MpegEncContext *s, 
2947
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2948
                              int dir, uint8_t **ref_picture, 
2949
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2950
{
2951
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2952
    int mb_x, mb_y, i;
2953
    uint8_t *ptr, *dest;
2954

    
2955
    mb_x = s->mb_x;
2956
    mb_y = s->mb_y;
2957

    
2958
    if(s->obmc && s->pict_type != B_TYPE){
2959
        int16_t mv_cache[4][4][2];
2960
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2961
        const int mot_stride= s->b8_stride;
2962
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2963

    
2964
        assert(!s->mb_skiped);
2965
                
2966
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2967
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2968
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2969

    
2970
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2971
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2972
        }else{
2973
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2974
        }
2975

    
2976
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2977
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2978
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2979
        }else{
2980
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2981
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2982
        }
2983

    
2984
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2985
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2986
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2987
        }else{
2988
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2989
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2990
        }
2991
        
2992
        mx = 0;
2993
        my = 0;
2994
        for(i=0;i<4;i++) {
2995
            const int x= (i&1)+1;
2996
            const int y= (i>>1)+1;
2997
            int16_t mv[5][2]= {
2998
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2999
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3000
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3001
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3002
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3003
            //FIXME cleanup
3004
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3005
                        ref_picture[0],
3006
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3007
                        pix_op[1],
3008
                        mv);
3009

    
3010
            mx += mv[0][0];
3011
            my += mv[0][1];
3012
        }
3013
        if(!(s->flags&CODEC_FLAG_GRAY))
3014
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3015

    
3016
        return;
3017
    }
3018
   
3019
    switch(s->mv_type) {
3020
    case MV_TYPE_16X16:
3021
#ifdef CONFIG_RISKY
3022
        if(s->mcsel){
3023
            if(s->real_sprite_warping_points==1){
3024
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
3025
                            ref_picture);
3026
            }else{
3027
                gmc_motion(s, dest_y, dest_cb, dest_cr,
3028
                            ref_picture);
3029
            }
3030
        }else if(s->quarter_sample){
3031
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
3032
                        0, 0, 0,
3033
                        ref_picture, pix_op, qpix_op,
3034
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3035
        }else if(s->mspel){
3036
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3037
                        ref_picture, pix_op,
3038
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3039
        }else
3040
#endif
3041
        {
3042
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3043
                        0, 0, 0,
3044
                        ref_picture, pix_op,
3045
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3046
        }           
3047
        break;
3048
    case MV_TYPE_8X8:
3049
        mx = 0;
3050
        my = 0;
3051
        if(s->quarter_sample){
3052
            for(i=0;i<4;i++) {
3053
                motion_x = s->mv[dir][i][0];
3054
                motion_y = s->mv[dir][i][1];
3055

    
3056
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3057
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3058
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3059
                    
3060
                /* WARNING: do no forget half pels */
3061
                src_x = clip(src_x, -16, s->width);
3062
                if (src_x == s->width)
3063
                    dxy &= ~3;
3064
                src_y = clip(src_y, -16, s->height);
3065
                if (src_y == s->height)
3066
                    dxy &= ~12;
3067
                    
3068
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3069
                if(s->flags&CODEC_FLAG_EMU_EDGE){
3070
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
3071
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3072
                        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);
3073
                        ptr= s->edge_emu_buffer;
3074
                    }
3075
                }
3076
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3077
                qpix_op[1][dxy](dest, ptr, s->linesize);
3078

    
3079
                mx += s->mv[dir][i][0]/2;
3080
                my += s->mv[dir][i][1]/2;
3081
            }
3082
        }else{
3083
            for(i=0;i<4;i++) {
3084
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3085
                            ref_picture[0], 0, 0,
3086
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3087
                            s->width, s->height, s->linesize,
3088
                            s->h_edge_pos, s->v_edge_pos,
3089
                            8, 8, pix_op[1],
3090
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3091

    
3092
                mx += s->mv[dir][i][0];
3093
                my += s->mv[dir][i][1];
3094
            }
3095
        }
3096

    
3097
        if(!(s->flags&CODEC_FLAG_GRAY))
3098
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3099
        break;
3100
    case MV_TYPE_FIELD:
3101
        if (s->picture_structure == PICT_FRAME) {
3102
            if(s->quarter_sample){
3103
                for(i=0; i<2; i++){
3104
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
3105
                                1, i, s->field_select[dir][i],
3106
                                ref_picture, pix_op, qpix_op,
3107
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
3108
                }
3109
            }else{
3110
                /* top field */       
3111
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3112
                            1, 0, s->field_select[dir][0],
3113
                            ref_picture, pix_op,
3114
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3115
                /* bottom field */
3116
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3117
                            1, 1, s->field_select[dir][1],
3118
                            ref_picture, pix_op,
3119
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3120
            }
3121
        } else {
3122
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3123
                ref_picture= s->current_picture_ptr->data;
3124
            } 
3125

    
3126
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3127
                        0, 0, s->field_select[dir][0],
3128
                        ref_picture, pix_op,
3129
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3130
        }
3131
        break;
3132
    case MV_TYPE_16X8:
3133
        for(i=0; i<2; i++){
3134
            uint8_t ** ref2picture;
3135

    
3136
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3137
                ref2picture= ref_picture;
3138
            }else{
3139
                ref2picture= s->current_picture_ptr->data;
3140
            } 
3141

    
3142
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3143
                        0, 0, s->field_select[dir][i],
3144
                        ref2picture, pix_op,
3145
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3146
                
3147
            dest_y += 16*s->linesize;
3148
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3149
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3150
        }        
3151
        break;
3152
    case MV_TYPE_DMV:
3153
        if(s->picture_structure == PICT_FRAME){
3154
            for(i=0; i<2; i++){
3155
                int j;
3156
                for(j=0; j<2; j++){
3157
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3158
                                1, j, j^i,
3159
                                ref_picture, pix_op,
3160
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3161
                }
3162
                pix_op = s->dsp.avg_pixels_tab; 
3163
            }
3164
        }else{
3165
            for(i=0; i<2; i++){
3166
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3167
                            0, 0, s->picture_structure != i+1,
3168
                            ref_picture, pix_op,
3169
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3170

    
3171
                // after put we make avg of the same block
3172
                pix_op=s->dsp.avg_pixels_tab; 
3173

    
3174
                //opposite parity is always in the same frame if this is second field
3175
                if(!s->first_field){
3176
                    ref_picture = s->current_picture_ptr->data;    
3177
                }
3178
            }
3179
        }
3180
    break;
3181
    default: assert(0);
3182
    }
3183
}
3184

    
3185
/**
3186
 * motion compesation of a single macroblock
3187
 * @param s context
3188
 * @param dest_y luma destination pointer
3189
 * @param dest_cb chroma cb/u destination pointer
3190
 * @param dest_cr chroma cr/v destination pointer
3191
 * @param dir direction (0->forward, 1->backward)
3192
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3193
 * @param pic_op halfpel motion compensation function (average or put normally)
3194
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3195
 */
3196
static inline void MPV_motion_lowres(MpegEncContext *s, 
3197
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3198
                              int dir, uint8_t **ref_picture, 
3199
                              h264_chroma_mc_func *pix_op)
3200
{
3201
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3202
    int mb_x, mb_y, i;
3203
    uint8_t *ptr, *dest;
3204
    const int lowres= s->avctx->lowres;
3205
    const int block_s= 8>>lowres;    
3206

    
3207
    mb_x = s->mb_x;
3208
    mb_y = s->mb_y;
3209

    
3210
    switch(s->mv_type) {
3211
    case MV_TYPE_16X16:
3212
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 
3213
                    0, 0, 0,
3214
                    ref_picture, pix_op,
3215
                    s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3216
        break;
3217
/*    case MV_TYPE_8X8:
3218
        mx = 0;
3219
        my = 0;
3220
            for(i=0;i<4;i++) {
3221
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3222
                            ref_picture[0], 0, 0,
3223
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3224
                            s->width, s->height, s->linesize,
3225
                            s->h_edge_pos, s->v_edge_pos,
3226
                            8, 8, pix_op[1],
3227
                            s->mv[dir][i][0], s->mv[dir][i][1]);
3228

3229
                mx += s->mv[dir][i][0];
3230
                my += s->mv[dir][i][1];
3231
            }
3232

3233
        if(!(s->flags&CODEC_FLAG_GRAY))
3234
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3235
        break;*/
3236
    case MV_TYPE_FIELD:
3237
        if (s->picture_structure == PICT_FRAME) {
3238
            /* top field */       
3239
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3240
                        1, 0, s->field_select[dir][0],
3241
                        ref_picture, pix_op,
3242
                        s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3243
            /* bottom field */
3244
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3245
                        1, 1, s->field_select[dir][1],
3246
                        ref_picture, pix_op,
3247
                        s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3248
        } else {
3249
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3250
                ref_picture= s->current_picture_ptr->data;
3251
            } 
3252

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

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

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

    
3298
                // after put we make avg of the same block
3299
                pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3300

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

    
3312
/* put block[] to dest[] */
3313
static inline void put_dct(MpegEncContext *s, 
3314
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3315
{
3316
    s->dct_unquantize_intra(s, block, i, qscale);
3317
    s->dsp.idct_put (dest, line_size, block);
3318
}
3319

    
3320
/* add block[] to dest[] */
3321
static inline void add_dct(MpegEncContext *s, 
3322
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3323
{
3324
    if (s->block_last_index[i] >= 0) {
3325
        s->dsp.idct_add (dest, line_size, block);
3326
    }
3327
}
3328

    
3329
static inline void add_dequant_dct(MpegEncContext *s, 
3330
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3331
{
3332
    if (s->block_last_index[i] >= 0) {
3333
        s->dct_unquantize_inter(s, block, i, qscale);
3334

    
3335
        s->dsp.idct_add (dest, line_size, block);
3336
    }
3337
}
3338

    
3339
/**
3340
 * cleans dc, ac, coded_block for the current non intra MB
3341
 */
3342
void ff_clean_intra_table_entries(MpegEncContext *s)
3343
{
3344
    int wrap = s->b8_stride;
3345
    int xy = s->block_index[0];
3346
    
3347
    s->dc_val[0][xy           ] = 
3348
    s->dc_val[0][xy + 1       ] = 
3349
    s->dc_val[0][xy     + wrap] =
3350
    s->dc_val[0][xy + 1 + wrap] = 1024;
3351
    /* ac pred */
3352
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3353
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3354
    if (s->msmpeg4_version>=3) {
3355
        s->coded_block[xy           ] =
3356
        s->coded_block[xy + 1       ] =
3357
        s->coded_block[xy     + wrap] =
3358
        s->coded_block[xy + 1 + wrap] = 0;
3359
    }
3360
    /* chroma */
3361
    wrap = s->mb_stride;
3362
    xy = s->mb_x + s->mb_y * wrap;
3363
    s->dc_val[1][xy] =
3364
    s->dc_val[2][xy] = 1024;
3365
    /* ac pred */
3366
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3367
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3368
    
3369
    s->mbintra_table[xy]= 0;
3370
}
3371

    
3372
/* generic function called after a macroblock has been parsed by the
3373
   decoder or after it has been encoded by the encoder.
3374

3375
   Important variables used:
3376
   s->mb_intra : true if intra macroblock
3377
   s->mv_dir   : motion vector direction
3378
   s->mv_type  : motion vector type
3379
   s->mv       : motion vector
3380
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3381
 */
3382
static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3383
{
3384
    int mb_x, mb_y;
3385
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3386
#ifdef HAVE_XVMC
3387
    if(s->avctx->xvmc_acceleration){
3388
        XVMC_decode_mb(s);//xvmc uses pblocks
3389
        return;
3390
    }
3391
#endif
3392

    
3393
    mb_x = s->mb_x;
3394
    mb_y = s->mb_y;
3395

    
3396
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3397
       /* save DCT coefficients */
3398
       int i,j;
3399
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3400
       for(i=0; i<6; i++)
3401
           for(j=0; j<64; j++)
3402
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3403
    }
3404

    
3405
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3406

    
3407
    /* update DC predictors for P macroblocks */
3408
    if (!s->mb_intra) {
3409
        if (s->h263_pred || s->h263_aic) {
3410
            if(s->mbintra_table[mb_xy])
3411
                ff_clean_intra_table_entries(s);
3412
        } else {
3413
            s->last_dc[0] =
3414
            s->last_dc[1] =
3415
            s->last_dc[2] = 128 << s->intra_dc_precision;
3416
        }
3417
    }
3418
    else if (s->h263_pred || s->h263_aic)
3419
        s->mbintra_table[mb_xy]=1;
3420

    
3421
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3422
        uint8_t *dest_y, *dest_cb, *dest_cr;
3423
        int dct_linesize, dct_offset;
3424
        op_pixels_func (*op_pix)[4];
3425
        qpel_mc_func (*op_qpix)[16];
3426
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3427
        const int uvlinesize= s->current_picture.linesize[1];
3428
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3429
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3430

    
3431
        /* avoid copy if macroblock skipped in last frame too */
3432
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3433
        if(!s->encoding){
3434
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3435
            const int age= s->current_picture.age;
3436

    
3437
            assert(age);
3438

    
3439
            if (s->mb_skiped) {
3440
                s->mb_skiped= 0;
3441
                assert(s->pict_type!=I_TYPE);
3442
 
3443
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3444
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3445

    
3446
                /* if previous was skipped too, then nothing to do !  */
3447
                if (*mbskip_ptr >= age && s->current_picture.reference){
3448
                    return;
3449
                }
3450
            } else if(!s->current_picture.reference){
3451
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3452
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3453
            } else{
3454
                *mbskip_ptr = 0; /* not skipped */
3455
            }
3456
        }
3457
        
3458
        dct_linesize = linesize << s->interlaced_dct;
3459
        dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3460
        
3461
        if(readable){
3462
            dest_y=  s->dest[0];
3463
            dest_cb= s->dest[1];
3464
            dest_cr= s->dest[2];
3465
        }else{
3466
            dest_y = s->b_scratchpad;
3467
            dest_cb= s->b_scratchpad+16*linesize;
3468
            dest_cr= s->b_scratchpad+32*linesize;
3469
        }
3470

    
3471
        if (!s->mb_intra) {
3472
            /* motion handling */
3473
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3474
            if(!s->encoding){
3475
                if(lowres_flag){
3476
                    h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3477

    
3478
                    if (s->mv_dir & MV_DIR_FORWARD) {
3479
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3480
                        op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3481
                    }
3482
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3483
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3484
                    }
3485
                }else{
3486
                    if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3487
                        op_pix = s->dsp.put_pixels_tab;
3488
                        op_qpix= s->dsp.put_qpel_pixels_tab;
3489
                    }else{
3490
                        op_pix = s->dsp.put_no_rnd_pixels_tab;
3491
                        op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3492
                    }
3493
                    if (s->mv_dir & MV_DIR_FORWARD) {
3494
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3495
                        op_pix = s->dsp.avg_pixels_tab;
3496
                        op_qpix= s->dsp.avg_qpel_pixels_tab;
3497
                    }
3498
                    if (s->mv_dir & MV_DIR_BACKWARD) {
3499
                        MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3500
                    }
3501
                }
3502
            }
3503

    
3504
            /* skip dequant / idct if we are really late ;) */
3505
            if(s->hurry_up>1) return;
3506

    
3507
            /* add dct residue */
3508
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3509
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3510
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3511
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3512
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3513
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3514

    
3515
                if(!(s->flags&CODEC_FLAG_GRAY)){
3516
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3517
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3518
                }
3519
            } else if(s->codec_id != CODEC_ID_WMV2){
3520
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3521
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3522
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3523
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3524

    
3525
                if(!(s->flags&CODEC_FLAG_GRAY)){
3526
                    if(s->chroma_y_shift){//Chroma420
3527
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3528
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3529
                    }else{
3530
                        //chroma422
3531
                        dct_linesize = uvlinesize << s->interlaced_dct;
3532
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3533

    
3534
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3535
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3536
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3537
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3538
                        if(!s->chroma_x_shift){//Chroma444
3539
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3540
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3541
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3542
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3543
                        }
3544
                    }
3545
                }//fi gray
3546
            }
3547
#ifdef CONFIG_RISKY
3548
            else{
3549
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3550
            }
3551
#endif
3552
        } else {
3553
            /* dct only in intra block */
3554
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3555
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3556
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3557
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3558
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3559

    
3560
                if(!(s->flags&CODEC_FLAG_GRAY)){
3561
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3562
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3563
                }
3564
            }else{
3565
                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
3566
                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3567
                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
3568
                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3569

    
3570
                if(!(s->flags&CODEC_FLAG_GRAY)){
3571
                    if(s->chroma_y_shift){
3572
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3573
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3574
                    }else{
3575

    
3576
                        dct_linesize = uvlinesize << s->interlaced_dct;
3577
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3578

    
3579
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3580
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3581
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3582
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3583
                        if(!s->chroma_x_shift){//Chroma444
3584
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3585
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3586
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3587
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3588
                        }
3589
                    }
3590
                }//gray
3591
            }
3592
        }
3593
        if(!readable){
3594
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3595
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3596
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3597
        }
3598
    }
3599
}
3600

    
3601
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3602
    if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3603
    else                  MPV_decode_mb_internal(s, block, 0);
3604
}
3605

    
3606
#ifdef CONFIG_ENCODERS
3607

    
3608
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3609
{
3610
    static const char tab[64]=
3611
        {3,2,2,1,1,1,1,1,
3612
         1,1,1,1,1,1,1,1,
3613
         1,1,1,1,1,1,1,1,
3614
         0,0,0,0,0,0,0,0,
3615
         0,0,0,0,0,0,0,0,
3616
         0,0,0,0,0,0,0,0,
3617
         0,0,0,0,0,0,0,0,
3618
         0,0,0,0,0,0,0,0};
3619
    int score=0;
3620
    int run=0;
3621
    int i;
3622
    DCTELEM *block= s->block[n];
3623
    const int last_index= s->block_last_index[n];
3624
    int skip_dc;
3625

    
3626
    if(threshold<0){
3627
        skip_dc=0;
3628
        threshold= -threshold;
3629
    }else
3630
        skip_dc=1;
3631

    
3632
    /* are all which we could set to zero are allready zero? */
3633
    if(last_index<=skip_dc - 1) return;
3634

    
3635
    for(i=0; i<=last_index; i++){
3636
        const int j = s->intra_scantable.permutated[i];
3637
        const int level = ABS(block[j]);
3638
        if(level==1){
3639
            if(skip_dc && i==0) continue;
3640
            score+= tab[run];
3641
            run=0;
3642
        }else if(level>1){
3643
            return;
3644
        }else{
3645
            run++;
3646
        }
3647
    }
3648
    if(score >= threshold) return;
3649
    for(i=skip_dc; i<=last_index; i++){
3650
        const int j = s->intra_scantable.permutated[i];
3651
        block[j]=0;
3652
    }
3653
    if(block[0]) s->block_last_index[n]= 0;
3654
    else         s->block_last_index[n]= -1;
3655
}
3656

    
3657
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3658
{
3659
    int i;
3660
    const int maxlevel= s->max_qcoeff;
3661
    const int minlevel= s->min_qcoeff;
3662
    int overflow=0;
3663
    
3664
    if(s->mb_intra){
3665
        i=1; //skip clipping of intra dc
3666
    }else
3667
        i=0;
3668
    
3669
    for(;i<=last_index; i++){
3670
        const int j= s->intra_scantable.permutated[i];
3671
        int level = block[j];
3672
       
3673
        if     (level>maxlevel){
3674
            level=maxlevel;
3675
            overflow++;
3676
        }else if(level<minlevel){
3677
            level=minlevel;
3678
            overflow++;
3679
        }
3680
        
3681
        block[j]= level;
3682
    }
3683
    
3684
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3685
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3686
}
3687

    
3688
#endif //CONFIG_ENCODERS
3689

    
3690
/**
3691
 *
3692
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3693
 */
3694
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3695
    if (s->avctx->draw_horiz_band) {
3696
        AVFrame *src;
3697
        int offset[4];
3698
        
3699
        if(s->picture_structure != PICT_FRAME){
3700
            h <<= 1;
3701
            y <<= 1;
3702
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3703
        }
3704

    
3705
        h= FFMIN(h, (s->height>>s->avctx->lowres) - y);
3706

    
3707
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3708
            src= (AVFrame*)s->current_picture_ptr;
3709
        else if(s->last_picture_ptr)
3710
            src= (AVFrame*)s->last_picture_ptr;
3711
        else
3712
            return;
3713
            
3714
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3715
            offset[0]=
3716
            offset[1]=
3717
            offset[2]=
3718
            offset[3]= 0;
3719
        }else{
3720
            offset[0]= y * s->linesize;;
3721
            offset[1]= 
3722
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3723
            offset[3]= 0;
3724
        }
3725

    
3726
        emms_c();
3727

    
3728
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3729
                                  y, s->picture_structure, h);
3730
    }
3731
}
3732

    
3733
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3734
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3735
    const int uvlinesize= s->current_picture.linesize[1];
3736
    const int mb_size= 4 - s->avctx->lowres;
3737
        
3738
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3739
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3740
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3741
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3742
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3743
    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;
3744
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3745

    
3746
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3747
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3748
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3749

    
3750
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3751
    {
3752
        s->dest[0] += s->mb_y *   linesize << mb_size;
3753
        s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3754
        s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3755
    }
3756
}
3757

    
3758
#ifdef CONFIG_ENCODERS
3759

    
3760
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3761
    int x, y;
3762
//FIXME optimize
3763
    for(y=0; y<8; y++){
3764
        for(x=0; x<8; x++){
3765
            int x2, y2;
3766
            int sum=0;
3767
            int sqr=0;
3768
            int count=0;
3769

    
3770
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3771
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3772
                    int v= ptr[x2 + y2*stride];
3773
                    sum += v;
3774
                    sqr += v*v;
3775
                    count++;
3776
                }
3777
            }
3778
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3779
        }
3780
    }
3781
}
3782

    
3783
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3784
{
3785
    int16_t weight[6][64];
3786
    DCTELEM orig[6][64];
3787
    const int mb_x= s->mb_x;
3788
    const int mb_y= s->mb_y;
3789
    int i;
3790
    int skip_dct[6];
3791
    int dct_offset   = s->linesize*8; //default for progressive frames
3792
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3793
    int wrap_y, wrap_c;
3794
    
3795
    for(i=0; i<6; i++) skip_dct[i]=0;
3796
    
3797
    if(s->adaptive_quant){
3798
        const int last_qp= s->qscale;
3799
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3800

    
3801
        s->lambda= s->lambda_table[mb_xy];
3802
        update_qscale(s);
3803
    
3804
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3805
            s->dquant= s->qscale - last_qp;
3806

    
3807
            if(s->out_format==FMT_H263){
3808
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3809
            
3810
                if(s->codec_id==CODEC_ID_MPEG4){        
3811
                    if(!s->mb_intra){
3812
                        if(s->pict_type == B_TYPE){
3813
                            if(s->dquant&1) 
3814
                                s->dquant= (s->dquant/2)*2;
3815
                            if(s->mv_dir&MV_DIRECT)
3816
                                s->dquant= 0;
3817
                        }
3818
                        if(s->mv_type==MV_TYPE_8X8)
3819
                            s->dquant=0;
3820
                    }
3821
                }
3822
            }
3823
        }
3824
        ff_set_qscale(s, last_qp + s->dquant);
3825
    }else if(s->flags&CODEC_FLAG_QP_RD)
3826
        ff_set_qscale(s, s->qscale + s->dquant);
3827

    
3828
    wrap_y = s->linesize;
3829
    wrap_c = s->uvlinesize;
3830
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3831
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3832
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3833

    
3834
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3835
        uint8_t *ebuf= s->edge_emu_buffer + 32;
3836
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3837
        ptr_y= ebuf;
3838
        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);
3839
        ptr_cb= ebuf+18*wrap_y;
3840
        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);
3841
        ptr_cr= ebuf+18*wrap_y+8;
3842
    }
3843

    
3844
    if (s->mb_intra) {
3845
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3846
            int progressive_score, interlaced_score;
3847

    
3848
            s->interlaced_dct=0;
3849
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3850
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3851

    
3852
            if(progressive_score > 0){
3853
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3854
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3855
                if(progressive_score > interlaced_score){
3856
                    s->interlaced_dct=1;
3857
            
3858
                    dct_offset= wrap_y;
3859
                    wrap_y<<=1;
3860
                }
3861
            }
3862
        }
3863
        
3864
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3865
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3866
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3867
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3868

    
3869
        if(s->flags&CODEC_FLAG_GRAY){
3870
            skip_dct[4]= 1;
3871
            skip_dct[5]= 1;
3872
        }else{
3873
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3874
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3875
        }
3876
    }else{
3877
        op_pixels_func (*op_pix)[4];
3878
        qpel_mc_func (*op_qpix)[16];
3879
        uint8_t *dest_y, *dest_cb, *dest_cr;
3880

    
3881
        dest_y  = s->dest[0];
3882
        dest_cb = s->dest[1];
3883
        dest_cr = s->dest[2];
3884

    
3885
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3886
            op_pix = s->dsp.put_pixels_tab;
3887
            op_qpix= s->dsp.put_qpel_pixels_tab;
3888
        }else{
3889
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3890
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3891
        }
3892

    
3893
        if (s->mv_dir & MV_DIR_FORWARD) {
3894
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3895
            op_pix = s->dsp.avg_pixels_tab;
3896
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3897
        }
3898
        if (s->mv_dir & MV_DIR_BACKWARD) {
3899
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3900
        }
3901

    
3902
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3903
            int progressive_score, interlaced_score;
3904

    
3905
            s->interlaced_dct=0;
3906
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3907
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3908
            
3909
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3910

    
3911
            if(progressive_score>0){
3912
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3913
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3914
            
3915
                if(progressive_score > interlaced_score){
3916
                    s->interlaced_dct=1;
3917
            
3918
                    dct_offset= wrap_y;
3919
                    wrap_y<<=1;
3920
                }
3921
            }
3922
        }
3923
        
3924
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3925
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3926
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3927
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3928
        
3929
        if(s->flags&CODEC_FLAG_GRAY){
3930
            skip_dct[4]= 1;
3931
            skip_dct[5]= 1;
3932
        }else{
3933
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3934
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3935
        }
3936
        /* pre quantization */         
3937
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3938
            //FIXME optimize
3939
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3940
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3941
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3942
            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;
3943
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3944
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3945
        }
3946
    }
3947

    
3948
    if(s->avctx->quantizer_noise_shaping){
3949
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3950
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3951
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3952
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3953
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3954
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3955
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3956
    }
3957
            
3958
    /* DCT & quantize */
3959
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3960
    {
3961
        for(i=0;i<6;i++) {
3962
            if(!skip_dct[i]){
3963
                int overflow;
3964
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3965
            // FIXME we could decide to change to quantizer instead of clipping
3966
            // JS: I don't think that would be a good idea it could lower quality instead
3967
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3968
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3969
            }else
3970
                s->block_last_index[i]= -1;
3971
        }
3972
        if(s->avctx->quantizer_noise_shaping){
3973
            for(i=0;i<6;i++) {
3974
                if(!skip_dct[i]){
3975
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3976
                }
3977
            }
3978
        }
3979
        
3980
        if(s->luma_elim_threshold && !s->mb_intra)
3981
            for(i=0; i<4; i++)
3982
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3983
        if(s->chroma_elim_threshold && !s->mb_intra)
3984
            for(i=4; i<6; i++)
3985
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3986

    
3987
        if(s->flags & CODEC_FLAG_CBP_RD){
3988
            for(i=0;i<6;i++) {
3989
                if(s->block_last_index[i] == -1)
3990
                    s->coded_score[i]= INT_MAX/256;
3991
            }
3992
        }
3993
    }
3994

    
3995
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3996
        s->block_last_index[4]=
3997
        s->block_last_index[5]= 0;
3998
        s->block[4][0]=
3999
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4000
    }
4001

    
4002
    //non c quantize code returns incorrect block_last_index FIXME
4003
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4004
        for(i=0; i<6; i++){
4005
            int j;
4006
            if(s->block_last_index[i]>0){
4007
                for(j=63; j>0; j--){
4008
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4009
                }
4010
                s->block_last_index[i]= j;
4011
            }
4012
        }
4013
    }
4014

    
4015
    /* huffman encode */
4016
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4017
    case CODEC_ID_MPEG1VIDEO:
4018
    case CODEC_ID_MPEG2VIDEO:
4019
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4020
#ifdef CONFIG_RISKY
4021
    case CODEC_ID_MPEG4:
4022
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4023
    case CODEC_ID_MSMPEG4V2:
4024
    case CODEC_ID_MSMPEG4V3:
4025
    case CODEC_ID_WMV1:
4026
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4027
    case CODEC_ID_WMV2:
4028
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4029
    case CODEC_ID_H263:
4030
    case CODEC_ID_H263P:
4031
    case CODEC_ID_FLV1:
4032
    case CODEC_ID_RV10:
4033
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
4034
#endif
4035
    case CODEC_ID_MJPEG:
4036
        mjpeg_encode_mb(s, s->block); break;
4037
    default:
4038
        assert(0);
4039
    }
4040
}
4041

    
4042
#endif //CONFIG_ENCODERS
4043

    
4044
void ff_mpeg_flush(AVCodecContext *avctx){
4045
    int i;
4046
    MpegEncContext *s = avctx->priv_data;
4047
    
4048
    if(s==NULL || s->picture==NULL) 
4049
        return;
4050
    
4051
    for(i=0; i<MAX_PICTURE_COUNT; i++){
4052
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4053
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
4054
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4055
    }
4056
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4057
    
4058
    s->parse_context.state= -1;
4059
    s->parse_context.frame_start_found= 0;
4060
    s->parse_context.overread= 0;
4061
    s->parse_context.overread_index= 0;
4062
    s->parse_context.index= 0;
4063
    s->parse_context.last_index= 0;
4064
    s->bitstream_buffer_size=0;
4065
}
4066

    
4067
#ifdef CONFIG_ENCODERS
4068
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4069
{
4070
    const uint16_t *srcw= (uint16_t*)src;
4071
    int words= length>>4;
4072
    int bits= length&15;
4073
    int i;
4074

    
4075
    if(length==0) return;
4076
    
4077
    if(words < 16){
4078
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4079
    }else if(put_bits_count(pb)&7){
4080
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4081
    }else{
4082
        for(i=0; put_bits_count(pb)&31; i++)
4083
            put_bits(pb, 8, src[i]);
4084
        flush_put_bits(pb);
4085
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
4086
        skip_put_bytes(pb, 2*words-i);
4087
    }
4088
        
4089
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4090
}
4091

    
4092
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4093
    int i;
4094

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

    
4097
    /* mpeg1 */
4098
    d->mb_skip_run= s->mb_skip_run;
4099
    for(i=0; i<3; i++)
4100
        d->last_dc[i]= s->last_dc[i];
4101
    
4102
    /* statistics */
4103
    d->mv_bits= s->mv_bits;
4104
    d->i_tex_bits= s->i_tex_bits;
4105
    d->p_tex_bits= s->p_tex_bits;
4106
    d->i_count= s->i_count;
4107
    d->f_count= s->f_count;
4108
    d->b_count= s->b_count;
4109
    d->skip_count= s->skip_count;
4110
    d->misc_bits= s->misc_bits;
4111
    d->last_bits= 0;
4112

    
4113
    d->mb_skiped= 0;
4114
    d->qscale= s->qscale;
4115
    d->dquant= s->dquant;
4116
}
4117

    
4118
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4119
    int i;
4120

    
4121
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
4122
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4123
    
4124
    /* mpeg1 */
4125
    d->mb_skip_run= s->mb_skip_run;
4126
    for(i=0; i<3; i++)
4127
        d->last_dc[i]= s->last_dc[i];
4128
    
4129
    /* statistics */
4130
    d->mv_bits= s->mv_bits;
4131
    d->i_tex_bits= s->i_tex_bits;
4132
    d->p_tex_bits= s->p_tex_bits;
4133
    d->i_count= s->i_count;
4134
    d->f_count= s->f_count;
4135
    d->b_count= s->b_count;
4136
    d->skip_count= s->skip_count;
4137
    d->misc_bits= s->misc_bits;
4138

    
4139
    d->mb_intra= s->mb_intra;
4140
    d->mb_skiped= s->mb_skiped;
4141
    d->mv_type= s->mv_type;
4142
    d->mv_dir= s->mv_dir;
4143
    d->pb= s->pb;
4144
    if(s->data_partitioning){
4145
        d->pb2= s->pb2;
4146
        d->tex_pb= s->tex_pb;
4147
    }
4148
    d->block= s->block;
4149
    for(i=0; i<6; i++)
4150
        d->block_last_index[i]= s->block_last_index[i];
4151
    d->interlaced_dct= s->interlaced_dct;
4152
    d->qscale= s->qscale;
4153
}
4154

    
4155
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
4156
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4157
                           int *dmin, int *next_block, int motion_x, int motion_y)
4158
{
4159
    int score;
4160
    uint8_t *dest_backup[3];
4161
    
4162
    copy_context_before_encode(s, backup, type);
4163

    
4164
    s->block= s->blocks[*next_block];
4165
    s->pb= pb[*next_block];
4166
    if(s->data_partitioning){
4167
        s->pb2   = pb2   [*next_block];
4168
        s->tex_pb= tex_pb[*next_block];
4169
    }
4170
    
4171
    if(*next_block){
4172
        memcpy(dest_backup, s->dest, sizeof(s->dest));
4173
        s->dest[0] = s->rd_scratchpad;
4174
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4175
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4176
        assert(s->linesize >= 32); //FIXME
4177
    }
4178

    
4179
    encode_mb(s, motion_x, motion_y);
4180
    
4181
    score= put_bits_count(&s->pb);
4182
    if(s->data_partitioning){
4183
        score+= put_bits_count(&s->pb2);
4184
        score+= put_bits_count(&s->tex_pb);
4185
    }
4186
   
4187
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4188
        MPV_decode_mb(s, s->block);
4189

    
4190
        score *= s->lambda2;
4191
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
4192
    }
4193
    
4194
    if(*next_block){
4195
        memcpy(s->dest, dest_backup, sizeof(s->dest));
4196
    }
4197

    
4198
    if(score<*dmin){
4199
        *dmin= score;
4200
        *next_block^=1;
4201

    
4202
        copy_context_after_encode(best, s, type);
4203
    }
4204
}
4205
                
4206
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4207
    uint32_t *sq = squareTbl + 256;
4208
    int acc=0;
4209
    int x,y;
4210
    
4211
    if(w==16 && h==16) 
4212
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4213
    else if(w==8 && h==8)
4214
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4215
    
4216
    for(y=0; y<h; y++){
4217
        for(x=0; x<w; x++){
4218
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4219
        } 
4220
    }
4221
    
4222
    assert(acc>=0);
4223
    
4224
    return acc;
4225
}
4226

    
4227
static int sse_mb(MpegEncContext *s){
4228
    int w= 16;
4229
    int h= 16;
4230

    
4231
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4232
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4233

    
4234
    if(w==16 && h==16)
4235
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
4236
        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)
4237
               +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)
4238
               +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);
4239
      }else{
4240
        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)
4241
               +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)
4242
               +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);
4243
      }
4244
    else
4245
        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)
4246
               +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)
4247
               +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);
4248
}
4249

    
4250
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4251
    MpegEncContext *s= arg;
4252

    
4253
    
4254
    s->me.pre_pass=1;
4255
    s->me.dia_size= s->avctx->pre_dia_size;
4256
    s->first_slice_line=1;
4257
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4258
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4259
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4260
        }
4261
        s->first_slice_line=0;
4262
    }
4263
    
4264
    s->me.pre_pass=0;
4265
    
4266
    return 0;
4267
}
4268

    
4269
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4270
    MpegEncContext *s= arg;
4271

    
4272
    s->me.dia_size= s->avctx->dia_size;
4273
    s->first_slice_line=1;
4274
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4275
        s->mb_x=0; //for block init below
4276
        ff_init_block_index(s);
4277
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4278
            s->block_index[0]+=2;
4279
            s->block_index[1]+=2;
4280
            s->block_index[2]+=2;
4281
            s->block_index[3]+=2;
4282
            
4283
            /* compute motion vector & mb_type and store in context */
4284
            if(s->pict_type==B_TYPE)
4285
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4286
            else
4287
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4288
        }
4289
        s->first_slice_line=0;
4290
    }
4291
    return 0;
4292
}
4293

    
4294
static int mb_var_thread(AVCodecContext *c, void *arg){
4295
    MpegEncContext *s= arg;
4296
    int mb_x, mb_y;
4297

    
4298
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4299
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4300
            int xx = mb_x * 16;
4301
            int yy = mb_y * 16;
4302
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4303
            int varc;
4304
            int sum = s->dsp.pix_sum(pix, s->linesize);
4305
    
4306
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4307

    
4308
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4309
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4310
            s->me.mb_var_sum_temp    += varc;
4311
        }
4312
    }
4313
    return 0;
4314
}
4315

    
4316
static void write_slice_end(MpegEncContext *s){
4317
    if(s->codec_id==CODEC_ID_MPEG4){
4318
        if(s->partitioned_frame){
4319
            ff_mpeg4_merge_partitions(s);
4320
        }
4321
    
4322
        ff_mpeg4_stuffing(&s->pb);
4323
    }else if(s->out_format == FMT_MJPEG){
4324
        ff_mjpeg_stuffing(&s->pb);
4325
    }
4326

    
4327
    align_put_bits(&s->pb);
4328
    flush_put_bits(&s->pb);
4329
}
4330

    
4331
static int encode_thread(AVCodecContext *c, void *arg){
4332
    MpegEncContext *s= arg;
4333
    int mb_x, mb_y, pdif = 0;
4334
    int i, j;
4335
    MpegEncContext best_s, backup_s;
4336
    uint8_t bit_buf[2][3000];
4337
    uint8_t bit_buf2[2][3000];
4338
    uint8_t bit_buf_tex[2][3000];
4339
    PutBitContext pb[2], pb2[2], tex_pb[2];
4340
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4341

    
4342
    for(i=0; i<2; i++){
4343
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4344
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4345
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4346
    }
4347

    
4348
    s->last_bits= put_bits_count(&s->pb);
4349
    s->mv_bits=0;
4350
    s->misc_bits=0;
4351
    s->i_tex_bits=0;
4352
    s->p_tex_bits=0;
4353
    s->i_count=0;
4354
    s->f_count=0;
4355
    s->b_count=0;
4356
    s->skip_count=0;
4357

    
4358
    for(i=0; i<3; i++){
4359
        /* init last dc values */
4360
        /* note: quant matrix value (8) is implied here */
4361
        s->last_dc[i] = 128 << s->intra_dc_precision;
4362
        
4363
        s->current_picture_ptr->error[i] = 0;
4364
    }
4365
    s->mb_skip_run = 0;
4366
    memset(s->last_mv, 0, sizeof(s->last_mv));
4367
     
4368
    s->last_mv_dir = 0;
4369

    
4370
#ifdef CONFIG_RISKY
4371
    switch(s->codec_id){
4372
    case CODEC_ID_H263:
4373
    case CODEC_ID_H263P:
4374
    case CODEC_ID_FLV1:
4375
        s->gob_index = ff_h263_get_gob_height(s);
4376
        break;
4377
    case CODEC_ID_MPEG4:
4378
        if(s->partitioned_frame)
4379
            ff_mpeg4_init_partitions(s);
4380
        break;
4381
    }
4382
#endif
4383

    
4384
    s->resync_mb_x=0;
4385
    s->resync_mb_y=0; 
4386
    s->first_slice_line = 1;
4387
    s->ptr_lastgob = s->pb.buf;
4388
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4389
//    printf("row %d at %X\n", s->mb_y, (int)s);
4390
        s->mb_x=0;
4391
        s->mb_y= mb_y;
4392

    
4393
        ff_set_qscale(s, s->qscale);
4394
        ff_init_block_index(s);
4395
        
4396
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4397
            const int xy= mb_y*s->mb_stride + mb_x;
4398
            int mb_type= s->mb_type[xy];
4399
//            int d;
4400
            int dmin= INT_MAX;
4401
            int dir;
4402

    
4403
            s->mb_x = mb_x;
4404
            ff_update_block_index(s);
4405

    
4406
            /* write gob / video packet header  */
4407
#ifdef CONFIG_RISKY
4408
            if(s->rtp_mode){
4409
                int current_packet_size, is_gob_start;
4410
                
4411
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4412
                
4413
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4414
                
4415
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4416
                
4417
                switch(s->codec_id){
4418
                case CODEC_ID_H263:
4419
                case CODEC_ID_H263P:
4420
                    if(!s->h263_slice_structured)
4421
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4422
                    break;
4423
                case CODEC_ID_MPEG2VIDEO:
4424
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4425
                case CODEC_ID_MPEG1VIDEO:
4426
                    if(s->mb_skip_run) is_gob_start=0;
4427
                    break;
4428
                }
4429

    
4430
                if(is_gob_start){
4431
                    if(s->start_mb_y != mb_y || mb_x!=0){
4432
                        write_slice_end(s);
4433

    
4434
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4435
                            ff_mpeg4_init_partitions(s);
4436
                        }
4437
                    }
4438
                
4439
                    assert((put_bits_count(&s->pb)&7) == 0);
4440
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4441
                    
4442
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4443
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4444
                        int d= 100 / s->avctx->error_rate;
4445
                        if(r % d == 0){
4446
                            current_packet_size=0;
4447
#ifndef ALT_BITSTREAM_WRITER
4448
                            s->pb.buf_ptr= s->ptr_lastgob;
4449
#endif
4450
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4451
                        }
4452
                    }
4453
        
4454
                    if (s->avctx->rtp_callback)
4455
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4456
                    
4457
                    switch(s->codec_id){
4458
                    case CODEC_ID_MPEG4:
4459
                        ff_mpeg4_encode_video_packet_header(s);
4460
                        ff_mpeg4_clean_buffers(s);
4461
                    break;
4462
                    case CODEC_ID_MPEG1VIDEO:
4463
                    case CODEC_ID_MPEG2VIDEO:
4464
                        ff_mpeg1_encode_slice_header(s);
4465
                        ff_mpeg1_clean_buffers(s);
4466
                    break;
4467
                    case CODEC_ID_H263:
4468
                    case CODEC_ID_H263P:
4469
                        h263_encode_gob_header(s, mb_y);                       
4470
                    break;
4471
                    }
4472

    
4473
                    if(s->flags&CODEC_FLAG_PASS1){
4474
                        int bits= put_bits_count(&s->pb);
4475
                        s->misc_bits+= bits - s->last_bits;
4476
                        s->last_bits= bits;
4477
                    }
4478
    
4479
                    s->ptr_lastgob += current_packet_size;
4480
                    s->first_slice_line=1;
4481
                    s->resync_mb_x=mb_x;
4482
                    s->resync_mb_y=mb_y;
4483
                }
4484
            }
4485
#endif
4486

    
4487
            if(  (s->resync_mb_x   == s->mb_x)
4488
               && s->resync_mb_y+1 == s->mb_y){
4489
                s->first_slice_line=0; 
4490
            }
4491

    
4492
            s->mb_skiped=0;
4493
            s->dquant=0; //only for QP_RD
4494

    
4495
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4496
                int next_block=0;
4497
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4498

    
4499
                copy_context_before_encode(&backup_s, s, -1);
4500
                backup_s.pb= s->pb;
4501
                best_s.data_partitioning= s->data_partitioning;
4502
                best_s.partitioned_frame= s->partitioned_frame;
4503
                if(s->data_partitioning){
4504
                    backup_s.pb2= s->pb2;
4505
                    backup_s.tex_pb= s->tex_pb;
4506
                }
4507

    
4508
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4509
                    s->mv_dir = MV_DIR_FORWARD;
4510
                    s->mv_type = MV_TYPE_16X16;
4511
                    s->mb_intra= 0;
4512
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4513
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4514
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4515
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4516
                }
4517
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4518
                    s->mv_dir = MV_DIR_FORWARD;
4519
                    s->mv_type = MV_TYPE_FIELD;
4520
                    s->mb_intra= 0;
4521
                    for(i=0; i<2; i++){
4522
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4523
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4524
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4525
                    }
4526
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4527
                                 &dmin, &next_block, 0, 0);
4528
                }
4529
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4530
                    s->mv_dir = MV_DIR_FORWARD;
4531
                    s->mv_type = MV_TYPE_16X16;
4532
                    s->mb_intra= 0;
4533
                    s->mv[0][0][0] = 0;
4534
                    s->mv[0][0][1] = 0;
4535
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4536
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4537
                }
4538
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4539
                    s->mv_dir = MV_DIR_FORWARD;
4540
                    s->mv_type = MV_TYPE_8X8;
4541
                    s->mb_intra= 0;
4542
                    for(i=0; i<4; i++){
4543
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4544
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4545
                    }
4546
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4547
                                 &dmin, &next_block, 0, 0);
4548
                }
4549
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4550
                    s->mv_dir = MV_DIR_FORWARD;
4551
                    s->mv_type = MV_TYPE_16X16;
4552
                    s->mb_intra= 0;
4553
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4554
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4555
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4556
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4557
                }
4558
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4559
                    s->mv_dir = MV_DIR_BACKWARD;
4560
                    s->mv_type = MV_TYPE_16X16;
4561
                    s->mb_intra= 0;
4562
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4563
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4564
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4565
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4566
                }
4567
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4568
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4569
                    s->mv_type = MV_TYPE_16X16;
4570
                    s->mb_intra= 0;
4571
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4572
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4573
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4574
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4575
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4576
                                 &dmin, &next_block, 0, 0);
4577
                }
4578
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4579
                    int mx= s->b_direct_mv_table[xy][0];
4580
                    int my= s->b_direct_mv_table[xy][1];
4581
                    
4582
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4583
                    s->mb_intra= 0;
4584
#ifdef CONFIG_RISKY
4585
                    ff_mpeg4_set_direct_mv(s, mx, my);
4586
#endif
4587
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4588
                                 &dmin, &next_block, mx, my);
4589
                }
4590
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4591
                    s->mv_dir = MV_DIR_FORWARD;
4592
                    s->mv_type = MV_TYPE_FIELD;
4593
                    s->mb_intra= 0;
4594
                    for(i=0; i<2; i++){
4595
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4596
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4597
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4598
                    }
4599
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4600
                                 &dmin, &next_block, 0, 0);
4601
                }
4602
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4603
                    s->mv_dir = MV_DIR_BACKWARD;
4604
                    s->mv_type = MV_TYPE_FIELD;
4605
                    s->mb_intra= 0;
4606
                    for(i=0; i<2; i++){
4607
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4608
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4609
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4610
                    }
4611
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4612
                                 &dmin, &next_block, 0, 0);
4613
                }
4614
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4615
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4616
                    s->mv_type = MV_TYPE_FIELD;
4617
                    s->mb_intra= 0;
4618
                    for(dir=0; dir<2; dir++){
4619
                        for(i=0; i<2; i++){
4620
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4621
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4622
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4623
                        }
4624
                    }
4625
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4626
                                 &dmin, &next_block, 0, 0);
4627
                }
4628
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4629
                    s->mv_dir = 0;
4630
                    s->mv_type = MV_TYPE_16X16;
4631
                    s->mb_intra= 1;
4632
                    s->mv[0][0][0] = 0;
4633
                    s->mv[0][0][1] = 0;
4634
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4635
                                 &dmin, &next_block, 0, 0);
4636
                    if(s->h263_pred || s->h263_aic){
4637
                        if(best_s.mb_intra)
4638
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4639
                        else
4640
                            ff_clean_intra_table_entries(s); //old mode?
4641
                    }
4642
                }
4643

    
4644
                if(s->flags & CODEC_FLAG_QP_RD){
4645
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4646
                        const int last_qp= backup_s.qscale;
4647
                        int dquant, dir, qp, dc[6];
4648
                        DCTELEM ac[6][16];
4649
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4650
                        
4651
                        assert(backup_s.dquant == 0);
4652

    
4653
                        //FIXME intra
4654
                        s->mv_dir= best_s.mv_dir;
4655
                        s->mv_type = MV_TYPE_16X16;
4656
                        s->mb_intra= best_s.mb_intra;
4657
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4658
                        s->mv[