Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpegvideo.c @ 1140139f

History | View | Annotate | Download (219 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

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

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

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

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

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

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

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

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

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

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

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

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

    
1185
    s->encoding = 1;
1186

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

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

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

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

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

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

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

    
1255
    ff_rate_control_uninit(s);
1256

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

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

    
1266
#endif //CONFIG_ENCODERS
1267

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1862
#ifdef CONFIG_ENCODERS
1863

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

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

    
1897

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

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

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

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

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

    
1983
    return 0;
1984
}
1985

    
1986
static void select_input_picture(MpegEncContext *s){
1987
    int i;
1988

    
1989
    for(i=1; i<MAX_PICTURE_COUNT; i++)
1990
        s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1991
    s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1992

    
1993
    /* set next picture types & ordering */
1994
    if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1995
        if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1996
            s->reordered_input_picture[0]= s->input_picture[0];
1997
            s->reordered_input_picture[0]->pict_type= I_TYPE;
1998
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1999
        }else{
2000
            int b_frames;
2001
            
2002
            if(s->flags&CODEC_FLAG_PASS2){
2003
                for(i=0; i<s->max_b_frames+1; i++){
2004
                    int pict_num= s->input_picture[0]->display_picture_number + i;
2005
                    int pict_type= s->rc_context.entry[pict_num].new_pict_type;
2006
                    s->input_picture[i]->pict_type= pict_type;
2007
                    
2008
                    if(i + 1 >= s->rc_context.num_entries) break;
2009
                }
2010
            }
2011

    
2012
            if(s->input_picture[0]->pict_type){
2013
                /* user selected pict_type */
2014
                for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
2015
                    if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
2016
                }
2017
            
2018
                if(b_frames > s->max_b_frames){
2019
                    av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2020
                    b_frames = s->max_b_frames;
2021
                }
2022
            }else if(s->avctx->b_frame_strategy==0){
2023
                b_frames= s->max_b_frames;
2024
                while(b_frames && !s->input_picture[b_frames]) b_frames--;
2025
            }else if(s->avctx->b_frame_strategy==1){
2026
                for(i=1; i<s->max_b_frames+1; i++){
2027
                    if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2028
                        s->input_picture[i]->b_frame_score= 
2029
                            get_intra_count(s, s->input_picture[i  ]->data[0], 
2030
                                               s->input_picture[i-1]->data[0], s->linesize) + 1;
2031
                    }
2032
                }
2033
                for(i=0; i<s->max_b_frames; i++){
2034
                    if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2035
                }
2036
                                
2037
                b_frames= FFMAX(0, i-1);
2038
                
2039
                /* reset scores */
2040
                for(i=0; i<b_frames+1; i++){
2041
                    s->input_picture[i]->b_frame_score=0;
2042
                }
2043
            }else{
2044
                av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2045
                b_frames=0;
2046
            }
2047

    
2048
            emms_c();
2049
//static int b_count=0;
2050
//b_count+= b_frames;
2051
//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2052
            if(s->picture_in_gop_number + b_frames >= s->gop_size){
2053
                if(s->flags & CODEC_FLAG_CLOSED_GOP)
2054
                    b_frames=0;
2055
                s->input_picture[b_frames]->pict_type= I_TYPE;
2056
            }
2057
            
2058
            if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
2059
               && b_frames
2060
               && s->input_picture[b_frames]->pict_type== I_TYPE)
2061
                b_frames--;
2062

    
2063
            s->reordered_input_picture[0]= s->input_picture[b_frames];
2064
            if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2065
                s->reordered_input_picture[0]->pict_type= P_TYPE;
2066
            s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2067
            for(i=0; i<b_frames; i++){
2068
                s->reordered_input_picture[i+1]= s->input_picture[i];
2069
                s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2070
                s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2071
            }
2072
        }
2073
    }
2074
    
2075
    if(s->reordered_input_picture[0]){
2076
        s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2077

    
2078
        copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2079

    
2080
        if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2081
            // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2082
        
2083
            int i= ff_find_unused_picture(s, 0);
2084
            Picture *pic= &s->picture[i];
2085

    
2086
            /* mark us unused / free shared pic */
2087
            for(i=0; i<4; i++)
2088
                s->reordered_input_picture[0]->data[i]= NULL;
2089
            s->reordered_input_picture[0]->type= 0;
2090
            
2091
            pic->reference              = s->reordered_input_picture[0]->reference;
2092
            
2093
            alloc_picture(s, pic, 0);
2094

    
2095
            copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2096

    
2097
            s->current_picture_ptr= pic;
2098
        }else{
2099
            // input is not a shared pix -> reuse buffer for current_pix
2100

    
2101
            assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 
2102
                   || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2103
            
2104
            s->current_picture_ptr= s->reordered_input_picture[0];
2105
            for(i=0; i<4; i++){
2106
                s->new_picture.data[i]+=16;
2107
            }
2108
        }
2109
        copy_picture(&s->current_picture, s->current_picture_ptr);
2110
    
2111
        s->picture_number= s->new_picture.display_picture_number;
2112
//printf("dpn:%d\n", s->picture_number);
2113
    }else{
2114
       memset(&s->new_picture, 0, sizeof(Picture));
2115
    }
2116
}
2117

    
2118
int MPV_encode_picture(AVCodecContext *avctx,
2119
                       unsigned char *buf, int buf_size, void *data)
2120
{
2121
    MpegEncContext *s = avctx->priv_data;
2122
    AVFrame *pic_arg = data;
2123
    int i, stuffing_count;
2124

    
2125
    if(avctx->pix_fmt != PIX_FMT_YUV420P){
2126
        av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2127
        return -1;
2128
    }
2129
    
2130
    for(i=0; i<avctx->thread_count; i++){
2131
        int start_y= s->thread_context[i]->start_mb_y;
2132
        int   end_y= s->thread_context[i]->  end_mb_y;
2133
        int h= s->mb_height;
2134
        uint8_t *start= buf + buf_size*start_y/h;
2135
        uint8_t *end  = buf + buf_size*  end_y/h;
2136

    
2137
        init_put_bits(&s->thread_context[i]->pb, start, end - start);
2138
    }
2139

    
2140
    s->picture_in_gop_number++;
2141

    
2142
    load_input_picture(s, pic_arg);
2143
    
2144
    select_input_picture(s);
2145
    
2146
    /* output? */
2147
    if(s->new_picture.data[0]){
2148
        s->pict_type= s->new_picture.pict_type;
2149
//emms_c();
2150
//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2151
        MPV_frame_start(s, avctx);
2152

    
2153
        encode_picture(s, s->picture_number);
2154
        
2155
        avctx->real_pict_num  = s->picture_number;
2156
        avctx->header_bits = s->header_bits;
2157
        avctx->mv_bits     = s->mv_bits;
2158
        avctx->misc_bits   = s->misc_bits;
2159
        avctx->i_tex_bits  = s->i_tex_bits;
2160
        avctx->p_tex_bits  = s->p_tex_bits;
2161
        avctx->i_count     = s->i_count;
2162
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2163
        avctx->skip_count  = s->skip_count;
2164

    
2165
        MPV_frame_end(s);
2166

    
2167
        if (s->out_format == FMT_MJPEG)
2168
            mjpeg_picture_trailer(s);
2169
        
2170
        if(s->flags&CODEC_FLAG_PASS1)
2171
            ff_write_pass1_stats(s);
2172

    
2173
        for(i=0; i<4; i++){
2174
            avctx->error[i] += s->current_picture_ptr->error[i];
2175
        }
2176

    
2177
        flush_put_bits(&s->pb);
2178
        s->frame_bits  = put_bits_count(&s->pb);
2179

    
2180
        stuffing_count= ff_vbv_update(s, s->frame_bits);
2181
        if(stuffing_count){
2182
            switch(s->codec_id){
2183
            case CODEC_ID_MPEG1VIDEO:
2184
            case CODEC_ID_MPEG2VIDEO:
2185
                while(stuffing_count--){
2186
                    put_bits(&s->pb, 8, 0);
2187
                }
2188
            break;
2189
            case CODEC_ID_MPEG4:
2190
                put_bits(&s->pb, 16, 0);
2191
                put_bits(&s->pb, 16, 0x1C3);
2192
                stuffing_count -= 4;
2193
                while(stuffing_count--){
2194
                    put_bits(&s->pb, 8, 0xFF);
2195
                }
2196
            break;
2197
            default:
2198
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2199
            }
2200
            flush_put_bits(&s->pb);
2201
            s->frame_bits  = put_bits_count(&s->pb);
2202
        }
2203

    
2204
        /* update mpeg1/2 vbv_delay for CBR */    
2205
        if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2206
           && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2207
            int vbv_delay;
2208

    
2209
            assert(s->repeat_first_field==0);
2210
            
2211
            vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2212
            assert(vbv_delay < 0xFFFF);
2213

    
2214
            s->vbv_delay_ptr[0] &= 0xF8;
2215
            s->vbv_delay_ptr[0] |= vbv_delay>>13;
2216
            s->vbv_delay_ptr[1]  = vbv_delay>>5;
2217
            s->vbv_delay_ptr[2] &= 0x07;
2218
            s->vbv_delay_ptr[2] |= vbv_delay<<3;
2219
        }
2220
        s->total_bits += s->frame_bits;
2221
        avctx->frame_bits  = s->frame_bits;
2222
    }else{
2223
        assert((pbBufPtr(&s->pb) == s->pb.buf));
2224
        s->frame_bits=0;
2225
    }
2226
    assert((s->frame_bits&7)==0);
2227
    
2228
    return s->frame_bits/8;
2229
}
2230

    
2231
#endif //CONFIG_ENCODERS
2232

    
2233
static inline void gmc1_motion(MpegEncContext *s,
2234
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2235
                               uint8_t **ref_picture)
2236
{
2237
    uint8_t *ptr;
2238
    int offset, src_x, src_y, linesize, uvlinesize;
2239
    int motion_x, motion_y;
2240
    int emu=0;
2241

    
2242
    motion_x= s->sprite_offset[0][0];
2243
    motion_y= s->sprite_offset[0][1];
2244
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2245
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2246
    motion_x<<=(3-s->sprite_warping_accuracy);
2247
    motion_y<<=(3-s->sprite_warping_accuracy);
2248
    src_x = clip(src_x, -16, s->width);
2249
    if (src_x == s->width)
2250
        motion_x =0;
2251
    src_y = clip(src_y, -16, s->height);
2252
    if (src_y == s->height)
2253
        motion_y =0;
2254

    
2255
    linesize = s->linesize;
2256
    uvlinesize = s->uvlinesize;
2257
    
2258
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
2259

    
2260
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2261
        if(   (unsigned)src_x >= s->h_edge_pos - 17
2262
           || (unsigned)src_y >= s->v_edge_pos - 17){
2263
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2264
            ptr= s->edge_emu_buffer;
2265
        }
2266
    }
2267
    
2268
    if((motion_x|motion_y)&7){
2269
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2270
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2271
    }else{
2272
        int dxy;
2273
        
2274
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2275
        if (s->no_rounding){
2276
            s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2277
        }else{
2278
            s->dsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
2279
        }
2280
    }
2281
    
2282
    if(s->flags&CODEC_FLAG_GRAY) return;
2283

    
2284
    motion_x= s->sprite_offset[1][0];
2285
    motion_y= s->sprite_offset[1][1];
2286
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2287
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2288
    motion_x<<=(3-s->sprite_warping_accuracy);
2289
    motion_y<<=(3-s->sprite_warping_accuracy);
2290
    src_x = clip(src_x, -8, s->width>>1);
2291
    if (src_x == s->width>>1)
2292
        motion_x =0;
2293
    src_y = clip(src_y, -8, s->height>>1);
2294
    if (src_y == s->height>>1)
2295
        motion_y =0;
2296

    
2297
    offset = (src_y * uvlinesize) + src_x;
2298
    ptr = ref_picture[1] + offset;
2299
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2300
        if(   (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2301
           || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2302
            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);
2303
            ptr= s->edge_emu_buffer;
2304
            emu=1;
2305
        }
2306
    }
2307
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2308
    
2309
    ptr = ref_picture[2] + offset;
2310
    if(emu){
2311
        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);
2312
        ptr= s->edge_emu_buffer;
2313
    }
2314
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2315
    
2316
    return;
2317
}
2318

    
2319
static inline void gmc_motion(MpegEncContext *s,
2320
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2321
                               uint8_t **ref_picture)
2322
{
2323
    uint8_t *ptr;
2324
    int linesize, uvlinesize;
2325
    const int a= s->sprite_warping_accuracy;
2326
    int ox, oy;
2327

    
2328
    linesize = s->linesize;
2329
    uvlinesize = s->uvlinesize;
2330

    
2331
    ptr = ref_picture[0];
2332

    
2333
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2334
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2335

    
2336
    s->dsp.gmc(dest_y, ptr, linesize, 16,
2337
           ox, 
2338
           oy, 
2339
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2340
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2341
           a+1, (1<<(2*a+1)) - s->no_rounding,
2342
           s->h_edge_pos, s->v_edge_pos);
2343
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2344
           ox + s->sprite_delta[0][0]*8, 
2345
           oy + s->sprite_delta[1][0]*8, 
2346
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2347
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2348
           a+1, (1<<(2*a+1)) - s->no_rounding,
2349
           s->h_edge_pos, s->v_edge_pos);
2350

    
2351
    if(s->flags&CODEC_FLAG_GRAY) return;
2352

    
2353
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2354
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2355

    
2356
    ptr = ref_picture[1];
2357
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2358
           ox, 
2359
           oy, 
2360
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2361
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2362
           a+1, (1<<(2*a+1)) - s->no_rounding,
2363
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2364
    
2365
    ptr = ref_picture[2];
2366
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2367
           ox, 
2368
           oy, 
2369
           s->sprite_delta[0][0], s->sprite_delta[0][1],
2370
           s->sprite_delta[1][0], s->sprite_delta[1][1], 
2371
           a+1, (1<<(2*a+1)) - s->no_rounding,
2372
           s->h_edge_pos>>1, s->v_edge_pos>>1);
2373
}
2374

    
2375
/**
2376
 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2377
 * @param buf destination buffer
2378
 * @param src source buffer
2379
 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2380
 * @param block_w width of block
2381
 * @param block_h height of block
2382
 * @param src_x x coordinate of the top left sample of the block in the source buffer
2383
 * @param src_y y coordinate of the top left sample of the block in the source buffer
2384
 * @param w width of the source buffer
2385
 * @param h height of the source buffer
2386
 */
2387
void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h, 
2388
                                    int src_x, int src_y, int w, int h){
2389
    int x, y;
2390
    int start_y, start_x, end_y, end_x;
2391

    
2392
    if(src_y>= h){
2393
        src+= (h-1-src_y)*linesize;
2394
        src_y=h-1;
2395
    }else if(src_y<=-block_h){
2396
        src+= (1-block_h-src_y)*linesize;
2397
        src_y=1-block_h;
2398
    }
2399
    if(src_x>= w){
2400
        src+= (w-1-src_x);
2401
        src_x=w-1;
2402
    }else if(src_x<=-block_w){
2403
        src+= (1-block_w-src_x);
2404
        src_x=1-block_w;
2405
    }
2406

    
2407
    start_y= FFMAX(0, -src_y);
2408
    start_x= FFMAX(0, -src_x);
2409
    end_y= FFMIN(block_h, h-src_y);
2410
    end_x= FFMIN(block_w, w-src_x);
2411

    
2412
    // copy existing part
2413
    for(y=start_y; y<end_y; y++){
2414
        for(x=start_x; x<end_x; x++){
2415
            buf[x + y*linesize]= src[x + y*linesize];
2416
        }
2417
    }
2418

    
2419
    //top
2420
    for(y=0; y<start_y; y++){
2421
        for(x=start_x; x<end_x; x++){
2422
            buf[x + y*linesize]= buf[x + start_y*linesize];
2423
        }
2424
    }
2425

    
2426
    //bottom
2427
    for(y=end_y; y<block_h; y++){
2428
        for(x=start_x; x<end_x; x++){
2429
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2430
        }
2431
    }
2432
                                    
2433
    for(y=0; y<block_h; y++){
2434
       //left
2435
        for(x=0; x<start_x; x++){
2436
            buf[x + y*linesize]= buf[start_x + y*linesize];
2437
        }
2438
       
2439
       //right
2440
        for(x=end_x; x<block_w; x++){
2441
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2442
        }
2443
    }
2444
}
2445

    
2446
static inline int hpel_motion(MpegEncContext *s, 
2447
                                  uint8_t *dest, uint8_t *src,
2448
                                  int field_based, int field_select,
2449
                                  int src_x, int src_y,
2450
                                  int width, int height, int stride,
2451
                                  int h_edge_pos, int v_edge_pos,
2452
                                  int w, int h, op_pixels_func *pix_op,
2453
                                  int motion_x, int motion_y)
2454
{
2455
    int dxy;
2456
    int emu=0;
2457

    
2458
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2459
    src_x += motion_x >> 1;
2460
    src_y += motion_y >> 1;
2461
                
2462
    /* WARNING: do no forget half pels */
2463
    src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2464
    if (src_x == width)
2465
        dxy &= ~1;
2466
    src_y = clip(src_y, -16, height);
2467
    if (src_y == height)
2468
        dxy &= ~2;
2469
    src += src_y * stride + src_x;
2470

    
2471
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2472
        if(   (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2473
           || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2474
            ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2475
                             src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2476
            src= s->edge_emu_buffer;
2477
            emu=1;
2478
        }
2479
    }
2480
    if(field_select)
2481
        src += s->linesize;
2482
    pix_op[dxy](dest, src, stride, h);
2483
    return emu;
2484
}
2485

    
2486
/* apply one mpeg motion vector to the three components */
2487
static always_inline void mpeg_motion(MpegEncContext *s,
2488
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2489
                               int field_based, int bottom_field, int field_select,
2490
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2491
                               int motion_x, int motion_y, int h)
2492
{
2493
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2494
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2495
    
2496
#if 0    
2497
if(s->quarter_sample)
2498
{
2499
    motion_x>>=1;
2500
    motion_y>>=1;
2501
}
2502
#endif
2503

    
2504
    v_edge_pos = s->v_edge_pos >> field_based;
2505
    linesize   = s->current_picture.linesize[0] << field_based;
2506
    uvlinesize = s->current_picture.linesize[1] << field_based;
2507

    
2508
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2509
    src_x = s->mb_x* 16               + (motion_x >> 1);
2510
    src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2511

    
2512
    if (s->out_format == FMT_H263) {
2513
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2514
            mx = (motion_x>>1)|(motion_x&1);
2515
            my = motion_y >>1;
2516
            uvdxy = ((my & 1) << 1) | (mx & 1);
2517
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2518
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2519
        }else{
2520
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2521
            uvsrc_x = src_x>>1;
2522
            uvsrc_y = src_y>>1;
2523
        }
2524
    }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2525
        mx = motion_x / 4;
2526
        my = motion_y / 4;
2527
        uvdxy = 0;
2528
        uvsrc_x = s->mb_x*8 + mx;
2529
        uvsrc_y = s->mb_y*8 + my;
2530
    } else {
2531
        if(s->chroma_y_shift){
2532
            mx = motion_x / 2;
2533
            my = motion_y / 2;
2534
            uvdxy = ((my & 1) << 1) | (mx & 1);
2535
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
2536
            uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2537
        } else {
2538
            if(s->chroma_x_shift){
2539
            //Chroma422
2540
                mx = motion_x / 2;
2541
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2542
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
2543
                uvsrc_y = src_y;
2544
            } else {
2545
            //Chroma444
2546
                uvdxy = dxy;
2547
                uvsrc_x = src_x;
2548
                uvsrc_y = src_y;
2549
            }
2550
        }
2551
    }
2552

    
2553
    ptr_y  = ref_picture[0] + src_y * linesize + src_x;
2554
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2555
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2556

    
2557
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2558
       || (unsigned)src_y >    v_edge_pos - (motion_y&1) - h){
2559
            if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2560
               s->codec_id == CODEC_ID_MPEG1VIDEO){
2561
                av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2562
                return ;
2563
            }
2564
            ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2565
                             src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2566
            ptr_y = s->edge_emu_buffer;
2567
            if(!(s->flags&CODEC_FLAG_GRAY)){
2568
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2569
                ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based, 
2570
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2571
                ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 
2572
                                 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2573
                ptr_cb= uvbuf;
2574
                ptr_cr= uvbuf+16;
2575
            }
2576
    }
2577

    
2578
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2579
        dest_y += s->linesize;
2580
        dest_cb+= s->uvlinesize;
2581
        dest_cr+= s->uvlinesize;
2582
    }
2583

    
2584
    if(field_select){
2585
        ptr_y += s->linesize;
2586
        ptr_cb+= s->uvlinesize;
2587
        ptr_cr+= s->uvlinesize;
2588
    }
2589

    
2590
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2591
    
2592
    if(!(s->flags&CODEC_FLAG_GRAY)){
2593
        pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2594
        pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2595
    }
2596
}
2597
//FIXME move to dsputil, avg variant, 16x16 version
2598
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2599
    int x;
2600
    uint8_t * const top   = src[1];
2601
    uint8_t * const left  = src[2];
2602
    uint8_t * const mid   = src[0];
2603
    uint8_t * const right = src[3];
2604
    uint8_t * const bottom= src[4];
2605
#define OBMC_FILTER(x, t, l, m, r, b)\
2606
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2607
#define OBMC_FILTER4(x, t, l, m, r, b)\
2608
    OBMC_FILTER(x         , t, l, m, r, b);\
2609
    OBMC_FILTER(x+1       , t, l, m, r, b);\
2610
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
2611
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
2612
    
2613
    x=0;
2614
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
2615
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2616
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2617
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2618
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2619
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2620
    x+= stride;
2621
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
2622
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2623
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2624
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2625
    x+= stride;
2626
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
2627
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2628
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2629
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2630
    x+= 2*stride;
2631
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
2632
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2633
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2634
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2635
    x+= 2*stride;
2636
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
2637
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2638
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2639
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2640
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2641
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2642
    x+= stride;
2643
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
2644
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2645
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2646
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2647
}
2648

    
2649
/* obmc for 1 8x8 luma block */
2650
static inline void obmc_motion(MpegEncContext *s,
2651
                               uint8_t *dest, uint8_t *src,
2652
                               int src_x, int src_y,
2653
                               op_pixels_func *pix_op,
2654
                               int16_t mv[5][2]/* mid top left right bottom*/)
2655
#define MID    0
2656
{
2657
    int i;
2658
    uint8_t *ptr[5];
2659
    
2660
    assert(s->quarter_sample==0);
2661
    
2662
    for(i=0; i<5; i++){
2663
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2664
            ptr[i]= ptr[MID];
2665
        }else{
2666
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2667
            hpel_motion(s, ptr[i], src, 0, 0,
2668
                        src_x, src_y,
2669
                        s->width, s->height, s->linesize,
2670
                        s->h_edge_pos, s->v_edge_pos,
2671
                        8, 8, pix_op,
2672
                        mv[i][0], mv[i][1]);
2673
        }
2674
    }
2675

    
2676
    put_obmc(dest, ptr, s->linesize);                
2677
}
2678

    
2679
static inline void qpel_motion(MpegEncContext *s,
2680
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2681
                               int field_based, int bottom_field, int field_select,
2682
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2683
                               qpel_mc_func (*qpix_op)[16],
2684
                               int motion_x, int motion_y, int h)
2685
{
2686
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2687
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2688

    
2689
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2690
    src_x = s->mb_x *  16                 + (motion_x >> 2);
2691
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2692

    
2693
    v_edge_pos = s->v_edge_pos >> field_based;
2694
    linesize = s->linesize << field_based;
2695
    uvlinesize = s->uvlinesize << field_based;
2696
    
2697
    if(field_based){
2698
        mx= motion_x/2;
2699
        my= motion_y>>1;
2700
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2701
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
2702
        mx= (motion_x>>1) + rtab[motion_x&7];
2703
        my= (motion_y>>1) + rtab[motion_y&7];
2704
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2705
        mx= (motion_x>>1)|(motion_x&1);
2706
        my= (motion_y>>1)|(motion_y&1);
2707
    }else{
2708
        mx= motion_x/2;
2709
        my= motion_y/2;
2710
    }
2711
    mx= (mx>>1)|(mx&1);
2712
    my= (my>>1)|(my&1);
2713

    
2714
    uvdxy= (mx&1) | ((my&1)<<1);
2715
    mx>>=1;
2716
    my>>=1;
2717

    
2718
    uvsrc_x = s->mb_x *  8                 + mx;
2719
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
2720

    
2721
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
2722
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2723
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2724

    
2725
    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16 
2726
       || (unsigned)src_y >    v_edge_pos - (motion_y&3) - h  ){
2727
        ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 
2728
                         src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2729
        ptr_y= s->edge_emu_buffer;
2730
        if(!(s->flags&CODEC_FLAG_GRAY)){
2731
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2732
            ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based, 
2733
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2734
            ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based, 
2735
                             uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2736
            ptr_cb= uvbuf;
2737
            ptr_cr= uvbuf + 16;
2738
        }
2739
    }
2740

    
2741
    if(!field_based)
2742
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
2743
    else{
2744
        if(bottom_field){
2745
            dest_y += s->linesize;
2746
            dest_cb+= s->uvlinesize;
2747
            dest_cr+= s->uvlinesize;
2748
        }
2749

    
2750
        if(field_select){
2751
            ptr_y  += s->linesize;
2752
            ptr_cb += s->uvlinesize;
2753
            ptr_cr += s->uvlinesize;
2754
        }
2755
        //damn interlaced mode
2756
        //FIXME boundary mirroring is not exactly correct here
2757
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
2758
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2759
    }
2760
    if(!(s->flags&CODEC_FLAG_GRAY)){
2761
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2762
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2763
    }
2764
}
2765

    
2766
inline int ff_h263_round_chroma(int x){
2767
    if (x >= 0)
2768
        return  (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2769
    else {
2770
        x = -x;
2771
        return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2772
    }
2773
}
2774

    
2775
/**
2776
 * h263 chorma 4mv motion compensation.
2777
 */
2778
static inline void chroma_4mv_motion(MpegEncContext *s,
2779
                                     uint8_t *dest_cb, uint8_t *dest_cr,
2780
                                     uint8_t **ref_picture,
2781
                                     op_pixels_func *pix_op,
2782
                                     int mx, int my){
2783
    int dxy, emu=0, src_x, src_y, offset;
2784
    uint8_t *ptr;
2785
    
2786
    /* In case of 8X8, we construct a single chroma motion vector
2787
       with a special rounding */
2788
    mx= ff_h263_round_chroma(mx);
2789
    my= ff_h263_round_chroma(my);
2790
    
2791
    dxy = ((my & 1) << 1) | (mx & 1);
2792
    mx >>= 1;
2793
    my >>= 1;
2794

    
2795
    src_x = s->mb_x * 8 + mx;
2796
    src_y = s->mb_y * 8 + my;
2797
    src_x = clip(src_x, -8, s->width/2);
2798
    if (src_x == s->width/2)
2799
        dxy &= ~1;
2800
    src_y = clip(src_y, -8, s->height/2);
2801
    if (src_y == s->height/2)
2802
        dxy &= ~2;
2803
    
2804
    offset = (src_y * (s->uvlinesize)) + src_x;
2805
    ptr = ref_picture[1] + offset;
2806
    if(s->flags&CODEC_FLAG_EMU_EDGE){
2807
        if(   (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2808
           || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2809
            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);
2810
            ptr= s->edge_emu_buffer;
2811
            emu=1;
2812
        }
2813
    }
2814
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2815

    
2816
    ptr = ref_picture[2] + offset;
2817
    if(emu){
2818
        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);
2819
        ptr= s->edge_emu_buffer;
2820
    }
2821
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2822
}
2823

    
2824
/**
2825
 * motion compesation of a single macroblock
2826
 * @param s context
2827
 * @param dest_y luma destination pointer
2828
 * @param dest_cb chroma cb/u destination pointer
2829
 * @param dest_cr chroma cr/v destination pointer
2830
 * @param dir direction (0->forward, 1->backward)
2831
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2832
 * @param pic_op halfpel motion compensation function (average or put normally)
2833
 * @param pic_op qpel motion compensation function (average or put normally)
2834
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2835
 */
2836
static inline void MPV_motion(MpegEncContext *s, 
2837
                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2838
                              int dir, uint8_t **ref_picture, 
2839
                              op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2840
{
2841
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2842
    int mb_x, mb_y, i;
2843
    uint8_t *ptr, *dest;
2844

    
2845
    mb_x = s->mb_x;
2846
    mb_y = s->mb_y;
2847

    
2848
    if(s->obmc && s->pict_type != B_TYPE){
2849
        int16_t mv_cache[4][4][2];
2850
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
2851
        const int mot_stride= s->b8_stride;
2852
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2853

    
2854
        assert(!s->mb_skiped);
2855
                
2856
        memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy           ], sizeof(int16_t)*4);
2857
        memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2858
        memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2859

    
2860
        if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2861
            memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2862
        }else{
2863
            memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2864
        }
2865

    
2866
        if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2867
            *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2868
            *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2869
        }else{
2870
            *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2871
            *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2872
        }
2873

    
2874
        if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2875
            *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2876
            *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2877
        }else{
2878
            *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2879
            *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2880
        }
2881
        
2882
        mx = 0;
2883
        my = 0;
2884
        for(i=0;i<4;i++) {
2885
            const int x= (i&1)+1;
2886
            const int y= (i>>1)+1;
2887
            int16_t mv[5][2]= {
2888
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
2889
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2890
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2891
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2892
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2893
            //FIXME cleanup
2894
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2895
                        ref_picture[0],
2896
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2897
                        pix_op[1],
2898
                        mv);
2899

    
2900
            mx += mv[0][0];
2901
            my += mv[0][1];
2902
        }
2903
        if(!(s->flags&CODEC_FLAG_GRAY))
2904
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2905

    
2906
        return;
2907
    }
2908
   
2909
    switch(s->mv_type) {
2910
    case MV_TYPE_16X16:
2911
#ifdef CONFIG_RISKY
2912
        if(s->mcsel){
2913
            if(s->real_sprite_warping_points==1){
2914
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
2915
                            ref_picture);
2916
            }else{
2917
                gmc_motion(s, dest_y, dest_cb, dest_cr,
2918
                            ref_picture);
2919
            }
2920
        }else if(s->quarter_sample){
2921
            qpel_motion(s, dest_y, dest_cb, dest_cr, 
2922
                        0, 0, 0,
2923
                        ref_picture, pix_op, qpix_op,
2924
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2925
        }else if(s->mspel){
2926
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2927
                        ref_picture, pix_op,
2928
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2929
        }else
2930
#endif
2931
        {
2932
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
2933
                        0, 0, 0,
2934
                        ref_picture, pix_op,
2935
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
2936
        }           
2937
        break;
2938
    case MV_TYPE_8X8:
2939
        mx = 0;
2940
        my = 0;
2941
        if(s->quarter_sample){
2942
            for(i=0;i<4;i++) {
2943
                motion_x = s->mv[dir][i][0];
2944
                motion_y = s->mv[dir][i][1];
2945

    
2946
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2947
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2948
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2949
                    
2950
                /* WARNING: do no forget half pels */
2951
                src_x = clip(src_x, -16, s->width);
2952
                if (src_x == s->width)
2953
                    dxy &= ~3;
2954
                src_y = clip(src_y, -16, s->height);
2955
                if (src_y == s->height)
2956
                    dxy &= ~12;
2957
                    
2958
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2959
                if(s->flags&CODEC_FLAG_EMU_EDGE){
2960
                    if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8 
2961
                       || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2962
                        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);
2963
                        ptr= s->edge_emu_buffer;
2964
                    }
2965
                }
2966
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2967
                qpix_op[1][dxy](dest, ptr, s->linesize);
2968

    
2969
                mx += s->mv[dir][i][0]/2;
2970
                my += s->mv[dir][i][1]/2;
2971
            }
2972
        }else{
2973
            for(i=0;i<4;i++) {
2974
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2975
                            ref_picture[0], 0, 0,
2976
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2977
                            s->width, s->height, s->linesize,
2978
                            s->h_edge_pos, s->v_edge_pos,
2979
                            8, 8, pix_op[1],
2980
                            s->mv[dir][i][0], s->mv[dir][i][1]);
2981

    
2982
                mx += s->mv[dir][i][0];
2983
                my += s->mv[dir][i][1];
2984
            }
2985
        }
2986

    
2987
        if(!(s->flags&CODEC_FLAG_GRAY))
2988
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2989
        break;
2990
    case MV_TYPE_FIELD:
2991
        if (s->picture_structure == PICT_FRAME) {
2992
            if(s->quarter_sample){
2993
                for(i=0; i<2; i++){
2994
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
2995
                                1, i, s->field_select[dir][i],
2996
                                ref_picture, pix_op, qpix_op,
2997
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
2998
                }
2999
            }else{
3000
                /* top field */       
3001
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3002
                            1, 0, s->field_select[dir][0],
3003
                            ref_picture, pix_op,
3004
                            s->mv[dir][0][0], s->mv[dir][0][1], 8);
3005
                /* bottom field */
3006
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
3007
                            1, 1, s->field_select[dir][1],
3008
                            ref_picture, pix_op,
3009
                            s->mv[dir][1][0], s->mv[dir][1][1], 8);
3010
            }
3011
        } else {
3012
            if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3013
                ref_picture= s->current_picture_ptr->data;
3014
            } 
3015

    
3016
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
3017
                        0, 0, s->field_select[dir][0],
3018
                        ref_picture, pix_op,
3019
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
3020
        }
3021
        break;
3022
    case MV_TYPE_16X8:
3023
        for(i=0; i<2; i++){
3024
            uint8_t ** ref2picture;
3025

    
3026
            if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3027
                ref2picture= ref_picture;
3028
            }else{
3029
                ref2picture= s->current_picture_ptr->data;
3030
            } 
3031

    
3032
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3033
                        0, 0, s->field_select[dir][i],
3034
                        ref2picture, pix_op,
3035
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3036
                
3037
            dest_y += 16*s->linesize;
3038
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3039
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3040
        }        
3041
        break;
3042
    case MV_TYPE_DMV:
3043
        if(s->picture_structure == PICT_FRAME){
3044
            for(i=0; i<2; i++){
3045
                int j;
3046
                for(j=0; j<2; j++){
3047
                    mpeg_motion(s, dest_y, dest_cb, dest_cr,
3048
                                1, j, j^i,
3049
                                ref_picture, pix_op,
3050
                                s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3051
                }
3052
                pix_op = s->dsp.avg_pixels_tab; 
3053
            }
3054
        }else{
3055
            for(i=0; i<2; i++){
3056
                mpeg_motion(s, dest_y, dest_cb, dest_cr, 
3057
                            0, 0, s->picture_structure != i+1,
3058
                            ref_picture, pix_op,
3059
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3060

    
3061
                // after put we make avg of the same block
3062
                pix_op=s->dsp.avg_pixels_tab; 
3063

    
3064
                //opposite parity is always in the same frame if this is second field
3065
                if(!s->first_field){
3066
                    ref_picture = s->current_picture_ptr->data;    
3067
                }
3068
            }
3069
        }
3070
    break;
3071
    default: assert(0);
3072
    }
3073
}
3074

    
3075

    
3076
/* put block[] to dest[] */
3077
static inline void put_dct(MpegEncContext *s, 
3078
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3079
{
3080
    s->dct_unquantize_intra(s, block, i, qscale);
3081
    s->dsp.idct_put (dest, line_size, block);
3082
}
3083

    
3084
/* add block[] to dest[] */
3085
static inline void add_dct(MpegEncContext *s, 
3086
                           DCTELEM *block, int i, uint8_t *dest, int line_size)
3087
{
3088
    if (s->block_last_index[i] >= 0) {
3089
        s->dsp.idct_add (dest, line_size, block);
3090
    }
3091
}
3092

    
3093
static inline void add_dequant_dct(MpegEncContext *s, 
3094
                           DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3095
{
3096
    if (s->block_last_index[i] >= 0) {
3097
        s->dct_unquantize_inter(s, block, i, qscale);
3098

    
3099
        s->dsp.idct_add (dest, line_size, block);
3100
    }
3101
}
3102

    
3103
/**
3104
 * cleans dc, ac, coded_block for the current non intra MB
3105
 */
3106
void ff_clean_intra_table_entries(MpegEncContext *s)
3107
{
3108
    int wrap = s->b8_stride;
3109
    int xy = s->block_index[0];
3110
    
3111
    s->dc_val[0][xy           ] = 
3112
    s->dc_val[0][xy + 1       ] = 
3113
    s->dc_val[0][xy     + wrap] =
3114
    s->dc_val[0][xy + 1 + wrap] = 1024;
3115
    /* ac pred */
3116
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3117
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3118
    if (s->msmpeg4_version>=3) {
3119
        s->coded_block[xy           ] =
3120
        s->coded_block[xy + 1       ] =
3121
        s->coded_block[xy     + wrap] =
3122
        s->coded_block[xy + 1 + wrap] = 0;
3123
    }
3124
    /* chroma */
3125
    wrap = s->mb_stride;
3126
    xy = s->mb_x + s->mb_y * wrap;
3127
    s->dc_val[1][xy] =
3128
    s->dc_val[2][xy] = 1024;
3129
    /* ac pred */
3130
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3131
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3132
    
3133
    s->mbintra_table[xy]= 0;
3134
}
3135

    
3136
/* generic function called after a macroblock has been parsed by the
3137
   decoder or after it has been encoded by the encoder.
3138

3139
   Important variables used:
3140
   s->mb_intra : true if intra macroblock
3141
   s->mv_dir   : motion vector direction
3142
   s->mv_type  : motion vector type
3143
   s->mv       : motion vector
3144
   s->interlaced_dct : true if interlaced dct used (mpeg2)
3145
 */
3146
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
3147
{
3148
    int mb_x, mb_y;
3149
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3150
#ifdef HAVE_XVMC
3151
    if(s->avctx->xvmc_acceleration){
3152
        XVMC_decode_mb(s);//xvmc uses pblocks
3153
        return;
3154
    }
3155
#endif
3156

    
3157
    mb_x = s->mb_x;
3158
    mb_y = s->mb_y;
3159

    
3160
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3161
       /* save DCT coefficients */
3162
       int i,j;
3163
       DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3164
       for(i=0; i<6; i++)
3165
           for(j=0; j<64; j++)
3166
               *dct++ = block[i][s->dsp.idct_permutation[j]];
3167
    }
3168

    
3169
    s->current_picture.qscale_table[mb_xy]= s->qscale;
3170

    
3171
    /* update DC predictors for P macroblocks */
3172
    if (!s->mb_intra) {
3173
        if (s->h263_pred || s->h263_aic) {
3174
            if(s->mbintra_table[mb_xy])
3175
                ff_clean_intra_table_entries(s);
3176
        } else {
3177
            s->last_dc[0] =
3178
            s->last_dc[1] =
3179
            s->last_dc[2] = 128 << s->intra_dc_precision;
3180
        }
3181
    }
3182
    else if (s->h263_pred || s->h263_aic)
3183
        s->mbintra_table[mb_xy]=1;
3184

    
3185
    if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3186
        uint8_t *dest_y, *dest_cb, *dest_cr;
3187
        int dct_linesize, dct_offset;
3188
        op_pixels_func (*op_pix)[4];
3189
        qpel_mc_func (*op_qpix)[16];
3190
        const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3191
        const int uvlinesize= s->current_picture.linesize[1];
3192
        const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
3193

    
3194
        /* avoid copy if macroblock skipped in last frame too */
3195
        /* skip only during decoding as we might trash the buffers during encoding a bit */
3196
        if(!s->encoding){
3197
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3198
            const int age= s->current_picture.age;
3199

    
3200
            assert(age);
3201

    
3202
            if (s->mb_skiped) {
3203
                s->mb_skiped= 0;
3204
                assert(s->pict_type!=I_TYPE);
3205
 
3206
                (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3207
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3208

    
3209
                /* if previous was skipped too, then nothing to do !  */
3210
                if (*mbskip_ptr >= age && s->current_picture.reference){
3211
                    return;
3212
                }
3213
            } else if(!s->current_picture.reference){
3214
                (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3215
                if(*mbskip_ptr >99) *mbskip_ptr= 99;
3216
            } else{
3217
                *mbskip_ptr = 0; /* not skipped */
3218
            }
3219
        }
3220

    
3221
        dct_linesize = linesize << s->interlaced_dct;
3222
        dct_offset =(s->interlaced_dct)? linesize : linesize*8;
3223

    
3224
        if(readable){
3225
            dest_y=  s->dest[0];
3226
            dest_cb= s->dest[1];
3227
            dest_cr= s->dest[2];
3228
        }else{
3229
            dest_y = s->b_scratchpad;
3230
            dest_cb= s->b_scratchpad+16*linesize;
3231
            dest_cr= s->b_scratchpad+32*linesize;
3232
        }
3233
        if (!s->mb_intra) {
3234
            /* motion handling */
3235
            /* decoding or more than one mb_type (MC was allready done otherwise) */
3236
            if(!s->encoding){
3237
                if ((!s->no_rounding) || s->pict_type==B_TYPE){                
3238
                    op_pix = s->dsp.put_pixels_tab;
3239
                    op_qpix= s->dsp.put_qpel_pixels_tab;
3240
                }else{
3241
                    op_pix = s->dsp.put_no_rnd_pixels_tab;
3242
                    op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3243
                }
3244

    
3245
                if (s->mv_dir & MV_DIR_FORWARD) {
3246
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3247
                    op_pix = s->dsp.avg_pixels_tab;
3248
                    op_qpix= s->dsp.avg_qpel_pixels_tab;
3249
                }
3250
                if (s->mv_dir & MV_DIR_BACKWARD) {
3251
                    MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3252
                }
3253
            }
3254

    
3255
            /* skip dequant / idct if we are really late ;) */
3256
            if(s->hurry_up>1) return;
3257

    
3258
            /* add dct residue */
3259
            if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3260
                                || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3261
                add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3262
                add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3263
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3264
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3265

    
3266
                if(!(s->flags&CODEC_FLAG_GRAY)){
3267
                    add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3268
                    add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3269
                }
3270
            } else if(s->codec_id != CODEC_ID_WMV2){
3271
                add_dct(s, block[0], 0, dest_y, dct_linesize);
3272
                add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
3273
                add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
3274
                add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
3275

    
3276
                if(!(s->flags&CODEC_FLAG_GRAY)){
3277
                    if(s->chroma_y_shift){//Chroma420
3278
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
3279
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
3280
                    }else{
3281
                        //chroma422
3282
                        dct_linesize = uvlinesize << s->interlaced_dct;
3283
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3284

    
3285
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
3286
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
3287
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3288
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3289
                        if(!s->chroma_x_shift){//Chroma444
3290
                            add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3291
                            add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3292
                            add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3293
                            add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3294
                        }
3295
                    }
3296
                }//fi gray
3297
            }
3298
#ifdef CONFIG_RISKY
3299
            else{
3300
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3301
            }
3302
#endif
3303
        } else {
3304
            /* dct only in intra block */
3305
            if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3306
                put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
3307
                put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
3308
                put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
3309
                put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
3310

    
3311
                if(!(s->flags&CODEC_FLAG_GRAY)){
3312
                    put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3313
                    put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3314
                }
3315
            }else{
3316
                s->dsp.idct_put(dest_y                 , dct_linesize, block[0]);
3317
                s->dsp.idct_put(dest_y              + 8, dct_linesize, block[1]);
3318
                s->dsp.idct_put(dest_y + dct_offset    , dct_linesize, block[2]);
3319
                s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
3320

    
3321
                if(!(s->flags&CODEC_FLAG_GRAY)){
3322
                    if(s->chroma_y_shift){
3323
                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3324
                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3325
                    }else{
3326

    
3327
                        dct_linesize = uvlinesize << s->interlaced_dct;
3328
                        dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3329

    
3330
                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
3331
                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
3332
                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3333
                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3334
                        if(!s->chroma_x_shift){//Chroma444
3335
                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
3336
                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
3337
                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3338
                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3339
                        }
3340
                    }
3341
                }//gray
3342
            }
3343
        }
3344
        if(!readable){
3345
            s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3346
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3347
            s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3348
        }
3349
    }
3350
}
3351

    
3352
#ifdef CONFIG_ENCODERS
3353

    
3354
static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3355
{
3356
    static const char tab[64]=
3357
        {3,2,2,1,1,1,1,1,
3358
         1,1,1,1,1,1,1,1,
3359
         1,1,1,1,1,1,1,1,
3360
         0,0,0,0,0,0,0,0,
3361
         0,0,0,0,0,0,0,0,
3362
         0,0,0,0,0,0,0,0,
3363
         0,0,0,0,0,0,0,0,
3364
         0,0,0,0,0,0,0,0};
3365
    int score=0;
3366
    int run=0;
3367
    int i;
3368
    DCTELEM *block= s->block[n];
3369
    const int last_index= s->block_last_index[n];
3370
    int skip_dc;
3371

    
3372
    if(threshold<0){
3373
        skip_dc=0;
3374
        threshold= -threshold;
3375
    }else
3376
        skip_dc=1;
3377

    
3378
    /* are all which we could set to zero are allready zero? */
3379
    if(last_index<=skip_dc - 1) return;
3380

    
3381
    for(i=0; i<=last_index; i++){
3382
        const int j = s->intra_scantable.permutated[i];
3383
        const int level = ABS(block[j]);
3384
        if(level==1){
3385
            if(skip_dc && i==0) continue;
3386
            score+= tab[run];
3387
            run=0;
3388
        }else if(level>1){
3389
            return;
3390
        }else{
3391
            run++;
3392
        }
3393
    }
3394
    if(score >= threshold) return;
3395
    for(i=skip_dc; i<=last_index; i++){
3396
        const int j = s->intra_scantable.permutated[i];
3397
        block[j]=0;
3398
    }
3399
    if(block[0]) s->block_last_index[n]= 0;
3400
    else         s->block_last_index[n]= -1;
3401
}
3402

    
3403
static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3404
{
3405
    int i;
3406
    const int maxlevel= s->max_qcoeff;
3407
    const int minlevel= s->min_qcoeff;
3408
    int overflow=0;
3409
    
3410
    if(s->mb_intra){
3411
        i=1; //skip clipping of intra dc
3412
    }else
3413
        i=0;
3414
    
3415
    for(;i<=last_index; i++){
3416
        const int j= s->intra_scantable.permutated[i];
3417
        int level = block[j];
3418
       
3419
        if     (level>maxlevel){
3420
            level=maxlevel;
3421
            overflow++;
3422
        }else if(level<minlevel){
3423
            level=minlevel;
3424
            overflow++;
3425
        }
3426
        
3427
        block[j]= level;
3428
    }
3429
    
3430
    if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3431
        av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3432
}
3433

    
3434
#endif //CONFIG_ENCODERS
3435

    
3436
/**
3437
 *
3438
 * @param h is the normal height, this will be reduced automatically if needed for the last row
3439
 */
3440
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3441
    if (s->avctx->draw_horiz_band) {
3442
        AVFrame *src;
3443
        int offset[4];
3444
        
3445
        if(s->picture_structure != PICT_FRAME){
3446
            h <<= 1;
3447
            y <<= 1;
3448
            if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3449
        }
3450

    
3451
        h= FFMIN(h, s->height - y);
3452

    
3453
        if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 
3454
            src= (AVFrame*)s->current_picture_ptr;
3455
        else if(s->last_picture_ptr)
3456
            src= (AVFrame*)s->last_picture_ptr;
3457
        else
3458
            return;
3459
            
3460
        if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3461
            offset[0]=
3462
            offset[1]=
3463
            offset[2]=
3464
            offset[3]= 0;
3465
        }else{
3466
            offset[0]= y * s->linesize;;
3467
            offset[1]= 
3468
            offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3469
            offset[3]= 0;
3470
        }
3471

    
3472
        emms_c();
3473

    
3474
        s->avctx->draw_horiz_band(s->avctx, src, offset,
3475
                                  y, s->picture_structure, h);
3476
    }
3477
}
3478

    
3479
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3480
    const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3481
    const int uvlinesize= s->current_picture.linesize[1];
3482
        
3483
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3484
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3485
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3486
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3487
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3488
    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;
3489
    //block_index is not used by mpeg2, so it is not affected by chroma_format
3490

    
3491
    s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << 4);
3492
    s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
3493
    s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (4 - s->chroma_x_shift));
3494

    
3495
    if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3496
    {
3497
        s->dest[0] += s->mb_y *   linesize << 4;
3498
        s->dest[1] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
3499
        s->dest[2] += s->mb_y * uvlinesize << (4 - s->chroma_y_shift);
3500
    }
3501
}
3502

    
3503
#ifdef CONFIG_ENCODERS
3504

    
3505
static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3506
    int x, y;
3507
//FIXME optimize
3508
    for(y=0; y<8; y++){
3509
        for(x=0; x<8; x++){
3510
            int x2, y2;
3511
            int sum=0;
3512
            int sqr=0;
3513
            int count=0;
3514

    
3515
            for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3516
                for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3517
                    int v= ptr[x2 + y2*stride];
3518
                    sum += v;
3519
                    sqr += v*v;
3520
                    count++;
3521
                }
3522
            }
3523
            weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3524
        }
3525
    }
3526
}
3527

    
3528
static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3529
{
3530
    int16_t weight[6][64];
3531
    DCTELEM orig[6][64];
3532
    const int mb_x= s->mb_x;
3533
    const int mb_y= s->mb_y;
3534
    int i;
3535
    int skip_dct[6];
3536
    int dct_offset   = s->linesize*8; //default for progressive frames
3537
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3538
    int wrap_y, wrap_c;
3539
    
3540
    for(i=0; i<6; i++) skip_dct[i]=0;
3541
    
3542
    if(s->adaptive_quant){
3543
        const int last_qp= s->qscale;
3544
        const int mb_xy= mb_x + mb_y*s->mb_stride;
3545

    
3546
        s->lambda= s->lambda_table[mb_xy];
3547
        update_qscale(s);
3548
    
3549
        if(!(s->flags&CODEC_FLAG_QP_RD)){
3550
            s->dquant= s->qscale - last_qp;
3551

    
3552
            if(s->out_format==FMT_H263){
3553
                s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3554
            
3555
                if(s->codec_id==CODEC_ID_MPEG4){        
3556
                    if(!s->mb_intra){
3557
                        if(s->pict_type == B_TYPE){
3558
                            if(s->dquant&1) 
3559
                                s->dquant= (s->dquant/2)*2;
3560
                            if(s->mv_dir&MV_DIRECT)
3561
                                s->dquant= 0;
3562
                        }
3563
                        if(s->mv_type==MV_TYPE_8X8)
3564
                            s->dquant=0;
3565
                    }
3566
                }
3567
            }
3568
        }
3569
        ff_set_qscale(s, last_qp + s->dquant);
3570
    }else if(s->flags&CODEC_FLAG_QP_RD)
3571
        ff_set_qscale(s, s->qscale + s->dquant);
3572

    
3573
    wrap_y = s->linesize;
3574
    wrap_c = s->uvlinesize;
3575
    ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3576
    ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3577
    ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3578

    
3579
    if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3580
        uint8_t *ebuf= s->edge_emu_buffer + 32;
3581
        ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
3582
        ptr_y= ebuf;
3583
        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);
3584
        ptr_cb= ebuf+18*wrap_y;
3585
        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);
3586
        ptr_cr= ebuf+18*wrap_y+8;
3587
    }
3588

    
3589
    if (s->mb_intra) {
3590
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3591
            int progressive_score, interlaced_score;
3592

    
3593
            s->interlaced_dct=0;
3594
            progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8) 
3595
                              +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3596

    
3597
            if(progressive_score > 0){
3598
                interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8) 
3599
                                  +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
3600
                if(progressive_score > interlaced_score){
3601
                    s->interlaced_dct=1;
3602
            
3603
                    dct_offset= wrap_y;
3604
                    wrap_y<<=1;
3605
                }
3606
            }
3607
        }
3608
        
3609
        s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
3610
        s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
3611
        s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
3612
        s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3613

    
3614
        if(s->flags&CODEC_FLAG_GRAY){
3615
            skip_dct[4]= 1;
3616
            skip_dct[5]= 1;
3617
        }else{
3618
            s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3619
            s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3620
        }
3621
    }else{
3622
        op_pixels_func (*op_pix)[4];
3623
        qpel_mc_func (*op_qpix)[16];
3624
        uint8_t *dest_y, *dest_cb, *dest_cr;
3625

    
3626
        dest_y  = s->dest[0];
3627
        dest_cb = s->dest[1];
3628
        dest_cr = s->dest[2];
3629

    
3630
        if ((!s->no_rounding) || s->pict_type==B_TYPE){
3631
            op_pix = s->dsp.put_pixels_tab;
3632
            op_qpix= s->dsp.put_qpel_pixels_tab;
3633
        }else{
3634
            op_pix = s->dsp.put_no_rnd_pixels_tab;
3635
            op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3636
        }
3637

    
3638
        if (s->mv_dir & MV_DIR_FORWARD) {
3639
            MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3640
            op_pix = s->dsp.avg_pixels_tab;
3641
            op_qpix= s->dsp.avg_qpel_pixels_tab;
3642
        }
3643
        if (s->mv_dir & MV_DIR_BACKWARD) {
3644
            MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3645
        }
3646

    
3647
        if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3648
            int progressive_score, interlaced_score;
3649

    
3650
            s->interlaced_dct=0;
3651
            progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8) 
3652
                              +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3653
            
3654
            if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3655

    
3656
            if(progressive_score>0){
3657
                interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8) 
3658
                                  +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
3659
            
3660
                if(progressive_score > interlaced_score){
3661
                    s->interlaced_dct=1;
3662
            
3663
                    dct_offset= wrap_y;
3664
                    wrap_y<<=1;
3665
                }
3666
            }
3667
        }
3668
        
3669
        s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
3670
        s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
3671
        s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
3672
        s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3673
        
3674
        if(s->flags&CODEC_FLAG_GRAY){
3675
            skip_dct[4]= 1;
3676
            skip_dct[5]= 1;
3677
        }else{
3678
            s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3679
            s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3680
        }
3681
        /* pre quantization */         
3682
        if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3683
            //FIXME optimize
3684
            if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3685
            if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3686
            if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3687
            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;
3688
            if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3689
            if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3690
        }
3691
    }
3692

    
3693
    if(s->avctx->quantizer_noise_shaping){
3694
        if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y                 , wrap_y);
3695
        if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y              + 8, wrap_y);
3696
        if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
3697
        if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3698
        if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb                , wrap_c);
3699
        if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr                , wrap_c);
3700
        memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3701
    }
3702
            
3703
    /* DCT & quantize */
3704
    assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3705
    {
3706
        for(i=0;i<6;i++) {
3707
            if(!skip_dct[i]){
3708
                int overflow;
3709
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3710
            // FIXME we could decide to change to quantizer instead of clipping
3711
            // JS: I don't think that would be a good idea it could lower quality instead
3712
            //     of improve it. Just INTRADC clipping deserves changes in quantizer
3713
                if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3714
            }else
3715
                s->block_last_index[i]= -1;
3716
        }
3717
        if(s->avctx->quantizer_noise_shaping){
3718
            for(i=0;i<6;i++) {
3719
                if(!skip_dct[i]){
3720
                    s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3721
                }
3722
            }
3723
        }
3724
        
3725
        if(s->luma_elim_threshold && !s->mb_intra)
3726
            for(i=0; i<4; i++)
3727
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3728
        if(s->chroma_elim_threshold && !s->mb_intra)
3729
            for(i=4; i<6; i++)
3730
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3731

    
3732
        if(s->flags & CODEC_FLAG_CBP_RD){
3733
            for(i=0;i<6;i++) {
3734
                if(s->block_last_index[i] == -1)
3735
                    s->coded_score[i]= INT_MAX/256;
3736
            }
3737
        }
3738
    }
3739

    
3740
    if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3741
        s->block_last_index[4]=
3742
        s->block_last_index[5]= 0;
3743
        s->block[4][0]=
3744
        s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3745
    }
3746

    
3747
    //non c quantize code returns incorrect block_last_index FIXME
3748
    if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
3749
        for(i=0; i<6; i++){
3750
            int j;
3751
            if(s->block_last_index[i]>0){
3752
                for(j=63; j>0; j--){
3753
                    if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
3754
                }
3755
                s->block_last_index[i]= j;
3756
            }
3757
        }
3758
    }
3759

    
3760
    /* huffman encode */
3761
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3762
    case CODEC_ID_MPEG1VIDEO:
3763
    case CODEC_ID_MPEG2VIDEO:
3764
        mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3765
#ifdef CONFIG_RISKY
3766
    case CODEC_ID_MPEG4:
3767
        mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3768
    case CODEC_ID_MSMPEG4V2:
3769
    case CODEC_ID_MSMPEG4V3:
3770
    case CODEC_ID_WMV1:
3771
        msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3772
    case CODEC_ID_WMV2:
3773
         ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3774
    case CODEC_ID_H263:
3775
    case CODEC_ID_H263P:
3776
    case CODEC_ID_FLV1:
3777
    case CODEC_ID_RV10:
3778
        h263_encode_mb(s, s->block, motion_x, motion_y); break;
3779
#endif
3780
    case CODEC_ID_MJPEG:
3781
        mjpeg_encode_mb(s, s->block); break;
3782
    default:
3783
        assert(0);
3784
    }
3785
}
3786

    
3787
#endif //CONFIG_ENCODERS
3788

    
3789
void ff_mpeg_flush(AVCodecContext *avctx){
3790
    int i;
3791
    MpegEncContext *s = avctx->priv_data;
3792
    
3793
    if(s==NULL || s->picture==NULL) 
3794
        return;
3795
    
3796
    for(i=0; i<MAX_PICTURE_COUNT; i++){
3797
       if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3798
                                    || s->picture[i].type == FF_BUFFER_TYPE_USER))
3799
        avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3800
    }
3801
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3802
    
3803
    s->parse_context.state= -1;
3804
    s->parse_context.frame_start_found= 0;
3805
    s->parse_context.overread= 0;
3806
    s->parse_context.overread_index= 0;
3807
    s->parse_context.index= 0;
3808
    s->parse_context.last_index= 0;
3809
    s->bitstream_buffer_size=0;
3810
}
3811

    
3812
#ifdef CONFIG_ENCODERS
3813
void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3814
{
3815
    const uint16_t *srcw= (uint16_t*)src;
3816
    int words= length>>4;
3817
    int bits= length&15;
3818
    int i;
3819

    
3820
    if(length==0) return;
3821
    
3822
    if(words < 16){
3823
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3824
    }else if(put_bits_count(pb)&7){
3825
        for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
3826
    }else{
3827
        for(i=0; put_bits_count(pb)&31; i++)
3828
            put_bits(pb, 8, src[i]);
3829
        flush_put_bits(pb);
3830
        memcpy(pbBufPtr(pb), src+i, 2*words-i);
3831
        skip_put_bytes(pb, 2*words-i);
3832
    }
3833
        
3834
    put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
3835
}
3836

    
3837
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3838
    int i;
3839

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

    
3842
    /* mpeg1 */
3843
    d->mb_skip_run= s->mb_skip_run;
3844
    for(i=0; i<3; i++)
3845
        d->last_dc[i]= s->last_dc[i];
3846
    
3847
    /* statistics */
3848
    d->mv_bits= s->mv_bits;
3849
    d->i_tex_bits= s->i_tex_bits;
3850
    d->p_tex_bits= s->p_tex_bits;
3851
    d->i_count= s->i_count;
3852
    d->f_count= s->f_count;
3853
    d->b_count= s->b_count;
3854
    d->skip_count= s->skip_count;
3855
    d->misc_bits= s->misc_bits;
3856
    d->last_bits= 0;
3857

    
3858
    d->mb_skiped= 0;
3859
    d->qscale= s->qscale;
3860
    d->dquant= s->dquant;
3861
}
3862

    
3863
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3864
    int i;
3865

    
3866
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 
3867
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3868
    
3869
    /* mpeg1 */
3870
    d->mb_skip_run= s->mb_skip_run;
3871
    for(i=0; i<3; i++)
3872
        d->last_dc[i]= s->last_dc[i];
3873
    
3874
    /* statistics */
3875
    d->mv_bits= s->mv_bits;
3876
    d->i_tex_bits= s->i_tex_bits;
3877
    d->p_tex_bits= s->p_tex_bits;
3878
    d->i_count= s->i_count;
3879
    d->f_count= s->f_count;
3880
    d->b_count= s->b_count;
3881
    d->skip_count= s->skip_count;
3882
    d->misc_bits= s->misc_bits;
3883

    
3884
    d->mb_intra= s->mb_intra;
3885
    d->mb_skiped= s->mb_skiped;
3886
    d->mv_type= s->mv_type;
3887
    d->mv_dir= s->mv_dir;
3888
    d->pb= s->pb;
3889
    if(s->data_partitioning){
3890
        d->pb2= s->pb2;
3891
        d->tex_pb= s->tex_pb;
3892
    }
3893
    d->block= s->block;
3894
    for(i=0; i<6; i++)
3895
        d->block_last_index[i]= s->block_last_index[i];
3896
    d->interlaced_dct= s->interlaced_dct;
3897
    d->qscale= s->qscale;
3898
}
3899

    
3900
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 
3901
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3902
                           int *dmin, int *next_block, int motion_x, int motion_y)
3903
{
3904
    int score;
3905
    uint8_t *dest_backup[3];
3906
    
3907
    copy_context_before_encode(s, backup, type);
3908

    
3909
    s->block= s->blocks[*next_block];
3910
    s->pb= pb[*next_block];
3911
    if(s->data_partitioning){
3912
        s->pb2   = pb2   [*next_block];
3913
        s->tex_pb= tex_pb[*next_block];
3914
    }
3915
    
3916
    if(*next_block){
3917
        memcpy(dest_backup, s->dest, sizeof(s->dest));
3918
        s->dest[0] = s->rd_scratchpad;
3919
        s->dest[1] = s->rd_scratchpad + 16*s->linesize;
3920
        s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
3921
        assert(s->linesize >= 32); //FIXME
3922
    }
3923

    
3924
    encode_mb(s, motion_x, motion_y);
3925
    
3926
    score= put_bits_count(&s->pb);
3927
    if(s->data_partitioning){
3928
        score+= put_bits_count(&s->pb2);
3929
        score+= put_bits_count(&s->tex_pb);
3930
    }
3931
   
3932
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3933
        MPV_decode_mb(s, s->block);
3934

    
3935
        score *= s->lambda2;
3936
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
3937
    }
3938
    
3939
    if(*next_block){
3940
        memcpy(s->dest, dest_backup, sizeof(s->dest));
3941
    }
3942

    
3943
    if(score<*dmin){
3944
        *dmin= score;
3945
        *next_block^=1;
3946

    
3947
        copy_context_after_encode(best, s, type);
3948
    }
3949
}
3950
                
3951
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3952
    uint32_t *sq = squareTbl + 256;
3953
    int acc=0;
3954
    int x,y;
3955
    
3956
    if(w==16 && h==16) 
3957
        return s->dsp.sse[0](NULL, src1, src2, stride, 16);
3958
    else if(w==8 && h==8)
3959
        return s->dsp.sse[1](NULL, src1, src2, stride, 8);
3960
    
3961
    for(y=0; y<h; y++){
3962
        for(x=0; x<w; x++){
3963
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3964
        } 
3965
    }
3966
    
3967
    assert(acc>=0);
3968
    
3969
    return acc;
3970
}
3971

    
3972
static int sse_mb(MpegEncContext *s){
3973
    int w= 16;
3974
    int h= 16;
3975

    
3976
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3977
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3978

    
3979
    if(w==16 && h==16)
3980
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
3981
        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)
3982
               +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)
3983
               +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);
3984
      }else{
3985
        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)
3986
               +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)
3987
               +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);
3988
      }
3989
    else
3990
        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)
3991
               +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)
3992
               +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);
3993
}
3994

    
3995
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
3996
    MpegEncContext *s= arg;
3997

    
3998
    
3999
    s->me.pre_pass=1;
4000
    s->me.dia_size= s->avctx->pre_dia_size;
4001
    s->first_slice_line=1;
4002
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4003
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4004
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4005
        }
4006
        s->first_slice_line=0;
4007
    }
4008
    
4009
    s->me.pre_pass=0;
4010
    
4011
    return 0;
4012
}
4013

    
4014
static int estimate_motion_thread(AVCodecContext *c, void *arg){
4015
    MpegEncContext *s= arg;
4016

    
4017
    s->me.dia_size= s->avctx->dia_size;
4018
    s->first_slice_line=1;
4019
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4020
        s->mb_x=0; //for block init below
4021
        ff_init_block_index(s);
4022
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4023
            s->block_index[0]+=2;
4024
            s->block_index[1]+=2;
4025
            s->block_index[2]+=2;
4026
            s->block_index[3]+=2;
4027
            
4028
            /* compute motion vector & mb_type and store in context */
4029
            if(s->pict_type==B_TYPE)
4030
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4031
            else
4032
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4033
        }
4034
        s->first_slice_line=0;
4035
    }
4036
    return 0;
4037
}
4038

    
4039
static int mb_var_thread(AVCodecContext *c, void *arg){
4040
    MpegEncContext *s= arg;
4041
    int mb_x, mb_y;
4042

    
4043
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4044
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4045
            int xx = mb_x * 16;
4046
            int yy = mb_y * 16;
4047
            uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4048
            int varc;
4049
            int sum = s->dsp.pix_sum(pix, s->linesize);
4050
    
4051
            varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4052

    
4053
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4054
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4055
            s->me.mb_var_sum_temp    += varc;
4056
        }
4057
    }
4058
    return 0;
4059
}
4060

    
4061
static void write_slice_end(MpegEncContext *s){
4062
    if(s->codec_id==CODEC_ID_MPEG4){
4063
        if(s->partitioned_frame){
4064
            ff_mpeg4_merge_partitions(s);
4065
        }
4066
    
4067
        ff_mpeg4_stuffing(&s->pb);
4068
    }else if(s->out_format == FMT_MJPEG){
4069
        ff_mjpeg_stuffing(&s->pb);
4070
    }
4071

    
4072
    align_put_bits(&s->pb);
4073
    flush_put_bits(&s->pb);
4074
}
4075

    
4076
static int encode_thread(AVCodecContext *c, void *arg){
4077
    MpegEncContext *s= arg;
4078
    int mb_x, mb_y, pdif = 0;
4079
    int i, j;
4080
    MpegEncContext best_s, backup_s;
4081
    uint8_t bit_buf[2][3000];
4082
    uint8_t bit_buf2[2][3000];
4083
    uint8_t bit_buf_tex[2][3000];
4084
    PutBitContext pb[2], pb2[2], tex_pb[2];
4085
//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4086

    
4087
    for(i=0; i<2; i++){
4088
        init_put_bits(&pb    [i], bit_buf    [i], 3000);
4089
        init_put_bits(&pb2   [i], bit_buf2   [i], 3000);
4090
        init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4091
    }
4092

    
4093
    s->last_bits= put_bits_count(&s->pb);
4094
    s->mv_bits=0;
4095
    s->misc_bits=0;
4096
    s->i_tex_bits=0;
4097
    s->p_tex_bits=0;
4098
    s->i_count=0;
4099
    s->f_count=0;
4100
    s->b_count=0;
4101
    s->skip_count=0;
4102

    
4103
    for(i=0; i<3; i++){
4104
        /* init last dc values */
4105
        /* note: quant matrix value (8) is implied here */
4106
        s->last_dc[i] = 128 << s->intra_dc_precision;
4107
        
4108
        s->current_picture_ptr->error[i] = 0;
4109
    }
4110
    s->mb_skip_run = 0;
4111
    memset(s->last_mv, 0, sizeof(s->last_mv));
4112
     
4113
    s->last_mv_dir = 0;
4114

    
4115
#ifdef CONFIG_RISKY
4116
    switch(s->codec_id){
4117
    case CODEC_ID_H263:
4118
    case CODEC_ID_H263P:
4119
    case CODEC_ID_FLV1:
4120
        s->gob_index = ff_h263_get_gob_height(s);
4121
        break;
4122
    case CODEC_ID_MPEG4:
4123
        if(s->partitioned_frame)
4124
            ff_mpeg4_init_partitions(s);
4125
        break;
4126
    }
4127
#endif
4128

    
4129
    s->resync_mb_x=0;
4130
    s->resync_mb_y=0; 
4131
    s->first_slice_line = 1;
4132
    s->ptr_lastgob = s->pb.buf;
4133
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4134
//    printf("row %d at %X\n", s->mb_y, (int)s);
4135
        s->mb_x=0;
4136
        s->mb_y= mb_y;
4137

    
4138
        ff_set_qscale(s, s->qscale);
4139
        ff_init_block_index(s);
4140
        
4141
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4142
            const int xy= mb_y*s->mb_stride + mb_x;
4143
            int mb_type= s->mb_type[xy];
4144
//            int d;
4145
            int dmin= INT_MAX;
4146
            int dir;
4147

    
4148
            s->mb_x = mb_x;
4149
            ff_update_block_index(s);
4150

    
4151
            /* write gob / video packet header  */
4152
#ifdef CONFIG_RISKY
4153
            if(s->rtp_mode){
4154
                int current_packet_size, is_gob_start;
4155
                
4156
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4157
                
4158
                is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 
4159
                
4160
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4161
                
4162
                switch(s->codec_id){
4163
                case CODEC_ID_H263:
4164
                case CODEC_ID_H263P:
4165
                    if(!s->h263_slice_structured)
4166
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4167
                    break;
4168
                case CODEC_ID_MPEG2VIDEO:
4169
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4170
                case CODEC_ID_MPEG1VIDEO:
4171
                    if(s->mb_skip_run) is_gob_start=0;
4172
                    break;
4173
                }
4174

    
4175
                if(is_gob_start){
4176
                    if(s->start_mb_y != mb_y || mb_x!=0){
4177
                        write_slice_end(s);
4178

    
4179
                        if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4180
                            ff_mpeg4_init_partitions(s);
4181
                        }
4182
                    }
4183
                
4184
                    assert((put_bits_count(&s->pb)&7) == 0);
4185
                    current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4186
                    
4187
                    if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4188
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4189
                        int d= 100 / s->avctx->error_rate;
4190
                        if(r % d == 0){
4191
                            current_packet_size=0;
4192
#ifndef ALT_BITSTREAM_WRITER
4193
                            s->pb.buf_ptr= s->ptr_lastgob;
4194
#endif
4195
                            assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4196
                        }
4197
                    }
4198
        
4199
                    if (s->avctx->rtp_callback)
4200
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4201
                    
4202
                    switch(s->codec_id){
4203
                    case CODEC_ID_MPEG4:
4204
                        ff_mpeg4_encode_video_packet_header(s);
4205
                        ff_mpeg4_clean_buffers(s);
4206
                    break;
4207
                    case CODEC_ID_MPEG1VIDEO:
4208
                    case CODEC_ID_MPEG2VIDEO:
4209
                        ff_mpeg1_encode_slice_header(s);
4210
                        ff_mpeg1_clean_buffers(s);
4211
                    break;
4212
                    case CODEC_ID_H263:
4213
                    case CODEC_ID_H263P:
4214
                        h263_encode_gob_header(s, mb_y);                       
4215
                    break;
4216
                    }
4217

    
4218
                    if(s->flags&CODEC_FLAG_PASS1){
4219
                        int bits= put_bits_count(&s->pb);
4220
                        s->misc_bits+= bits - s->last_bits;
4221
                        s->last_bits= bits;
4222
                    }
4223
    
4224
                    s->ptr_lastgob += current_packet_size;
4225
                    s->first_slice_line=1;
4226
                    s->resync_mb_x=mb_x;
4227
                    s->resync_mb_y=mb_y;
4228
                }
4229
            }
4230
#endif
4231

    
4232
            if(  (s->resync_mb_x   == s->mb_x)
4233
               && s->resync_mb_y+1 == s->mb_y){
4234
                s->first_slice_line=0; 
4235
            }
4236

    
4237
            s->mb_skiped=0;
4238
            s->dquant=0; //only for QP_RD
4239

    
4240
            if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4241
                int next_block=0;
4242
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4243

    
4244
                copy_context_before_encode(&backup_s, s, -1);
4245
                backup_s.pb= s->pb;
4246
                best_s.data_partitioning= s->data_partitioning;
4247
                best_s.partitioned_frame= s->partitioned_frame;
4248
                if(s->data_partitioning){
4249
                    backup_s.pb2= s->pb2;
4250
                    backup_s.tex_pb= s->tex_pb;
4251
                }
4252

    
4253
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
4254
                    s->mv_dir = MV_DIR_FORWARD;
4255
                    s->mv_type = MV_TYPE_16X16;
4256
                    s->mb_intra= 0;
4257
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
4258
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
4259
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 
4260
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4261
                }
4262
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 
4263
                    s->mv_dir = MV_DIR_FORWARD;
4264
                    s->mv_type = MV_TYPE_FIELD;
4265
                    s->mb_intra= 0;
4266
                    for(i=0; i<2; i++){
4267
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4268
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4269
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4270
                    }
4271
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 
4272
                                 &dmin, &next_block, 0, 0);
4273
                }
4274
                if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4275
                    s->mv_dir = MV_DIR_FORWARD;
4276
                    s->mv_type = MV_TYPE_16X16;
4277
                    s->mb_intra= 0;
4278
                    s->mv[0][0][0] = 0;
4279
                    s->mv[0][0][1] = 0;
4280
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb, 
4281
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4282
                }
4283
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){                 
4284
                    s->mv_dir = MV_DIR_FORWARD;
4285
                    s->mv_type = MV_TYPE_8X8;
4286
                    s->mb_intra= 0;
4287
                    for(i=0; i<4; i++){
4288
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4289
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4290
                    }
4291
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 
4292
                                 &dmin, &next_block, 0, 0);
4293
                }
4294
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4295
                    s->mv_dir = MV_DIR_FORWARD;
4296
                    s->mv_type = MV_TYPE_16X16;
4297
                    s->mb_intra= 0;
4298
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4299
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4300
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 
4301
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4302
                }
4303
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4304
                    s->mv_dir = MV_DIR_BACKWARD;
4305
                    s->mv_type = MV_TYPE_16X16;
4306
                    s->mb_intra= 0;
4307
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4308
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4309
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 
4310
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4311
                }
4312
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4313
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4314
                    s->mv_type = MV_TYPE_16X16;
4315
                    s->mb_intra= 0;
4316
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4317
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4318
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4319
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4320
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 
4321
                                 &dmin, &next_block, 0, 0);
4322
                }
4323
                if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4324
                    int mx= s->b_direct_mv_table[xy][0];
4325
                    int my= s->b_direct_mv_table[xy][1];
4326
                    
4327
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4328
                    s->mb_intra= 0;
4329
#ifdef CONFIG_RISKY
4330
                    ff_mpeg4_set_direct_mv(s, mx, my);
4331
#endif
4332
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 
4333
                                 &dmin, &next_block, mx, my);
4334
                }
4335
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 
4336
                    s->mv_dir = MV_DIR_FORWARD;
4337
                    s->mv_type = MV_TYPE_FIELD;
4338
                    s->mb_intra= 0;
4339
                    for(i=0; i<2; i++){
4340
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4341
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4342
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4343
                    }
4344
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 
4345
                                 &dmin, &next_block, 0, 0);
4346
                }
4347
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 
4348
                    s->mv_dir = MV_DIR_BACKWARD;
4349
                    s->mv_type = MV_TYPE_FIELD;
4350
                    s->mb_intra= 0;
4351
                    for(i=0; i<2; i++){
4352
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4353
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4354
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4355
                    }
4356
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 
4357
                                 &dmin, &next_block, 0, 0);
4358
                }
4359
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 
4360
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4361
                    s->mv_type = MV_TYPE_FIELD;
4362
                    s->mb_intra= 0;
4363
                    for(dir=0; dir<2; dir++){
4364
                        for(i=0; i<2; i++){
4365
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4366
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4367
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4368
                        }
4369
                    }
4370
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 
4371
                                 &dmin, &next_block, 0, 0);
4372
                }
4373
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4374
                    s->mv_dir = 0;
4375
                    s->mv_type = MV_TYPE_16X16;
4376
                    s->mb_intra= 1;
4377
                    s->mv[0][0][0] = 0;
4378
                    s->mv[0][0][1] = 0;
4379
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 
4380
                                 &dmin, &next_block, 0, 0);
4381
                    if(s->h263_pred || s->h263_aic){
4382
                        if(best_s.mb_intra)
4383
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4384
                        else
4385
                            ff_clean_intra_table_entries(s); //old mode?
4386
                    }
4387
                }
4388

    
4389
                if(s->flags & CODEC_FLAG_QP_RD){
4390
                    if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4391
                        const int last_qp= backup_s.qscale;
4392
                        int dquant, dir, qp, dc[6];
4393
                        DCTELEM ac[6][16];
4394
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4395
                        
4396
                        assert(backup_s.dquant == 0);
4397

    
4398
                        //FIXME intra
4399
                        s->mv_dir= best_s.mv_dir;
4400
                        s->mv_type = MV_TYPE_16X16;
4401
                        s->mb_intra= best_s.mb_intra;
4402
                        s->mv[0][0][0] = best_s.mv[0][0][0];
4403
                        s->mv[0][0][1] = best_s.mv[0][0][1];
4404
                        s->mv[1][0][0] = best_s.mv[1][0][0];
4405
                        s->mv[1][0][1] = best_s.mv[1][0][1];
4406
                        
4407
                        dir= s->pict_type == B_TYPE ? 2 : 1;
4408
                        if(last_qp + dir > s->avctx->qmax) dir= -dir;
4409
                        for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4410
                            qp= last_qp + dquant;
4411
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4412
                                break;
4413
                            backup_s.dquant= dquant;
4414
                            if(s->mb_intra && s->dc_val[0]){
4415
                                for(i=0; i<6; i++){
4416
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
4417
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4418
                                }
4419
                            }
4420

    
4421
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 
4422
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4423
                            if(best_s.qscale != qp){
4424
                                if(s->mb_intra && s->dc_val[0]){
4425
                                    for(i=0; i<6; i++){
4426
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
4427
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4428
                                    }
4429
                                }
4430
                                if(dir > 0 && dquant==dir){
4431
                                    dquant= 0;
4432
                                    dir= -dir;
4433
                                }else
4434
                                    break;
4435
                            }
4436
                        }
4437
                        qp= best_s.qscale;
4438
                        s->current_picture.qscale_table[xy]= qp;
4439
                    }
4440
                }
4441

    
4442
                copy_context_after_encode(s, &best_s, -1);
4443
                
4444
                pb_bits_count= put_bits_count(&s->pb);
4445
                flush_put_bits(&s->pb);
4446
                ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4447
                s->pb= backup_s.pb;
4448
                
4449
                if(s->data_partitioning){
4450
                    pb2_bits_count= put_bits_count(&s->pb2);
4451
                    flush_put_bits(&s->pb2);
4452
                    ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4453
                    s->pb2= backup_s.pb2;
4454
                    
4455
                    tex_pb_bits_count= put_bits_count(&s->tex_pb);
4456
                    flush_put_bits(&s->tex_pb);
4457
                    ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4458
                    s->tex_pb= backup_s.tex_pb;
4459
                }
4460
                s->last_bits= put_bits_count(&s->pb);
4461
               
4462
#ifdef CONFIG_RISKY
4463
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4464
                    ff_h263_update_motion_val(s);
4465
#endif
4466
        
4467
                if(next_block==0){ //FIXME 16 vs linesize16
4468
                    s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
4469
                    s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
4470
                    s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4471
                }
4472

    
4473
                if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4474
                    MPV_decode_mb(s, s->block);
4475
            } else {
4476
                int motion_x, motion_y;
4477
                s->mv_type=MV_TYPE_16X16;
4478
                // only one MB-Type possible
4479
                
4480
                switch(mb_type){
4481
                case CANDIDATE_MB_TYPE_INTRA:
4482
                    s->mv_dir = 0;
4483
                    s->mb_intra= 1;
4484
                    motion_x= s->mv[0][0][0] = 0;
4485
                    motion_y= s->mv[0][0][1] = 0;
4486
                    break;
4487
                case CANDIDATE_MB_TYPE_INTER:
4488
                    s->mv_dir = MV_DIR_FORWARD;
4489
                    s->mb_intra= 0;
4490
                    motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4491
                    motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4492
                    break;
4493
                case CANDIDATE_MB_TYPE_INTER_I:
4494
                    s->mv_dir = MV_DIR_FORWARD;
4495
                    s->mv_type = MV_TYPE_FIELD;
4496
                    s->mb_intra= 0;
4497
                    for(i=0; i<2; i++){
4498
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4499
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4500
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4501
                    }
4502
                    motion_x = motion_y = 0;
4503
                    break;
4504
                case CANDIDATE_MB_TYPE_INTER4V:
4505
                    s->mv_dir = MV_DIR_FORWARD;
4506
                    s->mv_type = MV_TYPE_8X8;
4507
                    s->mb_intra= 0;
4508
                    for(i=0; i<4; i++){
4509
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4510
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4511
                    }
4512
                    motion_x= motion_y= 0;
4513
                    break;
4514
                case CANDIDATE_MB_TYPE_DIRECT:
4515
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4516
                    s->mb_intra= 0;
4517
                    motion_x=s->b_direct_mv_table[xy][0];
4518
                    motion_y=s->b_direct_mv_table[xy][1];
4519
#ifdef CONFIG_RISKY
4520
                    ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4521
#endif
4522
                    break;
4523
                case CANDIDATE_MB_TYPE_BIDIR:
4524
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4525
                    s->mb_intra= 0;
4526
                    motion_x=0;
4527
                    motion_y=0;
4528
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4529
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4530
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4531
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4532
                    break;
4533
                case CANDIDATE_MB_TYPE_BACKWARD:
4534
                    s->mv_dir = MV_DIR_BACKWARD;
4535
                    s->mb_intra= 0;
4536
                    motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4537
                    motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4538
                    break;
4539
                case CANDIDATE_MB_TYPE_FORWARD:
4540
                    s->mv_dir = MV_DIR_FORWARD;
4541
                    s->mb_intra= 0;
4542
                    motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4543
                    motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4544
//                    printf(" %d %d ", motion_x, motion_y);
4545
                    break;
4546
                case CANDIDATE_MB_TYPE_FORWARD_I:
4547
                    s->mv_dir = MV_DIR_FORWARD;
4548
                    s->mv_type = MV_TYPE_FIELD;
4549
                    s->mb_intra= 0;
4550
                    for(i=0; i<2; i++){
4551
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4552
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4553
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4554
                    }
4555
                    motion_x=motion_y=0;
4556
                    break;
4557
                case CANDIDATE_MB_TYPE_BACKWARD_I:
4558
                    s->mv_dir = MV_DIR_BACKWARD;
4559
                    s->mv_type = MV_TYPE_FIELD;
4560
                    s->mb_intra= 0;
4561
                    for(i=0; i<2; i++){
4562
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4563
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4564
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4565
                    }
4566
                    motion_x=motion_y=0;
4567
                    break;
4568
                case CANDIDATE_MB_TYPE_BIDIR_I:
4569
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4570
                    s->mv_type = MV_TYPE_FIELD;
4571
                    s->mb_intra= 0;
4572
                    for(dir=0; dir<2; dir++){
4573
                        for(i=0; i<2; i++){
4574
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4575
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4576
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4577
                        }
4578
                    }
4579
                    motion_x=motion_y=0;
4580
                    break;
4581
                default:
4582
                    motion_x=motion_y=0; //gcc warning fix
4583
                    av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4584
                }
4585

    
4586
                encode_mb(s, motion_x, motion_y);
4587

    
4588
                // RAL: Update last macrobloc type
4589
                s->last_mv_dir = s->mv_dir;
4590
            
4591
#ifdef CONFIG_RISKY
4592
                if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4593
                    ff_h263_update_motion_val(s);
4594
#endif
4595
                
4596
                MPV_decode_mb(s, s->block);
4597
            }
4598

    
4599
            /* clean the MV table in IPS frames for direct mode in B frames */
4600
            if(s->mb_intra /* && I,P,S_TYPE */){
4601
                s->p_mv_table[xy][0]=0;
4602
                s->p_mv_table[xy][1]=0;
4603
            }
4604
            
4605
            if(s->flags&CODEC_FLAG_PSNR){
4606
                int w= 16;
4607
                int h= 16;
4608

    
4609
                if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4610
                if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4611

    
4612
                s->current_picture_ptr->error[0] += sse(
4613
                    s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4614
                    s->dest[0], w, h, s->linesize);
4615
                s->current_picture_ptr->error[1] += sse(
4616
                    s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4617
                    s->dest[1], w>>1, h>>1, s->uvlinesize);
4618
                s->current_picture_ptr->error[2] += sse(
4619
                    s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
4620
                    s->dest[2], w>>1, h>>1, s->uvlinesize);
4621
            }
4622
            if(s->loop_filter)
4623
                ff_h263_loop_filter(s);
4624
//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4625
        }
4626
    }
4627

    
4628
#ifdef CONFIG_RISKY
4629
    //not beautifull here but we must write it before flushing so it has to be here
4630
    if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4631
        msmpeg4_encode_ext_header(s);
4632
#endif
4633

    
4634
    write_slice_end(s);
4635

    
4636
    /* Send the last GOB if RTP */    
4637
    if (s->avctx->rtp_callback) {
4638
        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4639
        /* Call the RTP callback to send the last GOB */
4640
        emms_c();
4641
        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
4642
    }
4643

    
4644
    return 0;